diff --git a/.Rbuildignore b/.Rbuildignore
index d52a90bfee..77f2adccbe 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -44,6 +44,8 @@
 ^src/library/curl/tools/option_table[.]txt$
 ^src/library/jsonlite/src/yajl/libstatyajl[.]a$
 ^src/library/pkgdepends/man/macros/eval2[.]Rd$
+^src/library/ts/man/macros/eval2[.]Rd$
+^src/library/tstoml/man/macros/eval2[.]Rd$
 ^src/library/processx/src/supervisor/supervisor$
 ^src/library/processx/src/tools/px$
 ^src/library/processx/src/tools/sock$
diff --git a/.github/workflows/R-CMD-check.yaml b/.github/workflows/R-CMD-check.yaml
index 55dd03e4cc..597a0cc30a 100644
--- a/.github/workflows/R-CMD-check.yaml
+++ b/.github/workflows/R-CMD-check.yaml
@@ -42,7 +42,7 @@ jobs:
       R_KEEP_PKG_SOURCE: yes
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: r-lib/actions/setup-pandoc@v2
 
diff --git a/.github/workflows/linux-builder-containers.yaml b/.github/workflows/linux-builder-containers.yaml
index 9f8bad1a08..ced0a740dd 100644
--- a/.github/workflows/linux-builder-containers.yaml
+++ b/.github/workflows/linux-builder-containers.yaml
@@ -30,10 +30,10 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Login to GitHub Container Registry
-      uses: docker/login-action@v3
+      uses: docker/login-action@v4
       with:
         registry: ghcr.io
         username: ${{ github.repository_owner }}
@@ -69,10 +69,10 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Login to GitHub Container Registry
-      uses: docker/login-action@v3
+      uses: docker/login-action@v4
       with:
         registry: ghcr.io
         username: ${{ github.repository_owner }}
diff --git a/.github/workflows/nightly.yaml b/.github/workflows/nightly.yaml
index 5e4ec4a7cc..656820fb11 100644
--- a/.github/workflows/nightly.yaml
+++ b/.github/workflows/nightly.yaml
@@ -98,7 +98,7 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -155,7 +155,7 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -220,7 +220,7 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -291,7 +291,7 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -325,13 +325,13 @@ jobs:
 
     steps:
     - name: Set up QEMU
-      uses: docker/setup-qemu-action@v3
+      uses: docker/setup-qemu-action@v4
 
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
+      uses: docker/setup-buildx-action@v4
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -364,7 +364,7 @@ jobs:
     steps:
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -412,7 +412,7 @@ jobs:
         sudo apt-get update
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         fetch-depth: 10
 
@@ -439,7 +439,7 @@ jobs:
 
     - name: Deploy to GitHub pages (test)
       if: github.event_name != 'pull_request'
-      uses: JamesIves/github-pages-deploy-action@v4.5.0
+      uses: JamesIves/github-pages-deploy-action@v4.8.0
       with:
         repository-name: r-lib/r-lib.github.io
         token: ${{ secrets.PAK_GHCR_TOKEN }}
@@ -457,7 +457,7 @@ jobs:
 
     - name: Deploy to GitHub Pages (prod)
       if: github.event_name != 'pull_request'
-      uses: JamesIves/github-pages-deploy-action@v4.5.0
+      uses: JamesIves/github-pages-deploy-action@v4.8.0
       with:
         repository-name: r-lib/r-lib.github.io
         token: ${{ secrets.PAK_GHCR_TOKEN }}
diff --git a/.github/workflows/pkgdown.yaml b/.github/workflows/pkgdown.yaml
index f25e128acb..8267c25c50 100644
--- a/.github/workflows/pkgdown.yaml
+++ b/.github/workflows/pkgdown.yaml
@@ -23,7 +23,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: r-lib/actions/setup-pandoc@v2
 
@@ -54,7 +54,7 @@ jobs:
 
       - name: Deploy to GitHub pages 🚀
         if: github.event_name != 'pull_request'
-        uses: JamesIves/github-pages-deploy-action@v4.5.0
+        uses: JamesIves/github-pages-deploy-action@v4.8.0
         with:
           clean: false
           branch: gh-pages
diff --git a/.github/workflows/pr-commands.yaml b/.github/workflows/pr-commands.yaml
index 2edd93f27e..7b9913ea6f 100644
--- a/.github/workflows/pr-commands.yaml
+++ b/.github/workflows/pr-commands.yaml
@@ -18,7 +18,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: r-lib/actions/pr-fetch@v2
         with:
@@ -57,7 +57,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: r-lib/actions/pr-fetch@v2
         with:
diff --git a/.github/workflows/test-coverage.yaml b/.github/workflows/test-coverage.yaml
deleted file mode 100644
index 0ab748d657..0000000000
--- a/.github/workflows/test-coverage.yaml
+++ /dev/null
@@ -1,62 +0,0 @@
-# Workflow derived from https://github.com/r-lib/actions/tree/v2/examples
-# Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help
-on:
-  push:
-    branches: [main, master]
-  pull_request:
-
-name: test-coverage.yaml
-
-permissions: read-all
-
-jobs:
-  test-coverage:
-    runs-on: ubuntu-latest
-    env:
-      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: r-lib/actions/setup-r@v2
-        with:
-          use-public-rspm: true
-
-      - uses: r-lib/actions/setup-r-dependencies@v2
-        with:
-          extra-packages: any::covr, any::xml2
-          needs: coverage
-
-      - name: Test coverage
-        run: |
-          cov <- covr::package_coverage(
-            quiet = FALSE,
-            clean = FALSE,
-            install_path = file.path(normalizePath(Sys.getenv("RUNNER_TEMP"), winslash = "/"), "package")
-          )
-          print(cov)
-          covr::to_cobertura(cov)
-        shell: Rscript {0}
-
-      - uses: codecov/codecov-action@v5
-        with:
-          # Fail if error if not on PR, or if on PR and token is given
-          fail_ci_if_error: ${{ github.event_name != 'pull_request' || secrets.CODECOV_TOKEN }}
-          files: ./cobertura.xml
-          plugins: noop
-          disable_search: true
-          token: ${{ secrets.CODECOV_TOKEN }}
-
-      - name: Show testthat output
-        if: always()
-        run: |
-          ## --------------------------------------------------------------------
-          find '${{ runner.temp }}/package' -name 'testthat.Rout*' -exec cat '{}' \; || true
-        shell: bash
-
-      - name: Upload test results
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: coverage-test-failures
-          path: ${{ runner.temp }}/package
diff --git a/.gitignore b/.gitignore
index 7d2bc2a0ab..158cac957d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,8 @@
 /src/library/curl/tools/option_table.txt
 /src/library/jsonlite/src/yajl/libstatyajl.a
 /src/library/pkgdepends/man/macros/eval2.Rd
+/src/library/ts/man/macros/eval2.Rd
+/src/library/tstoml/man/macros/eval2.Rd
 /src/library/processx/src/supervisor/supervisor
 /src/library/processx/src/supervisor/supervisor.dSYM/
 /src/library/processx/src/tools/px
diff --git a/DESCRIPTION b/DESCRIPTION
index 8d4d6468d5..4db7c2fe36 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -113,11 +113,13 @@ Config/needs/dependencies:
     keyring,
     lpSolve,
     pkgbuild,
-    pkgcache,
-    pkgdepends,
+    r-lib/pkgcache@feature/ppm-sso,
+    r-lib/pkgdepends,
     pkgsearch,
     processx,
     ps,
+    r-lib/ts,
+    gaborcsardi/tstoml,
     yaml
 Config/Needs/website:
     r-lib/asciicast,
diff --git a/NAMESPACE b/NAMESPACE
index 289acb58a1..c825febc75 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -58,6 +58,9 @@ export(ppm_platforms)
 export(ppm_r_versions)
 export(ppm_repo_url)
 export(ppm_snapshots)
+export(ppm_sso_login)
+export(ppm_sso_logout)
+export(ppm_sso_status)
 export(repo_add)
 export(repo_auth)
 export(repo_auth_key_get)
diff --git a/R/auth.R b/R/auth.R
index f9e1771b5e..59b045158c 100644
--- a/R/auth.R
+++ b/R/auth.R
@@ -9,6 +9,8 @@
 #'
 #' ```{r child = "man/chunks/auth.Rmd"}
 #' ```
+#'
+#' @seealso [repo_auth()], [ppm_sso_login()].
 NULL
 
 #' Query or set repository password in the system credential store
diff --git a/R/embed.R b/R/embed.R
index f446c9861c..f42b516c4e 100644
--- a/R/embed.R
+++ b/R/embed.R
@@ -225,6 +225,15 @@ embed <- local({
     )
 
     lib <- lib_dir()
+
+    if (grepl("@", pkg)) {
+      pkgsplit <- strsplit(pkg, "@")[[1]]
+      pkg <- pkgsplit[1]
+      ref <- pkgsplit[2]
+    } else {
+      ref <- "main"
+    }
+
     pkg_name <- sub("^.*/", "", pkg)
     if (mode == "add") {
       if (file.exists(file.path(lib, pkg_name))) {
@@ -236,8 +245,9 @@ embed <- local({
     on.exit(unlink(tmp, recursive = TRUE), add = TRUE)
     if (grepl("/", pkg)) {
       url <- sprintf(
-        "https://github.com/%s/archive/refs/heads/main.tar.gz",
-        pkg
+        "https://github.com/%s/archive/refs/heads/%s.tar.gz",
+        pkg,
+        ref
       )
       path1 <- file.path(tmp, paste0(pkg_name, ".tar.gz"))
       download.file(url, path1)
@@ -303,6 +313,7 @@ embed <- local({
       rimraf(file.path(lib, pkg, "inst", "CITATION"))
       rimraf(file.path(lib, pkg, "MD5"))
       rimraf(file.path(lib, pkg, "README.md"))
+      rimraf(file.path(lib, pkg, "inst", "tsdocs"))
     }
   }
 
diff --git a/R/onload.R b/R/onload.R
index e3316cab4e..54c92a0c57 100644
--- a/R/onload.R
+++ b/R/onload.R
@@ -19,6 +19,7 @@ pkg_data <- new.env(parent = emptyenv())
     # We don't use the env vars that cli supports, on purpose, because
     # they are inherited in the subprocess of the subprocess
     options(
+      pak.is_worker = TRUE,
       cli.num_colors = as.numeric(Sys.getenv("R_PKG_NUM_COLORS", "1")),
       rlib_interactive = (Sys.getenv("R_PKG_INTERACTIVE") == "TRUE"),
       cli.dynamic = (Sys.getenv("R_PKG_DYNAMIC_TTY") == "TRUE")
diff --git a/R/ppm-sso.R b/R/ppm-sso.R
new file mode 100644
index 0000000000..829ace45fc
--- /dev/null
+++ b/R/ppm-sso.R
@@ -0,0 +1,114 @@
+#' Posit Package Manager single sign-on (SSO) authentication
+#'
+#' @details
+#' ## Set up SSO authentication:
+#' - Set the `PACKAGEMANAGER_ADDRESS` environment variable to the URL of
+#'   your RStudio Package Manager instance. For example, add this line to
+#'   your `.Renviron` file:
+#'   ```
+#'   PACKAGEMANAGER_ADDRESS=https://<ppm-url>
+#'   ```
+#'   Alternatively, you can also set it in your shell profile on Unix,
+#'   or in the System or User environment variables on Windows.
+#' - Set `options(repos)` to include a repository from your Package Manager
+#'   instance. Include `__token__` as the username in the URL. For example:
+#'   ```
+#'   options(repos = c(
+#'     PPM = "https://__token__@<ppm-url>/<repo-path>",
+#'     getOption("repos")
+#'   ))
+#'   ```
+#'   You probably want to add this to your `.Rprofile` file, so that it is
+#'   set in every R session.
+#' - Call [repo_get()] to trigger authentication and caching of the token.
+#'   You should be prompted to log in via your browser, and the obtained
+#'   token will be cached for future use. Call `ppm_sso_status()` to check
+#'   the status of your authentication, including the path of the cached
+#'   token and its expiration time.
+#' - Alternatively, you can call `ppm_sso_login()` directly to trigger
+#'   the login process directly.
+#'
+#' `ppm_sso_login()` initiates the SSO login process. You should be
+#' prompted to log in via your browser, and the obtained token will be
+#' cached for future use.
+#'
+#' @return `ppm_sso_login()` returns the obtained token invisibly.
+#'
+#' @seealso [Authenticated repositories],
+#'   <https://docs.posit.co/rspm/admin/authentication/>
+#' @export
+#' @examplesIf FALSE
+#' Sys.setenv(PACKAGEMANAGER_ADDRESS = "https://<ppm-url>")
+#' options(repos = c(
+#'   PPM = "https://__token__@<ppm-url>/<repo-path>",
+#'   getOption("repos")
+#' ))
+#' ppm_sso_login()
+#' ppm_sso_status()
+#' ppm_sso_status(connect = TRUE)
+#' ppm_sso_logout()
+
+ppm_sso_login <- function() {
+  res <- remote(
+    function() {
+      asNamespace("pkgcache")$ppm_sso_login()
+    },
+    list()
+  )
+  invisible(res)
+}
+
+#' @rdname ppm_sso_login
+#' @details
+#' `ppm_sso_logout()` removes the cached token, effectively logging you
+#' out. If there is no cached token, it does nothing.
+#' @return `ppm_sso_logout()` does not return anything.
+#' @export
+
+ppm_sso_logout <- function() {
+  res <- remote(
+    function() {
+      asNamespace("pkgcache")$ppm_sso_logout()
+    },
+    list()
+  )
+  invisible(res)
+}
+
+#' @rdname ppm_sso_login
+#' @param connect If `TRUE`, also checks if the token is valid by making a test
+#'   request to the Package Manager instance. This requires an active internet
+#'   connection and may take a few seconds. If `FALSE`, only checks if a
+#'   token is cached and not expired.
+#' @details
+#' `ppm_sso_status()` checks the status of your authentication, including
+#' the path of the cached token and its expiration time.
+#' @return `ppm_sso_status()` returns a list with the following components:
+#' - `ppm_url`: The URL of the Package Manager instance.
+#' - `token_file`: The path of the cached token file.
+#' - `token`: The cached token (partially masked for display) or `NA` if
+#'   no token is found locally.
+#' - `valid`: `TRUE` if the token is valid (only if `connect = TRUE`),
+#'   `FALSE` if invalid, or `NA` if not checked.
+#' - `issuer`: The issuer of the token, or `NA` if not available.
+#' - `subject`: The subject of the token, or `NA` if not available.
+#' - `audience`: The audience of the token, or `NA` if not available.
+#' - `issued_at`: The issue time of the token as a POSIXct object, or `NA`
+#'   if not available.
+#' - `expires_at`: The expiration time of the token as a POSIXct object,
+#'   or `NA`  if not available.
+#' - `expired`: `TRUE` if the token is expired, `FALSE` if not expired,
+#'   or `NA` if expiration time is not available.
+#' - `expires_in`: The time until expiration as a difftime object, or
+#'   `NA` if expiration time is not available or the token is already
+#'   expired.
+#' @export
+ppm_sso_status <- function(connect = FALSE) {
+  remote(
+    function(connect) {
+      ret <- asNamespace("pkgcache")$ppm_sso_status(connect)
+      asNamespace("pak")$pak_preformat(ret)
+    },
+    list(connect)
+  )
+}
diff --git a/R/subprocess.R b/R/subprocess.R
index 6cfe161695..f2e9e70b89 100644
--- a/R/subprocess.R
+++ b/R/subprocess.R
@@ -74,10 +74,12 @@ remote <- function(func, args = list()) {
   opts <- options()
   extraopts <- c("Ncpus", "BioC_mirror")
   pkg_options <- opts[
-    grepl("^pkg[.]", names(opts)) | grepl("^async_http_", names(opts)) | names(opts) %in% extraopts
+    grepl("^pkg[.]", names(opts)) |
+      grepl("^async_http_", names(opts)) |
+      names(opts) %in% extraopts
   ]
   envs <- Sys.getenv()
-  extraenvs <- c("R_BIOC_VERSION", "PATH")
+  extraenvs <- c("R_BIOC_VERSION", "PATH", "PACKAGEMANAGER_ADDRESS")
   if (any(grepl("@", subst_args[["__repos__"]]))) {
     extraenvs <- c(extraenvs, envs[grep("^https?://", names(envs))])
   }
diff --git a/_pkgdown.yml b/_pkgdown.yml
index 281d2d15f3..ce342445de 100644
--- a/_pkgdown.yml
+++ b/_pkgdown.yml
@@ -93,6 +93,9 @@ reference:
   - ppm_r_versions
   - ppm_repo_url
   - ppm_snapshots
+  - ppm_sso_login
+  - ppm_sso_logout
+  - ppm_sso_status
   - repo_add
   - repo_auth
   - repo_auth_key_get
diff --git a/inst/COPYRIGHTS b/inst/COPYRIGHTS
index 961c8a1b27..806b67403c 100644
--- a/inst/COPYRIGHTS
+++ b/inst/COPYRIGHTS
@@ -42,6 +42,18 @@ pak (c) 2017-2024 Posit Software, PBC (formerly RStudio)
 (c) Giampaolo Rodola
 (c) Posit Software, PBC (formerly RStudio)
 
+# ts
+
+(c) Gábor Csárdi
+(c) Tree-sitter authors
+(c) Posit Software, PBC (formerly RStudio)
+
+# tstoml
+
+(c) Gábor Csárdi
+(c) Tree-sitter authors
+(c) Posit Software, PBC (formerly RStudio)
+
 ## yaml
 
 (c) Shawn P Garbett
diff --git a/man/chunks/auth.Rmd b/man/chunks/auth.Rmd
index e643ad776a..2abdee9d39 100644
--- a/man/chunks/auth.Rmd
+++ b/man/chunks/auth.Rmd
@@ -1,6 +1,17 @@
 
 ## Configuring authenticated repositories
 
+\if{text}{
+  Note: the configuration of PPM SSO authentication is described in the
+  Posit Package Manager SSO authentication section below.
+}
+
+<blockquote>
+Note: the configuration of PPM SSO authentication is described in the
+<a href="#ppm-sso-auth">Posit Package Manager SSO authentication section
+below</a>.
+</blockquote>
+
 To use authentication you need to include a user name in the repository
 URL. You can set the repository URL in the `repos` option with
 [base::options()] as usual, or you can use [repo_add()].
@@ -224,3 +235,40 @@ meta_list()
 
 E.g. here `meta_update()` outputs an authentication message, but
 `meta_list()` does not.
+
+<a id="ppm-sso-auth"></a>
+## Posit Package Manager SSO authentication
+
+1. To set up PPM SSO authentication, set the `PACKAGEMANAGER_ADDRESS`
+environment variable to the URL of your RStudio Package Manager instance.
+For example, add this line to your `.Renviron` file:
+```
+PACKAGEMANAGER_ADDRESS=https://<ppm-url>
+```
+
+Alternatively, you can also set it in your shell profile on Unix,
+or in the System or User environment variables on Windows.
+
+2. Set `options(repos)` to include a repository from your Package Manager
+instance. Include `__token__` as the username in the URL. For example:
+```
+options(repos = c(
+  PPM = "https://__token__@<ppm-url>/<repo-path>",
+  getOption("repos")
+))
+```
+You probably want to add this to your `.Rprofile` file, so that it is set
+in every R session.
+
+3. Call [repo_get()] to trigger authentication and caching of the token.
+You should be prompted to log in via your browser, and the obtained
+token will be cached for future use. Call `ppm_sso_status()` to check
+the status of your authentication, including the path of the cached
+token and its expiration time.
+
+Alternatively, you can call `ppm_sso_login()` directly to trigger
+the login process directly.
+
+See also the [Authentication chapter](
+  https://docs.posit.co/rspm/admin/authentication/) of the
+Posit Package Manager Documentation.
diff --git a/man/ppm_sso_login.Rd b/man/ppm_sso_login.Rd
new file mode 100644
index 0000000000..c40b573eb7
--- /dev/null
+++ b/man/ppm_sso_login.Rd
@@ -0,0 +1,110 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/ppm-sso.R
+\name{ppm_sso_login}
+\alias{ppm_sso_login}
+\alias{ppm_sso_logout}
+\alias{ppm_sso_status}
+\title{Posit Package Manager single sign-on (SSO) authentication}
+\usage{
+ppm_sso_login()
+
+ppm_sso_logout()
+
+ppm_sso_status(connect = FALSE)
+}
+\arguments{
+\item{connect}{If \code{TRUE}, also checks if the token is valid by making a test
+request to the Package Manager instance. This requires an active internet
+connection and may take a few seconds. If \code{FALSE}, only checks if a
+token is cached and not expired.}
+}
+\value{
+\code{ppm_sso_login()} returns the obtained token invisibly.
+
+\code{ppm_sso_logout()} does not return anything.
+
+\code{ppm_sso_status()} returns a list with the following components:
+\itemize{
+\item \code{ppm_url}: The URL of the Package Manager instance.
+\item \code{token_file}: The path of the cached token file.
+\item \code{token}: The cached token (partially masked for display) or \code{NA} if
+no token is found locally.
+\item \code{valid}: \code{TRUE} if the token is valid (only if \code{connect = TRUE}),
+\code{FALSE} if invalid, or \code{NA} if not checked.
+\item \code{issuer}: The issuer of the token, or \code{NA} if not available.
+\item \code{subject}: The subject of the token, or \code{NA} if not available.
+\item \code{audience}: The audience of the token, or \code{NA} if not available.
+\item \code{issued_at}: The issue time of the token as a POSIXct object, or \code{NA}
+if not available.
+\item \code{expires_at}: The expiration time of the token as a POSIXct object,
+or \code{NA}  if not available.
+\item \code{expired}: \code{TRUE} if the token is expired, \code{FALSE} if not expired,
+or \code{NA} if expiration time is not available.
+\item \code{expires_in}: The time until expiration as a difftime object, or
+\code{NA} if expiration time is not available or the token is already
+expired.
+}
+}
+\description{
+Posit Package Manager single sign-on (SSO) authentication
+}
+\details{
+\subsection{Set up SSO authentication:}{
+\itemize{
+\item Set the \code{PACKAGEMANAGER_ADDRESS} environment variable to the URL of
+your RStudio Package Manager instance. For example, add this line to
+your \code{.Renviron} file:
+
+\if{html}{\out{<div class="sourceCode">}}\preformatted{PACKAGEMANAGER_ADDRESS=https://<ppm-url>
+}\if{html}{\out{</div>}}
+
+Alternatively, you can also set it in your shell profile on Unix,
+or in the System or User environment variables on Windows.
+\item Set \code{options(repos)} to include a repository from your Package Manager
+instance. Include \verb{__token__} as the username in the URL. For example:
+
+\if{html}{\out{<div class="sourceCode">}}\preformatted{options(repos = c(
+  PPM = "https://__token__@<ppm-url>/<repo-path>",
+  getOption("repos")
+))
+}\if{html}{\out{</div>}}
+
+You probably want to add this to your \code{.Rprofile} file, so that it is
+set in every R session.
+\item Call \code{\link[=repo_get]{repo_get()}} to trigger authentication and caching of the token.
+You should be prompted to log in via your browser, and the obtained
+token will be cached for future use. Call \code{ppm_sso_status()} to check
+the status of your authentication, including the path of the cached
+token and its expiration time.
+\item Alternatively, you can call \code{ppm_sso_login()} directly to trigger
+the login process directly.
+}
+
+\code{ppm_sso_login()} initiates the SSO login process. You should be
+prompted to log in via your browser, and the obtained token will be
+cached for future use.
+}
+
+\code{ppm_sso_logout()} removes the cached token, effectively logging you
+out. If there is no cached token, it does nothing.
+
+\code{ppm_sso_status()} checks the status of your authentication, including
+the path of the cached token and its expiration time.
+}
+\examples{
+\dontshow{if (FALSE) withAutoprint(\{ # examplesIf}
+Sys.setenv(PACKAGEMANAGER_ADDRESS = "https://<ppm-url>")
+options(repos = c(
+  PPM = "https://__token__@<ppm-url>/<repo-path>",
+  getOption("repos")
+))
+ppm_sso_login()
+ppm_sso_status()
+ppm_sso_status(connect = TRUE)
+ppm_sso_logout()
+\dontshow{\}) # examplesIf}
+}
+\seealso{
+\link{Authenticated repositories},
+\url{https://docs.posit.co/rspm/admin/authentication/}
+}
diff --git a/man/repo-auth.Rd b/man/repo-auth.Rd
index 280b7a5763..d77457cbbd 100644
--- a/man/repo-auth.Rd
+++ b/man/repo-auth.Rd
@@ -8,6 +8,18 @@ pak supports HTTP basic authentication when interacting with CRAN-like
 repositories.
 \subsection{Configuring authenticated repositories}{
 
+\if{text}{
+  Note: the configuration of PPM SSO authentication is described in the
+  Posit Package Manager SSO authentication section below.
+}\if{html}{\out{
+<blockquote>
+Note: the configuration of PPM SSO authentication is described in the
+<a href="#ppm-sso-auth">Posit Package Manager SSO authentication section
+below</a>.
+</blockquote>
+}}
+
+
 To use authentication you need to include a user name in the repository
 URL. You can set the repository URL in the \code{repos} option with
 \code{\link[base:options]{base::options()}} as usual, or you can use \code{\link[=repo_add]{repo_add()}}.
@@ -296,9 +308,53 @@ x Did not find credentials for repo <http://username@127.0.0.1:59571/>, keyring
 
 E.g. here \code{meta_update()} outputs an authentication message, but
 \code{meta_list()} does not.
+
+\if{html}{\out{<a id="ppm-sso-auth">}}\if{html}{\out{</a>}}
+}
+
+\subsection{Posit Package Manager SSO authentication}{
+\enumerate{
+\item To set up PPM SSO authentication, set the \code{PACKAGEMANAGER_ADDRESS}
+environment variable to the URL of your RStudio Package Manager instance.
+For example, add this line to your \code{.Renviron} file:
+}
+
+\if{html}{\out{<div class="sourceCode">}}\preformatted{PACKAGEMANAGER_ADDRESS=https://<ppm-url>
+}\if{html}{\out{</div>}}
+
+Alternatively, you can also set it in your shell profile on Unix,
+or in the System or User environment variables on Windows.
+\enumerate{
+\item Set \code{options(repos)} to include a repository from your Package Manager
+instance. Include \verb{__token__} as the username in the URL. For example:
+}
+
+\if{html}{\out{<div class="sourceCode">}}\preformatted{options(repos = c(
+  PPM = "https://__token__@<ppm-url>/<repo-path>",
+  getOption("repos")
+))
+}\if{html}{\out{</div>}}
+
+You probably want to add this to your \code{.Rprofile} file, so that it is set
+in every R session.
+\enumerate{
+\item Call \code{\link[=repo_get]{repo_get()}} to trigger authentication and caching of the token.
+You should be prompted to log in via your browser, and the obtained
+token will be cached for future use. Call \code{ppm_sso_status()} to check
+the status of your authentication, including the path of the cached
+token and its expiration time.
+}
+
+Alternatively, you can call \code{ppm_sso_login()} directly to trigger
+the login process directly.
+
+See also the \href{https://docs.posit.co/rspm/admin/authentication/}{Authentication chapter} of the
+Posit Package Manager Documentation.
 }
 }
 \seealso{
+\code{\link[=repo_auth]{repo_auth()}}, \code{\link[=ppm_sso_login]{ppm_sso_login()}}.
+
 Other authenticated repositories: 
 \code{\link{repo_auth}()},
 \code{\link{repo_auth_key_get}()}
diff --git a/src/dummy/ts/DESCRIPTION b/src/dummy/ts/DESCRIPTION
new file mode 100644
index 0000000000..833fb35e69
--- /dev/null
+++ b/src/dummy/ts/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: ts
+Version: 100.0.0
diff --git a/src/dummy/tstoml/DESCRIPTION b/src/dummy/tstoml/DESCRIPTION
new file mode 100644
index 0000000000..ef4e4038dd
--- /dev/null
+++ b/src/dummy/tstoml/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: tstoml
+Version: 100.0.0
diff --git a/src/install-embedded.R b/src/install-embedded.R
index 76a55ed9e2..70f306b24c 100644
--- a/src/install-embedded.R
+++ b/src/install-embedded.R
@@ -82,7 +82,10 @@ install_order <- function() {
     "jsonlite",
     "lpSolve",
     "ps",
+    "ts",
     "zip",
+    # ts
+    "tstoml",
     # ps, R6
     "processx",
     # processx, R6
@@ -91,7 +94,7 @@ install_order <- function() {
     "desc",
     # callr, cli, desc, processx, R6
     "pkgbuild",
-    # callr, cli, curl, filelock, jsonlite, prettyunis, processx, R6
+    # callr, cli, curl, filelock, jsonlite, prettyunis, processx, R6, ts, tstoml
     "pkgcache",
     # curl, jsonlite
     "pkgsearch",
diff --git a/src/library/pkgcache/DESCRIPTION b/src/library/pkgcache/DESCRIPTION
index 138a247828..8a0600c246 100644
--- a/src/library/pkgcache/DESCRIPTION
+++ b/src/library/pkgcache/DESCRIPTION
@@ -15,19 +15,21 @@ URL: https://r-lib.github.io/pkgcache/,
 BugReports: https://github.com/r-lib/pkgcache/issues
 Depends: R (>= 3.4)
 Imports: callr (>= 2.0.4.9000), cli (>= 3.2.0), curl (>= 3.2),
-        filelock, jsonlite, processx (>= 3.3.0.9001), R6, tools, utils
+        filelock, jsonlite, processx (>= 3.3.0.9001), R6, tools, ts,
+        tstoml, utils
 Suggests: covr, debugme, desc, fs, keyring, pillar, pingr, rprojroot,
         sessioninfo, spelling, testthat (>= 3.2.0), webfakes (>=
         1.1.5), withr, zip
+Remotes: r-lib/ts, gaborcsardi/tstoml
 Config/Needs/website: tidyverse/tidytemplate
 Config/testthat/edition: 3
 Config/usethis/last-upkeep: 2025-04-30
 Encoding: UTF-8
 Language: en-US
 Roxygen: list(markdown = TRUE, r6 = FALSE)
-RoxygenNote: 7.3.2.9000
+RoxygenNote: 7.3.3
 NeedsCompilation: yes
-Packaged: 2026-04-22 20:18:20 UTC; gaborcsardi
+Packaged: 2026-05-13 12:32:46 UTC; gaborcsardi
 Author: Gábor Csárdi [aut, cre],
   Posit Software, PBC [cph, fnd] (ROR: <https://ror.org/03wc8by49>)
 Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
diff --git a/src/library/pkgcache/NAMESPACE b/src/library/pkgcache/NAMESPACE
index 6635a11224..ff8464fa86 100644
--- a/src/library/pkgcache/NAMESPACE
+++ b/src/library/pkgcache/NAMESPACE
@@ -1,7 +1,9 @@
 # Generated by roxygen2: do not edit by hand
 
 S3method("[",pkgcache_repo_status_summary)
+S3method(format,ppm_sso_status)
 S3method(print,pkgcache_repo_status_summary)
+S3method(print,ppm_sso_status)
 S3method(summary,pkgcache_repo_status)
 export(bioc_devel_version)
 export(bioc_release_version)
@@ -41,6 +43,9 @@ export(ppm_platforms)
 export(ppm_r_versions)
 export(ppm_repo_url)
 export(ppm_snapshots)
+export(ppm_sso_login)
+export(ppm_sso_logout)
+export(ppm_sso_status)
 export(repo_add)
 export(repo_auth)
 export(repo_get)
diff --git a/src/library/pkgcache/R/aa-assertthat.R b/src/library/pkgcache/R/aa-assertthat.R
index 5d1d49007d..9beb8eef10 100644
--- a/src/library/pkgcache/R/aa-assertthat.R
+++ b/src/library/pkgcache/R/aa-assertthat.R
@@ -1,6 +1,8 @@
 assert_that <- function(..., env = parent.frame(), msg = NULL) {
   res <- see_if(..., env = env, msg = msg)
-  if (res) return(TRUE)
+  if (res) {
+    return(TRUE)
+  }
 
   throw(new_assert_error(attr(res, "msg")))
 }
@@ -27,7 +29,9 @@ see_if <- function(..., env = parent.frame(), msg = NULL) {
 
     # Failed, so figure out message to produce
     if (!res) {
-      if (is.null(msg)) msg <- get_message(res, assertion, env)
+      if (is.null(msg)) {
+        msg <- get_message(res, assertion, env)
+      }
       return(structure(FALSE, msg = msg))
     }
   }
@@ -36,12 +40,14 @@ see_if <- function(..., env = parent.frame(), msg = NULL) {
 }
 
 check_result <- function(x) {
-  if (!is.logical(x))
+  if (!is.logical(x)) {
     throw(new_assert_error(
       "assert_that: assertion must return a logical value"
     ))
-  if (any(is.na(x)))
+  }
+  if (any(is.na(x))) {
     throw(new_assert_error("assert_that: missing values present in assertion"))
+  }
   if (length(x) != 1) {
     throw(new_assert_error("assert_that: length of assertion is not 1"))
   }
@@ -57,7 +63,9 @@ get_message <- function(res, call, env = parent.frame()) {
   }
 
   f <- eval(call[[1]], env)
-  if (!is.primitive(f)) call <- match.call(f, call)
+  if (!is.primitive(f)) {
+    call <- match.call(f, call)
+  }
   fname <- deparse(call[[1]])
 
   fail <- on_failure(f) %||% base_fs[[fname]] %||% fail_default
diff --git a/src/library/pkgcache/R/aaa-async.R b/src/library/pkgcache/R/aaa-async.R
index 2227751ab4..d2d6640996 100644
--- a/src/library/pkgcache/R/aaa-async.R
+++ b/src/library/pkgcache/R/aaa-async.R
@@ -22,7 +22,9 @@
 
 async <- function(fun) {
   fun <- as.function(fun)
-  if (is_async(fun)) return(fun)
+  if (is_async(fun)) {
+    return(fun)
+  }
 
   async_fun <- fun
   body(async_fun) <- bquote({
@@ -339,7 +341,9 @@ get_default_event_loop <- function() {
 
 push_event_loop <- function() {
   num_loops <- length(async_env$loops)
-  if (num_loops > 0) async_env$loops[[num_loops]]$suspend()
+  if (num_loops > 0) {
+    async_env$loops[[num_loops]]$suspend()
+  }
   new_el <- event_loop$new()
   async_env$loops <- c(async_env$loops, list(new_el))
   new_el
@@ -453,7 +457,9 @@ NULL
 
 async_next <- function(el = NULL) {
   el <- el %||% find_sync_frame()$new_el
-  if (is.null(el)) stop("No async context")
+  if (is.null(el)) {
+    stop("No async context")
+  }
   ## TODO: some visual indication that something has happened?
   if (!el$run("once")) message("[ASYNC] async phase complete")
 }
@@ -466,7 +472,9 @@ async_next <- function(el = NULL) {
 
 async_step <- function() {
   el <- find_sync_frame()$new_el
-  if (is.null(el)) stop("No async context")
+  if (is.null(el)) {
+    stop("No async context")
+  }
   ## TODO: some visual indication that something has happened?
   old <- options(async_debug_steps = TRUE)
   on.exit(options(old))
@@ -492,7 +500,9 @@ async_step_back <- function() {
 
 async_list <- function(def = NULL) {
   def <- def %||% find_sync_frame()$res
-  if (is.null(def)) stop("No async context")
+  if (is.null(def)) {
+    stop("No async context")
+  }
   info <- list()
   find_parents <- function(def) {
     info <<- c(info, list(get_private(def)$get_info()))
@@ -520,7 +530,9 @@ async_tree <- function(def = NULL) {
 
 async_debug <- function(id, action = TRUE, parent = TRUE) {
   def <- find_deferred(id)
-  if (is.null(def)) stop("Cannot find deferred `", id, "`")
+  if (is.null(def)) {
+    stop("Cannot find deferred `", id, "`")
+  }
   prv <- get_private(def)
 
   if (prv$state != "pending") {
@@ -563,11 +575,17 @@ async_debug <- function(id, action = TRUE, parent = TRUE) {
 
 async_wait_for <- function(id) {
   el <- find_sync_frame()$new_el
-  if (is.null(el)) stop("No async context")
+  if (is.null(el)) {
+    stop("No async context")
+  }
   def <- find_deferred(id)
-  if (is.null(def)) stop("Cannot find deferred `", id, "`")
+  if (is.null(def)) {
+    stop("Cannot find deferred `", id, "`")
+  }
   priv <- get_private(def)
-  while (priv$state == "pending") el$run("once")
+  while (priv$state == "pending") {
+    el$run("once")
+  }
   message("[ASYNC] ", id, "  resolved")
 }
 
@@ -684,9 +702,13 @@ find_async_data_frame <- function() {
 
 find_deferred <- function(id, def = NULL) {
   def <- def %||% find_sync_frame()$res
-  if (is.null(def)) stop("No async context")
+  if (is.null(def)) {
+    stop("No async context")
+  }
   search_parents <- function(def) {
-    if (get_private(def)$id == id) return(def)
+    if (get_private(def)$id == id) {
+      return(def)
+    }
     prn <- get_private(def)$parents
     for (p in lapply(prn, search_parents)) {
       if (!is.null(p)) return(p)
@@ -1132,7 +1154,7 @@ deferred <- R6Class(
       type = NULL,
       call = sys.call(-1),
       event_emitter = NULL
-    )
+    ) {
       async_def_init(
         self,
         private,
@@ -1145,7 +1167,8 @@ deferred <- R6Class(
         type,
         call,
         event_emitter
-      ),
+      )
+    },
     then = function(on_fulfilled) def_then(self, private, on_fulfilled),
     catch = function(...) def_catch(self, private, ...),
     finally = function(on_finally) def_finally(self, private, on_finally),
@@ -1185,14 +1208,17 @@ deferred <- R6Class(
     reject = function(reason) def__reject(self, private, reason),
     progress = function(data) def__progress(self, private, data),
 
-    make_error_object = function(err)
-      def__make_error_object(self, private, err),
+    make_error_object = function(err) {
+      def__make_error_object(self, private, err)
+    },
 
-    maybe_cancel_parents = function(reason)
-      def__maybe_cancel_parents(self, private, reason),
+    maybe_cancel_parents = function(reason) {
+      def__maybe_cancel_parents(self, private, reason)
+    },
     add_as_parent = function(child) def__add_as_parent(self, private, child),
-    update_parent = function(old, new)
-      def__update_parent(self, private, old, new),
+    update_parent = function(old, new) {
+      def__update_parent(self, private, old, new)
+    },
 
     get_info = function() def__get_info(self, private)
   )
@@ -1240,7 +1266,9 @@ async_def_init <- function(
 }
 
 def__run_action <- function(self, private) {
-  if (private$running) return()
+  if (private$running) {
+    return()
+  }
   action <- private$action
   private$running <- TRUE
   private$action <- NULL
@@ -1261,7 +1289,9 @@ def__run_action <- function(self, private) {
 
     private$event_loop$add_next_tick(
       function() {
-        if (isTRUE(getOption("async_debug_steps", FALSE))) debug1(action)
+        if (isTRUE(getOption("async_debug_steps", FALSE))) {
+          debug1(action)
+        }
         `__async_data__` <- list(private$id, "action", self, skip = 2L)
         do.call(action, args)
       },
@@ -1275,8 +1305,11 @@ def__run_action <- function(self, private) {
     prt_priv <- get_private(prt)
     if (prt_priv$state != "pending") {
       def__call_then(
-        if (prt_priv$state == "fulfilled") "parent_resolve" else
-          "parent_reject",
+        if (prt_priv$state == "fulfilled") {
+          "parent_resolve"
+        } else {
+          "parent_reject"
+        },
         self,
         prt_priv$value
       )
@@ -1337,7 +1370,9 @@ def_finally <- function(self, private, on_finally) {
 }
 
 def_cancel <- function(self, private, reason) {
-  if (private$state != "pending") return()
+  if (private$state != "pending") {
+    return()
+  }
   cancel_cond <- structure(
     list(message = reason %||% "Deferred computation cancelled", call = NULL),
     class = c("async_cancelled", "error", "condition")
@@ -1352,8 +1387,12 @@ def__null <- function(self, private) {
 }
 
 def__resolve <- function(self, private, value) {
-  if (private$cancelled) return()
-  if (private$state != "pending") return()
+  if (private$cancelled) {
+    return()
+  }
+  if (private$state != "pending") {
+    return()
+  }
 
   if (is_deferred(value)) {
     private$parent_resolve <- def__make_parent_resolve(NULL)
@@ -1460,8 +1499,12 @@ def__make_parent_reject_catch <- function(handlers) {
 }
 
 def__reject <- function(self, private, reason) {
-  if (private$cancelled) return()
-  if (private$state != "pending") return()
+  if (private$cancelled) {
+    return()
+  }
+  if (private$state != "pending") {
+    return()
+  }
 
   ## 'reason' cannot be a deferred here
 
@@ -1483,11 +1526,17 @@ def__reject <- function(self, private, reason) {
 
 def__maybe_cancel_parents <- function(self, private, reason) {
   for (parent in private$parents) {
-    if (is.null(parent)) next
+    if (is.null(parent)) {
+      next
+    }
 
     parent_priv <- get_private(parent)
-    if (parent_priv$state != "pending") next
-    if (parent_priv$shared) next
+    if (parent_priv$state != "pending") {
+      next
+    }
+    if (parent_priv$shared) {
+      next
+    }
     parent$cancel(reason)
   }
 }
@@ -1495,8 +1544,12 @@ def__maybe_cancel_parents <- function(self, private, reason) {
 def__call_then <- function(which, x, value) {
   force(value)
   private <- get_private(x)
-  if (!private$running) return()
-  if (private$state != "pending") return()
+  if (!private$running) {
+    return()
+  }
+  if (private$state != "pending") {
+    return()
+  }
 
   cb <- private[[which]]
   private$event_loop$add_next_tick(
@@ -1527,7 +1580,9 @@ def__add_as_parent <- function(self, private, child) {
 
   private$children <- c(private$children, child)
 
-  if (get_private(child)$running) private$run_action()
+  if (get_private(child)$running) {
+    private$run_action()
+  }
   if (private$state == "pending") {
     ## Nothing to do
   } else if (private$state == "fulfilled") {
@@ -1549,8 +1604,12 @@ def__update_parent <- function(self, private, old, new) {
 }
 
 def__progress <- function(self, private, data) {
-  if (private$state != "pending") return()
-  if (is.null(private$progress_callback)) return()
+  if (private$state != "pending") {
+    return()
+  }
+  if (is.null(private$progress_callback)) {
+    return()
+  }
   private$progress_callback(data)
 }
 
@@ -1767,34 +1826,48 @@ event_loop <- R6Class(
       file = NULL,
       progress = NULL,
       data = NULL
-    ) el_add_http(self, private, handle, callback, file, progress, data),
-    http_setopt = function(total_con = NULL, host_con = NULL, multiplex = NULL)
-      el_http_setopt(self, private, total_con, host_con, multiplex),
-
-    add_process = function(conns, callback, data)
-      el_add_process(self, private, conns, callback, data),
-    add_r_process = function(conns, callback, data)
-      el_add_r_process(self, private, conns, callback, data),
-    add_pool_task = function(callback, data)
-      el_add_pool_task(self, private, callback, data),
-    add_delayed = function(delay, func, callback, rep = FALSE)
-      el_add_delayed(self, private, delay, func, callback, rep),
-    add_next_tick = function(func, callback, data = NULL)
-      el_add_next_tick(self, private, func, callback, data),
+    ) {
+      el_add_http(self, private, handle, callback, file, progress, data)
+    },
+    http_setopt = function(
+      total_con = NULL,
+      host_con = NULL,
+      multiplex = NULL
+    ) {
+      el_http_setopt(self, private, total_con, host_con, multiplex)
+    },
+
+    add_process = function(conns, callback, data) {
+      el_add_process(self, private, conns, callback, data)
+    },
+    add_r_process = function(conns, callback, data) {
+      el_add_r_process(self, private, conns, callback, data)
+    },
+    add_pool_task = function(callback, data) {
+      el_add_pool_task(self, private, callback, data)
+    },
+    add_delayed = function(delay, func, callback, rep = FALSE) {
+      el_add_delayed(self, private, delay, func, callback, rep)
+    },
+    add_next_tick = function(func, callback, data = NULL) {
+      el_add_next_tick(self, private, func, callback, data)
+    },
 
     cancel = function(id) el_cancel(self, private, id),
     cancel_all = function() el_cancel_all(self, private),
 
-    run = function(mode = c("default", "nowait", "once"))
-      el_run(self, private, mode = match.arg(mode)),
+    run = function(mode = c("default", "nowait", "once")) {
+      el_run(self, private, mode = match.arg(mode))
+    },
 
     suspend = function() el_suspend(self, private),
     wakeup = function() el_wakeup(self, private)
   ),
 
   private = list(
-    create_task = function(callback, ..., id = NULL, type = "foobar")
-      el__create_task(self, private, callback, ..., id = id, type = type),
+    create_task = function(callback, ..., id = NULL, type = "foobar") {
+      el__create_task(self, private, callback, ..., id = id, type = type)
+    },
     ensure_pool = function() el__ensure_pool(self, private),
     get_poll_timeout = function() el__get_poll_timeout(self, private),
     run_pending = function() el__run_pending(self, private),
@@ -1839,7 +1912,9 @@ el_add_http <- function(self, private, handle, callback, progress, file, data) {
     type = "http"
   )
   private$ensure_pool()
-  if (!is.null(outfile)) cat("", file = outfile)
+  if (!is.null(outfile)) {
+    cat("", file = outfile)
+  }
 
   content <- NULL
 
@@ -1994,7 +2069,9 @@ el_run <- function(self, private, mode) {
   ## because some time we might switch to that.
 
   alive <- private$is_alive()
-  if (!alive) private$update_time()
+  if (!alive) {
+    private$update_time()
+  }
 
   while (alive && !private$stop_flag) {
     private$update_time()
@@ -2229,8 +2306,12 @@ el__create_task <- function(self, private, callback, data, ..., id, type) {
 el__ensure_pool <- function(self, private) {
   getopt <- function(nm) {
     anm <- paste0("async_http_", nm)
-    if (!is.null(v <- getOption(anm))) return(v)
-    if (!is.na(v <- Sys.getenv(toupper(anm), NA_character_))) return(v)
+    if (!is.null(v <- getOption(anm))) {
+      return(v)
+    }
+    if (!is.na(v <- Sys.getenv(toupper(anm), NA_character_))) {
+      return(v)
+    }
     NULL
   }
   if (is.null(private$pool)) {
@@ -2249,9 +2330,15 @@ el__ensure_pool <- function(self, private) {
 
 el_http_setopt <- function(self, private, total_con, host_con, multiplex) {
   private$ensure_pool()
-  if (!is.null(total_con)) private$http_opts$total_con <- total_con
-  if (!is.null(host_con)) private$http_opts$host_con <- host_con
-  if (!is.null(multiplex)) private$http_opts$multiplex <- multiplex
+  if (!is.null(total_con)) {
+    private$http_opts$total_con <- total_con
+  }
+  if (!is.null(host_con)) {
+    private$http_opts$host_con <- host_con
+  }
+  if (!is.null(multiplex)) {
+    private$http_opts$multiplex <- multiplex
+  }
   curl::multi_set(
     pool = private$pool,
     total_con = private$http_opts$total_con,
@@ -2401,24 +2488,29 @@ event_emitter <- R6Class(
   public = list(
     initialize = function(async = TRUE) ee_init(self, private, async),
 
-    listen_on = function(event, callback)
-      ee_listen_on(self, private, event, callback),
+    listen_on = function(event, callback) {
+      ee_listen_on(self, private, event, callback)
+    },
 
-    listen_off = function(event, callback)
-      ee_listen_off(self, private, event, callback),
+    listen_off = function(event, callback) {
+      ee_listen_off(self, private, event, callback)
+    },
 
-    listen_once = function(event, callback)
-      ee_listen_once(self, private, event, callback),
+    listen_once = function(event, callback) {
+      ee_listen_once(self, private, event, callback)
+    },
 
     emit = function(event, ...) ee_emit(self, private, event, ...),
 
     get_event_names = function() ee_get_event_names(self, private),
 
-    get_listener_count = function(event)
-      ee_get_listener_count(self, private, event),
+    get_listener_count = function(event) {
+      ee_get_listener_count(self, private, event)
+    },
 
-    remove_all_listeners = function(event)
+    remove_all_listeners = function(event) {
       ee_remove_all_listeners(self, private, event)
+    }
   ),
 
   private = list(
@@ -2426,8 +2518,9 @@ event_emitter <- R6Class(
     async = NULL,
 
     cleanup_events = function() ee__cleanup_events(self, private),
-    error_callback = function(err, res)
+    error_callback = function(err, res) {
       ee__error_callback(self, private, err, res)
+    }
   )
 )
 
@@ -2468,7 +2561,9 @@ ee_emit <- function(self, private, event, ...) {
   list(...)
   tocall <- private$lsts[[event]]
   once <- vlapply(tocall, "[[", "once")
-  if (any(once)) private$lsts[[event]] <- tocall[!once]
+  if (any(once)) {
+    private$lsts[[event]] <- tocall[!once]
+  }
 
   ## a for loop is not good here, because it does not create
   ## a closure for lst
@@ -2514,13 +2609,19 @@ ee__cleanup_events <- function(self, private) {
 }
 
 ee__error_callback <- function(self, private, err, res) {
-  if (is.null(err)) return()
+  if (is.null(err)) {
+    return()
+  }
   tocall <- private$lsts[["error"]]
   once <- vlapply(tocall, "[[", "once")
-  if (any(once)) private$lsts[["error"]] <- tocall[!once]
+  if (any(once)) {
+    private$lsts[["error"]] <- tocall[!once]
+  }
 
   if (length(tocall)) {
-    for (lst in tocall) lst$cb(err)
+    for (lst in tocall) {
+      lst$cb(err)
+    }
   } else {
     stop(err)
   }
@@ -3012,7 +3113,9 @@ http_post <- function(
   if (!is.null(data_file)) {
     data <- readBin(data_file, "raw", file.size(data_file))
   }
-  if (!is.null(data) && !is.raw(data)) data <- charToRaw(data)
+  if (!is.null(data) && !is.raw(data)) {
+    data <- charToRaw(data)
+  }
   options <- get_default_curl_options(options)
 
   make_deferred_http(
@@ -3066,9 +3169,13 @@ http_delete <- mark_as_async(http_delete)
 
 get_default_curl_options <- function(options) {
   getopt <- function(nm) {
-    if (!is.null(v <- options[[nm]])) return(v)
+    if (!is.null(v <- options[[nm]])) {
+      return(v)
+    }
     anm <- paste0("async_http_", nm)
-    if (!is.null(v <- getOption(anm))) return(v)
+    if (!is.null(v <- getOption(anm))) {
+      return(v)
+    }
     if (!is.na(v <- Sys.getenv(toupper(anm), NA_character_))) return(v)
   }
   modifyList(
@@ -3156,8 +3263,12 @@ make_deferred_http <- function(cb, file) {
 #' }
 
 http_stop_for_status <- function(resp) {
-  if (!is.integer(resp$status_code)) stop("Not an HTTP response")
-  if (resp$status_code < 400) return(invisible(resp))
+  if (!is.integer(resp$status_code)) {
+    stop("Not an HTTP response")
+  }
+  if (resp$status_code < 400) {
+    return(invisible(resp))
+  }
   stop(http_error(resp))
 }
 
@@ -3805,11 +3916,15 @@ async_retryable <- function(task, times) {
 
 async_sequence <- function(..., .list = NULL) {
   funcs <- c(list(...), .list)
-  if (length(funcs) == 0) stop("Function list empty in `async_sequence`")
+  if (length(funcs) == 0) {
+    stop("Function list empty in `async_sequence`")
+  }
 
   function(...) {
     dx <- async(funcs[[1]])(...)
-    for (i in seq_along(funcs)[-1]) dx <- dx$then(funcs[[i]])
+    for (i in seq_along(funcs)[-1]) {
+      dx <- dx$then(funcs[[i]])
+    }
     dx
   }
 }
@@ -3891,7 +4006,9 @@ synchronise <- function(expr) {
 
   res <- expr
 
-  if (!is_deferred(res)) return(res)
+  if (!is_deferred(res)) {
+    return(res)
+  }
 
   ## We need an extra final promise that cannot be replaced,
   ## so priv stays the same.
@@ -3909,8 +4026,12 @@ synchronise <- function(expr) {
   priv$null()
   priv$run_action()
 
-  if (isTRUE(getOption("async_debug"))) start_browser()
-  while (priv$state == "pending") new_el$run("once")
+  if (isTRUE(getOption("async_debug"))) {
+    start_browser()
+  }
+  while (priv$state == "pending") {
+    new_el$run("once")
+  }
 
   if (priv$state == "fulfilled") priv$value else stop(priv$value)
 }
@@ -3984,7 +4105,9 @@ run_event_loop <- function(expr) {
 }
 
 distill_error <- function(err) {
-  if (is.null(err$aframe)) return(err)
+  if (is.null(err$aframe)) {
+    return(err)
+  }
   err$aframe <- list(
     frame = err$aframe$frame,
     deferred = err$aframe$data[[1]],
@@ -4214,8 +4337,9 @@ async_timer <- R6Class(
   "async_timer",
   inherit = event_emitter,
   public = list(
-    initialize = function(delay, callback)
-      async_timer_init(self, private, super, delay, callback),
+    initialize = function(delay, callback) {
+      async_timer_init(self, private, super, delay, callback)
+    },
     cancel = function() async_timer_cancel(self, private)
   ),
 
@@ -4290,7 +4414,9 @@ async_try_each <- function(..., .list = list()) {
     call = sys.call(),
     action = function(resolve) {
       nx <<- length(defs)
-      if (nx == 0) resolve(NULL)
+      if (nx == 0) {
+        resolve(NULL)
+      }
       wh <<- 1L
       defs[[wh]]$then(self)
     },
@@ -4414,7 +4540,9 @@ call_with_callback <- function(func, callback, info = NULL) {
         recerror <<- e
         recerror$aframe <<- recerror$aframe %||% find_async_data_frame()
         recerror$calls <<- recerror$calls %||% sys.calls()
-        if (is.null(recerror[["call"]])) recerror[["call"]] <<- sys.call()
+        if (is.null(recerror[["call"]])) {
+          recerror[["call"]] <<- sys.call()
+        }
         recerror$parents <<- recerror$parents %||% sys.parents()
         recerror[names(info)] <<- info
         handler <- getOption("async.error")
@@ -4471,7 +4599,9 @@ file_size <- function(...) {
 }
 
 read_all <- function(filename, encoding) {
-  if (is.null(filename)) return(NULL)
+  if (is.null(filename)) {
+    return(NULL)
+  }
   r <- readBin(filename, what = raw(0), n = file_size(filename))
   s <- rawToChar(r)
   Encoding(s) <- encoding
@@ -4739,21 +4869,24 @@ NULL
 worker_pool <- R6Class(
   public = list(
     initialize = function() wp_init(self, private),
-    add_task = function(func, args, id, event_loop)
-      wp_add_task(self, private, func, args, id, event_loop),
+    add_task = function(func, args, id, event_loop) {
+      wp_add_task(self, private, func, args, id, event_loop)
+    },
     get_fds = function() wp_get_fds(self, private),
     get_pids = function() wp_get_pids(self, private),
     get_poll_connections = function() wp_get_poll_connections(self, private),
-    notify_event = function(pids, event_loop)
-      wp_notify_event(self, private, pids, event_loop),
+    notify_event = function(pids, event_loop) {
+      wp_notify_event(self, private, pids, event_loop)
+    },
     start_workers = function() wp_start_workers(self, private),
     kill_workers = function() wp_kill_workers(self, private),
     cancel_task = function(id) wp_cancel_task(self, private, id),
     cancel_all_tasks = function() wp_cancel_all_tasks(self, private),
     get_result = function(id) wp_get_result(self, private, id),
     list_workers = function() wp_list_workers(self, private),
-    list_tasks = function(event_loop = NULL, status = NULL)
+    list_tasks = function(event_loop = NULL, status = NULL) {
       wp_list_tasks(self, private, event_loop, status)
+    }
   ),
 
   private = list(
@@ -4775,7 +4908,9 @@ wp_start_workers <- function(self, private) {
   num <- worker_pool_size()
 
   ## See if we need to start more
-  if (NROW(private$workers) >= num) return(invisible())
+  if (NROW(private$workers) >= num) {
+    return(invisible())
+  }
 
   ## Yeah, start some more
   to_start <- num - NROW(private$workers)
@@ -4842,11 +4977,17 @@ wp_notify_event <- function(self, private, pids, event_loop) {
   which <- match(pids, private$workers$pid)
   for (w in which) {
     msg <- private$workers$session[[w]]$read()
-    if (is.null(msg)) next
+    if (is.null(msg)) {
+      next
+    }
     if (msg$code == 200 || (msg$code >= 500 && msg$code < 600)) {
-      if (msg$code >= 500 && msg$code < 600) dead <- c(dead, w)
+      if (msg$code >= 500 && msg$code < 600) {
+        dead <- c(dead, w)
+      }
       wt <- match(private$workers$task[[w]], private$tasks$id)
-      if (is.na(wt)) stop("Internal error, no such task")
+      if (is.na(wt)) {
+        stop("Internal error, no such task")
+      }
       private$tasks$result[[wt]] <- msg
       private$tasks$status[[wt]] <- "done"
       private$workers$task[[w]] <- NA_character_
@@ -4876,7 +5017,9 @@ wp_kill_workers <- function(self, private) {
 
 wp_cancel_task <- function(self, private, id) {
   wt <- match(id, private$tasks$id)
-  if (is.na(wt)) stop("Unknown task")
+  if (is.na(wt)) {
+    stop("Unknown task")
+  }
 
   if (private$tasks$status[[wt]] == "running") {
     wk <- match(id, private$workers$task)
@@ -4892,9 +5035,13 @@ wp_cancel_all_tasks <- function(self, private) {
 
 wp_get_result <- function(self, private, id) {
   wt <- match(id, private$tasks$id)
-  if (is.na(wt)) stop("Unknown task")
+  if (is.na(wt)) {
+    stop("Unknown task")
+  }
 
-  if (private$tasks$status[[wt]] != "done") stop("Task not done yet")
+  if (private$tasks$status[[wt]] != "done") {
+    stop("Task not done yet")
+  }
   result <- private$tasks$result[[wt]]
   private$tasks <- private$tasks[-wt, ]
   result
@@ -4907,8 +5054,12 @@ wp_list_workers <- function(self, private) {
 wp_list_tasks <- function(self, private, event_loop, status) {
   dont_show <- c("func", "args", "result")
   ret <- private$tasks
-  if (!is.null(event_loop)) ret <- ret[ret$event_loop %in% event_loop, ]
-  if (!is.null(status)) ret <- ret[ret$status %in% status, ]
+  if (!is.null(event_loop)) {
+    ret <- ret[ret$event_loop %in% event_loop, ]
+  }
+  if (!is.null(status)) {
+    ret <- ret[ret$status %in% status, ]
+  }
   ret[, setdiff(colnames(private$tasks), dont_show)]
 }
 
@@ -4918,7 +5069,9 @@ wp_list_tasks <- function(self, private, event_loop, status) {
 
 wp__try_start <- function(self, private) {
   sts <- vcapply(private$workers$session, function(x) x$get_state())
-  if (all(sts != "idle")) return()
+  if (all(sts != "idle")) {
+    return()
+  }
   can_work <- sts == "idle"
 
   can_run <- private$tasks$status == "waiting"
@@ -4971,7 +5124,9 @@ wp__try_start <- function(self, private) {
 
 wp__interrupt_worker <- function(self, private, pid) {
   ww <- match(pid, private$workers$pid)
-  if (is.na(ww)) stop("Unknown task in interrupt_worker() method")
+  if (is.na(ww)) {
+    stop("Unknown task in interrupt_worker() method")
+  }
 
   kill <- FALSE
   sess <- private$workers$session[[ww]]
diff --git a/src/library/pkgcache/R/aaa-rstudio-detect.R b/src/library/pkgcache/R/aaa-rstudio-detect.R
index 1428330e86..5d7d0084cf 100644
--- a/src/library/pkgcache/R/aaa-rstudio-detect.R
+++ b/src/library/pkgcache/R/aaa-rstudio-detect.R
@@ -51,8 +51,12 @@ rstudio <- local({
     }
 
     # Cached?
-    if (clear_cache) data <<- NULL
-    if (!is.null(data)) return(get_caps(data))
+    if (clear_cache) {
+      data <<- NULL
+    }
+    if (!is.null(data)) {
+      return(get_caps(data))
+    }
 
     if (
       (rspid <- Sys.getenv("RSTUDIO_SESSION_PID")) != "" &&
@@ -86,7 +90,9 @@ rstudio <- local({
     pane <- Sys.getenv("RSTUDIO_CHILD_PROCESS_PANE")
 
     # this should not happen, but be defensive and fall back
-    if (pane == "") return(detect_old(clear_cache))
+    if (pane == "") {
+      return(detect_old(clear_cache))
+    }
 
     # direct subprocess
     new$type <- if (rspid == parentpid) {
@@ -175,7 +181,9 @@ rstudio <- local({
     }
 
     installing <- Sys.getenv("R_PACKAGE_DIR", "")
-    if (cache && installing == "") data <<- new
+    if (cache && installing == "") {
+      data <<- new
+    }
 
     get_caps(new)
   }
diff --git a/src/library/pkgcache/R/archive.R b/src/library/pkgcache/R/archive.R
index ed5e6eaefb..2c739d2deb 100644
--- a/src/library/pkgcache/R/archive.R
+++ b/src/library/pkgcache/R/archive.R
@@ -101,7 +101,7 @@ cran_archive_cache <- R6Class(
       replica_path = tempfile(),
       cran_mirror = default_cran_mirror(),
       update_after = as.difftime(7, units = "days")
-    )
+    ) {
       cac_init(
         self,
         private,
@@ -109,17 +109,20 @@ cran_archive_cache <- R6Class(
         replica_path,
         cran_mirror,
         update_after
-      ),
+      )
+    },
 
-    list = function(packages = NULL, update_after = NULL)
-      synchronise(self$async_list(packages, update_after)),
-    async_list = function(packages = NULL, update_after = NULL)
+    list = function(packages = NULL, update_after = NULL) {
+      synchronise(self$async_list(packages, update_after))
+    },
+    async_list = function(packages = NULL, update_after = NULL) {
       cac_async_list(
         self,
         private,
         packages,
         update_after %||% private$update_after
-      ),
+      )
+    },
 
     update = function() synchronise(self$async_update()),
     async_update = function() cac_async_update(self, private),
@@ -136,25 +139,31 @@ cran_archive_cache <- R6Class(
     get_hash = function() {
       cli::hash_obj_md5(list(private$cran_mirror, private$cache_version))
     },
-    get_cache_file = function(which = c("primary", "replica"))
-      cac__get_cache_file(self, private, match.arg(which)),
+    get_cache_file = function(which = c("primary", "replica")) {
+      cac__get_cache_file(self, private, match.arg(which))
+    },
 
-    async_ensure_cache = function(max_age = private$update_after)
-      cac__async_ensure_cache(self, private, max_age),
+    async_ensure_cache = function(max_age = private$update_after) {
+      cac__async_ensure_cache(self, private, max_age)
+    },
 
-    get_current_data = function(max_age)
-      cac__get_current_data(self, private, max_age),
-    get_memory_cache = function(max_age)
-      cac__get_memory_cache(self, private, max_age),
+    get_current_data = function(max_age) {
+      cac__get_current_data(self, private, max_age)
+    },
+    get_memory_cache = function(max_age) {
+      cac__get_memory_cache(self, private, max_age)
+    },
     load_replica = function(max_age) cac__load_replica(self, private, max_age),
     load_primary = function(max_age) cac__load_primary(self, private, max_age),
 
     update_memory_cache = function() cac__update_memory_cache(self, private),
     update_replica = function() cac__update_replica(self, private),
-    update_primary = function(lock = TRUE)
-      cac__update_primary(self, private, lock),
-    convert_archive_file = function(raw, out)
-      cac__convert_archive_file(self, private, raw, out),
+    update_primary = function(lock = TRUE) {
+      cac__update_primary(self, private, lock)
+    },
+    convert_archive_file = function(raw, out) {
+      cac__convert_archive_file(self, private, raw, out)
+    },
 
     cache_version = "1",
 
@@ -220,8 +229,12 @@ cac_async_check_update <- function(self, private) {
   self
   private
 
-  if (!is.null(private$update_deferred)) return(private$update_deferred) # nocov
-  if (!is.null(private$chk_update_deferred)) return(private$chk_update_deferred) # nocov
+  if (!is.null(private$update_deferred)) {
+    return(private$update_deferred)
+  } # nocov
+  if (!is.null(private$chk_update_deferred)) {
+    return(private$chk_update_deferred)
+  } # nocov
 
   private$chk_update_deferred <- async(private$update_replica)()$then(function(
     ret
@@ -297,7 +310,9 @@ cac__async_ensure_cache <- function(self, private, max_age) {
 }
 
 cac__get_current_data <- function(self, private, max_age) {
-  if (is.null(private$data)) stop("No data loaded")
+  if (is.null(private$data)) {
+    stop("No data loaded")
+  }
   if (
     is.null(private$data_time) ||
       Sys.time() - private$data_time > max_age
@@ -311,7 +326,9 @@ cac__get_memory_cache <- function(self, private, max_age) {
   rds <- private$get_cache_file("primary")
   hash <- private$get_hash()
   hit <- cmc__data[[hash]]
-  if (is.null(hit)) stop("Not in memory cache")
+  if (is.null(hit)) {
+    stop("Not in memory cache")
+  }
   if (is.null(hit$data_time) || Sys.time() - hit$data_time > max_age) {
     stop("Memory cache outdated")
   }
@@ -322,10 +339,14 @@ cac__get_memory_cache <- function(self, private, max_age) {
 
 cac__load_replica <- function(self, private, max_age) {
   rds <- private$get_cache_file("replica")
-  if (!file.exists(rds)) stop("No replica RDS in cache")
+  if (!file.exists(rds)) {
+    stop("No replica RDS in cache")
+  }
 
   time <- file_get_time(rds)
-  if (Sys.time() - time > max_age) stop("Replica RDS file outdated")
+  if (Sys.time() - time > max_age) {
+    stop("Replica RDS file outdated")
+  }
 
   private$data <- readRDS(rds)
   private$data_time <- time
@@ -340,12 +361,18 @@ cac__load_primary <- function(self, private, max_age) {
   pri_lock <- paste0(pri_file, "-lock")
   mkdirp(dirname(pri_lock))
   l <- filelock::lock(pri_lock, exclusive = FALSE, private$lock_timeout)
-  if (is.null(l)) stop("Cannot acquire lock to copy RDS")
+  if (is.null(l)) {
+    stop("Cannot acquire lock to copy RDS")
+  }
   on.exit(filelock::unlock(l), add = TRUE)
 
-  if (!file.exists(pri_file)) stop("No primary RDS file in cache")
+  if (!file.exists(pri_file)) {
+    stop("No primary RDS file in cache")
+  }
   time <- file_get_time(pri_file)
-  if (Sys.time() - time > max_age) stop("Primary RDS cache file outdated")
+  if (Sys.time() - time > max_age) {
+    stop("Primary RDS cache file outdated")
+  }
 
   file_copy_with_time(pri_file, rep_file)
 
@@ -434,7 +461,9 @@ cac__update_primary <- function(self, private, lock) {
     pri_lock <- paste0(pri_file, "-lock")
     mkdirp(dirname(pri_lock))
     l <- filelock::lock(pri_lock, exclusive = FALSE, private$lock_timeout)
-    if (is.null(l)) stop("Cannot acquire lock to copy RDS")
+    if (is.null(l)) {
+      stop("Cannot acquire lock to copy RDS")
+    }
     on.exit(filelock::unlock(l), add = TRUE)
   }
 
diff --git a/src/library/pkgcache/R/async-http.R b/src/library/pkgcache/R/async-http.R
index 95e97db5a2..72a9f1e364 100644
--- a/src/library/pkgcache/R/async-http.R
+++ b/src/library/pkgcache/R/async-http.R
@@ -17,9 +17,13 @@ default_http_version <- function() {
 
 update_async_timeouts <- function(options) {
   getopt <- function(nm) {
-    if (!is.null(v <- options[[nm]])) return(v)
+    if (!is.null(v <- options[[nm]])) {
+      return(v)
+    }
     anm <- paste0("pkgcache_", nm)
-    if (!is.null(v <- getOption(anm))) return(v)
+    if (!is.null(v <- getOption(anm))) {
+      return(v)
+    }
     if (!is.na(v <- Sys.getenv(toupper(anm), NA_character_))) return(v)
   }
   utils::modifyList(
diff --git a/src/library/pkgcache/R/auth.R b/src/library/pkgcache/R/auth.R
index 5b9baf664f..e3cf891a5b 100644
--- a/src/library/pkgcache/R/auth.R
+++ b/src/library/pkgcache/R/auth.R
@@ -83,7 +83,9 @@ repo_auth <- function(
     url <- res$url[w]
     if (check_credentials) {
       cred <- repo_auth_headers(url, warn = FALSE)
-      if (is.null(cred)) next
+      if (is.null(cred)) {
+        next
+      }
       res$username[w] <- cred$username
       res$has_password[w] <- cred$found
       res$auth_domains[w] <- list(cred$auth_domains)
@@ -174,7 +176,7 @@ repo_auth_headers <- function(
   # - host URL w/o username
   # We try each with and without a keyring username
   urls <- unique(unlist(
-    parsed_url[c("repouserurl", "repourl", "hostuserurl", "hosturl")]
+    parsed_url[c("repouserurl", "repourl", "hostuserurl", "hosturl", "host")]
   ))
 
   if (use_cache) {
@@ -197,10 +199,18 @@ repo_auth_headers <- function(
     error = NULL
   )
 
-  pwd <- repo_auth_netrc(parsed_url$host, parsed_url$username)
+  pwd <- repo_auth_sso(parsed_url$repourl, parsed_url$username)
   if (!is.null(pwd)) {
     res$auth_domain <- parsed_url$host
-    res$source <- paste0(".netrc")
+    res$source <- "SSO"
+  }
+
+  if (is.null(pwd)) {
+    pwd <- repo_auth_netrc(parsed_url$host, parsed_url$username)
+    if (!is.null(pwd)) {
+      res$auth_domain <- parsed_url$host
+      res$source <- paste0(".netrc")
+    }
   }
 
   if (is.null(pwd) && !requireNamespace("keyring", quietly = TRUE)) {
@@ -315,7 +325,9 @@ parse_url_basic_auth <- function(url) {
 
 add_auth_status <- function(repos) {
   maybe_has_auth <- grepl("^https?://[^/]*@", repos$url)
-  if (!any(maybe_has_auth)) return(repos)
+  if (!any(maybe_has_auth)) {
+    return(repos)
+  }
 
   key <- random_key()
   on.exit(clear_auth_cache(key), add = TRUE)
@@ -326,7 +338,9 @@ add_auth_status <- function(repos) {
   for (w in which(maybe_has_auth)) {
     url <- repos$url[w]
     creds <- repo_auth_headers(url, warn = FALSE)
-    if (is.null(creds)) next
+    if (is.null(creds)) {
+      next
+    }
     repos$username[w] <- creds$username
     repos$has_password[w] <- creds$found
   }
@@ -342,7 +356,9 @@ repo_auth_netrc <- function(host, username) {
       netrc_path <- path.expand("~/_netrc")
     }
   }
-  if (!file.exists(netrc_path)) return(NULL)
+  if (!file.exists(netrc_path)) {
+    return(NULL)
+  }
 
   # netrc files do not allow port numbers
   host <- sub(":[0-9]+$", "", host)
@@ -453,3 +469,28 @@ repo_auth_netrc <- function(host, username) {
 
   NULL
 }
+
+repo_auth_sso <- function(repourl, username) {
+  ppm_url <- Sys.getenv("PACKAGEMANAGER_ADDRESS", NA_character_)
+  if (is.na(ppm_url)) {
+    return(NULL)
+  }
+
+  if (!startsWith(repourl, ppm_url)) {
+    return(NULL)
+  }
+
+  token <- tryCatch(
+    ppm_sso_auth(repourl),
+    error = function(e) {
+      cli::cli_alert_warning(
+        "PPM SSO authentication failed for repo {.url {repourl}}: {conditionMessage(e)}"
+      )
+      cli::cli_alert_info(
+        "Try calling {.code ppm_sso_login()} directly."
+      )
+      NULL
+    }
+  )
+  token
+}
diff --git a/src/library/pkgcache/R/bioc.R b/src/library/pkgcache/R/bioc.R
index 0645af2b7d..5e8015bbfa 100644
--- a/src/library/pkgcache/R/bioc.R
+++ b/src/library/pkgcache/R/bioc.R
@@ -122,6 +122,7 @@ bioconductor <- local({
     "4.2" = package_version("3.16"),
     "4.3" = package_version("3.18"),
     "4.4" = package_version("3.20"),
+    "4.5" = package_version("3.22"),
     NULL
     # Do not include R 4.5 <-> Bioc 3.21, because R 4.5 will use
     # Bioc 3.22 eventually.
@@ -152,7 +153,9 @@ bioconductor <- local({
         http_url <- sub("^https", "http", config_url())
         new <- tryCatch(read_url(http_url), error = function(x) x)
       }
-      if (inherits(new, "error")) stop(new)
+      if (inherits(new, "error")) {
+        stop(new)
+      }
       yaml_config <<- new
     }
 
@@ -160,7 +163,9 @@ bioconductor <- local({
   }
 
   set_yaml_config <- function(text) {
-    if (length(text) == 1) text <- strsplit(text, "\n", fixed = TRUE)[[1]]
+    if (length(text) == 1) {
+      text <- strsplit(text, "\n", fixed = TRUE)[[1]]
+    }
     yaml_config <<- text
   }
 
@@ -230,7 +235,9 @@ bioconductor <- local({
     forget = FALSE
   ) {
     minor <- as.character(get_minor_r_version(r_version))
-    if (minor %in% names(builtin_map)) return(builtin_map[[minor]])
+    if (minor %in% names(builtin_map)) {
+      return(builtin_map[[minor]])
+    }
 
     # If we are not in the map, then we need to look this up in
     # YAML data. It is possible that the current R version matches multiple
@@ -251,7 +258,9 @@ bioconductor <- local({
         mine <- rev(mine)[1]
       }
     }
-    if (!is.na(mine)) return(map$bioc_version[mine])
+    if (!is.na(mine)) {
+      return(map$bioc_version[mine])
+    }
 
     # If it is not even in the YAML, then it must be some very old
     # or very new version. If old, we fail. If new, we assume bioc-devel.
@@ -281,8 +290,9 @@ bioconductor <- local({
       BioCsoft = "{mirror}/packages/{bv}/bioc",
       BioCann = "{mirror}/packages/{bv}/data/annotation",
       BioCexp = "{mirror}/packages/{bv}/data/experiment",
-      BioCworkflows = if (bioc_version >= "3.7")
-        "{mirror}/packages/{bv}/workflows",
+      BioCworkflows = if (bioc_version >= "3.7") {
+        "{mirror}/packages/{bv}/workflows"
+      },
       BioCextra = if (bioc_version <= "3.5") "{mirror}/packages/{bv}/extra",
       BioCbooks = if (bioc_version >= "3.12") "{mirror}/packages/{bv}/books"
     )
diff --git a/src/library/pkgcache/R/cran-app.R b/src/library/pkgcache/R/cran-app.R
index 639eab7b93..258518e18d 100644
--- a/src/library/pkgcache/R/cran-app.R
+++ b/src/library/pkgcache/R/cran-app.R
@@ -16,14 +16,18 @@ make_dummy_package <- function(data, path) {
   ))
   unlink(package, recursive = TRUE)
   out <- dir()
-  if (length(out) != 1) stop("Failed to build package ", package, " :(")
+  if (length(out) != 1) {
+    stop("Failed to build package ", package, " :(")
+  }
   mkdirp(path)
   file.copy(out, path, overwrite = TRUE)
   out
 }
 
 dummy_so <- function() {
-  if (!is.null(fake_env$dummy_so)) return(fake_env$dummy_so)
+  if (!is.null(fake_env$dummy_so)) {
+    return(fake_env$dummy_so)
+  }
 
   mkdirp(tmp <- tempfile())
   on.exit(unlink(tmp, recursive = TRUE), add = TRUE)
@@ -175,15 +179,19 @@ make_dummy_repo_platform <- function(repo, packages = NULL, options = list()) {
     if (
       options[["platform"]] == "source" &&
         packages$Package[i] %in% options[["no_sources"]]
-    )
+    ) {
       next
+    }
     if (
       options[["platform"]] != "source" &&
         packages$Package[i] %in% options[["no_binaries"]]
-    )
+    ) {
       next
+    }
     if (extra$archive[i]) {
-      if (isTRUE(options$no_archive)) next
+      if (isTRUE(options$no_archive)) {
+        next
+      }
       pkg_dir <- file.path(pkgs_dir, "Archive", packages$Package[i])
     } else {
       pkg_dir <- pkgs_dir
@@ -271,7 +279,9 @@ cran_app <- function(
   app <- webfakes::new_app()
 
   # Log requests by default
-  if (log) app$use("logger" = webfakes::mw_log())
+  if (log) {
+    app$use("logger" = webfakes::mw_log())
+  }
 
   if (!is.null(basic_auth)) {
     app$use("basic auth" = function(req, res) {
@@ -374,7 +384,9 @@ bioc_app <- function(packages = NULL, log = interactive(), options = list()) {
   app <- webfakes::new_app()
 
   # Log requests by default
-  if (log) app$use("logger" = webfakes::mw_log())
+  if (log) {
+    app$use("logger" = webfakes::mw_log())
+  }
 
   # Parse all kinds of bodies
   app$use("json body parser" = webfakes::mw_json())
diff --git a/src/library/pkgcache/R/data-frame.R b/src/library/pkgcache/R/data-frame.R
index 2651c2a446..60192bddc4 100644
--- a/src/library/pkgcache/R/data-frame.R
+++ b/src/library/pkgcache/R/data-frame.R
@@ -2,7 +2,9 @@ find_in_data_frame <- function(df, ..., .list = NULL) {
   cols <- drop_nulls(c(list(...), .list))
   idx <- seq_len(nrow(df))
   for (i in seq_along(cols)) {
-    if (length(idx) == 0) break
+    if (length(idx) == 0) {
+      break
+    }
     n <- names(cols)[i]
     idx <- idx[df[[n]][idx] %in% cols[[i]]]
   }
diff --git a/src/library/pkgcache/R/errors.R b/src/library/pkgcache/R/errors.R
index 7d1d585acb..4dda3e0bde 100644
--- a/src/library/pkgcache/R/errors.R
+++ b/src/library/pkgcache/R/errors.R
@@ -224,16 +224,24 @@ err <- local({
     always_trace <- isTRUE(getOption("rlib_error_always_trace"))
     .hide_from_trace <- 1L
     # .error_frame <- cond
-    if (!always_trace) signalCondition(cond)
+    if (!always_trace) {
+      signalCondition(cond)
+    }
 
-    if (is.null(cond$`_pid`)) cond$`_pid` <- Sys.getpid()
-    if (is.null(cond$`_timestamp`)) cond$`_timestamp` <- Sys.time()
+    if (is.null(cond$`_pid`)) {
+      cond$`_pid` <- Sys.getpid()
+    }
+    if (is.null(cond$`_timestamp`)) {
+      cond$`_timestamp` <- Sys.time()
+    }
 
     # If we get here that means that the condition was not caught by
     # an exiting handler. That means that we need to create a trace.
     # If there is a hand-constructed trace already in the error object,
     # then we'll just leave it there.
-    if (is.null(cond$trace)) cond <- add_trace_back(cond, frame = frame)
+    if (is.null(cond$trace)) {
+      cond <- add_trace_back(cond, frame = frame)
+    }
 
     # Set up environment to store .Last.error, it will be just before
     # baseenv(), so it is almost as if it was in baseenv() itself, like
@@ -250,11 +258,15 @@ err <- local({
     env$.Last.error.trace <- cond$trace
 
     # If we always wanted a trace, then we signal the condition here
-    if (always_trace) signalCondition(cond)
+    if (always_trace) {
+      signalCondition(cond)
+    }
 
     # If this is not an error, then we'll just return here. This allows
     # throwing interrupt conditions for example, with the same UI.
-    if (!inherits(cond, "error")) return(invisible())
+    if (!inherits(cond, "error")) {
+      return(invisible())
+    }
     .hide_from_trace <- NULL
 
     # Top-level handler, this is intended for testing only for now,
@@ -492,8 +504,12 @@ err <- local({
     for (start in hide_from) {
       hide_this <- invisible_frames[[funs[start]]]
       for (i in seq_along(hide_this)) {
-        if (start + i > length(funs)) break
-        if (funs[start + i] != hide_this[i]) break
+        if (start + i > length(funs)) {
+          break
+        }
+        if (funs[start + i] != hide_this[i]) {
+          break
+        }
         visibles[start + i] <- FALSE
       }
     }
@@ -527,19 +543,32 @@ err <- local({
   }
 
   get_call_scope <- function(call, ns) {
-    if (is.na(ns)) return("global")
-    if (!is.call(call)) return("")
+    if (is.na(ns)) {
+      return("global")
+    }
+    if (!is.call(call)) {
+      return("")
+    }
     if (
       is.call(call[[1]]) &&
         (call[[1]][[1]] == quote(`::`) || call[[1]][[1]] == quote(`:::`))
-    )
+    ) {
+      return("")
+    }
+    if (ns == "base") {
+      return("::")
+    }
+    if (!ns %in% loadedNamespaces()) {
       return("")
-    if (ns == "base") return("::")
-    if (!ns %in% loadedNamespaces()) return("")
+    }
     name <- call_name(call)
     nsenv <- asNamespace(ns)$.__NAMESPACE__.
-    if (is.null(nsenv)) return("::")
-    if (is.null(nsenv$exports)) return(":::")
+    if (is.null(nsenv)) {
+      return("::")
+    }
+    if (is.null(nsenv$exports)) {
+      return(":::")
+    }
     if (exists(name, envir = nsenv$exports, inherits = FALSE)) {
       "::"
     } else if (exists(name, envir = asNamespace(ns), inherits = FALSE)) {
@@ -729,7 +758,9 @@ err <- local({
           conditionMessage(cond$parent)
         }
         add_exp <- substr(cli::ansi_strip(msg[1]), 1, 1) != "!"
-        if (add_exp) msg[1] <- paste0(exp, msg[1])
+        if (add_exp) {
+          msg[1] <- paste0(exp, msg[1])
+        }
         c(format_header_line_cli(cond$parent, prefix = "Caused by error"), msg)
       }
     )
@@ -827,14 +858,18 @@ err <- local({
       NULL
     } else {
       cl <- trimws(format(call))
-      if (length(cl) > 1) cl <- paste0(cl[1], " ", cli::symbol$ellipsis)
+      if (length(cl) > 1) {
+        cl <- paste0(cl[1], " ", cli::symbol$ellipsis)
+      }
       cli::format_inline("{.code {cl}}")
     }
   }
 
   format_srcref_cli <- function(call, srcref = NULL) {
     ref <- get_srcref(call, srcref)
-    if (is.null(ref)) return("")
+    if (is.null(ref)) {
+      return("")
+    }
 
     link <- if (ref$file != "") {
       cli::style_hyperlink(
@@ -993,14 +1028,18 @@ err <- local({
       NULL
     } else {
       cl <- trimws(format(call))
-      if (length(cl) > 1) cl <- paste0(cl[1], " ...")
+      if (length(cl) > 1) {
+        cl <- paste0(cl[1], " ...")
+      }
       paste0("`", cl, "`")
     }
   }
 
   format_srcref_plain <- function(call, srcref = NULL) {
     ref <- get_srcref(call, srcref)
-    if (is.null(ref)) return("")
+    if (is.null(ref)) {
+      return("")
+    }
 
     link <- if (ref$file != "") {
       paste0(basename(ref$file), ":", ref$line, ":", ref$col)
@@ -1052,10 +1091,16 @@ err <- local({
 
   get_srcref <- function(call, srcref = NULL) {
     ref <- srcref %||% utils::getSrcref(call)
-    if (is.null(ref)) return(NULL)
-    if (inherits(ref, "processed_srcref")) return(ref)
+    if (is.null(ref)) {
+      return(NULL)
+    }
+    if (inherits(ref, "processed_srcref")) {
+      return(ref)
+    }
     file <- utils::getSrcFilename(ref, full.names = TRUE)[1]
-    if (is.na(file)) file <- ""
+    if (is.na(file)) {
+      file <- ""
+    }
     line <- utils::getSrcLocation(ref) %||% ""
     col <- utils::getSrcLocation(ref, which = "column") %||% ""
     structure(
diff --git a/src/library/pkgcache/R/installed.R b/src/library/pkgcache/R/installed.R
index 21baebd1c8..8a4a770062 100644
--- a/src/library/pkgcache/R/installed.R
+++ b/src/library/pkgcache/R/installed.R
@@ -23,7 +23,9 @@ parse_description <- function(path) {
 }
 
 fix_encodings <- function(lst, col = "Encoding") {
-  if (!col %in% names(lst)) return(lst)
+  if (!col %in% names(lst)) {
+    return(lst)
+  }
   utf8 <- which(!is.na(lst[[col]]) & lst[[col]] == "UTF-8")
   other <- which(!is.na(lst[[col]]) & lst[[col]] != "UTf-8")
   unq <- unique(lst[[col]][other])
@@ -148,16 +150,18 @@ guess_packages_type <- function(path) {
       buf[1] == 0x1f &&
       buf[2] == 0x8b &&
       buf[3] == 0x08
-  )
+  ) {
     return("gzip")
+  }
 
   if (
     length(buf) >= 3 &&
       buf[1] == 0x42 &&
       buf[2] == 0x5a &&
       buf[3] == 0x68
-  )
+  ) {
     return("bzip2")
+  }
 
   if (
     length(buf) >= 6 &&
@@ -167,15 +171,17 @@ guess_packages_type <- function(path) {
       buf[4] == 0x58 &&
       buf[5] == 0x5A &&
       buf[6] == 0x00
-  )
+  ) {
     return("xz")
+  }
 
   if (
     length(buf) >= 2 &&
       buf[1] %in% as.raw(c(0x58, 0x41, 0x42)) &&
       buf[2] == 0x0a
-  )
+  ) {
     return("rds")
+  }
 
   "uncompressed"
 }
@@ -336,7 +342,9 @@ parse_installed <- function(
     tbl <- tbl[keep, ]
   }
 
-  if (reencode) tbl <- fix_encodings(tbl)
+  if (reencode) {
+    tbl <- fix_encodings(tbl)
+  }
 
   tbl
 }
diff --git a/src/library/pkgcache/R/iso-date.R b/src/library/pkgcache/R/iso-date.R
index 8736e15687..2137ae0408 100644
--- a/src/library/pkgcache/R/iso-date.R
+++ b/src/library/pkgcache/R/iso-date.R
@@ -10,7 +10,9 @@ ymd <- function(x) as.POSIXct(x, format = "%Y %m %d", tz = "UTC")
 yj <- function(x) as.POSIXct(x, format = "%Y %j", tz = "UTC")
 
 parse_iso_8601 <- function(dates, default_tz = "UTC") {
-  if (default_tz == "") default_tz <- Sys.timezone()
+  if (default_tz == "") {
+    default_tz <- Sys.timezone()
+  }
   dates <- as.character(dates)
   match <- re_match(dates, iso_regex)
   matching <- !is.na(match$.match)
diff --git a/src/library/pkgcache/R/metadata-cache.R b/src/library/pkgcache/R/metadata-cache.R
index bbb6c5644a..746b1056d6 100644
--- a/src/library/pkgcache/R/metadata-cache.R
+++ b/src/library/pkgcache/R/metadata-cache.R
@@ -179,7 +179,7 @@ cranlike_metadata_cache <- R6Class(
       cran_mirror = default_cran_mirror(),
       repos = getOption("repos"),
       update_after = as.difftime(7, units = "days")
-    )
+    ) {
       cmc_init(
         self,
         private,
@@ -191,21 +191,27 @@ cranlike_metadata_cache <- R6Class(
         cran_mirror,
         repos,
         update_after
-      ),
-
-    deps = function(packages, dependencies = NA, recursive = TRUE)
-      synchronise(self$async_deps(packages, dependencies, recursive)),
-    async_deps = function(packages, dependencies = NA, recursive = TRUE)
-      cmc_async_deps(self, private, packages, dependencies, recursive),
-
-    revdeps = function(packages, dependencies = NA, recursive = TRUE)
-      synchronise(self$async_revdeps(packages, dependencies, recursive)),
-    async_revdeps = function(packages, dependencies = NA, recursive = TRUE)
-      cmc_async_revdeps(self, private, packages, dependencies, recursive),
+      )
+    },
+
+    deps = function(packages, dependencies = NA, recursive = TRUE) {
+      synchronise(self$async_deps(packages, dependencies, recursive))
+    },
+    async_deps = function(packages, dependencies = NA, recursive = TRUE) {
+      cmc_async_deps(self, private, packages, dependencies, recursive)
+    },
+
+    revdeps = function(packages, dependencies = NA, recursive = TRUE) {
+      synchronise(self$async_revdeps(packages, dependencies, recursive))
+    },
+    async_revdeps = function(packages, dependencies = NA, recursive = TRUE) {
+      cmc_async_revdeps(self, private, packages, dependencies, recursive)
+    },
 
     list = function(packages = NULL) synchronise(self$async_list(packages)),
-    async_list = function(packages = NULL)
-      cmc_async_list(self, private, packages),
+    async_list = function(packages = NULL) {
+      cmc_async_list(self, private, packages)
+    },
 
     update = function() synchronise(self$async_update()),
     async_update = function() cmc_async_update(self, private),
@@ -219,32 +225,42 @@ cranlike_metadata_cache <- R6Class(
   ),
 
   private = list(
-    get_cache_files = function(which = c("primary", "replica"))
-      cmc__get_cache_files(self, private, match.arg(which)),
-
-    async_ensure_cache = function(max_age = private$update_after)
-      cmc__async_ensure_cache(self, private, max_age),
-
-    get_current_data = function(max_age)
-      cmc__get_current_data(self, private, max_age),
-    get_memory_cache = function(max_age)
-      cmc__get_memory_cache(self, private, max_age),
-    load_replica_rds = function(max_age)
-      cmc__load_replica_rds(self, private, max_age),
-    load_primary_rds = function(max_age)
-      cmc__load_primary_rds(self, private, max_age),
-    load_primary_pkgs = function(max_age)
-      cmc__load_primary_pkgs(self, private, max_age),
+    get_cache_files = function(which = c("primary", "replica")) {
+      cmc__get_cache_files(self, private, match.arg(which))
+    },
+
+    async_ensure_cache = function(max_age = private$update_after) {
+      cmc__async_ensure_cache(self, private, max_age)
+    },
+
+    get_current_data = function(max_age) {
+      cmc__get_current_data(self, private, max_age)
+    },
+    get_memory_cache = function(max_age) {
+      cmc__get_memory_cache(self, private, max_age)
+    },
+    load_replica_rds = function(max_age) {
+      cmc__load_replica_rds(self, private, max_age)
+    },
+    load_primary_rds = function(max_age) {
+      cmc__load_primary_rds(self, private, max_age)
+    },
+    load_primary_pkgs = function(max_age) {
+      cmc__load_primary_pkgs(self, private, max_age)
+    },
 
     update_replica_pkgs = function() cmc__update_replica_pkgs(self, private),
-    update_replica_rds = function(alert = TRUE)
-      cmc__update_replica_rds(self, private, alert),
-    update_primary = function(rds = TRUE, packages = TRUE, lock = TRUE)
-      cmc__update_primary(self, private, rds, packages, lock),
+    update_replica_rds = function(alert = TRUE) {
+      cmc__update_replica_rds(self, private, alert)
+    },
+    update_primary = function(rds = TRUE, packages = TRUE, lock = TRUE) {
+      cmc__update_primary(self, private, rds, packages, lock)
+    },
     update_memory_cache = function() cmc__update_memory_cache(self, private),
 
-    copy_to_replica = function(rds = TRUE, pkgs = FALSE, etags = FALSE)
-      cmc__copy_to_replica(self, private, rds, pkgs, etags),
+    copy_to_replica = function(rds = TRUE, pkgs = FALSE, etags = FALSE) {
+      cmc__copy_to_replica(self, private, rds, pkgs, etags)
+    },
 
     ## We use this to make sure that different versions of pkgcache can
     ## share the same metadata cache directory. It is used to calculate
@@ -345,7 +361,9 @@ cmc_async_list <- function(self, private, packages) {
 cmc_async_update <- function(self, private) {
   self
   private
-  if (!is.null(private$update_deferred)) return(private$update_deferred)
+  if (!is.null(private$update_deferred)) {
+    return(private$update_deferred)
+  }
 
   private$update_deferred <- async(private$update_replica_pkgs)()$then(
     function() private$update_replica_rds()
@@ -358,8 +376,12 @@ cmc_async_check_update <- function(self, private) {
   self
   private
 
-  if (!is.null(private$update_deferred)) return(private$update_deferred)
-  if (!is.null(private$chk_update_deferred)) return(private$chk_update_deferred)
+  if (!is.null(private$update_deferred)) {
+    return(private$update_deferred)
+  }
+  if (!is.null(private$chk_update_deferred)) {
+    return(private$chk_update_deferred)
+  }
 
   private$chk_update_deferred <- async(private$update_replica_pkgs)()$then(
     function(ret) {
@@ -540,7 +562,9 @@ ppm_binary_url <- function(urls, r_version) {
 
   # If multiple R versions are requested, then we give up, and pretend
   # that PPM binaries are source packages
-  if (length(r_version) != 1) return(res)
+  if (length(r_version) != 1) {
+    return(res)
+  }
 
   # http://rspm.infra/all/__linux__/bionic/latest ->
   # http://rspm.infra/all/latest/bin/linux/4.2-bionic/contrib/4.2/PACKAGES
@@ -615,7 +639,9 @@ cmc__async_ensure_cache <- function(self, private, max_age) {
 
 cmc__get_current_data <- function(self, private, max_age) {
   "!!DEBUG Get current data?"
-  if (is.null(private$data)) stop("No data loaded")
+  if (is.null(private$data)) {
+    stop("No data loaded")
+  }
   if (
     is.null(private$data_time) ||
       Sys.time() - private$data_time > max_age
@@ -634,7 +660,9 @@ cmc__get_memory_cache <- function(self, private, max_age) {
   "!!DEBUG Get from memory cache?"
   rds <- private$get_cache_files("primary")$rds
   hit <- cmc__data[[rds]]
-  if (is.null(hit)) stop("Not in the memory cache")
+  if (is.null(hit)) {
+    stop("Not in the memory cache")
+  }
   if (is.null(hit$data_time) || Sys.time() - hit$data_time > max_age) {
     stop("Memory cache outdated")
   }
@@ -660,10 +688,14 @@ cmc__get_memory_cache <- function(self, private, max_age) {
 cmc__load_replica_rds <- function(self, private, max_age) {
   "!!DEBUG Load replica RDS?"
   rds <- private$get_cache_files("replica")$rds
-  if (!file.exists(rds)) stop("No replica RDS file in cache")
+  if (!file.exists(rds)) {
+    stop("No replica RDS file in cache")
+  }
 
   time <- file_get_time(rds)
-  if (Sys.time() - time > max_age) stop("Replica RDS cache file outdated")
+  if (Sys.time() - time > max_age) {
+    stop("Replica RDS cache file outdated")
+  }
 
   sts <- cli::cli_process_start("Loading metadata database")
   private$data <- readRDS(rds)
@@ -692,12 +724,18 @@ cmc__load_primary_rds <- function(self, private, max_age) {
 
   mkdirp(dirname(pri_files$lock))
   l <- filelock::lock(pri_files$lock, exclusive = FALSE, private$lock_timeout)
-  if (is.null(l)) stop("Cannot acquire lock to copy RDS")
+  if (is.null(l)) {
+    stop("Cannot acquire lock to copy RDS")
+  }
   on.exit(filelock::unlock(l), add = TRUE)
 
-  if (!file.exists(pri_files$rds)) stop("No primary RDS file in cache")
+  if (!file.exists(pri_files$rds)) {
+    stop("No primary RDS file in cache")
+  }
   time <- file_get_time(pri_files$rds)
-  if (Sys.time() - time > max_age) stop("Primary RDS cache file outdated")
+  if (Sys.time() - time > max_age) {
+    stop("Primary RDS cache file outdated")
+  }
 
   ## Metadata files might be missing or outdated, that's ok (?)
   pkgs_times <- file_get_time(pri_files$pkgs$path)
@@ -741,7 +779,9 @@ cmc__load_primary_pkgs <- function(self, private, max_age) {
   ## Lock
   mkdirp(dirname(pri_files$lock))
   l <- filelock::lock(pri_files$lock, exclusive = FALSE, private$lock_timeout)
-  if (is.null(l)) stop("Cannot acquire lock to copy PACKAGES files")
+  if (is.null(l)) {
+    stop("Cannot acquire lock to copy PACKAGES files")
+  }
   on.exit(filelock::unlock(l), add = TRUE)
 
   ## Check if PACKAGES exist and current. It is OK if metadata is missing
@@ -819,11 +859,17 @@ cmc__update_replica_pkgs <- function(self, private) {
 
 missing_pkgs_note <- function(pkgs, result) {
   bad <- vlapply(result[seq_len(nrow(pkgs))], inherits, "error")
-  if (!any(bad)) return()
+  if (!any(bad)) {
+    return()
+  }
 
   repo_name <- function(type, url) {
-    if (type == "cran") return("CRAN")
-    if (type == "bioc") return("Bioconductor")
+    if (type == "cran") {
+      return("CRAN")
+    }
+    if (type == "bioc") {
+      return("Bioconductor")
+    }
     sub("^https?://([^/]*).*$", "\\1", url)
   }
 
@@ -857,7 +903,9 @@ missing_pkgs_note <- function(pkgs, result) {
 
 cmc__update_replica_rds <- function(self, private, alert) {
   "!!DEBUG Update replica RDS"
-  if (alert) sts <- cli::cli_process_start("Updating metadata database")
+  if (alert) {
+    sts <- cli::cli_process_start("Updating metadata database")
+  }
   rep_files <- private$get_cache_files("replica")
 
   data_list <- lapply_rows(
@@ -880,7 +928,9 @@ cmc__update_replica_rds <- function(self, private, alert) {
 
   data_list <- data_list[!vlapply(data_list, is.null)]
 
-  if (length(data_list) == 0) stop("No metadata available")
+  if (length(data_list) == 0) {
+    stop("No metadata available")
+  }
 
   private$data <- merge_packages_data(.list = data_list)
   save_rds(private$data, rep_files$rds)
@@ -889,7 +939,9 @@ cmc__update_replica_rds <- function(self, private, alert) {
 
   private$update_memory_cache()
 
-  if (alert) cli::cli_process_done(sts)
+  if (alert) {
+    cli::cli_process_done(sts)
+  }
   private$data
 }
 
@@ -905,7 +957,9 @@ cmc__update_replica_rds <- function(self, private, alert) {
 
 cmc__update_primary <- function(self, private, rds, packages, lock) {
   "!!DEBUG Updata primary cache"
-  if (!rds && !packages) return()
+  if (!rds && !packages) {
+    return()
+  }
 
   pri_files <- private$get_cache_files("primary")
   rep_files <- private$get_cache_files("replica")
@@ -913,7 +967,9 @@ cmc__update_primary <- function(self, private, rds, packages, lock) {
   if (lock) {
     mkdirp(dirname(pri_files$lock))
     l <- filelock::lock(pri_files$lock, exclusive = TRUE, private$lock_timeout)
-    if (is.null(l)) stop("Cannot acquire lock to update primary cache")
+    if (is.null(l)) {
+      stop("Cannot acquire lock to update primary cache")
+    }
     on.exit(filelock::unlock(l), add = TRUE)
   }
 
@@ -954,7 +1010,9 @@ cmc__copy_to_replica <- function(self, private, rds, pkgs, etags) {
 
   mkdirp(dirname(pri_files$lock))
   l <- filelock::lock(pri_files$lock, exclusive = FALSE, private$lock_timeout)
-  if (is.null(l)) stop("Cannot acquire lock to copy primary cache")
+  if (is.null(l)) {
+    stop("Cannot acquire lock to copy primary cache")
+  }
   on.exit(filelock::unlock(l), add = TRUE)
 
   if (rds) {
@@ -995,9 +1053,13 @@ extract_deps <- function(pkgs, packages, dependencies, recursive) {
       pkgs$deps$package[pkgs$deps$upstream %in% new & pkgs$deps$type %in% dep],
       packages
     )
-    if (!length(new)) break
+    if (!length(new)) {
+      break
+    }
     packages <- c(packages, new)
-    if (!recursive) break
+    if (!recursive) {
+      break
+    }
     dep <- tolower(realdep$indirect)
   }
 
@@ -1021,9 +1083,13 @@ extract_revdeps <- function(pkgs, packages, dependencies, recursive) {
       pkgs$deps$upstream[pkgs$deps$ref %in% new & pkgs$deps$type %in% dep],
       packages
     )
-    if (!length(new)) break
+    if (!length(new)) {
+      break
+    }
     packages <- c(packages, new)
-    if (!recursive) break
+    if (!recursive) {
+      break
+    }
     dep <- tolower(realdep$indirect)
   }
 
diff --git a/src/library/pkgcache/R/onload.R b/src/library/pkgcache/R/onload.R
index 7d69377cb4..1c679b4bcf 100644
--- a/src/library/pkgcache/R/onload.R
+++ b/src/library/pkgcache/R/onload.R
@@ -1,6 +1,7 @@
 ## nocov start
 
 pkgenv <- new.env(parent = emptyenv())
+pkgenv$ppm_sso_cache <- new.env(parent = emptyenv())
 
 pkgenv$r_versions <- list(
   list(version = "0.60", date = "1997-12-04T08:47:58.000000Z"),
@@ -254,6 +255,7 @@ pkgenv$ppm_distros_cached <-
  focal                   linux   focal          ubuntu       20.04     TRUE
  jammy                   linux   jammy          ubuntu       22.04     TRUE
  noble                   linux   noble          ubuntu       24.04     TRUE
+ resolute                linux   resolute       ubuntu       26.04     TRUE
  buster                  linux   buster         debian       10        FALSE
  bullseye                linux   bullseye       debian       11        TRUE
  bookworm                linux   bookworm       debian       12        TRUE
diff --git a/src/library/pkgcache/R/package-cache.R b/src/library/pkgcache/R/package-cache.R
index cf1fcec77e..6264fe7c4f 100644
--- a/src/library/pkgcache/R/package-cache.R
+++ b/src/library/pkgcache/R/package-cache.R
@@ -158,7 +158,9 @@ package_cache <- R6Class(
 
       # updates for unexpected PPM binaries and sources
       # need to update 'path', 'platform', 'sha256'
-      if (is.list(.headers)) .headers <- .headers[[1]]
+      if (is.list(.headers)) {
+        .headers <- .headers[[1]]
+      }
       .headers <- tolower(.headers)
       if ("x-repository-type: rspm" %in% .headers) {
         fields <- update_fields_for_ppm_download(path, extra, .headers)
@@ -341,8 +343,9 @@ package_cache <- R6Class(
       on_progress
       http_headers
       async_constant()$then(
-        function()
+        function() {
           self$copy_to(target, url = urls[1], path = path, ..., .list = .list)
+        }
       )$then(function(res) {
         if (!nrow(res)) {
           ## Not in the cache, download and add it
@@ -469,7 +472,9 @@ create_empty_db_file_if_needed <- function(path) {
   mkdirp(path)
 
   dbfile <- get_db_file(path)
-  if (file.exists(dbfile)) return()
+  if (file.exists(dbfile)) {
+    return()
+  }
 
   lockfile <- get_lock_file(path)
 
@@ -495,18 +500,24 @@ make_empty_db_data_frame <- function() {
 update_fields_for_ppm_download <- function(path, extra, headers) {
   res <- list(path = path, extra = extra)
   pkg_type <- grep("^x-package-type:", headers, value = TRUE)[1]
-  if (is.na(pkg_type)) return(res)
+  if (is.na(pkg_type)) {
+    return(res)
+  }
   pkg_type <- sub("^x-package-type: ?", "", pkg_type)
 
   if (pkg_type == "binary") {
     # Got a binary package, check what kind
     bin_tag <- grep("x-package-binary-tag:", headers, value = TRUE)[1]
-    if (is.na(bin_tag)) return(res)
+    if (is.na(bin_tag)) {
+      return(res)
+    }
     bin_tag <- sub("x-package-binary-tag: ?", "", bin_tag)
     synchronise(async_get_ppm_status())
     rver <- strsplit(bin_tag, "-")[[1]][[1]]
     binurl <- strsplit(bin_tag, "-")[[1]][[2]]
-    if (!binurl %in% pkgenv$ppm_distros$binary_url) return(res)
+    if (!binurl %in% pkgenv$ppm_distros$binary_url) {
+      return(res)
+    }
 
     # fix platform if neeeded
     if (!is.null(extra$platform) && extra$platform == "source") {
diff --git a/src/library/pkgcache/R/platform-linux.R b/src/library/pkgcache/R/platform-linux.R
index 6607215866..12e9d39fb8 100644
--- a/src/library/pkgcache/R/platform-linux.R
+++ b/src/library/pkgcache/R/platform-linux.R
@@ -57,9 +57,13 @@ remove_quotes <- function(x) {
 
 parse_os_release <- function(lines) {
   id <- grep("^ID=", lines, value = TRUE)[1]
-  if (is.na(id)) return(unknown_dist())
+  if (is.na(id)) {
+    return(unknown_dist())
+  }
   id <- trimws(sub("^ID=(.*)$", "\\1", id, perl = TRUE))
-  if (is_quoted(id)) id <- remove_quotes(id)
+  if (is_quoted(id)) {
+    id <- remove_quotes(id)
+  }
 
   ver <- grep("^VERSION_ID=", lines, value = TRUE)[1]
   if (!is.na(ver)) {
@@ -71,7 +75,9 @@ parse_os_release <- function(lines) {
     stringsAsFactors = FALSE,
     distribution = id
   )
-  if (!is.na(ver)) out$release <- ver
+  if (!is.na(ver)) {
+    out$release <- ver
+  }
 
   if (is.na(ver) && id == "debian") {
     pn <- grep("^PRETTY_NAME=", lines, value = TRUE)[1]
@@ -86,7 +92,9 @@ parse_os_release <- function(lines) {
 parse_redhat_release <- function(lines) {
   pcs <- strsplit(lines[1], " ", fixed = TRUE)[[1]]
   id <- tolower(pcs[1])
-  if (id == "" || is.na(id)) return(unknown_dist())
+  if (id == "" || is.na(id)) {
+    return(unknown_dist())
+  }
 
   wver <- grepl("^[-\\.0-9]+$", pcs)
 
@@ -94,7 +102,9 @@ parse_redhat_release <- function(lines) {
     stringsAsFactors = FALSE,
     distribution = id
   )
-  if (any(wver)) out$release <- pcs[wver][1]
+  if (any(wver)) {
+    out$release <- pcs[wver][1]
+  }
 
   out
 }
diff --git a/src/library/pkgcache/R/ppm-sso-app.R b/src/library/pkgcache/R/ppm-sso-app.R
new file mode 100644
index 0000000000..376115320c
--- /dev/null
+++ b/src/library/pkgcache/R/ppm-sso-app.R
@@ -0,0 +1,270 @@
+# nocov start
+
+# Fake PPM server that proxies to Auth0, for testing ppm_sso_device_flow().
+# Auth0 device flow does not use PKCE, so we verify the PKCE challenge
+# locally and forward only the device_code to Auth0's /oauth/token.
+ppm_sso_auth0_app <- function(
+  auth0_domain,
+  client_id,
+  audience = NULL,
+  scope = "openid profile email"
+) {
+  app <- webfakes::new_app()
+
+  app$use("logger" = webfakes::mw_log())
+  app$use("urlencoded body parser" = webfakes::mw_urlencoded())
+  app$use("json body parser" = webfakes::mw_json())
+
+  app$locals$challenges <- new.env(parent = emptyenv())
+  app$locals$auth0_domain <- auth0_domain
+  app$locals$client_id <- client_id
+  app$locals$audience <- audience
+  app$locals$scope <- scope
+
+  # Bearer-token check used by ppm_sso_can_authenticate(): any token passes.
+  app$get("/", function(req, res) {
+    res$set_status(200L)$send("ok")
+  })
+
+  app$post("/__api__/device", function(req, res) {
+    challenge <- req$form$code_challenge
+    method <- req$form$code_challenge_method %||% "S256"
+    if (!identical(method, "S256")) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "unsupported_challenge_method")
+      ))
+    }
+
+    payload <- list(
+      client_id = app$locals$client_id,
+      scope = app$locals$scope,
+      audience = app$locals$audience
+    )
+
+    upstream <- ppm_sso_post_form(
+      paste0("https://", app$locals$auth0_domain, "/oauth/device/code"),
+      payload
+    )
+
+    if (upstream$status >= 400L) {
+      return(res$set_status(upstream$status)$send_json(
+        auto_unbox = TRUE,
+        upstream$body
+      ))
+    }
+
+    assign(upstream$body$device_code, challenge, envir = app$locals$challenges)
+
+    res$send_json(
+      auto_unbox = TRUE,
+      list(
+        device_code = upstream$body$device_code,
+        user_code = upstream$body$user_code,
+        verification_uri = upstream$body$verification_uri,
+        verification_uri_complete = upstream$body$verification_uri_complete,
+        expires_in = upstream$body$expires_in,
+        interval = upstream$body$interval %||% 5L
+      )
+    )
+  })
+
+  app$post("/__api__/device_access", function(req, res) {
+    device_code <- req$form$device_code
+    verifier <- req$form$code_verifier
+
+    if (!exists(device_code, envir = app$locals$challenges, inherits = FALSE)) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "expired_token")
+      ))
+    }
+    expected <- get(
+      device_code,
+      envir = app$locals$challenges,
+      inherits = FALSE
+    )
+    actual <- ppm_sso_base64url_encode(ppm_sso_sha256_raw(verifier))
+    if (!identical(expected, actual)) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "invalid_grant")
+      ))
+    }
+
+    upstream <- ppm_sso_post_form(
+      paste0("https://", app$locals$auth0_domain, "/oauth/token"),
+      list(
+        grant_type = "urn:ietf:params:oauth:grant-type:device_code",
+        device_code = device_code,
+        client_id = app$locals$client_id
+      )
+    )
+
+    if (upstream$status == 200L) {
+      rm(list = device_code, envir = app$locals$challenges)
+      return(res$send_json(
+        auto_unbox = TRUE,
+        list(id_token = upstream$body$id_token)
+      ))
+    }
+
+    # Auth0 returns 403 for authorization_pending / slow_down; the PPM client
+    # only treats 400 as a soft pending state, so translate the status.
+    res$set_status(400L)$send_json(
+      auto_unbox = TRUE,
+      list(error = upstream$body$error %||% "unknown_error")
+    )
+  })
+
+  # Trivial token exchange: echo subject_token back as access_token.
+  app$post("/__api__/token", function(req, res) {
+    if (
+      !identical(
+        req$form$grant_type,
+        "urn:ietf:params:oauth:grant-type:token-exchange"
+      )
+    ) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "unsupported_grant_type")
+      ))
+    }
+    res$send_json(
+      auto_unbox = TRUE,
+      list(
+        access_token = req$form$subject_token,
+        token_type = "Bearer",
+        issued_token_type = "urn:ietf:params:oauth:token-type:access_token"
+      )
+    )
+  })
+
+  app
+}
+
+ppm_sso_app <- function() {
+  app <- webfakes::new_app()
+
+  app$use("logger" = webfakes::mw_log())
+  app$use("urlencoded body parser" = webfakes::mw_urlencoded())
+  app$use("json body parser" = webfakes::mw_json())
+
+  app$locals$challenges <- new.env(parent = emptyenv())
+
+  app$get("/", function(req, res) {
+    res$set_status(200L)$send("ok")
+  })
+
+  app$post("/__api__/device", function(req, res) {
+    challenge <- req$form$code_challenge
+    method <- req$form$code_challenge_method %||% "S256"
+    if (!identical(method, "S256")) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "unsupported_challenge_method")
+      ))
+    }
+
+    device_code <- ppm_sso_base64url_encode(.Call(pkgcache_rand_bytes, 32L))
+    user_code <- "ABCD-EFGH"
+    verification_uri <- "https://example.invalid/activate"
+
+    assign(device_code, challenge, envir = app$locals$challenges)
+
+    res$send_json(
+      auto_unbox = TRUE,
+      list(
+        device_code = device_code,
+        user_code = user_code,
+        verification_uri = verification_uri,
+        verification_uri_complete = paste0(
+          verification_uri,
+          "?user_code=",
+          user_code
+        ),
+        expires_in = 300L,
+        interval = 1L
+      )
+    )
+  })
+
+  app$post("/__api__/device_access", function(req, res) {
+    device_code <- req$form$device_code
+    verifier <- req$form$code_verifier
+
+    if (!exists(device_code, envir = app$locals$challenges, inherits = FALSE)) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "expired_token")
+      ))
+    }
+    expected <- get(
+      device_code,
+      envir = app$locals$challenges,
+      inherits = FALSE
+    )
+    actual <- ppm_sso_base64url_encode(ppm_sso_sha256_raw(verifier))
+    if (!identical(expected, actual)) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "invalid_grant")
+      ))
+    }
+
+    rm(list = device_code, envir = app$locals$challenges)
+    res$send_json(
+      auto_unbox = TRUE,
+      list(id_token = ppm_sso_local_make_jwt())
+    )
+  })
+
+  app$post("/__api__/token", function(req, res) {
+    if (
+      !identical(
+        req$form$grant_type,
+        "urn:ietf:params:oauth:grant-type:token-exchange"
+      )
+    ) {
+      return(res$set_status(400L)$send_json(
+        auto_unbox = TRUE,
+        list(error = "unsupported_grant_type")
+      ))
+    }
+    res$send_json(
+      auto_unbox = TRUE,
+      list(
+        access_token = req$form$subject_token,
+        token_type = "Bearer",
+        issued_token_type = "urn:ietf:params:oauth:token-type:access_token"
+      )
+    )
+  })
+
+  app
+}
+
+ppm_sso_local_make_jwt <- function(
+  iss = "https://ppm-sso-local.invalid/",
+  sub = "ppm-sso-local-user",
+  aud = "ppm-sso-local",
+  ttl = 3600L,
+  now = unclass(Sys.time())
+) {
+  header <- list(alg = "none", typ = "JWT")
+  payload <- list(
+    iss = iss,
+    sub = sub,
+    aud = aud,
+    iat = as.integer(now),
+    exp = as.integer(now + ttl)
+  )
+  enc <- function(x) {
+    ppm_sso_base64url_encode(charToRaw(
+      jsonlite::toJSON(x, auto_unbox = TRUE)
+    ))
+  }
+  paste0(enc(header), ".", enc(payload), ".")
+}
+
+# nocov end
diff --git a/src/library/pkgcache/R/ppm-sso.R b/src/library/pkgcache/R/ppm-sso.R
new file mode 100644
index 0000000000..43e797a15a
--- /dev/null
+++ b/src/library/pkgcache/R/ppm-sso.R
@@ -0,0 +1,648 @@
+#' Posit Package Manager single sign-on (SSO) authentication
+#'
+#' @details
+#' ## Set up SSO authentication:
+#' - Set the `PACKAGEMANAGER_ADDRESS` environment variable to the URL of
+#'   your RStudio Package Manager instance. For example, add this line to
+#'   your `.Renviron` file:
+#'   ```
+#'   PACKAGEMANAGER_ADDRESS=https://<ppm-url>
+#'   ```
+#'   Alternatively, you can also set it in your shell profile on Unix,
+#'   or in the System or User environment variables on Windows.
+#' - Set `options(repos)` to include a repository from your Package Manager
+#'   instance. Include `__token__` as the username in the URL. For example:
+#'   ```
+#'   options(repos = c(
+#'     PPM = "https://__token__@<ppm-url>/<repo-path>",
+#'     getOption("repos")
+#'   ))
+#'   ```
+#'   You probably want to add this to your `.Rprofile` file, so that it is
+#'   set in every R session.
+#' - Call [repo_get()] to trigger authentication and caching of the token.
+#'   You should be prompted to log in via your browser, and the obtained
+#'   token will be cached for future use. Call [ppm_sso_status()] to check
+#'   the status of your authentication, including the path of the cached
+#'   token and its expiration time.
+#' - Alternatively, you can call `ppm_sso_login()` directly to trigger
+#'   the login process directly.
+#'
+#' `ppm_sso_login()` initiates the SSO login process. You should be
+#' prompted to log in via your browser, and the obtained token will be
+#' cached for future use.
+#'
+#' @return `ppm_sso_login()` returns the obtained token invisibly.
+#'
+#' @seealso <https://docs.posit.co/rspm/admin/authentication/>
+#' @export
+#' @examplesIf FALSE
+#' Sys.setenv(PACKAGEMANAGER_ADDRESS = "https://<ppm-url>")
+#' options(repos = c(
+#'   PPM = "https://__token__@<ppm-url>/<repo-path>",
+#'   getOption("repos")
+#' ))
+#' ppm_sso_login()
+#' ppm_sso_status()
+#' ppm_sso_status(connect = TRUE)
+#' ppm_sso_logout()
+
+ppm_sso_login <- function() {
+  ppm_url <- Sys.getenv("PACKAGEMANAGER_ADDRESS", NA_character_)
+
+  identity_token <- ppm_sso_get_identity_token_from_file() %||%
+    ppm_sso_device_flow(ppm_url)
+  ppm_token <- ppm_sso_identity_to_ppm_token(ppm_url, identity_token)
+  ppm_sso_write_token_to_file(ppm_url, ppm_token)
+
+  invisible(ppm_token)
+}
+
+#' @rdname ppm_sso_login
+#' @details
+#' `ppm_sso_logout()` removes the cached token, effectively logging you
+#' out. If there is no cached token, it does nothing.
+#' @return `ppm_sso_logout()` does not return anything.
+#' @export
+
+ppm_sso_logout <- function() {
+  ppm_url <- Sys.getenv("PACKAGEMANAGER_ADDRESS", NA_character_)
+
+  # remove from cache if there
+  try_catch_null(suppressWarnings(rm(
+    list = ppm_url,
+    envir = pkgenv$ppm_sso_cache,
+    inherits = FALSE
+  )))
+  parsed <- parse_url(ppm_url)
+  try_catch_null(suppressWarnings(rm(
+    list = parsed$host,
+    envir = pkgenv$credentials,
+    inherits = FALSE
+  )))
+
+  token_file_path <- ppm_sso_token_path()
+  if (!file.exists(token_file_path)) {
+    return(invisible())
+  }
+  tokens <- try_catch_null({
+    tokens <- suppressWarnings(tstoml::ts_read_toml(token_file_path))
+    urls <- ts::ts_tree_unserialize(
+      ts::ts_tree_select(tokens, list("connections", TRUE, "address"))
+    )
+    idx <- which(urls == ppm_url)[1]
+    tokens
+  })
+
+  if (is.na(idx)) {
+    return(invisible())
+  }
+
+  tokens <- ts::ts_tree_delete(
+    ts::ts_tree_select(tokens, list("connections", idx))
+  )
+
+  ts::ts_tree_write(tokens, token_file_path)
+
+  invisible()
+}
+
+#' @rdname ppm_sso_login
+#' @param connect If `TRUE`, also checks if the token is valid by making a test
+#'   request to the Package Manager instance. This requires an active internet
+#'   connection and may take a few seconds. If `FALSE`, only checks if a
+#'   token is cached and not expired.
+#' @details
+#' `ppm_sso_status()` checks the status of your authentication, including
+#' the path of the cached token and its expiration time.
+#' @return `ppm_sso_status()` returns a list with the following components:
+#' - `ppm_url`: The URL of the Package Manager instance.
+#' - `token_file`: The path of the cached token file.
+#' - `token`: The cached token (partially masked for display) or `NA` if
+#'   no token is found locally.
+#' - `valid`: `TRUE` if the token is valid (only if `connect = TRUE`),
+#'   `FALSE` if invalid, or `NA` if not checked.
+#' - `issuer`: The issuer of the token, or `NA` if not available.
+#' - `subject`: The subject of the token, or `NA` if not available.
+#' - `audience`: The audience of the token, or `NA` if not available.
+#' - `issued_at`: The issue time of the token as a POSIXct object, or `NA`
+#'   if not available.
+#' - `expires_at`: The expiration time of the token as a POSIXct object,
+#'   or `NA`  if not available.
+#' - `expired`: `TRUE` if the token is expired, `FALSE` if not expired,
+#'   or `NA` if expiration time is not available.
+#' - `expires_in`: The time until expiration as a difftime object, or
+#'   `NA` if expiration time is not available or the token is already
+#'   expired.
+#' @export
+
+ppm_sso_status <- function(connect = FALSE) {
+  ppm_url <- Sys.getenv("PACKAGEMANAGER_ADDRESS", NA_character_)
+  ppm_sso_check_url(ppm_url)
+  token <- ppm_sso_get_cached_token(ppm_url, alive = TRUE) %||%
+    ppm_sso_get_existing_token(ppm_url, valid = FALSE)
+
+  jwt <- token %&&% jwt_split(token)
+  iat <- .POSIXct(jwt$payload$iat %||% NA_real_)
+  exp <- .POSIXct(jwt$payload$exp %||% NA_real_)
+  now <- Sys.time()
+  auth <- if (connect) {
+    token %&&%
+      try_catch_null(ppm_sso_can_authenticate(ppm_url, token)) %||%
+      FALSE
+  } else {
+    NA
+  }
+
+  structure(
+    list(
+      ppm_url = ppm_url,
+      token_file = ppm_sso_token_path(),
+      token = token %||% NA_character_,
+      valid = auth,
+      issuer = jwt$payload$iss %||% NA_character_,
+      subject = jwt$payload$sub %||% NA_character_,
+      audience = jwt$payload$aud %||% NA_character_,
+      issued_at = iat,
+      expires_at = exp,
+      expired = exp < now,
+      expires_in = if (!is.na(exp) && now < exp) {
+        exp - now
+      } else {
+        as.difftime(NA_real_, units = "secs")
+      }
+    ),
+    class = "ppm_sso_status"
+  )
+}
+
+jwt_split <- function(jwt) {
+  input <- strsplit(jwt, ".", fixed = TRUE)[[1]]
+  stopifnot(length(input) %in% c(2, 3))
+  header <- jsonlite::fromJSON(rawToChar(ppm_sso_base64url_decode(input[1])))
+  if (length(header$typ)) {
+    stopifnot(toupper(header$typ) == "JWT")
+  }
+  if (is.na(input[3])) {
+    input[3] = ""
+  }
+  sig <- ppm_sso_base64url_decode(input[3])
+  payload <- jsonlite::fromJSON(rawToChar(ppm_sso_base64url_decode(input[2])))
+  data <- charToRaw(paste(input[1:2], collapse = "."))
+  if (!grepl("^none|EdDSA|[HRE]S(256|384|512)$", header$alg)) {
+    stop("Invalid algorithm: ", header$alg)
+  }
+  if (grepl(".S\\d\\d\\d", header$alg)) {
+    type <- match.arg(substring(header$alg, 1, 1), c("HMAC", "RSA", "ECDSA"))
+    keysize <- as.numeric(substring(header$alg, 3))
+  } else {
+    type <- header$alg
+    keysize = NULL
+  }
+  list(
+    type = type,
+    keysize = keysize,
+    data = data,
+    sig = sig,
+    payload = payload,
+    header = header
+  )
+}
+
+#' @export
+
+print.ppm_sso_status <- function(x, ...) {
+  writeLines(format(x, ...))
+  invisible(x)
+}
+
+#' @export
+
+format.ppm_sso_status <- function(x, ...) {
+  token <- if (!is.na(x$token)) {
+    paste0(
+      substr(x$token, 1, 3),
+      "...",
+      substr(x$token, nchar(x$token) - 3, nchar(x$token))
+    )
+  } else {
+    NA_character_
+  }
+  key <- function(x) {
+    cli::col_cyan(x)
+  }
+  url <- function(x) {
+    if (!is.na(x) && startsWith(x, "http")) {
+      cli::style_hyperlink(x, x)
+    } else {
+      x
+    }
+  }
+  tick <- function(x, invert = FALSE) {
+    txt <- if (isTRUE(x)) {
+      "yes"
+    } else if (isFALSE(x)) {
+      "no"
+    } else {
+      "?"
+    }
+    if (invert) {
+      x <- !x
+    }
+    if (isTRUE(x)) {
+      cli::col_green(txt)
+    } else if (isFALSE(x)) {
+      cli::col_magenta(txt)
+    } else {
+      txt
+    }
+  }
+  ein <- if (is.na(x$expires_in)) "-" else format_time$pretty_dt(x$expires_in)
+  c(
+    cli::rule("PPM SSO Status"),
+    paste(key("PPM URL:    "), url(x$ppm_url)),
+    paste(key("Token file: "), x$token_file),
+    paste(key("Token:      "), token),
+    paste(key("Valid:      "), tick(x$valid)),
+    paste(key("Issuer:     "), url(x$issuer)),
+    paste(key("Subject:    "), x$subject),
+    paste(key("Audience:   "), x$audience),
+    paste(key("Issued at:  "), x$issued_at),
+    paste(key("Expires at: "), x$expires_at),
+    paste(key("Expired:    "), tick(x$expired, invert = TRUE)),
+    paste(key("Expires in: "), ein),
+    NULL
+  )
+}
+
+
+ppm_sso_check_url <- function(ppm_url) {
+  if (is.na(ppm_url)) {
+    stop(
+      "Please set the PACKAGEMANAGER_ADDRESS environment variable to ",
+      "the URL of your RStudio Package Manager instance."
+    )
+  }
+
+  if (is.na(parse_url(ppm_url)$host)) {
+    stop(
+      "The PACKAGEMANAGER_ADDRESS environment variable must be a valid URL, ",
+      "but got: ",
+      ppm_url
+    )
+  }
+}
+
+ppm_sso_auth <- function(repo) {
+  ppm_url <- Sys.getenv("PACKAGEMANAGER_ADDRESS", NA_character_)
+  parsed <- tryCatch(
+    parse_url(repo),
+    error = function(e) {
+      stop("Failed to parse repository URL: ", repo)
+    }
+  )
+  repo_host <- paste0(parsed$protocol, "://", parsed$host)
+  if (repo_host != ppm_url) {
+    stop(
+      "The repository URL (",
+      repo_host,
+      ") does not match the configured ",
+      "Package Manager URL (",
+      ppm_url,
+      ")."
+    )
+  }
+
+  token <- ppm_sso_get_cached_token(ppm_url, alive = TRUE) %||%
+    ppm_sso_get_existing_token(ppm_url, valid = TRUE) %||%
+    ppm_sso_login()
+
+  pkgenv$ppm_sso_cache[[ppm_url]] <- token
+
+  token
+}
+
+ppm_sso_get_cached_token <- function(ppm_url, alive = TRUE) {
+  token <- pkgenv$ppm_sso_cache[[ppm_url]]
+
+  # no token in cache
+  if (is.null(token)) {
+    return(NULL)
+  }
+
+  # no need to test if token is live
+  if (!alive) {
+    return(token)
+  }
+
+  # no expiration date
+  jwt <- jwt_split(token)
+  exp <- jwt$payload$exp
+  if (is.null(exp)) {
+    return(token)
+  }
+
+  # check if token is still valid
+  if (.POSIXct(exp) > Sys.time()) {
+    return(token)
+  }
+
+  # not valid any more, remove from cache
+  pkgenv$ppm_sso_cache[[ppm_url]] <- NULL
+
+  NULL
+}
+
+ppm_sso_post_form <- function(url, payload) {
+  payload <- payload[!vapply(payload, is.null, logical(1))]
+  body <- paste(
+    paste0(
+      curl::curl_escape(names(payload)),
+      "=",
+      curl::curl_escape(unlist(payload, use.names = FALSE))
+    ),
+    collapse = "&"
+  )
+  h <- curl::new_handle()
+  curl::handle_setheaders(
+    h,
+    "Content-Type" = "application/x-www-form-urlencoded"
+  )
+  curl::handle_setopt(h, post = TRUE, postfields = body)
+  resp <- curl::curl_fetch_memory(url, handle = h)
+  list(
+    status = resp$status_code,
+    body = tryCatch(
+      jsonlite::fromJSON(rawToChar(resp$content), simplifyVector = FALSE),
+      error = function(e) {
+        resp$content
+      }
+    )
+  )
+}
+
+ppm_sso_token_path <- function() {
+  file.path(
+    path.expand("~"),
+    ".ppm",
+    "tokens.toml"
+  )
+}
+
+ppm_sso_get_existing_token <- function(ppm_url, valid = TRUE) {
+  path <- ppm_sso_token_path()
+  try_catch_null({
+    ts_tokens <- suppressWarnings(tstoml::ts_read_toml(path))
+    for (conn in ts_tokens[[list("connections", TRUE)]]) {
+      if (identical(conn$address, ppm_url)) {
+        if (valid && !ppm_sso_can_authenticate(ppm_url, conn$token)) {
+          return(NULL)
+        }
+        return(conn$token)
+      }
+    }
+  })
+}
+
+ppm_sso_get_identity_token_from_file <- function() {
+  token_file <- Sys.getenv("PACKAGEMANAGER_IDENTITY_TOKEN_FILE", unset = NA)
+  if (is.na(token_file)) {
+    return(NULL)
+  }
+  try_catch_null({
+    trimws(readLines(token_file, n = 1, warn = FALSE))
+  })
+}
+
+ppm_sso_device_flow_init <- function(ppm_url) {
+  verifier <- ppm_sso_new_pkce_verifier()
+  challenge <- ppm_sso_new_pkce_challenge(verifier)
+
+  # 1. Initiate Device Auth
+  init_url <- paste0(ppm_url, "/__api__/device")
+  payload <- list(
+    code_challenge_method = "S256",
+    code_challenge = challenge
+  )
+  init_resp <- ppm_sso_post_form(init_url, payload)
+  if (init_resp$status >= 400) {
+    stop(
+      "Failed to initiate device authorization (HTTP ",
+      init_resp$status,
+      ")."
+    )
+  }
+  init_resp_body <- init_resp$body
+
+  display_uri <- init_resp_body$verification_uri_complete %||%
+    init_resp_body$verification_uri
+  if (is.null(display_uri)) {
+    stop("No verification URI found in device auth response.")
+  }
+
+  list(
+    verifier = verifier,
+    display_uri = display_uri,
+    user_code = init_resp_body$user_code,
+    device_code = init_resp_body$device_code,
+    expires_in = init_resp_body$expires_in,
+    interval = init_resp_body$interval
+  )
+}
+
+ppm_sso_device_flow_message <- function(ppm_url, init_result) {
+  cli::cli_rule("PPM SSO Login")
+  cli::cli_text("Login at {.url {init_result$display_uri}}")
+  cli::cli_text(
+    "and enter code {.emph {cli::col_magenta(init_result$user_code)}}
+     when prompted."
+  )
+  if (interactive()) {
+    readline("Press ENTER to open in browser...")
+    utils::browseURL(init_result$display_uri)
+  } else if (isTRUE(getOption("pak.is_worker"))) {
+    # called from pak, make the UI slightly nicer.
+    # unfortunately we cannot interact with the user here
+    utils::browseURL(init_result$display_uri)
+  }
+}
+
+ppm_sso_device_flow <- function(ppm_url) {
+  init_result <- ppm_sso_device_flow_init(ppm_url)
+  ppm_sso_device_flow_message(ppm_url, init_result)
+  token <- ppm_sso_device_flow_complete(ppm_url, init_result)
+  if (is.null(token)) {
+    stop("Failed to complete device authorization or obtain identity token.")
+  }
+  token
+}
+
+ppm_sso_can_authenticate <- function(ppm_url, token) {
+  h <- curl::new_handle()
+  curl::handle_setheaders(h, "Authorization" = paste("Bearer", token))
+  resp <- curl::curl_fetch_memory(ppm_url, handle = h)
+  status <- resp$status_code
+  status < 500 && status != 401 && status != 403
+}
+
+ppm_sso_identity_to_ppm_token <- function(ppm_url, identity_token) {
+  url <- paste0(ppm_url, "/__api__/token")
+  payload <- list(
+    grant_type = "urn:ietf:params:oauth:grant-type:token-exchange",
+    subject_token = identity_token,
+    subject_token_type = "urn:ietf:params:oauth:token-type:id_token"
+  )
+
+  resp <- ppm_sso_post_form(url, payload)
+  if (resp$status >= 400) {
+    stop(
+      "Failed to exchange identity token for PPM token (HTTP ",
+      resp$status,
+      ")."
+    )
+  }
+
+  token_data <- resp$body
+  if (is.null(token_data$access_token)) {
+    stop("Failed to exchange identity token for PPM token.")
+  }
+
+  token_data$access_token
+}
+
+ppm_sso_write_token_to_file <- function(ppm_url, token) {
+  # this is more difficult than it should be because TOML is unable
+  # to represent an empty array of tables
+  token_file_path <- ppm_sso_token_path()
+  mkdirp(dirname(token_file_path))
+  new_conn <- list(
+    address = ppm_url,
+    token = token,
+    auth_type = "sso"
+  )
+
+  tokens <- try_catch_null({
+    tokens <- suppressWarnings(tstoml::ts_read_toml(token_file_path))
+    urls <- ts::ts_tree_unserialize(
+      ts::ts_tree_select(tokens, list("connections", TRUE, "address"))
+    )
+    idx <- which(urls == ppm_url)[1]
+    tokens
+  })
+
+  if (is.null(tokens)) {
+    tokens <- tstoml::ts_parse_toml("")
+    tokens <- ts::ts_tree_insert(tokens, key = "connections", list(new_conn))
+  } else if (!is.na(idx)) {
+    tokens <- ts::ts_tree_update(
+      ts::ts_tree_select(tokens, list("connections", idx, "token")),
+      new_conn$token
+    )
+  } else if (length(urls) == 0) {
+    tokens <- ts::ts_tree_insert(tokens, key = "connections", list(new_conn))
+  } else {
+    tokens <- ts::ts_tree_insert(
+      ts::ts_tree_select(tokens, "connections"),
+      list(new_conn)
+    )
+  }
+
+  bytes <- as.raw(tokens)
+  file.create(token_file_path)
+  Sys.chmod(token_file_path, "600")
+  writeBin(bytes, token_file_path)
+}
+
+ppm_sso_base64url_decode <- function(x) {
+  # Add padding if missing
+  padding_needed <- (4 - nchar(x) %% 4) %% 4
+  x <- paste0(x, strrep("=", padding_needed))
+  # Replace URL-safe characters
+  x <- gsub("-", "+", gsub("_", "/", x))
+  processx::base64_decode(x)
+}
+
+ppm_sso_base64url_encode <- function(x) {
+  encoded <- processx::base64_encode(x)
+  # Make it URL-safe
+  gsub("\\+", "-", gsub("\\/", "_", gsub("=+$", "", encoded)))
+}
+
+ppm_sso_hex_to_raw <- function(s) {
+  n <- nchar(s)
+  as.raw(strtoi(substring(s, seq(1L, n, 2L), seq(2L, n, 2L)), 16L))
+}
+
+ppm_sso_sha256_raw <- function(x) {
+  ppm_sso_hex_to_raw(cli::hash_sha256(x))
+}
+
+ppm_sso_new_pkce_verifier <- function() {
+  ppm_sso_base64url_encode(.Call(pkgcache_rand_bytes, 32L))
+}
+
+ppm_sso_new_pkce_challenge <- function(verifier) {
+  ppm_sso_base64url_encode(ppm_sso_sha256_raw(verifier))
+}
+
+ppm_sso_device_flow_complete <- function(ppm_url, init_result) {
+  device_code <- init_result$device_code
+  verifier <- init_result$verifier
+  interval <- init_result$interval %||% 5
+  expires_in <- init_result$expires_in %||% 300
+
+  url <- paste0(ppm_url, "/__api__/device_access")
+  start_time <- Sys.time()
+  payload <- list(
+    device_code = device_code,
+    code_verifier = verifier
+  )
+
+  # PPM might not respond until the user completes auth, so show this
+  oldopt <- options(cli.progress_show_after = 0)
+  on.exit(options(oldopt), add = TRUE)
+  cli::cli_progress_bar(
+    format = "{cli::pb_spin} Waiting for browser."
+  )
+  cli::cli_progress_update()
+
+  while (as.numeric(Sys.time() - start_time) < expires_in) {
+    resp <- ppm_sso_post_form(url, payload)
+    status <- resp$status
+
+    if (status == 200) {
+      cli::cli_progress_done()
+      cli::cli_alert_success("Authorization successful.")
+      return(resp$body$id_token)
+    } else if (status == 400) {
+      error_code <- resp$body$error
+      if (error_code == "access_denied") {
+        cli::cli_progress_done()
+        cli::cli_alert_danger("Authorization denied by user.")
+        stop("Access denied by user.")
+      }
+      if (error_code == "expired_token") {
+        cli::cli_progress_done()
+        cli::cli_alert_danger("Device authorization request expired.")
+        stop("Device authorization request expired.")
+      }
+      # For "authorization_pending" or "slow_down", just wait and retry.
+    } else {
+      cli::cli_progress_done()
+      cli::cli_alert_danger(
+        "Device authorization failed (HTTP {status})."
+      )
+      stop("Device authorization failed.")
+    }
+
+    deadline <- Sys.time() + interval
+    while (Sys.time() < deadline) {
+      Sys.sleep(.1)
+      cli::cli_progress_update()
+    }
+  }
+
+  cli::cli_progress_done()
+  cli::cli_alert_danger("Device authorization timed out.")
+  stop("Device authorization timed out.")
+}
diff --git a/src/library/pkgcache/R/ppm.R b/src/library/pkgcache/R/ppm.R
index 035ce6290c..da3af1d641 100644
--- a/src/library/pkgcache/R/ppm.R
+++ b/src/library/pkgcache/R/ppm.R
@@ -244,7 +244,9 @@ ppm_has_binaries <- function() {
     current$cpu == "x86_64" &&
     (current$os == "mingw32" || grepl("linux", current$os))
 
-  if (!binaries) return(FALSE)
+  if (!binaries) {
+    return(FALSE)
+  }
 
   current_rver <- get_minor_r_version(getRversion())
   synchronise(async_get_ppm_status(
@@ -274,7 +276,9 @@ ppm_has_binaries <- function() {
 
 ppm_match_platform <- function(distros, plt) {
   which(vlapply(distros$platforms, function(dplts) {
-    if (plt %in% dplts) return(TRUE)
+    if (plt %in% dplts) {
+      return(TRUE)
+    }
     res <- grep("^/.*/$", dplts, value = TRUE)
     any(vlapply(res, function(re) {
       re <- sub("/$", "$", sub("^/", "^", re))
diff --git a/src/library/pkgcache/R/progress-bar.R b/src/library/pkgcache/R/progress-bar.R
index 23fec4ffbe..79114a874e 100644
--- a/src/library/pkgcache/R/progress-bar.R
+++ b/src/library/pkgcache/R/progress-bar.R
@@ -19,8 +19,7 @@ create_progress_bar <- function(data) {
   bar$data$current <- NA_integer_
 
   bar$timer <- async_timer$new(1 / 10, function() show_progress_bar(bar))
-  bar$timer$listen_on("error", function(...) {
-  })
+  bar$timer$listen_on("error", function(...) {})
 
   bar
 }
diff --git a/src/library/pkgcache/R/repo-set.R b/src/library/pkgcache/R/repo-set.R
index de63b15366..28725a017a 100644
--- a/src/library/pkgcache/R/repo-set.R
+++ b/src/library/pkgcache/R/repo-set.R
@@ -92,13 +92,15 @@ repo_resolve <- function(spec, username = NULL) {
 
 repo_add <- function(..., .list = NULL, username = NULL) {
   repo_add_internal(..., .list = .list, username = username)
-  invisible(suppressMessages(repo_get()))
+  invisible(repo_get())
 }
 
 repo_add_internal <- function(..., .list = NULL, username = NULL) {
   new <- c(list(...), .list)
 
-  if (length(new) == 0) return(invisible(repo_get()))
+  if (length(new) == 0) {
+    return(invisible(repo_get()))
+  }
 
   toadd <- unlist(mapply(
     repo_sugar,
@@ -187,17 +189,23 @@ repo_sugar <- function(x, nm, username = NULL) {
 }
 
 repo_sugar_url <- function(x, nm) {
-  if (is.null(nm) || nm == "") nm <- "EXTRA"
+  if (is.null(nm) || nm == "") {
+    nm <- "EXTRA"
+  }
   structure(x, names = nm)
 }
 
 repo_sugar_path <- function(x, nm) {
-  if (is.null(nm) || nm == "") nm <- "LOCAL"
+  if (is.null(nm) || nm == "") {
+    nm <- "LOCAL"
+  }
   structure(x, names = nm)
 }
 
 repo_sugar_mran <- function(x, nm) {
-  if (is.null(nm) || nm == "") nm <- "CRAN"
+  if (is.null(nm) || nm == "") {
+    nm <- "CRAN"
+  }
   date <- parse_spec(sub("^MRAN@", "", x))
   if (date < "2017-10-10") {
     stop("PPM snapshots go back to 2017-10-10 only")
@@ -211,7 +219,9 @@ repo_sugar_mran <- function(x, nm) {
 }
 
 repo_sugar_ppm <- function(x, nm) {
-  if (is.null(nm) || nm == "") nm <- "CRAN"
+  if (is.null(nm) || nm == "") {
+    nm <- "CRAN"
+  }
   x <- sub("^PPM@", "", x)
   x <- sub("^RSPM@", "", x)
   date <- parse_spec(x)
@@ -406,7 +416,7 @@ next_day <- function(x) {
 #'   for details.
 #' * `MRAN@...` repository specifications now resolve to PPM, but note that
 #'   PPM snapshots are only available from 2017-10-10. See more about this
-#'   at <https://posit.co/blog/migrating-from-mran-to-posit-package-manager/>.
+#'   at <https://posit.co/blog/migrating-from-mran-to-posit-package-manager>.
 #' * All dates (or times) can be specified in the ISO 8601 format.
 #' * If PPM does not have a snapshot available for a date, the next
 #'   available date is used.
diff --git a/src/library/pkgcache/R/repo-status.R b/src/library/pkgcache/R/repo-status.R
index 79d3f77875..33643a01d8 100644
--- a/src/library/pkgcache/R/repo-status.R
+++ b/src/library/pkgcache/R/repo-status.R
@@ -162,7 +162,9 @@ summary.pkgcache_repo_status <- function(object, ...) {
   ssm <- data_frame(repository = unique(key))
 
   pls <- unique(object$platform)
-  for (pl in pls) ssm[[pl]] <- TRUE
+  for (pl in pls) {
+    ssm[[pl]] <- TRUE
+  }
   ssm$ping <- NA_real_
 
   for (i in seq_len(nrow(ssm))) {
diff --git a/src/library/pkgcache/R/utils.R b/src/library/pkgcache/R/utils.R
index 5093370716..e5787c4d0d 100644
--- a/src/library/pkgcache/R/utils.R
+++ b/src/library/pkgcache/R/utils.R
@@ -2,6 +2,10 @@ repoman_data <- new.env(parent = emptyenv())
 
 `%||%` <- function(l, r) if (is.null(l)) r else l
 
+`%&&%` <- function(l, r) if (is.null(l)) NULL else r
+
+isFALSE <- function(x) is.logical(x) && length(x) == 1L && !is.na(x) && !x
+
 vcapply <- function(X, FUN, ...) {
   vapply(X, FUN, FUN.VALUE = character(1), ...)
 }
@@ -22,10 +26,16 @@ vdapply <- function(X, FUN, ...) {
 
 mapx <- function(...) {
   args <- list(...)
-  if (length(args) == 0) stop("No arguments to `mapx()`")
+  if (length(args) == 0) {
+    stop("No arguments to `mapx()`")
+  }
   fun <- args[[length(args)]]
-  if (!is.function(fun)) stop("Last `mapx()` argument not a function")
-  if (length(args) == 1) stop("No data to `mapx()`")
+  if (!is.function(fun)) {
+    stop("Last `mapx()` argument not a function")
+  }
+  if (length(args) == 1) {
+    stop("No data to `mapx()`")
+  }
   data <- args[-length(args)]
 
   lens <- setdiff(unique(viapply(data, length)), 1L)
@@ -167,7 +177,9 @@ file.size <- function(...) {
 
 msg_wrap <- function(..., .space = TRUE) {
   ret <- paste(strwrap(paste0(...)), collapse = "\n")
-  if (.space) ret <- paste0("\n", ret, "\n")
+  if (.space) {
+    ret <- paste0("\n", ret, "\n")
+  }
   ret
 }
 
diff --git a/src/library/pkgcache/inst/WORDLIST b/src/library/pkgcache/inst/WORDLIST
index 44bd7d327e..1d08957d29 100644
--- a/src/library/pkgcache/inst/WORDLIST
+++ b/src/library/pkgcache/inst/WORDLIST
@@ -13,11 +13,13 @@ Encodings
 FreeBSD
 MRAN
 PBC
+POSIXct
 README
 ROR
 RSPM
 RStudio
 SHA
+SSO
 Solaris
 Sur
 UTF
@@ -25,6 +27,7 @@ UUID
 archs
 async
 devel
+difftime
 encodings
 funder
 html
diff --git a/src/library/pkgcache/inst/fixtures/bioc-config.yaml b/src/library/pkgcache/inst/fixtures/bioc-config.yaml
index b407aa5bc5..b61c55584f 100644
--- a/src/library/pkgcache/inst/fixtures/bioc-config.yaml
+++ b/src/library/pkgcache/inst/fixtures/bioc-config.yaml
@@ -8,12 +8,12 @@ production_deploy_root: webadmin@master.bioconductor.org:/extra/www/bioc
 staging_dir: /loc/www/bioconductor-test-new
 
 ## CHANGE THIS WHEN WE RELEASE A VERSION:
-release_version: "3.22"
-r_version_associated_with_release: "4.5.0"
+release_version: "3.23"
+r_version_associated_with_release: "4.6.0"
 r_version_associated_with_devel: "4.6.0"
 
 ## CHANGE THIS WHEN WE RELEASE A VERSION:
-devel_version: "3.23"
+devel_version: "3.24"
 
 ## CHANGE THIS WHEN WE ADD A VERSION:
 ## This is the list of all versions for which we want to generate "new" 
@@ -24,26 +24,26 @@ devel_version: "3.23"
 ## let the no-longer-release version build one last time so package
 ## landing pages won't say "release version"):
 versions:
-- "3.22"
 - "3.23"
+- "3.24"
 
 ## CHANGE THIS (i.e., uncomment) as various parts of the new devel version 
 ## become available. set to "[]" if none are available.
 devel_repos:
 - "bioc"
 - "data/experiment"
-- "workflows"
-- "data/annotation"
+#- "workflows"
+#- "data/annotation"
 
 ## CHANGE this when the build machines change:
 ## also, don't include machines that are not building yet (comment them out)
 active_release_builders:
-  linux: "nebbiolo2"
+  linux: "nebbiolo1"
   mac_monterey: "lconway"
   mac_ventura: "kjohnson3"
 #  windows: "palomino8"
 active_devel_builders:
-  linux: "nebbiolo1"
+  linux: "nebbiolo2"
 #  windows: "palomino7"
 #  mac_monterey: "merida1"
 
@@ -166,6 +166,7 @@ r_ver_for_bioc_ver:
   "3.21": "4.5"
   "3.22": "4.5"
   "3.23": "4.6"
+  "3.24": "4.6"
 # UPDATE THIS when we release a version
 release_dates: # old info from http://en.wikipedia.org/wiki/Bioconductor#Milestones
   "1.0": "1/5/2001"
@@ -216,6 +217,7 @@ release_dates: # old info from http://en.wikipedia.org/wiki/Bioconductor#Milesto
   "3.20": "10/30/2024"
   "3.21": "04/16/2025"
   "3.22": "10/30/2025"
+  "3.23": "04/29/2026"
 release_last_built_dates:
   '2.0': 09/12/2007
   '2.1': 04/09/2008
@@ -254,6 +256,7 @@ release_last_built_dates:
   '3.19': 10/18/2024
   '3.20': 04/02/2025
   '3.21': 10/16/2025
+  '3.22': 04/08/2026
 mirrors:
  - 0-Bioconductor:
    - institution: Bioconductor, automatic redirection to servers worldwide
diff --git a/src/library/pkgcache/src/init.c b/src/library/pkgcache/src/init.c
index 97944f830c..9334b0ab03 100644
--- a/src/library/pkgcache/src/init.c
+++ b/src/library/pkgcache/src/init.c
@@ -30,6 +30,8 @@ static const R_CallMethodDef callMethods[]  = {
   REG(pkgcache_parse_packages_raw,    1),
   REG(pkgcache_graphics_api_version,  0),
 
+  REG(pkgcache_rand_bytes,            1),
+
   REG(pkgcache__gcov_flush,           0),
   { NULL, NULL, 0 }
 };
diff --git a/src/library/pkgcache/src/pkgcache.h b/src/library/pkgcache/src/pkgcache.h
index de0922f5ec..05c0a16954 100644
--- a/src/library/pkgcache/src/pkgcache.h
+++ b/src/library/pkgcache/src/pkgcache.h
@@ -12,3 +12,5 @@ SEXP pkgcache_parse_descriptions(SEXP paths, SEXP lowercase);
 SEXP pkgcache_parse_packages_raw(SEXP raw);
 
 SEXP pkgcache_graphics_api_version(void);
+
+SEXP pkgcache_rand_bytes(SEXP n);
diff --git a/src/library/pkgcache/src/rand.c b/src/library/pkgcache/src/rand.c
new file mode 100644
index 0000000000..f3b67e811e
--- /dev/null
+++ b/src/library/pkgcache/src/rand.c
@@ -0,0 +1,85 @@
+#include "pkgcache.h"
+
+#include <string.h>
+
+#if defined(_WIN32)
+# include <windows.h>
+# define RtlGenRandom SystemFunction036
+# ifdef __cplusplus
+extern "C"
+# endif
+BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
+# pragma comment(lib, "advapi32.lib")
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
+      defined(__NetBSD__) || defined(__DragonFly__)
+# include <stdlib.h>
+#else
+# include <errno.h>
+# include <fcntl.h>
+# include <unistd.h>
+# if defined(__linux__)
+#  include <sys/syscall.h>
+# endif
+#endif
+
+SEXP pkgcache_rand_bytes(SEXP n) {
+  int size = Rf_asInteger(n);
+  if (size == NA_INTEGER || size < 0) {
+    Rf_error("Invalid number of random bytes requested");
+  }
+  SEXP res = PROTECT(Rf_allocVector(RAWSXP, size));
+  if (size == 0) {
+    UNPROTECT(1);
+    return res;
+  }
+  unsigned char *buf = RAW(res);
+
+#if defined(_WIN32)
+  if (!RtlGenRandom((PVOID) buf, (ULONG) size)) {
+    Rf_error("Failed to obtain random bytes from RtlGenRandom");
+  }
+
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
+      defined(__NetBSD__) || defined(__DragonFly__)
+  arc4random_buf(buf, (size_t) size);
+
+#else
+  size_t off = 0;
+# if defined(__linux__) && defined(SYS_getrandom)
+  while (off < (size_t) size) {
+    long r = syscall(SYS_getrandom, buf + off, (size_t) size - off, 0);
+    if (r > 0) {
+      off += (size_t) r;
+    } else if (r < 0 && (errno == EINTR || errno == EAGAIN)) {
+      continue;
+    } else {
+      break; /* fall through to /dev/urandom */
+    }
+  }
+# endif
+  if (off < (size_t) size) {
+    int fd;
+    do {
+      fd = open("/dev/urandom", O_RDONLY);
+    } while (fd < 0 && errno == EINTR);
+    if (fd < 0) {
+      Rf_error("Failed to open /dev/urandom: %s", strerror(errno));
+    }
+    while (off < (size_t) size) {
+      ssize_t r = read(fd, buf + off, (size_t) size - off);
+      if (r > 0) {
+        off += (size_t) r;
+      } else if (r < 0 && errno == EINTR) {
+        continue;
+      } else {
+        close(fd);
+        Rf_error("Failed to read from /dev/urandom: %s", strerror(errno));
+      }
+    }
+    close(fd);
+  }
+#endif
+
+  UNPROTECT(1);
+  return res;
+}
diff --git a/src/library/pkgdepends/DESCRIPTION b/src/library/pkgdepends/DESCRIPTION
index eb3791cdf8..f1d3826b39 100644
--- a/src/library/pkgdepends/DESCRIPTION
+++ b/src/library/pkgdepends/DESCRIPTION
@@ -34,9 +34,9 @@ Config/Needs/website: r-lib/asciicast, pkgdown (>= 2.0.2),
 Config/testthat/edition: 3
 Config/usethis/last-upkeep: 2025-05-05
 Encoding: UTF-8
-RoxygenNote: 7.3.2.9000
+RoxygenNote: 7.3.3
 NeedsCompilation: yes
-Packaged: 2026-04-23 10:52:26 UTC; gaborcsardi
+Packaged: 2026-05-14 11:57:06 UTC; gaborcsardi
 Author: Gábor Csárdi [aut, cre],
   Posit Software, PBC [cph, fnd] (ROR: <https://ror.org/03wc8by49>)
 Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
diff --git a/src/library/pkgdepends/R/docs.R b/src/library/pkgdepends/R/docs.R
index dd09b63912..c6fc232285 100644
--- a/src/library/pkgdepends/R/docs.R
+++ b/src/library/pkgdepends/R/docs.R
@@ -71,8 +71,8 @@ generate_config_docs <- function() {
   alldocs
 }
 
-doc_share_rmd <- function(rmd, rds) {
-  md <- sub("[.]Rmd$", ".md", rmd)
+doc_share_rmd <- function(rmd, rds, md = NULL) {
+  md <- md %||% sub("[.]Rmd$", ".md", rmd)
   if (md == rmd) {
     stop("Docs Rmd file must have extension `.Rmd`")
   }
diff --git a/src/library/pkgdepends/R/download.R b/src/library/pkgdepends/R/download.R
index 5f39539107..d9acf4d47d 100644
--- a/src/library/pkgdepends/R/download.R
+++ b/src/library/pkgdepends/R/download.R
@@ -11,7 +11,7 @@
 #'
 #' ```{r child = {options(rx_downloads = TRUE); "tools/doc/resolution-result.Rmd" }}
 #' ```
-#' `r { options(rx_downloads = TRUE); doc_share_rmd("tools/doc/resolution-result.Rmd", "inst/docs/download-result.rds")}`
+#' `r { options(rx_downloads = TRUE); doc_share_rmd("tools/doc/resolution-result.Rmd", "inst/docs/download-result.rds", "tools/doc/download-result.md")}`
 #'
 #' @name pkg_downloads
 #' @aliases pkg_download_result
diff --git a/src/library/pkgdepends/R/errors.R b/src/library/pkgdepends/R/errors.R
index 35112e4ca0..d336ad91b2 100644
--- a/src/library/pkgdepends/R/errors.R
+++ b/src/library/pkgdepends/R/errors.R
@@ -167,13 +167,13 @@ err <- local({
   #'
   #' @noRd
   #' @param ... Parts of the error message, they will be converted to
-  #'   character and then concatenated, like in [stop()].
+  #'   character and then concatenated, like in `stop()`.
   #' @param call. A call object to include in the condition, or `TRUE`
-  #'   or `NULL`, meaning that [throw()] should add a call object
+  #'   or `NULL`, meaning that `throw()` should add a call object
   #'   automatically. If `FALSE`, then no call is added.
   #' @param srcref Alternative source reference object to use instead of
   #'   the one of `call.`.
-  #' @param domain Translation domain, see [stop()]. We set this to
+  #' @param domain Translation domain, see `stop()`. We set this to
   #'   `NA` by default, which means that no translation occurs. This
   #'   has the benefit that the error message is not re-encoded into
   #'   the native locale.
@@ -193,10 +193,10 @@ err <- local({
   #' It also adds the `rlib_error` class.
   #'
   #' @noRd
-  #' @param ... Passed to [new_cond()].
-  #' @param call. Passed to [new_cond()].
-  #' @param srcref Passed tp [new_cond()].
-  #' @param domain Passed to [new_cond()].
+  #' @param ... Passed to `new_cond()`.
+  #' @param call. Passed to `new_cond()`.
+  #' @param srcref Passed tp `new_cond()`.
+  #' @param domain Passed to `new_cond()`.
   #' @return Error condition object with classes `rlib_error`, `error`
   #'   and `condition`.
 
@@ -210,13 +210,13 @@ err <- local({
 
   #' Throw a condition
   #'
-  #' If the condition is an error, it will also call [stop()], after
+  #' If the condition is an error, it will also call `stop()`, after
   #' signalling the condition first. This means that if the condition is
-  #' caught by an exiting handler, then [stop()] is not called.
+  #' caught by an exiting handler, then `stop()` is not called.
   #'
   #' @noRd
   #' @param cond Condition object to throw. If it is an error condition,
-  #'   then it calls [stop()].
+  #'   then it calls `stop()`.
   #' @param parent Parent condition.
   #' @param frame The throwing context. Can be used to hide frames from
   #'   the backtrace.
@@ -340,7 +340,7 @@ err <- local({
   #' @noRd
   #' @param expr Expression to evaluate.
   #' @param err Error object or message to use for the child error.
-  #' @param call Call to use in the re-thrown error. See [throw()].
+  #' @param call Call to use in the re-thrown error. See `throw()`.
 
   chain_error <- function(expr, err, call = sys.call(-1), srcref = NULL) {
     .hide_from_trace <- 1
@@ -371,8 +371,8 @@ err <- local({
   #' adds the `c_error` class.
   #'
   #' @noRd
-  #' @param .NAME Compiled function to call, see [.Call()].
-  #' @param ... Function arguments, see [.Call()].
+  #' @param .NAME Compiled function to call, see `.Call()`.
+  #' @param ... Function arguments, see `.Call()`.
   #' @return Result of the call.
 
   chain_call <- function(.NAME, ...) {
@@ -406,14 +406,14 @@ err <- local({
 
   #' Version of entrace_call that supports cleancall
   #'
-  #' This function is the same as [entrace_call()], except that it
-  #' uses cleancall's [.Call()] wrapper, to enable resource cleanup.
+  #' This function is the same as `entrace_call()`, except that it
+  #' uses cleancall's `.Call()` wrapper, to enable resource cleanup.
   #' See https://github.com/r-lib/cleancall#readme for more about
   #' resource cleanup.
   #'
   #' @noRd
-  #' @param .NAME Compiled function to call, see [.Call()].
-  #' @param ... Function arguments, see [.Call()].
+  #' @param .NAME Compiled function to call, see `.Call()`.
+  #' @param ... Function arguments, see `.Call()`.
   #' @return Result of the call.
 
   chain_clean_call <- function(.NAME, ...) {
@@ -447,7 +447,7 @@ err <- local({
 
   #' Create a traceback
   #'
-  #' [throw()] calls this function automatically if an error is not caught,
+  #' `throw()` calls this function automatically if an error is not caught,
   #' so there is currently not much use to call it directly.
   #'
   #' @param cond Condition to add the trace to
diff --git a/src/library/pkgdepends/R/git-auth.R b/src/library/pkgdepends/R/git-auth.R
index 30c7fca289..43619d9778 100644
--- a/src/library/pkgdepends/R/git-auth.R
+++ b/src/library/pkgdepends/R/git-auth.R
@@ -335,7 +335,7 @@ gitcreds <- local({
   #' Run a `git credential` command
   #'
   #' @details
-  #' We set the [gitcreds_env()] environment variables, to avoid dialog boxes
+  #' We set the `gitcreds_env()` environment variables, to avoid dialog boxes
   #' from some credential helpers and also validation that potentiall needs
   #' an internet connection.
   #'
@@ -347,7 +347,7 @@ gitcreds <- local({
   #' @return Standard output, line by line.
   #'
   #' @noRd
-  #' @seealso [git_run()].
+  #' @seealso `git_run()`.
 
   gitcreds_run <- function(command, input, args = character()) {
     env <- gitcreds_env()
@@ -380,7 +380,7 @@ gitcreds <- local({
   #' * `stderr`: the standard error of the command, line by line.
   #'
   #' @param args Command line arguments.
-  #' @param input The standard input (the `input` argument of [system2()].
+  #' @param input The standard input (the `input` argument of `system2()`.
   #' @noRd
   #' @return Standard output, line by line.
 
@@ -429,7 +429,7 @@ gitcreds <- local({
   #' credentials. `TRUE` for replacing/deleting them.
   #'
   #' @noRd
-  #' @seealso [gitcreds_set()].
+  #' @seealso `gitcreds_set()`.
 
   ack <- function(url, current, what = "Replace") {
     msg("\n-> Your current credentials for ", squote(url), ":\n")
@@ -777,7 +777,7 @@ gitcreds <- local({
 
   `%||%` <- function(l, r) if (is.null(l)) r else l
 
-  #' Like [message()], but print to standard output in interactive
+  #' Like `message()`, but print to standard output in interactive
   #' sessions
   #'
   #' To avoid red output in RStudio, RGui, and R.app.
@@ -856,7 +856,7 @@ gitcreds <- local({
   #' Read all of a file
   #'
   #' @param path File to read.
-  #' @param ... Passed to [readChar()].
+  #' @param ... Passed to `readChar()`.
   #' @noRd
   #' @return String.
 
diff --git a/src/library/pkgdepends/R/git-protocol.R b/src/library/pkgdepends/R/git-protocol.R
index 11bbf8ffdf..19b3882c71 100644
--- a/src/library/pkgdepends/R/git-protocol.R
+++ b/src/library/pkgdepends/R/git-protocol.R
@@ -675,7 +675,7 @@ raw_as_utf8 <- function(x) {
 #'   git protocol docs for what these are.
 #' * `data`: for `data-pkt` lines this is a raw vector of the data.
 #' * `text`: for `data-pkt` lines that are text, this is the text of the
-#'   data. We use [raw_as_utf8()] to convert raw data to text, and sometimes
+#'   data. We use `raw_as_utf8()` to convert raw data to text, and sometimes
 #'   it might interpret binary data as text, especially if the data is
 #'   short. So this field is for convenience only.
 #'
@@ -815,7 +815,7 @@ git_create_message_v1 <- function(args = character(), caps = character()) {
 #'
 #' @inheritParams git_list_refs
 #' @inheritParams git_create_message_v2
-#' @return Response from git, already parsed with [git_parse_message()].
+#' @return Response from git, already parsed with `git_parse_message()`.
 #'
 #' @noRd
 
@@ -927,7 +927,7 @@ pkt_line <- function(payload, ...) {
 #' queries.
 #'
 #' @inheritParams git_list_refs
-#' @return Same as [git_list_refs()].
+#' @return Same as `git_list_refs()`.
 #' @noRd
 
 git_list_refs_v1 <- function(url) {
@@ -953,7 +953,7 @@ async_git_list_refs_v1 <- function(url) {
 #'
 #' @param response Response from git, as returned by `async::http_get()`, which
 #'   is the same as the object from `curl::curl_fetch_memory()`.
-#' @return Same as [git_list_refs()].
+#' @return Same as `git_list_refs()`.
 #' @noRd
 
 git_list_refs_v1_process <- function(response, url) {
@@ -1057,7 +1057,7 @@ git_parse_pkt_line_refs <- function(lines, url) {
 #' interested in a subset of refs.
 #'
 #' @inheritParams git_list_refs
-#' @return Same as [git_list_refs()].
+#' @return Same as `git_list_refs()`.
 #' @noRd
 
 git_list_refs_v2 <- function(url, prefixes = character()) {
@@ -1184,7 +1184,7 @@ check_initial_response <- function(psd, url) {
 #' @param reply The parsed message from the server.
 #' @param caps Capabilities that are passed in from the response to
 #'   the initial client request.
-#' @return Same as [git_list_refs()].
+#' @return Same as `git_list_refs()`.
 #' @noRd
 
 async_git_list_refs_v2_process_3 <- function(reply, caps, url) {
@@ -1218,7 +1218,7 @@ async_git_list_refs_v2_process_3 <- function(reply, caps, url) {
 #'   * `type`: `commit`, `tree`, `blob` or `tag`.
 #'   * `object`: the contents of the object. For `commit` the commit
 #'     data and message in a string. For `tree` a data frame, as returned
-#'     from [parse_tree()]. For `blob` and `tag` a raw vector.
+#'     from `parse_tree()`. For `blob` and `tag` a raw vector.
 #'   * `size`: unpacked size.
 #'   * `packed_size`: packed size (size header not included).
 #'
diff --git a/src/library/pkgdepends/inst/WORDLIST b/src/library/pkgdepends/inst/WORDLIST
index 8eee8b2d87..95cc7655ac 100644
--- a/src/library/pkgdepends/inst/WORDLIST
+++ b/src/library/pkgdepends/inst/WORDLIST
@@ -1,10 +1,13 @@
 Acromine
+Bioconductor
 CMD
+CRAN
 Capitan
 Codecov
 Config
 DevOps
 El
+FreeBSD
 GitLab
 HOWTO
 ILP
@@ -19,6 +22,7 @@ RedHat
 Rproj
 SHA
 Shorthands
+Solaris
 Sur
 async
 cli
@@ -31,6 +35,7 @@ ggplot
 gitcreds
 glmnet
 hexbin
+html
 keras
 kknn
 knitr
@@ -53,6 +58,8 @@ rstanarm
 shorthands
 sparklyr
 sshfs
+subdirectories
+subdirectory
 submodule
 submodules
 svglite
@@ -60,3 +67,4 @@ testthat
 tibbles
 uncompress
 uncompressing
+xml
diff --git a/src/library/pkgdepends/inst/docs/download-result.rds b/src/library/pkgdepends/inst/docs/download-result.rds
index af9a60cd64..107855954e 100644
Binary files a/src/library/pkgdepends/inst/docs/download-result.rds and b/src/library/pkgdepends/inst/docs/download-result.rds differ
diff --git a/src/library/pkgdepends/inst/docs/pkg-refs.rds b/src/library/pkgdepends/inst/docs/pkg-refs.rds
index ea1dcf8ea7..b45e0885a9 100644
Binary files a/src/library/pkgdepends/inst/docs/pkg-refs.rds and b/src/library/pkgdepends/inst/docs/pkg-refs.rds differ
diff --git a/src/library/pkgdepends/inst/docs/resolution-result.rds b/src/library/pkgdepends/inst/docs/resolution-result.rds
index d973071cc9..29641af97d 100644
Binary files a/src/library/pkgdepends/inst/docs/resolution-result.rds and b/src/library/pkgdepends/inst/docs/resolution-result.rds differ
diff --git a/src/library/ts/DESCRIPTION b/src/library/ts/DESCRIPTION
new file mode 100644
index 0000000000..c863be4f7e
--- /dev/null
+++ b/src/library/ts/DESCRIPTION
@@ -0,0 +1,32 @@
+Package: ts
+Title: Tree-Sitter Parsing Tools
+Version: 0.0.0.9000
+Authors@R: c(
+    person("Gábor", "Csárdi", , "csardi.gabor@gmail.com",
+        role = c("aut", "cre")),
+    person("Posit Software, PBC", role = c("cph", "fnd"),
+        comment = c(ROR = "03wc8by49")),
+    person("Tree-sitter authors", role = "cph", comment = "Tree-sitter C library")
+  )
+Description: Common tree-sitter parsing tools for R. It is meant to be
+    used by other packages that specialize in particular languages and
+    file formats.
+License: MIT + file LICENSE
+Depends: R (>= 4.1.0)
+Imports: cli, utils
+Suggests: magrittr, pillar, testthat (>= 3.0.0), tsjsonc, tstoml, withr
+Remotes: gaborcsardi/tsjsonc, gaborcsardi/tstoml
+Additional_repositories: https://github.com/r-lib/ts/releases/download
+Encoding: UTF-8
+RoxygenNote: 7.3.3
+URL: https://github.com/r-lib/ts, https://r-lib.github.io/ts/
+BugReports: https://github.com/r-lib/ts/issues
+Config/testthat/edition: 3
+Config/Needs/website: r-lib/asciicast, tidyverse/tidytemplate
+Biarch: true
+NeedsCompilation: yes
+Packaged: 2026-05-13 07:38:59 UTC; gaborcsardi
+Author: Gábor Csárdi [aut, cre],
+  Posit Software, PBC [cph, fnd] (ROR: <https://ror.org/03wc8by49>),
+  Tree-sitter authors [cph] (Tree-sitter C library)
+Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
diff --git a/src/library/ts/LICENSE b/src/library/ts/LICENSE
new file mode 100644
index 0000000000..f00d2e60d9
--- /dev/null
+++ b/src/library/ts/LICENSE
@@ -0,0 +1,2 @@
+YEAR: 2025--2026
+COPYRIGHT HOLDER: ts authors
diff --git a/src/library/ts/LICENSE.note b/src/library/ts/LICENSE.note
new file mode 100644
index 0000000000..c8336544bd
--- /dev/null
+++ b/src/library/ts/LICENSE.note
@@ -0,0 +1,24 @@
+Tree-sitter C library
+--------------------------------------------------------------------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2018--2026 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/library/ts/NAMESPACE b/src/library/ts/NAMESPACE
new file mode 100644
index 0000000000..5b276a0d85
--- /dev/null
+++ b/src/library/ts/NAMESPACE
@@ -0,0 +1,58 @@
+# Generated by roxygen2: do not edit by hand
+
+S3method("$",ts_tree)
+S3method("[",ts_tree)
+S3method("[[",ts_tree)
+S3method("[[<-",ts_tree)
+S3method("ts_tree_select<-",ts_tree)
+S3method(as.character,ts_caller_arg)
+S3method(as.character,ts_tree)
+S3method(as.raw,ts_tree)
+S3method(format,ts_parse_error)
+S3method(format,ts_tree)
+S3method(print,ts_parse_error)
+S3method(print,ts_tree)
+S3method(ts_tree_ast,default)
+S3method(ts_tree_dom,default)
+S3method(ts_tree_mark_selection1,ts_tree)
+S3method(ts_tree_new,ts_language)
+S3method(ts_tree_query,default)
+S3method(ts_tree_select1,default)
+S3method(ts_tree_select1,ts_tree.NULL)
+S3method(ts_tree_select1,ts_tree.character)
+S3method(ts_tree_select1,ts_tree.integer)
+S3method(ts_tree_select1,ts_tree.logical)
+S3method(ts_tree_select1,ts_tree.numeric)
+S3method(ts_tree_select1,ts_tree.ts_tree_selector_default)
+S3method(ts_tree_select1,ts_tree.ts_tree_selector_ids)
+S3method(ts_tree_select1,ts_tree.ts_tree_selector_regex)
+S3method(ts_tree_select1,ts_tree.ts_tree_selector_tsquery)
+S3method(ts_tree_sexpr,default)
+S3method(ts_tree_write,default)
+export("ts_tree_select<-")
+export(as_ts_caller_arg)
+export(ts_caller_arg)
+export(ts_caller_env)
+export(ts_check_named_arg)
+export(ts_cnd)
+export(ts_collapse)
+export(ts_list_parsers)
+export(ts_parse_error_cnd)
+export(ts_tree_ast)
+export(ts_tree_delete)
+export(ts_tree_deleted)
+export(ts_tree_dom)
+export(ts_tree_format)
+export(ts_tree_insert)
+export(ts_tree_mark_selection1)
+export(ts_tree_new)
+export(ts_tree_query)
+export(ts_tree_select)
+export(ts_tree_select1)
+export(ts_tree_selected_nodes)
+export(ts_tree_selection)
+export(ts_tree_sexpr)
+export(ts_tree_unserialize)
+export(ts_tree_update)
+export(ts_tree_write)
+useDynLib(ts, .registration = TRUE, .fixes = "c_")
diff --git a/src/library/ts/NEWS.md b/src/library/ts/NEWS.md
new file mode 100644
index 0000000000..a998f52a28
--- /dev/null
+++ b/src/library/ts/NEWS.md
@@ -0,0 +1,3 @@
+# ts (development version)
+
+* Initial CRAN submission.
diff --git a/src/library/ts/R/bracket-ts-tree.R b/src/library/ts/R/bracket-ts-tree.R
new file mode 100644
index 0000000000..03f47bc833
--- /dev/null
+++ b/src/library/ts/R/bracket-ts-tree.R
@@ -0,0 +1,96 @@
+#' Convert ts_tree object to a data frame
+#'
+#' @ts ts_tree_brackets_description
+#' Create a data frame for the syntax tree of a JSON document, by indexing
+#' a ts_tree object with single brackets. This is occasionally useful for
+#' exploration and debugging.
+#' @description \eval{ts:::doc_insert("ts_tree_brackets_description")}
+#'
+#' @ts ts_tree_brackets_details
+#' A tree-sitter tree object has at least four classes:
+#' * `ts_tree_<parser_name>`, e.g. `ts_tree_tsjsonc`,
+#' * `ts_tree`,
+#' * `tbl`, from the pillar package, for better printing when converted
+#'   to a data frame, and
+#' * `data.frame`, since it is a data frame internally.
+#'
+#' The `ts_tree` class has custom [format()] and [print()] methods, that
+#' show (part of) the underlying document, and also the selected elements,
+#' if any.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' It is sometimes useful to treat a `tree` `ts_tree` object as a data
+#' frame, and drop the `ts_tree` classes. This can be done by indexing with
+#' single brackets, e.g. `tree[]`. This returns a data frame with one
+#' row per token, and various columns with information about the tokens.
+#' See details in the 'Value' section or this page.
+#'
+#' @details \eval{ts:::doc_insert("ts::ts_tree_brackets_details")}
+#'
+#' @ts ts_tree_brackets_param_x
+#' A `ts_tree` object.
+#' @ts ts_tree_brackets_param_ij
+#' Incides, passed to the regular data.frame indexing method, see
+#' \code{\link[base:Extract]{'Extract'}}.
+#' @ts ts_tree_brackets_param_drop
+#' Passed to the regular data.frame indexing method, see
+#' \code{\link[base:Extract]{'Extract'}}.
+#'
+#' @param x \eval{ts:::doc_insert("ts::ts_tree_brackets_param_x")}
+#' @param i,j \eval{ts:::doc_insert("ts::ts_tree_brackets_param_ij")}
+#' @param drop \eval{ts:::doc_insert("ts::ts_tree_brackets_param_drop")}
+#'
+#' @ts ts_tree_brackets_return
+#' A data frame with one row per token, and columns:
+#' * `id`: integer, the id of the token. The (root) document node has id 1.
+#' * `parent`: integer, the id of the parent token. The root token has
+#'   parent `NA`
+#' * `field_name`: character, the field name of the token in its parent.
+#' * `type`: character, the type of the token.
+#' * `code`: character, the actual code of the token.
+#' * `start_byte`, `end_byte`: integer, the byte positions of the token
+#'   in the input.
+#' * `start_row`, `start_column`, `end_row`, `end_column`: integer, the
+#'   position of the token in the input.
+#' * `is_missing`: logical, whether the token is a missing token added by
+#'   the parser to recover from errors.
+#' * `has_error`: logical, whether the token has a parse error.
+#' * `children`: list of integer vectors, the ids of the children tokens.
+#' * `dom_type`: character, the type of the node in the DOM tree. See
+#'   \code{\link[ts:ts_tree_dom]{ts_tree_dom()}}. Nodes that are not part
+#'   of the DOM tree have `NA_character_` here.
+#' * `dom_children`: list of integer vectors, the ids of the children in the
+#'   DOM tree. See \code{\link[ts:ts_tree_dom]{ts_tree_dom()}}.
+#' * `dom_parent`: integer, the parent of the node in the DOM tree. See
+#'   \code{\link[ts:ts_tree_dom]{ts_tree_dom()}}. Nodes that are not part
+#'   of the DOM tree and the document node have have `NA_integer_` here.
+#'
+#' Other, undocumented columns may also be present, these are considered
+#' internal and may change without notice.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_brackets_return")}
+#'
+#' @name ts_tree-brackets
+#' @family ts_tree exploration
+#' @seealso \eval{ts:::doc_seealso("[")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' tree
+#'
+#' tree[]
+
+`[.ts_tree` <- function(x, i, j, drop = FALSE) {
+  class(x) <- setdiff(class(x), "ts_tree")
+  requireNamespace("pillar", quietly = TRUE)
+  NextMethod("[")
+}
+
+#' @export
+
+`$.ts_tree` <- function(x, name) {
+  class(x) <- setdiff(class(x), "ts_tree")
+  NextMethod(`$`)
+}
diff --git a/src/library/ts/R/cleancall.R b/src/library/ts/R/cleancall.R
new file mode 100644
index 0000000000..11e4d24607
--- /dev/null
+++ b/src/library/ts/R/cleancall.R
@@ -0,0 +1,3 @@
+call_with_cleanup <- function(ptr, ...) {
+  .Call(c_cleancall_call, pairlist(ptr, ...), parent.frame())
+}
diff --git a/src/library/ts/R/coerce.R b/src/library/ts/R/coerce.R
new file mode 100644
index 0000000000..d71a6e799f
--- /dev/null
+++ b/src/library/ts/R/coerce.R
@@ -0,0 +1,36 @@
+#' Raw bytes of a document of a tree-sitter tree
+#'
+#' @param x A `ts_tree` object.
+#' @return A raw vector containing the bytes of the document of the tree.
+#'
+#' @export
+#' @seealso [as.character.ts_tree()] to get the document as a character scalar.
+#' @examples
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' tree
+#' as.raw(tree)
+
+as.raw.ts_tree <- function(x) {
+  attr(x, "text")
+}
+
+#' The document of a tree-sitter tree as a character scalar
+#'
+#' @param x A `ts_tree` object.
+#' @param ... Ignored.
+#' @return A character scalar containing the document of the tree.
+#'
+#' @export
+#' @seealso [as.raw.ts_tree()] to get the document as a raw vector.
+#' @examples
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' tree
+#' as.character(tree)
+
+as.character.ts_tree <- function(x, ...) {
+  rawToChar(as.raw(x))
+}
diff --git a/src/library/ts/R/collapse.R b/src/library/ts/R/collapse.R
new file mode 100644
index 0000000000..8331ad35fe
--- /dev/null
+++ b/src/library/ts/R/collapse.R
@@ -0,0 +1,193 @@
+#' @rdname internal
+#' @param s For `ts_collapse()` a character vector to collapse.
+#' @param sep Separator string for most elements.
+#' @param sep2 Separator string for two elements.
+#' @param last Separator string before the last element.
+#' @param trunc Integer, maximum number of elements to show before
+#'   truncation.
+#' @param width Integer, maximum display width of the collapsed string.
+#'   If the collapsed string exceeds this width, it will be truncated
+#'   with `ellipsis`.
+#' @param ellipsis String to indicate truncation.
+#' @param style Character, the collapsing style to use. Possible values are
+#'   `"both-ends"` (the default), which shows the first few and last few
+#'   elements when truncating, and `"head"`, which shows only the first few
+#'   elements.
+#' @return `ts_collapse()` returns a character scalar, the collapsed string.
+#' @details `ts_collapse()` collapses a character vector into a single string,
+#'   with options for truncation by number of elements or display width.
+#'   It is useful for creating informative error messages.
+#' @export
+#' @examples
+#' ts_collapse(letters[1:3])
+#' ts_collapse(letters[1:10], trunc = 5)
+
+ts_collapse <- function(
+  s,
+  sep = ", ",
+  sep2 = sub("^,", "", last),
+  last = ", and ",
+  trunc = Inf,
+  width = Inf,
+  ellipsis = "...",
+  style = c("both-ends", "head")
+) {
+  style <- match.arg(style)
+  switch(
+    style,
+    "both-ends" = collapse_both_ends(
+      s,
+      sep,
+      sep2,
+      last,
+      trunc,
+      width,
+      ellipsis
+    ),
+    "head" = collapse_head(s, sep, sep2, last, trunc, width, ellipsis)
+  )
+}
+
+collapse_head_notrim <- function(x, trunc, sep, sep2, last, ellipsis) {
+  lnx <- length(x)
+
+  if (lnx == 1L) {
+    return(x)
+  }
+  if (lnx == 2L) {
+    return(paste0(x, collapse = sep2))
+  }
+  if (lnx <= trunc) {
+    # no truncation
+    return(paste0(
+      paste(x[1:(lnx - 1L)], collapse = sep),
+      last,
+      x[lnx]
+    ))
+  } else {
+    # truncation, no need for 'last'
+    return(paste0(
+      paste(x[1:trunc], collapse = sep),
+      sep,
+      ellipsis
+    ))
+  }
+}
+
+collapse_head <- function(x, sep, sep2, last, trunc, width, ellipsis) {
+  trunc <- max(trunc, 1L)
+  x <- as.character(x)
+  lnx <- length(x)
+
+  # special cases that do not need trimming
+  if (lnx == 0L) {
+    return("")
+  } else if (anyNA(x)) {
+    return(NA_character_)
+  }
+
+  # easier case, no width trimming
+  if (width == Inf) {
+    return(collapse_head_notrim(x, trunc, sep, sep2, last, ellipsis))
+  }
+
+  # complex case, with width wrapping
+  # first we truncate
+  tcd <- lnx > trunc
+  if (tcd) {
+    x <- x[1:trunc]
+  }
+
+  # then we calculate the width w/o trimming
+  wx <- nchar(x)
+  wsep <- nchar(sep, "width")
+  wsep2 <- nchar(sep2, "width")
+  wlast <- nchar(last, "width")
+  well <- nchar(ellipsis, "width")
+  if (!tcd) {
+    # x[1]
+    # x[1] and x[2]
+    # x[1], x[2], and x[3]
+    nsep <- if (lnx > 2L) lnx - 2L else 0L
+    nsep2 <- if (lnx == 2L) 1L else 0L
+    nlast <- if (lnx > 2L) 1L else 0L
+    wtot <- sum(wx) + nsep * wsep + nsep2 * wsep2 + nlast * wlast
+    if (wtot <= width) {
+      if (lnx == 1L) {
+        return(x)
+      } else if (lnx == 2L) {
+        return(paste0(x, collapse = sep2))
+      } else {
+        return(paste0(
+          paste(x[1:(lnx - 1L)], collapse = sep),
+          last,
+          x[lnx]
+        ))
+      }
+    }
+  } else {
+    # x[1], x[2], x[trunc], ...
+    wtot <- sum(wx) + trunc * wsep + well
+    if (wtot <= width) {
+      return(paste0(
+        paste(x, collapse = sep),
+        sep,
+        ellipsis
+      ))
+    }
+  }
+
+  # we need to find the longest possible truncation for the form
+  # x[1], x[2], x[trunc], ...
+  # each item is wx + wsep wide, so we search how many fits, with ellipsis
+  last <- function(x) if (length(x) >= 1L) x[length(x)] else x[NA_integer_]
+  trunc <- last(which(cumsum(wx + wsep) + well <= width))
+
+  # not even one element fits
+  if (is.na(trunc)) {
+    if (well > width) {
+      return(strtrim(ellipsis, width))
+    } else if (well == width) {
+      return(ellipsis)
+    } else if (well + wsep >= width) {
+      return(paste0(strtrim(x[1L], width), ellipsis))
+    } else {
+      return(paste0(
+        strtrim(x[1L], max(width - well - wsep, 0L)),
+        sep,
+        ellipsis
+      ))
+    }
+  }
+
+  return(paste0(
+    paste(x[1:trunc], collapse = sep),
+    sep,
+    ellipsis
+  ))
+}
+
+collapse_both_ends <- function(x, sep, sep2, last, trunc, width, ellipsis) {
+  # we always list at least 5 elements
+  trunc <- max(trunc, 5L)
+  trunc <- min(trunc, length(x))
+  if (length(x) <= 5L || length(x) <= trunc) {
+    return(collapse_head(x, sep, sep2, last, trunc = trunc, width, ellipsis))
+  }
+
+  # we have at least six elements in the vector
+  # 1, 2, 3, ..., 9, and 10
+  x <- as.character(c(x[1:(trunc - 2L)], x[length(x) - 1L], x[length(x)]))
+  paste0(
+    c(x[1:(trunc - 2L)], ellipsis, paste0(x[trunc - 1L], last, x[trunc])),
+    collapse = sep
+  )
+}
+
+trim <- function(x) {
+  has_newline <- function(x) any(grepl("\\n", x))
+  if (length(x) == 0L || !has_newline(x)) {
+    return(x)
+  }
+  call_with_cleanup(c_trim, x)
+}
diff --git a/src/library/ts/R/compat-vctrs.R b/src/library/ts/R/compat-vctrs.R
new file mode 100644
index 0000000000..8b4595e4e0
--- /dev/null
+++ b/src/library/ts/R/compat-vctrs.R
@@ -0,0 +1,643 @@
+# nocov start
+
+compat_vctrs <- local({
+  # Modified from https://github.com/r-lib/rlang/blob/master/R/compat-vctrs.R
+
+  # Construction ------------------------------------------------------------
+
+  # Constructs data frames inheriting from `"tbl"`. This allows the
+  # pillar package to take over printing as soon as it is loaded.
+  # The data frame otherwise behaves like a base data frame.
+  data_frame <- function(...) {
+    new_data_frame(df_list(...), .class = "tbl")
+  }
+
+  new_data_frame <- function(.x = list(), ..., .size = NULL, .class = NULL) {
+    n_cols <- length(.x)
+    if (n_cols != 0 && is.null(names(.x))) {
+      stop("Columns must be named.", call. = FALSE)
+    }
+
+    if (is.null(.size)) {
+      if (n_cols == 0) {
+        .size <- 0
+      } else {
+        .size <- vec_size(.x[[1]])
+      }
+    }
+
+    structure(
+      .x,
+      class = c(.class, "data.frame"),
+      row.names = .set_row_names(.size),
+      ...
+    )
+  }
+
+  df_list <- function(..., .size = NULL) {
+    vec_recycle_common(list(...), size = .size)
+  }
+
+  # Binding -----------------------------------------------------------------
+
+  vec_rbind <- function(...) {
+    xs <- vec_cast_common(list(...))
+    do.call(base::rbind, xs)
+  }
+
+  vec_cbind <- function(...) {
+    xs <- list(...)
+
+    ptype <- vec_ptype_common(lapply(xs, `[`, 0))
+    class <- setdiff(class(ptype), "data.frame")
+
+    xs <- vec_recycle_common(xs)
+    out <- do.call(base::cbind, xs)
+    new_data_frame(out, .class = class)
+  }
+
+  # Slicing -----------------------------------------------------------------
+
+  vec_size <- function(x) {
+    if (is.data.frame(x)) {
+      nrow(x)
+    } else {
+      length(x)
+    }
+  }
+
+  vec_rep <- function(x, times) {
+    i <- rep.int(seq_len(vec_size(x)), times)
+    vec_slice(x, i)
+  }
+
+  vec_recycle_common <- function(xs, size = NULL) {
+    sizes <- vapply(xs, vec_size, integer(1))
+
+    n <- unique(sizes)
+
+    if (length(n) == 1 && is.null(size)) {
+      return(xs)
+    }
+    n <- setdiff(n, 1L)
+
+    ns <- length(n)
+
+    if (ns == 0) {
+      if (is.null(size)) {
+        return(xs)
+      }
+    } else if (ns == 1) {
+      if (is.null(size)) {
+        size <- n
+      } else if (ns != size) {
+        stop("Inputs can't be recycled to `size`.", call. = FALSE)
+      }
+    } else {
+      stop("Inputs can't be recycled to a common size.", call. = FALSE)
+    }
+
+    to_recycle <- sizes == 1L
+    xs[to_recycle] <- lapply(xs[to_recycle], vec_rep, size)
+
+    xs
+  }
+
+  vec_slice <- function(x, i) {
+    if (is.logical(i)) {
+      i <- which(i)
+    }
+    stopifnot(is.numeric(i) || is.character(i))
+
+    if (is.null(x)) {
+      return(NULL)
+    }
+
+    if (is.data.frame(x)) {
+      # We need to be a bit careful to be generic. First empty all
+      # columns and expand the df to final size.
+      out <- x[i, 0, drop = FALSE]
+
+      # Then fill in with sliced columns
+      out[seq_along(x)] <- lapply(x, vec_slice, i)
+
+      # Reset automatic row names to work around `[` weirdness
+      if (is.numeric(attr(x, "row.names"))) {
+        row_names <- .set_row_names(nrow(out))
+      } else {
+        row_names <- attr(out, "row.names")
+      }
+
+      return(out)
+    }
+
+    d <- vec_dims(x)
+    if (d == 1) {
+      if (is.object(x)) {
+        out <- x[i]
+      } else {
+        out <- x[i, drop = FALSE]
+      }
+    } else if (d == 2) {
+      out <- x[i, , drop = FALSE]
+    } else {
+      j <- rep(list(quote(expr = )), d - 1)
+      out <- eval(as.call(list(
+        quote(`[`),
+        quote(x),
+        quote(i),
+        j,
+        drop = FALSE
+      )))
+    }
+
+    out
+  }
+  vec_dims <- function(x) {
+    d <- dim(x)
+    if (is.null(d)) {
+      1L
+    } else {
+      length(d)
+    }
+  }
+
+  vec_as_location <- function(i, n, names = NULL) {
+    out <- seq_len(n)
+    names(out) <- names
+
+    # Special-case recycling to size 0
+    if (is_logical(i, n = 1) && !length(out)) {
+      return(out)
+    }
+
+    unname(out[i])
+  }
+
+  vec_init <- function(x, n = 1L) {
+    vec_slice(x, rep_len(NA_integer_, n))
+  }
+
+  vec_assign <- function(x, i, value) {
+    if (is.null(x)) {
+      return(NULL)
+    }
+
+    if (is.logical(i)) {
+      i <- which(i)
+    }
+    stopifnot(
+      is.numeric(i) || is.character(i)
+    )
+
+    value <- vec_recycle(value, vec_size(i))
+    value <- vec_cast(value, to = x)
+
+    d <- vec_dims(x)
+
+    if (d == 1) {
+      x[i] <- value
+    } else if (d == 2) {
+      x[i, ] <- value
+    } else {
+      stop("Can't slice-assign arrays.", call. = FALSE)
+    }
+
+    x
+  }
+
+  vec_recycle <- function(x, size) {
+    if (is.null(x) || is.null(size)) {
+      return(NULL)
+    }
+
+    n_x <- vec_size(x)
+
+    if (n_x == size) {
+      x
+    } else if (size == 0L) {
+      vec_slice(x, 0L)
+    } else if (n_x == 1L) {
+      vec_slice(x, rep(1L, size))
+    } else {
+      stop("Incompatible lengths: ", n_x, ", ", size, call. = FALSE)
+    }
+  }
+
+  # Coercion ----------------------------------------------------------------
+
+  vec_cast_common <- function(xs, to = NULL) {
+    ptype <- vec_ptype_common(xs, ptype = to)
+    lapply(xs, vec_cast, to = ptype)
+  }
+
+  vec_cast <- function(x, to) {
+    if (is.null(x)) {
+      return(NULL)
+    }
+    if (is.null(to)) {
+      return(x)
+    }
+
+    if (vec_is_unspecified(x)) {
+      return(vec_init(to, vec_size(x)))
+    }
+
+    stop_incompatible_cast <- function(x, to) {
+      stop(
+        sprintf(
+          "Can't convert <%s> to <%s>.",
+          .rlang_vctrs_typeof(x),
+          .rlang_vctrs_typeof(to)
+        ),
+        call. = FALSE
+      )
+    }
+
+    lgl_cast <- function(x, to) {
+      lgl_cast_from_num <- function(x) {
+        if (any(!x %in% c(0L, 1L))) {
+          stop_incompatible_cast(x, to)
+        }
+        as.logical(x)
+      }
+
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = x,
+        integer = ,
+        double = lgl_cast_from_num(x),
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    int_cast <- function(x, to) {
+      int_cast_from_dbl <- function(x) {
+        out <- suppressWarnings(as.integer(x))
+        if (any((out != x) | xor(is.na(x), is.na(out)))) {
+          stop_incompatible_cast(x, to)
+        } else {
+          out
+        }
+      }
+
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = as.integer(x),
+        integer = x,
+        double = int_cast_from_dbl(x),
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    dbl_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = ,
+        integer = as.double(x),
+        double = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    chr_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        character = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    list_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        list = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    df_cast <- function(x, to) {
+      # Check for extra columns
+      if (length(setdiff(names(x), names(to))) > 0) {
+        stop(
+          "Can't convert data frame because of missing columns.",
+          call. = FALSE
+        )
+      }
+
+      # Avoid expensive [.data.frame method
+      out <- as.list(x)
+
+      # Coerce common columns
+      common <- intersect(names(x), names(to))
+      out[common] <- Map(vec_cast, out[common], to[common])
+
+      # Add new columns
+      from_type <- setdiff(names(to), names(x))
+      out[from_type] <- lapply(to[from_type], vec_init, n = vec_size(x))
+
+      # Ensure columns are ordered according to `to`
+      out <- out[names(to)]
+
+      new_data_frame(out)
+    }
+
+    rlib_df_cast <- function(x, to) {
+      new_data_frame(df_cast(x, to), .class = "tbl")
+    }
+    tib_cast <- function(x, to) {
+      new_data_frame(df_cast(x, to), .class = c("tbl_df", "tbl"))
+    }
+
+    switch(
+      .rlang_vctrs_typeof(to),
+      logical = lgl_cast(x, to),
+      integer = int_cast(x, to),
+      double = dbl_cast(x, to),
+      character = chr_cast(x, to),
+      list = list_cast(x, to),
+
+      base_data_frame = df_cast(x, to),
+      rlib_data_frame = rlib_df_cast(x, to),
+      tibble = tib_cast(x, to),
+
+      stop_incompatible_cast(x, to)
+    )
+  }
+
+  vec_ptype_common <- function(xs, ptype = NULL) {
+    if (!is.null(ptype)) {
+      return(vec_ptype(ptype))
+    }
+
+    xs <- Filter(function(x) !is.null(x), xs)
+
+    if (length(xs) == 0) {
+      return(NULL)
+    }
+
+    if (length(xs) == 1) {
+      out <- vec_ptype(xs[[1]])
+    } else {
+      xs <- map(xs, vec_ptype)
+      out <- Reduce(vec_ptype2, xs)
+    }
+
+    vec_ptype_finalise(out)
+  }
+
+  vec_ptype_finalise <- function(x) {
+    if (is.data.frame(x)) {
+      x[] <- lapply(x, vec_ptype_finalise)
+      return(x)
+    }
+
+    if (inherits(x, "rlang_unspecified")) {
+      logical()
+    } else {
+      x
+    }
+  }
+
+  vec_ptype <- function(x) {
+    if (vec_is_unspecified(x)) {
+      return(.rlang_vctrs_unspecified())
+    }
+
+    if (is.data.frame(x)) {
+      out <- new_data_frame(lapply(x, vec_ptype))
+
+      attrib <- attributes(x)
+      attrib$row.names <- attr(out, "row.names")
+      attributes(out) <- attrib
+
+      return(out)
+    }
+
+    vec_slice(x, 0)
+  }
+
+  vec_ptype2 <- function(x, y) {
+    stop_incompatible_type <- function(x, y) {
+      stop(
+        sprintf(
+          "Can't combine types <%s> and <%s>.",
+          .rlang_vctrs_typeof(x),
+          .rlang_vctrs_typeof(y)
+        ),
+        call. = FALSE
+      )
+    }
+
+    x_type <- .rlang_vctrs_typeof(x)
+    y_type <- .rlang_vctrs_typeof(y)
+
+    if (x_type == "unspecified" && y_type == "unspecified") {
+      return(.rlang_vctrs_unspecified())
+    }
+    if (x_type == "unspecified") {
+      return(y)
+    }
+    if (y_type == "unspecified") {
+      return(x)
+    }
+
+    df_ptype2 <- function(x, y) {
+      set_partition <- function(x, y) {
+        list(
+          both = intersect(x, y),
+          only_x = setdiff(x, y),
+          only_y = setdiff(y, x)
+        )
+      }
+
+      # Avoid expensive [.data.frame
+      x <- as.list(vec_slice(x, 0))
+      y <- as.list(vec_slice(y, 0))
+
+      # Find column types
+      names <- set_partition(names(x), names(y))
+      if (length(names$both) > 0) {
+        common_types <- Map(vec_ptype2, x[names$both], y[names$both])
+      } else {
+        common_types <- list()
+      }
+      only_x_types <- x[names$only_x]
+      only_y_types <- y[names$only_y]
+
+      # Combine and construct
+      out <- c(common_types, only_x_types, only_y_types)
+      out <- out[c(names(x), names$only_y)]
+      new_data_frame(out)
+    }
+
+    rlib_df_ptype2 <- function(x, y) {
+      new_data_frame(df_ptype2(x, y), .class = "tbl")
+    }
+    tib_ptype2 <- function(x, y) {
+      new_data_frame(df_ptype2(x, y), .class = c("tbl_df", "tbl"))
+    }
+
+    ptype <- switch(
+      x_type,
+
+      logical = switch(
+        y_type,
+        logical = x,
+        integer = y,
+        double = y,
+        stop_incompatible_type(x, y)
+      ),
+
+      integer = switch(
+        .rlang_vctrs_typeof(y),
+        logical = x,
+        integer = x,
+        double = y,
+        stop_incompatible_type(x, y)
+      ),
+
+      double = switch(
+        .rlang_vctrs_typeof(y),
+        logical = x,
+        integer = x,
+        double = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      character = switch(
+        .rlang_vctrs_typeof(y),
+        character = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      list = switch(
+        .rlang_vctrs_typeof(y),
+        list = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      base_data_frame = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        s3_data_frame = df_ptype2(x, y),
+        rlib_data_frame = rlib_df_ptype2(x, y),
+        tibble = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      rlib_data_frame = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        rlib_data_frame = ,
+        s3_data_frame = rlib_df_ptype2(x, y),
+        tibble = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      tibble = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        rlib_data_frame = ,
+        tibble = ,
+        s3_data_frame = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      stop_incompatible_type(x, y)
+    )
+
+    vec_slice(ptype, 0)
+  }
+
+  .rlang_vctrs_typeof <- function(x) {
+    if (is.object(x)) {
+      class <- class(x)
+
+      if (identical(class, "rlang_unspecified")) {
+        return("unspecified")
+      }
+      if (identical(class, "data.frame")) {
+        return("base_data_frame")
+      }
+      if (identical(class, c("tbl", "data.frame"))) {
+        return("rlib_data_frame")
+      }
+      if (identical(class, c("tbl_df", "tbl", "data.frame"))) {
+        return("tibble")
+      }
+      if (inherits(x, "data.frame")) {
+        return("s3_data_frame")
+      }
+
+      class <- paste0(class, collapse = "/")
+      stop(sprintf("Unimplemented class <%s>.", class), call. = FALSE)
+    }
+
+    type <- typeof(x)
+    switch(
+      type,
+      NULL = return("null"),
+      logical = if (vec_is_unspecified(x)) {
+        return("unspecified")
+      } else {
+        return(type)
+      },
+      integer = ,
+      double = ,
+      character = ,
+      raw = ,
+      list = return(type)
+    )
+
+    stop(sprintf("Unimplemented type <%s>.", type), call. = FALSE)
+  }
+
+  vec_is_unspecified <- function(x) {
+    !is.object(x) &&
+      typeof(x) == "logical" &&
+      length(x) &&
+      all(vapply(x, identical, logical(1), NA))
+  }
+
+  .rlang_vctrs_unspecified <- function(x = NULL) {
+    structure(
+      rep(NA, length(x)),
+      class = "rlang_unspecified"
+    )
+  }
+
+  .rlang_vctrs_s3_method <- function(generic, class, env = parent.frame()) {
+    fn <- get(generic, envir = env)
+
+    ns <- asNamespace(topenv(fn))
+    tbl <- ns$.__S3MethodsTable__.
+
+    for (c in class) {
+      name <- paste0(generic, ".", c)
+      if (exists(name, envir = tbl, inherits = FALSE)) {
+        return(get(name, envir = tbl))
+      }
+      if (exists(name, envir = globalenv(), inherits = FALSE)) {
+        return(get(name, envir = globalenv()))
+      }
+    }
+
+    NULL
+  }
+
+  environment()
+})
+
+data_frame <- compat_vctrs$data_frame
+
+as_data_frame <- function(x) {
+  if (is.matrix(x)) {
+    x <- as.data.frame(x, stringsAsFactors = FALSE)
+  } else {
+    x <- compat_vctrs$vec_recycle_common(x)
+  }
+  compat_vctrs$new_data_frame(x, .class = "tbl")
+}
+
+# nocov end
diff --git a/src/library/ts/R/docs.R b/src/library/ts/R/docs.R
new file mode 100644
index 0000000000..932d5c0bdf
--- /dev/null
+++ b/src/library/ts/R/docs.R
@@ -0,0 +1,315 @@
+dglue <- function(..., .envir = parent.frame()) {
+  glue(..., .open = "<<", .close = ">>", .envir = .envir)
+}
+
+is_rcmd_check <- function() {
+  if (Sys.getenv("GITHUB_ACTIONS") == "true") {
+    return(FALSE)
+  }
+  Sys.getenv("_R_CHECK_PACKAGE_NAME_", "") != "" ||
+    Sys.getenv("_R_RD_MACROS_PACKAGE_DIR_", "") != ""
+}
+
+doc_has_method <- function(method, package) {
+  method <- paste0(method, ".ts_tree_", sub("^ts", "", package))
+  length(utils::help(
+    topic = (method),
+    package = (package),
+    help_type = "text"
+  )) >
+    0
+}
+
+doc_seealso <- function(method) {
+  ts_package <- get_env("R_TS_PACKAGE")
+  if (is.null(ts_package)) {
+    psrs <- ts_list_parsers()
+    psrs <- psrs[!duplicated(psrs$package), ]
+    links <- vapply(
+      psrs$package,
+      function(pkg) {
+        if (doc_has_method(method, pkg)) {
+          glue(
+            "\\code{{\\link[{pkg}:{method}.{pkg}]{{{method}(<ts_tree_{pkg}>)}}}}",
+          )
+        } else {
+          ""
+        }
+      },
+      ""
+    )
+    links <- links[links != ""]
+    if (length(links) > 0) {
+      s <- if (length(links) > 1) "s"
+      glue("Method{s} in installed package{s}: {ts_collapse(links)}.")
+    } else {
+      ""
+    }
+  } else {
+    paste0(
+      "The generic of this method in the ts package: ",
+      glue("\\code{{\\link[ts:{method}]{{{method}()}}}}"),
+      "."
+    )
+  }
+}
+
+doc_insert <- function(key, manpkg = NULL) {
+  if (is_rcmd_check()) {
+    return("Placeholder.")
+  }
+  if (!is.null(manpkg)) {
+    Sys.setenv("R_TS_PACKAGE" = manpkg)
+    on.exit(Sys.unsetenv("R_TS_PACKAGE"), add = TRUE)
+  }
+  keypcs <- strsplit(key, "::", fixed = TRUE)[[1]]
+  if (length(keypcs) == 2) {
+    package <- keypcs[1]
+    key <- keypcs[2]
+  } else {
+    package <- "ts"
+  }
+  lib <- dirname(find.package(package))
+  output <- doc_create_chunk(key, lib, package, 1L, "<<contents>>")
+
+  mch <- gregexpr("\\\\eval\\{[^\\}]+\\}", output, perl = TRUE)
+  regmatches(output, mch)[[1]] <- lapply(
+    regmatches(output, mch)[[1]],
+    function(x) {
+      x <- sub("^\\\\eval\\{", "", x)
+      x <- sub("\\}$", "", x)
+      eval(parse(text = x))
+    }
+  )
+  output
+}
+
+doc_tabs <- function(key) {
+  if (is_rcmd_check()) {
+    return("Placeholder.")
+  }
+  package <- if (nzchar(ev <- Sys.getenv("R_TS_PACKAGE"))) {
+    ev
+  }
+
+  if (is.null(package)) {
+    doc_tabs_all(key)
+  } else {
+    doc_tabs_one(key, package)
+  }
+}
+
+doc_tabs_all <- function(key) {
+  # list all installed ts packages
+  psrs <- ts_list_parsers()
+  psrs <- psrs[!duplicated(psrs$package), ]
+
+  tsdocpath <- doc_path("ts")
+  t_tab <- read_char(file.path(tsdocpath, "tab.html"))
+  t_div <- read_char(file.path(tsdocpath, "tabs.html"))
+  t_btn <- read_char(file.path(tsdocpath, "btn.html"))
+  output <- buttons <- tabs <- ""
+
+  for (i in seq_len(nrow(psrs))) {
+    language <- sub("^ts", "", psrs$package[i])
+    tab <- doc_create_chunk(key, psrs$library[i], psrs$package[i], i, t_tab)
+    btn <- dglue(
+      t_btn,
+      .envir = c(psrs[i, ], list(idx = i, language = language))
+    )
+    if (!is.null(tab) && nzchar(tab)) {
+      tabs <- paste0(tabs, tab, "\n")
+      buttons <- paste0(buttons, btn, "\n")
+    }
+  }
+  if (tabs != "") {
+    output <- dglue(t_div, .envir = list(tabs = tabs, buttons = buttons))
+  }
+
+  output
+}
+
+doc_tabs_one <- function(key, package) {
+  lib <- dirname(find.package(package))
+  doc_create_chunk(key, lib, package, 1, "<<contents>>")
+}
+
+doc_path <- function(package) {
+  pkgdir <- find.package(package)
+  docpath <- file.path(pkgdir, "tsdocs")
+  if (!file.exists(docpath)) {
+    docpath <- file.path(pkgdir, "inst", "tsdocs")
+  }
+
+  docpath
+}
+
+doc_create_chunk <- function(key, lib, package, idx, template) {
+  file <- paste0(key, ".Rd")
+  path <- file.path(doc_path(package), file)
+  if (!file.exists(path)) {
+    return("")
+  }
+  x <- read_char(path)
+  lns <- strsplit(x, "\n", fixed = TRUE)[[1]]
+  rulepos <- which(lns == "# ---")
+  lns <- lns[(rulepos + 1):length(lns)]
+  lang_data <- list(
+    idx = idx,
+    package = package,
+    language = sub("^ts", "", package),
+    contents = paste(lns, collapse = "\n")
+  )
+  dglue(template, .envir = lang_data)
+}
+
+doc_extra <- function() {
+  if (is_rcmd_check()) {
+    return("Placeholder.")
+  }
+  tsdocpath <- doc_path("ts")
+  jspath <- file.path(tsdocpath, "tabs.js")
+  js <- read_char(jspath)
+
+  csspath1 <- file.path(doc_path("ts"), "w3.css")
+  css1 <- read_char(csspath1)
+  css <- ""
+  if (Sys.getenv("IN_PKGDOWN") == "true") {
+    csspath2 <- file.path(doc_path("ts"), "pkgdown.css")
+    css2 <- read_char(csspath2)
+    css <- gsub("%", "\\%", paste0(css1, "\n\n", css2), fixed = TRUE)
+    css <- paste0("<style>\n", css, "\n</style>\n")
+  } else {
+    # in Rd we insert CSS with JS, because tidy does not allow <style>
+    # tags in <body>
+    js <- paste0(
+      "styles = `",
+      gsub("%", "\\%", css1, fixed = TRUE),
+      "`;\n",
+      "var styleSheet = document.createElement('style');\n",
+      "styleSheet.textContent = styles;\n",
+      "document.head.appendChild(styleSheet);\n",
+      js
+    )
+  }
+
+  dglue("\\if{html}{\\out{<script>\n<<js>>\n</script>\n<<css>>}}")
+}
+
+doc_style_tab <- function(idx) {
+  paste0(
+    "padding: 0.01em 16px;",
+    "border: 1px solid #ccc!important;",
+    if (idx != 1) {
+      "display:none"
+    }
+  )
+}
+
+# ------------------------------------------------------------------------------
+# Roxygen2 roclet for generating manual stubs
+
+roxy_tag_parse.roxy_tag_ts <- function(x) {
+  lns <- strsplit(x$raw, "\n", fixed = TRUE)[[1]]
+  lns1p <- strsplit(lns[1], " ", fixed = TRUE)[[1]]
+  file <- lns1p[1]
+  title <- paste(lns1p[-1], collapse = " ")
+
+  x$raw <- paste(lns[-1], collapse = "\n")
+
+  pkg <- asNamespace("roxygen2")$roxy_meta_get("current_package")
+  asNamespace("roxygen2")$roxy_meta_set("current_package", "x")
+  on.exit(
+    asNamespace("roxygen2")$roxy_meta_set("current_package", pkg),
+    add = TRUE
+  )
+
+  x <- asNamespace("roxygen2")$tag_markdown_with_sections(x)
+  x$val <- list(
+    file = file,
+    title = title,
+    val = x$val
+  )
+  x
+}
+
+roclet_ts <- function() {
+  asNamespace("roxygen2")$roclet("ts")
+}
+
+roclet_process.roclet_ts <- function(x, blocks, env, base_path) {
+  for (block in blocks) {
+    tags <- asNamespace("roxygen2")$block_get_tags(block, "ts")
+
+    for (tag in tags) {
+      path <- file.path(
+        base_path,
+        "inst",
+        "tsdocs",
+        paste0(tag$val$file, ".Rd")
+      )
+      value <- paste0(
+        "#| title: ",
+        tag$val$title,
+        "\n# ---\n",
+        rd_patch_p(tag$val$val)
+      )
+      write_if_newer(value, path)
+    }
+  }
+  invisible(list())
+}
+
+# Rd2HTML adds a </p> before the \preformatted, this is a hach.
+# It might create an un-closed <p>, but that's apparently not a problem.
+rd_patch_p <- function(rd) {
+  gsub(
+    '\\out{<div class="sourceCode r">}}\\preformatted',
+    '\\out{<div class="sourceCode r"><p style="display:none">&nbsp;}}\\preformatted',
+    rd,
+    fixed = TRUE
+  )
+}
+
+write_if_newer <- function(txt, path) {
+  bin <- charToRaw(txt)
+  nl <- charToRaw("\n")
+  if (length(bin) > 0 && bin[[length(bin)]] != nl) {
+    bin <- c(bin, nl)
+  }
+  if (file.exists(path)) {
+    old <- readBin(path, what = "raw", n = file.size(path))
+    if (identical(old, bin)) {
+      return(invisible(FALSE))
+    }
+  }
+  dir.create(dirname(path), recursive = TRUE, showWarnings = FALSE)
+  cli::cli_alert_info("Manual stub at {.file {basename(path)}}.")
+  writeBin(bin, path)
+  invisible(TRUE)
+}
+
+roclet_output.roclet_ts <- function(x, results, base_path, ...) {
+  invisible(NULL)
+}
+
+ts_roclet_register <- function() {
+  registerS3method(
+    "roxy_tag_parse",
+    "roxy_tag_ts",
+    roxy_tag_parse.roxy_tag_ts,
+    asNamespace("roxygen2")
+  )
+  registerS3method(
+    "roclet_process",
+    "roclet_ts",
+    roclet_process.roclet_ts,
+    asNamespace("roxygen2")
+  )
+  registerS3method(
+    "roclet_output",
+    "roclet_ts",
+    roclet_output.roclet_ts,
+    asNamespace("roxygen2")
+  )
+}
diff --git a/src/library/ts/R/error.R b/src/library/ts/R/error.R
new file mode 100644
index 0000000000..8e1b1e0422
--- /dev/null
+++ b/src/library/ts/R/error.R
@@ -0,0 +1,283 @@
+#' Utility functions for ts language implementations (internal)
+#'
+#' These functions are for packages implementing new parsers based on the ts
+#' package. It is very unlikely that you will need to call these functions
+#' directly.
+#'
+#' @param ... Arguments collapsed and interpolated into a condition message.
+#' @param class A character vector of classes for the condition.
+#' @param call Environment of the call to associate with the condition,
+#'   defaults to the caller's environment.
+#' @param .envir The environment in which to evaluate the `...` expressions,
+#'   defaults to the parent frame.
+#' @return `ts_cnd()` returns an error condition object.
+#'
+#' @details `ts_cnd()` creates a condition object. It interpolates its
+#' arguments into a single message.
+#'
+#' @keywords internal
+#' @rdname internal
+#' @export
+
+ts_cnd <- function(
+  ...,
+  class = NULL,
+  call = ts_caller_env(),
+  .envir = parent.frame()
+) {
+  call <- frame_get(call, sys.call)
+  structure(
+    list(message = glue(..., .envir = .envir), call = call),
+    class = c(class, "error", "condition")
+  )
+}
+
+#' @rdname internal
+#' @param arg Argument name.
+#' @details `ts_caller_arg()` captures the expression used as an argument
+#'   to a function, for use in error messages.
+#' @return `ts_caller_arg()` returns the captured expression as a
+#'   ts_caller_arg object.
+#' @export
+
+ts_caller_arg <- function(arg) {
+  arg <- substitute(arg)
+  expr <- do.call(substitute, list(arg), envir = ts_caller_env())
+  structure(list(expr), class = "ts_caller_arg")
+}
+
+#' @rdname internal
+#' @param x Object to use as a caller argument.
+#' @details `as_ts_caller_arg()` converts an object into a caller argument
+#'   object. This is useful when referring to parts of the caller argument
+#'   in downstream error messages.
+#' @return `as_ts_caller_arg()` returns a ts_caller_arg object.
+#' @export
+
+as_ts_caller_arg <- function(x) {
+  structure(list(x), class = "ts_caller_arg")
+}
+
+#' @rdname internal
+#' @param x A ts_caller_arg object.
+#' @details `as.character.ts_caller_arg()` formats a caller argument
+#'   object as a short string for use in error messages. Multi-line
+#'   expressions are truncated after the first line.
+#' @return `as.character.ts_caller_arg()` returns a short string
+#'   representation of the caller argument, a character scalar.
+#' @export
+
+as.character.ts_caller_arg <- function(x, ...) {
+  lbl <- paste(format(x[[1]]), collapse = "\n")
+  gsub("\n.*$", "...", lbl)
+}
+
+# older R does not have a format method for names
+format.name <- function(x, ...) {
+  deparse(x, backtick = FALSE)
+}
+
+#' @rdname internal
+#' @param n Number of frames to go up to find the caller environment.
+#' @details `ts_caller_env()` returns the environment of the caller function,
+#'   `n` levels up the call stack. This is useful for associating error
+#'   conditions with the correct call.
+#' @return `ts_caller_env()` returns an environment, or `NULL` is called
+#'   from the global environment.
+#' @export
+
+ts_caller_env <- function(n = 1) {
+  parent.frame(n + 1)
+}
+
+frame_get <- function(frame, accessor) {
+  if (identical(frame, .GlobalEnv)) {
+    return(NULL)
+  }
+  frames <- evalq(sys.frames(), frame)
+  for (i in seq_along(frames)) {
+    if (identical(frames[[i]], frame)) {
+      return(accessor(i))
+    }
+  }
+  NULL
+}
+
+#' @rdname internal
+#' @param arg Argument to check.
+#' @param frame Frame number to inspect, defaults to the caller's frame.
+#' @details `ts_check_named_arg()` checks whether an argument was supplied
+#'   with a name. If not, it raises an error.
+#' @return `ts_check_named_arg()` returns `TRUE` invisibly if the argument
+#'   was named, otherwise it raises an error.
+#' @export
+
+ts_check_named_arg <- function(arg, frame = -1) {
+  arg <- as.character(substitute(arg))
+  if (!arg %in% names(sys.call(frame)[-1])) {
+    stop(ts_cnd(
+      paste0("The `", arg, "` argument must be fully named."),
+      call = ts_caller_env()
+    ))
+  }
+  invisible(TRUE)
+}
+
+#' @rdname internal
+#' @param tree A `ts_tree` object as returned by [ts_tree_new()].
+#' @param text Raw vector, the original text used to parse the tree.
+#' @param call Environment of the call to associate with the error
+#'   condition, defaults to the caller's environment.
+#' @details `ts_parse_error_cnd()` creates a parse error condition
+#'   associated with a `ts_tree` object and the original text.
+#'   The error message includes information about the location of
+#'   parse errors in the text. It also has `format()` and `print()`
+#'   methods to display the error together with the relevant lines
+#'   of the original text.
+#' @return `ts_parse_error_cnd()` returns a ts_parse_error condition
+#' @export
+
+ts_parse_error_cnd <- function(tree, text, call = ts_caller_env()) {
+  call <- frame_get(call, sys.call)
+  cnd <- structure(
+    list(
+      call = call,
+      tree = tree,
+      text = strsplit(rawToChar(text), "\r?\n")[[1]]
+    ),
+    class = c("ts_parse_error", "error", "condition")
+  )
+  cnd$message <- paste0(
+    format_ts_parse_error_(cnd),
+    collapse = "\n"
+  )
+  cnd
+}
+
+# TODO: taking the first row of the error is not always ideal, because
+# ERROR nodes may contain a leading comma before the element that has the
+# actual error, and if there is a line break after the comma, then we
+# mark the comma as the place of the error, instead of the real error in
+# next line.
+#
+# One workaround is to mark all lines of the ERROR node.
+# Another is to ignore the first child of the ERROR node if it is a comma,
+# but I am unsure if that's always correct. Sometimes that error may be
+# at the comma. Plus maybe we'd need to ignore more than just a first comma.
+# So maybe we should mark all rows of the ERROR node.
+
+format_ts_parse_error_ <- function(x, n = 2, ...) {
+  file <- attr(x$tree, "file") %||% "<text>"
+  nodes <- utils::head(which(x$tree$type == "ERROR" | x$tree$is_missing), n)
+  # if two errors start at the same position only show the first
+  nodes <- nodes[!duplicated(x$tree$start_byte[nodes])]
+
+  rows <- x$tree$start_row[nodes] + 1L
+  cols <- x$tree$start_column[nodes] + 1L
+  erows <- x$tree$end_row[nodes] + 1L
+
+  ecols <- ifelse(
+    rows == erows,
+    x$tree$end_column[nodes] + 1L,
+    nchar(x$text[rows])
+  )
+
+  lang <- toupper(get_tree_lang(x$tree))
+  unlist(mapply(
+    format_ts_parse_error_1,
+    lang,
+    file,
+    rows,
+    cols,
+    ecols,
+    MoreArgs = list(text = x$text)
+  ))
+}
+
+format_ts_parse_error_1 <- function(lang, text, file, row, col, ecol) {
+  head <- sprintf("%s parse error `%s`:%d:%d", toupper(lang), file, row, col)
+
+  nchar <- function(x) {
+    cli::ansi_nchar(x, type = "width")
+  }
+
+  rows <- c(if (row > 1L) row - 1L, row, if (row < length(text)) row + 1L)
+  linum <- structure(cli::col_grey(sprintf("%d| ", rows)), names = rows)
+  nlinum <- max(nchar(linum))
+
+  # assume a minimum width of 40, otherwise it is hard to format
+  width <- max(cli::console_width(), 40L) - nlinum
+
+  prefix <- substr(text[row], 1L, col - 1L)
+  error <- substr(text[row], col, ecol)
+  suffix <- substr(text[row], ecol + 1L, nchar(text[row]))
+
+  npre <- nchar(prefix)
+  nerr <- nchar(error)
+  nsuf <- nchar(suffix)
+  truncated <- FALSE
+  if (npre + nerr + nsuf > width) {
+    truncated <- TRUE
+    dots <- cli::col_grey("...")
+    # need to truncate, first suffix
+    if (nsuf > 10) {
+      suffix <- paste0(dots, substr(suffix, nchar(suffix) - 7, nchar(suffix)))
+      nsuf <- nchar(suffix)
+    }
+    if (npre + nerr + nsuf > width) {
+      # need to truncate, then prefix
+      if (npre > 10) {
+        prefix <- paste0(substr(prefix, 1, 7), dots)
+        npre <- nchar(prefix)
+      }
+      if (npre + nerr + nsuf > width) {
+        # need to truncate error
+        err_width <- width - npre - nsuf
+        error <- paste0(
+          substr(error, 1, err_width %/% 2),
+          dots,
+          substr(error, nchar(error) - err_width %/% 2 + 4, nchar(error))
+        )
+      }
+    }
+  }
+
+  # if we truncated the line, then do not show the context lines
+  ctx_before <- ctx_after <- NULL
+  if (truncated) {
+    linum <- linum[as.character(row)]
+  } else {
+    ctx_before <- if (row > 1) {
+      paste0(linum[as.character(row - 1)], text[row - 1])
+    }
+    ctx_after <- if (row < length(text)) {
+      paste0(linum[as.character(row + 1)], text[row + 1])
+    }
+  }
+
+  mark <- paste0(
+    strrep(" ", nlinum + nchar(prefix)),
+    cli::col_red(strrep("^", max(nchar(error), 1)))
+  )
+
+  c(
+    head,
+    ctx_before,
+    paste0(linum[as.character(row)], prefix, error, suffix),
+    mark,
+    ctx_after
+  )
+}
+
+#' @export
+
+format.ts_parse_error <- function(x, ...) {
+  c("<ts_parse_error>", format_ts_parse_error_(x, ...))
+}
+
+#' @export
+
+print.ts_parse_error <- function(x, ...) {
+  writeLines(format(x, ...))
+  invisible(x)
+}
diff --git a/src/library/ts/R/friendly-type.R b/src/library/ts/R/friendly-type.R
new file mode 100644
index 0000000000..d1dc5b3826
--- /dev/null
+++ b/src/library/ts/R/friendly-type.R
@@ -0,0 +1,184 @@
+# This is based on rlang:::obj_type_friendly, but adapted to base R
+
+friendly_type <- local({
+  friendly_type <- function(x, value = TRUE, length = FALSE) {
+    if (is_missing(x)) {
+      return("absent")
+    }
+
+    if (is.object(x)) {
+      if (inherits(x, "quosure")) {
+        return("a <quosure> object")
+      } else if (identical(class(x), "data.frame")) {
+        return("a data frame")
+      } else if (identical(class(x), c("tbl_df", "tbl", "data.frame"))) {
+        return("a tibble")
+      } else {
+        # this is sometimes wrong for 'h', but ce la vie
+        fst <- tolower(substr(class(x)[1], 1, 1))
+        prop <- if (fst %in% c("a", "e", "i", "o", "u")) {
+          "an"
+        } else {
+          "a"
+        }
+        return(paste0(prop, " <", class(x)[1], "> object"))
+      }
+    }
+
+    if (!is_vector(x)) {
+      return(as_friendly_type(typeof(x)))
+    }
+
+    n_dim <- length(dim(x))
+
+    if (value && !n_dim) {
+      if (is_na(x)) {
+        return(switch(
+          typeof(x),
+          logical = "`NA`",
+          integer = "an integer `NA`",
+          double = "a numeric `NA`",
+          complex = "a complex `NA`",
+          character = "a character `NA`",
+          typeof(x)
+        ))
+      }
+      if (length(x) == 1 && !is_list(x)) {
+        return(switch(
+          typeof(x),
+          logical = if (x) "`TRUE`" else "`FALSE`",
+          integer = "an integer",
+          double = "a number",
+          complex = "a complex number",
+          character = if (nzchar(x)) "a string" else "`\"\"`",
+          raw = "a raw value",
+          sprintf("a %s value", typeof(x))
+        ))
+      }
+      if (length(x) == 0) {
+        return(switch(
+          typeof(x),
+          logical = "an empty logical vector",
+          integer = "an empty integer vector",
+          double = "an empty numeric vector",
+          complex = "an empty complex vector",
+          character = "an empty character vector",
+          raw = "an empty raw vector",
+          list = "an empty list",
+          sprintf("a %s of length one", typeof(x))
+        ))
+      }
+    }
+
+    type <- friendly_vector_type(typeof(x), n_dim)
+
+    if (length && !n_dim) {
+      type <- paste0(type, sprintf(" of length %s", length(x)))
+    }
+
+    type
+  }
+
+  friendly_vector_type <- function(type, n_dim) {
+    if (type == "list") {
+      if (n_dim < 2) {
+        return("a list")
+      } else if (n_dim == 2) {
+        return("a list matrix")
+      } else {
+        return("a list array")
+      }
+    }
+
+    type <- switch(
+      type,
+      logical = "a logical %s",
+      integer = "an integer %s",
+      numeric = ,
+      double = "a double %s",
+      complex = "a complex %s",
+      character = "a character %s",
+      raw = "a raw %s",
+      type = paste0("a ", type, " %s")
+    )
+
+    if (n_dim < 2) {
+      kind <- "vector"
+    } else if (n_dim == 2) {
+      kind <- "matrix"
+    } else {
+      kind <- "array"
+    }
+    sprintf(type, kind)
+  }
+
+  as_friendly_type <- function(type) {
+    switch(
+      type,
+
+      list = "a list",
+
+      NULL = "NULL",
+      environment = "an environment",
+      externalptr = "a pointer",
+      weakref = "a weak reference",
+      S4 = "an S4 object",
+
+      name = ,
+      symbol = "a symbol",
+      language = "a call",
+      pairlist = "a pairlist node",
+      expression = "an expression vector",
+
+      char = "an internal string",
+      promise = "an internal promise",
+      ... = "an internal dots object",
+      any = "an internal `any` object",
+      bytecode = "an internal bytecode object",
+
+      primitive = ,
+      builtin = ,
+      special = "a primitive function",
+      closure = "a function",
+
+      type
+    )
+  }
+
+  is_missing <- function(x) {
+    missing(x) || identical(x, quote(expr = ))
+  }
+
+  is_vector <- function(x) {
+    t <- typeof(x)
+    t %in%
+      c(
+        "logical",
+        "integer",
+        "double",
+        "complex",
+        "character",
+        "raw",
+        "list"
+      )
+  }
+
+  is_scalar_vector <- function(x) {
+    is_vector(x) && length(x) == 1L
+  }
+
+  is_na <- function(x) {
+    is_scalar_vector(x) && is.na(x)
+  }
+
+  is_list <- function(x) {
+    typeof(x) == "list"
+  }
+
+  list(
+    .internal = environment(),
+    friendly_type = friendly_type
+  )
+})
+
+typename <- friendly_type$friendly_type
diff --git a/src/library/ts/R/glue.R b/src/library/ts/R/glue.R
new file mode 100644
index 0000000000..c4f1a914e0
--- /dev/null
+++ b/src/library/ts/R/glue.R
@@ -0,0 +1,37 @@
+# Compared to glue::glue(), these are fixed:
+# - .sep = ""
+# - .trim = TRUE
+# - .null = character()
+# - .literal = TRUE
+# - .comment = ""
+#
+# we also don't allow passing in data as arguments, and `text` is
+# a single argument, no need to `paste()` etc.
+
+glue <- function(
+  text,
+  .envir = parent.frame(),
+  .transformer = identity_transformer,
+  .open = "{",
+  .close = "}",
+  .cli = FALSE,
+  .trim = TRUE
+) {
+  text <- paste0(text, collapse = "")
+
+  if (.trim) {
+    text <- trim(text)
+  }
+
+  f <- function(expr) {
+    eval_func <- as.character(.transformer(expr, .envir) %||% character())
+  }
+
+  res <- call_with_cleanup(c_glue, text, f, .open, .close, .cli)
+
+  paste0(unlist(res), collapse = "")
+}
+
+identity_transformer <- function(text, envir) {
+  eval(parse(text = text, keep.source = FALSE), envir)
+}
diff --git a/src/library/ts/R/print.R b/src/library/ts/R/print.R
new file mode 100644
index 0000000000..00748a1a3d
--- /dev/null
+++ b/src/library/ts/R/print.R
@@ -0,0 +1,318 @@
+#' Print a tree-sitter tree
+#'
+#' @ts print_description
+#' Print a `ts_tree` object to the screen.
+#' @description \eval{ts:::doc_insert("ts::print_description")}
+#'
+#' @ts print_details
+#' Calls \code{\link[ts:format.ts_tree]{format.ts_tree()}} to format the
+#' ts_tree object, writes the formatted object to the standard output, and
+#' returns the original object invisibly.
+#'
+#' \eval{ts:::doc_tabs("print_examples")}
+#' @details \eval{ts:::doc_insert("ts::print_details")}
+#'
+#' @ts print_param_x
+#' `ts_tree` object to print.
+#' @ts print_param_dots
+#' Not used currently.
+#' @param x \eval{ts:::doc_insert("ts::print_param_x")}
+#' @param n \eval{ts:::doc_insert("ts::format_param_n")}
+#' @param ... \eval{ts:::doc_insert("ts::print_param_dots")}
+#'
+#' @ts print_return
+#' Invisibly returns the original `ts_tree` object.
+#' @return \eval{ts:::doc_insert("ts::print_return")}
+#'
+#' @family ts_tree generics
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' json <- tsjsonc::ts_parse_jsonc(
+#'   '{ "a": 1, "b": [10, 20, 30], "c": { "c1": true, "c2": 100 } }'
+#' )
+#' print(json)
+
+print.ts_tree <- function(x, n = 10, ...) {
+  writeLines(format(x, n = n, ...))
+  invisible(x)
+}
+
+#' Format tree-sitter trees
+#'
+#' @ts format_description
+#' Format a `ts_tree` object for printing.
+#' @description \eval{ts:::doc_insert("ts::format_description")}
+#'
+#' @ts format_details
+#' This is the engine of \code{\link[ts:print.ts_tree]{print.ts_tree()}},
+#' possibly useful to obtain a printed representation without doing the
+#' actual printing.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' If there are selected nodes in the tree, those will be highlighted
+#' in the output. See \code{\link[ts:ts_tree_select]{ts_tree_select()}} to
+#' select nodes in a tree.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' \eval{ts:::doc_tabs("format_examples")}
+#'
+#' @details \eval{ts:::doc_insert("ts::format_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts format_param_x
+#' `ts_tree` object.
+#' @ts format_param_n
+#' Number of lines, or number of selections to print.
+#' @ts format_param_dots
+#' Currently ignored.
+#' @param x \eval{ts:::doc_insert("ts::format_param_x")}
+#' @param n \eval{ts:::doc_insert("ts::format_param_n")}
+#' @param ... \eval{ts:::doc_insert("ts::format_param_dots")}
+#'
+#' @ts format_return
+#' Character vector of lines to print.
+#' @return \eval{ts:::doc_insert("ts::format_return")}
+#'
+#' @family ts_tree generics
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' json <- tsjsonc::ts_parse_jsonc(
+#'   '{ "a": 1, "b": [10, 20, 30], "c": { "c1": true, "c2": 100 } }'
+#' )
+#' format(json)
+
+format.ts_tree <- function(x, n = 10, ...) {
+  sel <- ts_tree_selected_nodes(x, default = FALSE)
+  if (length(sel) > 0) {
+    format_ts_tree_selection(x, n = n, ...)
+  } else {
+    format_ts_tree_noselection(x, n = n, ...)
+  }
+}
+
+format_ts_tree_noselection <- function(x, n = 10, ...) {
+  lns <- strsplit(rawToChar(attr(x, "text")), "\r?\n")[[1]]
+  nc <- length(lns)
+  sc <- min(nc, n)
+  lns <- utils::head(lns, sc)
+  num <- cli::col_grey(format(seq_len(sc)))
+
+  sel <- ts_tree_selection(x, default = FALSE)
+
+  grey <- cli::col_grey
+
+  sfn <- if (!is.null(attr(x, "file"))) paste0(basename(attr(x, "file")), ", ")
+  lang <- sub("^ts_tree_", "", grep("^ts_tree_", class(x), value = TRUE))
+
+  c(
+    if (is.null(sel)) {
+      grey(glue("# {lang} ({sfn}{nc} line{plural(nc)})"))
+    } else {
+      grey(glue("# {lang} ({sfn}{nc} line{plural(nc)}, 0 selected elements)"))
+    },
+    paste0(num, if (sc) cli::col_grey(" | "), lns),
+    if (nc > sc) {
+      c(
+        grey(glue("{cli::symbol$info} {nc-sc} more line{plural(nc-sc)}")),
+        grey(glue("{cli::symbol$info} Use `print(n = ...)` to see more lines"))
+      )
+    }
+  )
+}
+
+ts_tree_mark_selection <- function(tree, node) {
+  unlist(lapply(node, ts_tree_mark_selection1, tree = tree))
+}
+
+#' Helper function to decide which AST nodes to highlight for a selection
+#' (internal)
+#'
+#' This function are for packages implementing new parsers based on the ts
+#' package. It is very unlikely that you will need to call this function
+#' directly.
+#'
+#' In parsers where AST nodes do not correspond one-to-one to DOM nodes
+#' it is useful to highlight multiple AST nodes for a single selected
+#' DOM node. This generic function can be overridden in such parsers to
+#' return multiple AST node ids for a single selected (DOM) node id.
+#'
+#' @param tree Tree-sitter tree.
+#' @param node Node id, integer scalar.
+#' @return Integer vector of node ids to highlight.
+#' @export
+#' @examples
+#' # This is an internal generic for parser implementations, see the
+#' # tsjsonc and tstoml packages for examples of methods implementing
+#' # custom behavior.
+
+ts_tree_mark_selection1 <- function(tree, node) {
+  UseMethod("ts_tree_mark_selection1")
+}
+
+#' @rdname ts_tree_mark_selection1
+#' @details
+#' The default implementation simply returns the input node id.
+#' @export
+
+ts_tree_mark_selection1.ts_tree <- function(tree, node) {
+  node
+}
+
+format_ts_tree_selection <- function(x, n = n, context = 3, ...) {
+  lns <- strsplit(rawToChar(attr(x, "text")), "\r?\n")[[1]]
+  nlns <- length(lns)
+  num <- seq_along(lns)
+  sel <- ts_tree_selected_nodes(x, default = FALSE)
+  nsel <- length(sel)
+  ssel <- min(nsel, n)
+  sel <- utils::head(sel, ssel)
+  isel <- ts_tree_mark_selection(x, sel)
+
+  # calculate the lines affected by the first ssel selections
+  selrows <- rep(FALSE, nlns)
+  shwrows <- rep(FALSE, nlns)
+  for (sel1 in isel) {
+    beg <- x$start_row[sel1] + 1L
+    end <- x$end_row[sel1] + 1L
+    end <- x$end_row[sel1] + 1L
+    if (x$end_column[sel1] == 0) {
+      end <- end - 1L
+    }
+    selrows[beg:end] <- TRUE
+    sbeg <- max(1, beg - context)
+    send <- min(nlns, end + context)
+    shwrows[sbeg:send] <- TRUE
+  }
+
+  # now highlight the selected elements
+  mark <- rep("  ", nlns)
+  for (sel1 in isel) {
+    beg <- x$start_row[sel1] + 1L
+    end <- x$end_row[sel1] + 1L
+    endcol <- x$end_column[sel1]
+    if (x$end_column[sel1] == 0) {
+      end <- end - 1L
+      endcol <- cli::ansi_nchar(lns[end], type = "bytes")
+    }
+    rows <- beg:end
+    mark[rows] <- paste0(cli::bg_cyan(">"), " ")
+    # one row only
+    if (length(rows) == 1) {
+      lns[rows] <- hl(
+        lns[rows],
+        x$start_column[sel1] + 1L,
+        endcol
+      )
+    } else {
+      # first row
+      lns[rows[1]] <- hl(lns[rows[1]], x$start_column[sel1] + 1L, end = NULL)
+      # middle rows, if any
+      if (length(rows) > 2) {
+        mid <- middle(rows)
+        lns[mid] <- hl(lns[mid])
+      }
+      # last row
+      if (length(rows) >= 2) {
+        lns[rows[length(rows)]] <- hl(
+          lns[rows[length(rows)]],
+          start = NULL,
+          endcol
+        )
+      }
+    }
+  }
+
+  grey <- cli::col_grey
+
+  # add ... between consecutive lines
+  dots <- diff(c(1, num[shwrows])) > 1
+  dotlns <- num[shwrows][dots] - 1L
+  # add ... to the end
+  lastshown <- utils::tail(num[shwrows], 1)
+  if (lastshown < nlns) {
+    dotlns <- c(dotlns, lastshown + 1L)
+  }
+  shwrows[dotlns] <- TRUE
+
+  # format the ... lines
+  num[shwrows] <- format(num[shwrows])
+  num[dotlns] <- "..."
+  num <- grey(format(num[shwrows]))
+  lns[dotlns] <- ""
+  split <- rep(cli::col_grey(" | "), nlns)
+  split[dotlns] <- "   "
+
+  slns <- paste0(mark[shwrows], num, split[shwrows], lns[shwrows])
+
+  sfn <- if (!is.null(attr(x, "file"))) paste0(basename(attr(x, "file")), ", ")
+  lang <- sub("^ts_tree_", "", grep("^ts_tree_", class(x), value = TRUE))
+
+  c(
+    grey(glue(
+      "# {lang} ({sfn}{nlns} line{plural(nlns)}, \\
+      {nsel} selected element{plural(nsel)})"
+    )),
+    slns,
+    if (nsel > ssel) {
+      c(
+        grey(glue(
+          "{cli::symbol$info} {nsel-ssel} more selected \\
+          element{plural(nsel-ssel)}"
+        )),
+        grey(glue(
+          "{cli::symbol$info} Use `print(n = ...)` to see more selected \\
+           elements"
+        ))
+      )
+    }
+  )
+}
+
+plural <- function(x) {
+  if (x != 1) {
+    "s"
+  } else {
+    ""
+  }
+}
+
+# TODO: only vectorized for the default case
+
+hl <- function(txt, start = NULL, end = NULL) {
+  if (is.null(start) && is.null(end)) {
+    cli::col_cyan(txt)
+  } else if (is.null(end) && !is.null(start)) {
+    stopifnot(length(txt) == 1)
+    paste0(
+      if (start > 1) {
+        cli::ansi_substr(txt, 1, start - 1)
+      },
+      cli::col_cyan(cli::ansi_substr(txt, start, cli::ansi_nchar(txt)))
+    )
+  } else if (is.null(start) && !is.null(end)) {
+    stopifnot(length(txt) == 1)
+    nc <- cli::ansi_nchar(txt)
+    paste0(
+      cli::col_cyan(cli::ansi_substr(txt, 1, end)),
+      if (end < nc) {
+        cli::ansi_substr(txt, end + 1, nc)
+      }
+    )
+  } else {
+    stopifnot(length(txt) == 1)
+    nc <- cli::ansi_nchar(txt)
+    paste0(
+      if (start > 1) {
+        cli::ansi_substr(txt, 1, start - 1)
+      },
+      cli::col_cyan(cli::ansi_substr(txt, start, end)),
+      if (end < nc) {
+        cli::ansi_substr(txt, end + 1, nc)
+      }
+    )
+  }
+}
diff --git a/src/library/ts/R/ts-list-parsers.R b/src/library/ts/R/ts-list-parsers.R
new file mode 100644
index 0000000000..8955e7371e
--- /dev/null
+++ b/src/library/ts/R/ts-list-parsers.R
@@ -0,0 +1,250 @@
+#' List installed tree-sitter parsers
+#'
+#' The ts package contains a common interface to several tree-sitter
+#' parsers, implemented in other R packages. `ts_list_parsers()` lists
+#' the available parsers installed in the system.
+#'
+#' To see tree-sitter parser packages that are available on CRAN, but not
+#' installed on your system, see the packages that depend on ts and have a
+#' name with a 'ts' prefix.
+# TODO: add URLs here, or pkgsearch  example once ts is on CRAN.
+#'
+# NOTE: this only works if all suggested packages are installed.
+#' Here is an example that includes all tree-sitter parsers at this time:
+#'
+#' ```{asciicast}
+#' ts_list_parsers()
+#' ```
+#'
+#' @param lib_path Library paths to search for installed packages.
+#'   Default is [base::.libPaths()].
+#' @return A data frame with columns:
+#' * `package`: character, the name of the package.
+#' * `version`: character, the version of the package.
+#' * `title`: character, the title of the package.
+#' * `library`: character, the library path where the package is installed.
+#' * `loaded`: logical, whether the package is currently loaded.
+#' @export
+#' @examples
+#' ts_list_parsers()
+
+ts_list_parsers <- function(lib_path = .libPaths()) {
+  # installed packages
+  ipkgs <- list_installed_packages(lib_path)
+  ipkgs <- ipkgs[grepl("^ts.", basename(ipkgs))]
+  dscs1 <- lapply(ipkgs, function(pkg) {
+    suppressWarnings(utils::packageDescription(
+      basename(pkg),
+      lib.loc = dirname(pkg)
+    ))
+  })
+
+  # loaded packages
+  lpkgs <- loadedNamespaces()
+  lpkgs <- lpkgs[grepl("^ts.", lpkgs)]
+  dscs2 <- lapply(lpkgs, function(pkg) {
+    suppressWarnings(utils::packageDescription(pkg))
+  })
+
+  dscs <- Filter(has_ts_parser, c(dscs1, dscs2))
+  path <- map_chr(dscs, attr, "file", exact = TRUE)
+  dscs <- dscs[!duplicated(path)]
+  path <- path[!duplicated(path)]
+
+  pkgpath <- as.character(ifelse(
+    basename(path) == "DESCRIPTION",
+    dirname(path),
+    dirname(dirname(path))
+  ))
+
+  tspkgs <- data_frame(
+    package = map_chr(dscs, "[[", "Package"),
+    version = map_chr(dscs, "[[", "Version"),
+    title = map_chr(dscs, "[[", "Title"),
+    library = dirname(pkgpath)
+  )
+  nspath <- map_chr(tspkgs$package, function(pkg) {
+    if (pkg %in% loadedNamespaces()) {
+      getNamespaceInfo(pkg, "path")
+    } else {
+      NA_character_
+    }
+  })
+  tspkgs$loaded <- tspkgs$package %in% loadedNamespaces() & nspath == pkgpath
+
+  tspkgs <- tspkgs[order(tspkgs$package, !tspkgs$loaded, tspkgs$version), ]
+
+  class(tspkgs) <- c(
+    "ts_parser_list",
+    class(tspkgs)
+  )
+  tspkgs
+}
+
+format_rd_parser_list <- function(lst, method = NULL) {
+  if (is.null(method)) {
+    format_rd_parser_list_no_method(lst)
+  } else {
+    format_rd_parser_list_method(lst, method)
+  }
+}
+
+no_ts_package_message <- function() {
+  avail <- read.dcf(file.path(doc_path("ts"), "ts-packages.dcf"))
+  paste0(
+    "No tree-sitter parser packages are installed.\n",
+    "Available tree-sitter parser packages:\n",
+    "\\itemize{\n",
+    paste0(
+      collapse = "\n",
+      "\\item \\strong{\\href{",
+      avail[, "URL"],
+      "}{",
+      avail[, "Package"],
+      "}}: ",
+      avail[, 'Title'],
+      "\\if{text}{ (",
+      avail[, "URL"],
+      ")}."
+    ),
+    "\n}\n"
+  )
+}
+
+format_rd_parser_list_no_method <- function(lst) {
+  if (nrow(lst) == 0) {
+    return(no_ts_package_message())
+  }
+  lst <- lst[!duplicated(lst[, c("package", "version")]), ]
+
+  hd <- "Available tree-sitter parsers"
+  align <- "lll"
+  loaded_hd <- ""
+  loaded <- rep("", nrow(lst))
+  if (Sys.getenv("IN_PKGDOWN") != "true") {
+    hd <- "Installed tree-sitter parsers"
+    align <- "llcl"
+    loaded_hd <- "\\strong{Loaded} \\tab "
+    loaded <- paste0(ifelse(lst$loaded, "yes", "no"), " \\tab ")
+  }
+
+  lines <- map_chr(
+    seq_len(nrow(lst)),
+    function(i) {
+      pkg <- lst$package[i]
+      ver <- lst$version[i]
+      title <- lst$title[i]
+      glue(
+        "\\link[{pkg}:{pkg}-package]{{ {pkg}} \\tab \\
+         {ver} \\tab \\
+         {loaded[i]} \\
+         {title}.
+         "
+      )
+    }
+  )
+
+  paste0(
+    "\\subsection{",
+    hd,
+    "}{\n",
+    "\\tabular{",
+    align,
+    "}{\n",
+    "\\strong{Package} \\tab \\strong{Version} \\tab ",
+    loaded_hd,
+    "\\strong{Title} \\cr\n",
+    paste(lines, collapse = "\\cr\n"),
+    "\n}\n",
+    "}\n"
+  )
+}
+
+format_rd_parser_list_method <- function(lst, method) {
+  if (nrow(lst) == 0) {
+    return(no_ts_package_message())
+  }
+  lst <- lst[!duplicated(lst[, c("package", "version")]), ]
+
+  hd <- "Available tree-sitter parsers"
+  loaded_hd <- ""
+  loaded <- rep("", nrow(lst))
+  align <- "llll"
+  if (Sys.getenv("IN_PKGDOWN") != "true") {
+    hd <- "Installed tree-sitter parsers"
+    align <- "llcll"
+    loaded_hd <- "\\strong{Loaded} \\tab "
+    loaded <- paste0(ifelse(lst$loaded, "yes", "no"), " \\tab ")
+  }
+
+  lines <- map_chr(
+    seq_len(nrow(lst)),
+    function(i) {
+      pkg <- lst$package[i]
+      ver <- lst$version[i]
+      title <- lst$title[i]
+      method <- if (doc_has_method(method, pkg)) {
+        cls <- sub("^ts", "ts_tree_", pkg)
+        glue(
+          "\\code{{\\link[{pkg}:{method}.{cls}]{{{method}(<ts_tree_{pkg}>)}}}}"
+        )
+      }
+      glue(
+        "\\strong{{\\link[{pkg}:{pkg}-package]{{{pkg}}}}} \\tab \\
+         {ver} \\tab \\
+         {loaded[i]} \\
+         {title}. \\tab \\
+         {method}"
+      )
+    }
+  )
+  paste0(
+    "\\subsection{",
+    hd,
+    "}{\n",
+    "This is the manual page of the \\code{",
+    method,
+    "()} S3 generic function.\n",
+    "Methods in parser packages may override this generic.\n",
+    "For the ones that do see the links to their manual pages in the table.\n",
+    "\\tabular{",
+    align,
+    "}{\n",
+    "\\strong{Package} \\tab \\strong{Version} \\tab ",
+    loaded_hd,
+    "\\strong{Title} \\tab \\strong{Method} \\cr\n",
+    paste(lines, collapse = "\\cr\n"),
+    "\n}\n",
+    "}\n"
+  )
+}
+
+has_ts_parser <- function(dsc) {
+  is.list(dsc) &&
+    !is.null(dsc$Imports) &&
+    "ts" %in% parse_deps("Imports", dsc$Imports)$package
+}
+
+list_installed_packages <- function(lib_path = .libPaths()) {
+  unlist(lapply(lib_path, dir, full.names = TRUE))
+}
+
+parse_deps <- function(type, deps) {
+  deps <- str_trim(strsplit(deps, ",")[[1]])
+  deps <- lapply(strsplit(deps, "\\("), str_trim)
+  deps <- lapply(deps, sub, pattern = "\\)$", replacement = "")
+  deps <- deps[vapply(deps, function(x) length(x) != 0, FUN.VALUE = logical(1))]
+  res <- data.frame(
+    stringsAsFactors = FALSE,
+    type = if (length(deps)) type else character(),
+    package = vapply(deps, "[", "", 1),
+    version = vapply(deps, "[", "", 2)
+  )
+  res$version <- gsub("\\s+", " ", res$version)
+  res$version[is.na(res$version)] <- "*"
+  res
+}
+
+str_trim <- function(x) {
+  sub("^\\s+", "", sub("\\s+$", "", x, useBytes = TRUE), useBytes = TRUE)
+}
diff --git a/src/library/ts/R/ts-package.R b/src/library/ts/R/ts-package.R
new file mode 100644
index 0000000000..758990e05a
--- /dev/null
+++ b/src/library/ts/R/ts-package.R
@@ -0,0 +1,43 @@
+#' @details
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers())}
+#' @keywords internal
+#' @return
+#' Not applicable.
+#' @examples
+#' # See help("about", package = "ts")
+"_PACKAGE"
+
+## usethis namespace: start
+#' @useDynLib ts, .registration = TRUE, .fixes = "c_"
+## usethis namespace: end
+NULL
+
+## usethis namespace: start
+## usethis namespace: end
+NULL
+
+#' @name about
+#' @title About ts
+#' @description
+#' ts is a common interface to [tree-sitter](
+#'  https://tree-sitter.github.io/tree-sitter/) parsers, implemented in
+#' other R packages. It has a common API to
+#'
+#' - query,
+#' - edit,
+#' - format, and
+#' - unserialize
+#'
+#' tree-sitter parse trees.
+#'
+#' @return
+#' Not applicable.
+#'
+#' @examples
+#' # See above please.
+#'
+#' @details
+#'
+#' ```{r, child = "tools/man/about.Rmd"}
+#' ```
+NULL
diff --git a/src/library/ts/R/ts-tree-ast.R b/src/library/ts/R/ts-tree-ast.R
new file mode 100644
index 0000000000..b1aa223dce
--- /dev/null
+++ b/src/library/ts/R/ts-tree-ast.R
@@ -0,0 +1,134 @@
+#' Show the annotated syntax tree of a tree-sitter tree
+#'
+#' @ts ts_tree_ast_description
+#' `ts_tree_ast()` prints the annotated syntax tree of a ts_tree object.
+#' This syntax tree contains all tree-sitter nodes, and it shows the
+#' source code associated with each node, along with line numbers.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_ast_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_ast")}
+#'
+#' @ts ts_tree_ast_details
+#' ## The syntax tree and the DOM tree
+#'
+#' This syntax tree contains all nodes of the tree-sitter parse tree,
+#' including both named and unnamed nodes and comments. E.g. for a JSON(C)
+#' document it includes the pairs, brackets, braces, commas, colons,
+#' double quotes and string escape sequences as separate nodes.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' See \code{\link[ts:ts_tree_dom]{ts::ts_tree_dom()}} for a tree that
+#' shows the semantic structure of the parsed document, which may be
+#' different from the syntax tree.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_ast_details_syntax_vs_dom")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_ast_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_ast_param_tree
+#' A `ts_tree` object.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_ast_param_tree")}
+#'
+#' @ts ts_tree_ast_return
+#' Character vector, the formatted annotated syntax tree, line by
+#' line. It has class [cli_tree][cli::tree()], from the cli package. It
+#' may contain ANSI escape sequences for coloring and hyperlinks.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_ast_return")}
+#'
+#' @family ts_tree exploration
+#' @family ts_tree generics
+#' @seealso [ts_tree_dom()] to show the document object model (DOM) of a
+#'   ts_tree object.
+#'
+#'  \eval{ts:::doc_seealso("ts_tree_ast")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' tree
+#'
+#' ts_tree_ast(tree)
+#'
+#' ts_tree_dom(tree)
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   title = "TOML Example"
+#'   [owner]
+#'   name = "Tom Preston-Werner"
+#'   dob = 1979-05-27T07:32:00-08:00
+#' )")
+#'
+#' tree
+#'
+#' ts_tree_ast(tree)
+#'
+#' ts_tree_dom(tree)
+
+ts_tree_ast <- function(tree) {
+  UseMethod("ts_tree_ast")
+}
+
+#' @export
+
+ts_tree_ast.default <- function(tree) {
+  type <- tree$type
+  fn <- attr(tree, "file")
+  if (cli::ansi_has_hyperlink_support() && !is.null(fn)) {
+    type <- cli::style_hyperlink(
+      type,
+      sprintf(
+        "file://%s:%d:%d",
+        normalizePath(fn, mustWork = NA),
+        tree$start_row + 1L,
+        tree$start_column + 1
+      )
+    )
+  }
+
+  linum <- tree$start_row + 1
+  linum <- ifelse(duplicated(linum), "", as.character(linum))
+  linum <- format(linum, justify = "right")
+  # this is the spacer we need to put in for multi-line tokens
+  nlspc <- paste0("\n\t", strrep(" ", nchar(linum[1])), "|")
+  code <- ifelse(
+    is.na(tree$code),
+    "",
+    paste0(strrep(" ", tree$start_column), tree$code)
+  )
+
+  # we put in a \t, and later use it to align the lines vertically
+  treetab <- data_frame(
+    id = as.character(tree$id),
+    children = lapply(tree$children, as.character),
+    label = paste0(
+      type,
+      " (",
+      tree$id,
+      ")",
+      "\t",
+      linum,
+      "|",
+      gsub("\n", nlspc, code, fixed = TRUE)
+    )
+  )
+  tree <- cli::tree(treetab)
+
+  # align lines vertically. the size of the alignment is measured
+  # without the ANSI sequences, but then the substitution uses the
+  # full ANSI string
+  tabpos <- regexpr("\t", cli::ansi_strip(tree), fixed = TRUE)
+  maxtab <- max(tabpos)
+  tabpos2 <- regexpr("\t", tree, fixed = TRUE)
+  regmatches(tree, tabpos2) <- strrep(" ", maxtab - tabpos + 4)
+
+  tree
+}
diff --git a/src/library/ts/R/ts-tree-delete.R b/src/library/ts/R/ts-tree-delete.R
new file mode 100644
index 0000000000..d7363de4b7
--- /dev/null
+++ b/src/library/ts/R/ts-tree-delete.R
@@ -0,0 +1,79 @@
+#' Delete selected elements from a tree-sitter tree
+#'
+#' @ts ts_tree_delete_description
+#' Use \code{\link[ts:ts_tree_select]{ts_tree_select()}} to select the
+#' elements to be deleted, and then call `ts_tree_delete()` to remove them
+#' from the tree.
+#'
+#' @ts ts_tree_delete_details
+#' The formatting of the rest of the document is left as is.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_delete_details_formatting")}
+#'
+#' If the tree does not have a selection, the tree corresponding to the
+#' empty document is returned, i.e. the whole content is deleted.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_delete_details_no_selection")}
+#'
+#' If the tree has a selection, but it is the empty selection, then
+#' the tree is returned unchanged.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_delete_details_empty_selection")}
+#'
+#' For parsers that support comments, deleting elements that include
+#' comments typically delete the comments as well. Other comments are
+#' kept as is. See details in the manual of the specific parser.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_delete_details_comments")}
+#'
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_delete_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_delete")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_delete_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_delete_param_tree
+#' A `ts_tree` object.
+#'
+#' @param tree
+#' \eval{ts:::doc_insert("ts::ts_tree_delete_param_tree")}
+#' @param ... Extra arguments for methods.
+#'
+#' @ts ts_tree_delete_return
+#' The modified `ts_tree` object with the selected elements removed.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_delete_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_delete")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc(
+#'   "{ \"a\": //comment\ntrue, \"b\": [1, 2, 3] }"
+#' )
+#'
+#' tree
+#'
+#' tree |> ts_tree_select("a")
+#'
+#' tree |> ts_tree_select("a") |> ts_tree_delete()
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   [servers]
+#'   alpha = { ip = "127.0.0.1", dc = "eqdc10" }
+#'   beta = { ip = "127.0.0.2", dc = "eqdc20" }
+#' )")
+#'
+#' tree
+#'
+#' tree |> ts_tree_select("servers", TRUE, "dc")
+#' tree |> ts_tree_select("servers", TRUE, "dc") |> ts_tree_delete()
+
+ts_tree_delete <- function(tree, ...) {
+  UseMethod("ts_tree_delete")
+}
diff --git a/src/library/ts/R/ts-tree-dom.R b/src/library/ts/R/ts-tree-dom.R
new file mode 100644
index 0000000000..1b49137b97
--- /dev/null
+++ b/src/library/ts/R/ts-tree-dom.R
@@ -0,0 +1,98 @@
+#' Print the document object model (DOM) of a tree-sitter tree
+#'
+#' @ts ts_tree_dom_description
+#' `ts_tree_dom()` prints the document object model (DOM) tree of a ts_tree
+#' object. This tree only includes semantic elements. E.g. for a JSON(C)
+#' document it includes objects, arrays and various value types, but not
+#' the syntax elements like brackets, commas or colons.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_dom_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_dom")}
+#'
+#' @ts ts_tree_dom_details
+#' ## The syntax tree and the DOM tree
+#'
+#' See \code{\link[ts:ts_tree_ast]{ts_tree_ast()}} for the complete
+#' tree-sitter syntax tree that includes all nodes, including syntax
+#' elements like brackets and commas.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_ast_details_syntax_vs_dom")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_dom_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_dom_param_tree
+#' A `ts_tree` object.
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_dom_param_tree")}
+#'
+#' @ts ts_tree_dom_return
+#' Character vector, the formatted annotated syntax tree, line by
+#' line. It has class [cli_tree][cli::tree()], from the cli package. It
+#' may contain ANSI escape sequences for coloring and hyperlinks.
+#' @return
+#' \eval{ts:::doc_insert("ts::ts_tree_dom_return")}
+#'
+#' @family ts_tree exploration
+#' @family ts_tree generics
+#' @seealso [ts_tree_ast()] to show the annotated syntax tree of a
+#'   ts_tree object.
+#'
+#'   \eval{ts:::doc_seealso("ts_tree_dom")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' tree
+#'
+#' ts_tree_ast(tree)
+#'
+#' ts_tree_dom(tree)
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   title = "TOML Example"
+#'   [owner]
+#'   name = "Tom Preston-Werner"
+#'   dob = 1979-05-27T07:32:00-08:00
+#' )")
+#'
+#' tree
+#'
+#' ts_tree_ast(tree)
+#'
+#' ts_tree_dom(tree)
+
+ts_tree_dom <- function(tree) {
+  UseMethod("ts_tree_dom")
+}
+
+#' @export
+
+ts_tree_dom.default <- function(tree) {
+  is_dom_node <- c(1L, which(!is.na(tree$dom_parent)))
+  dom <- tree[is_dom_node, ]
+
+  treetab <- data_frame(
+    id = as.character(dom$id),
+    children = lapply(dom$dom_children, as.character),
+    label = paste0(
+      dom$dom_type,
+      " (",
+      dom$id,
+      ")",
+      ifelse(
+        is.na(dom$dom_name),
+        "",
+        cli::col_grey(paste0(" # ", dom$dom_name))
+      )
+    )
+  )
+
+  tree <- cli::tree(treetab)
+  tree
+}
diff --git a/src/library/ts/R/ts-tree-format.R b/src/library/ts/R/ts-tree-format.R
new file mode 100644
index 0000000000..5d4c34bf7d
--- /dev/null
+++ b/src/library/ts/R/ts-tree-format.R
@@ -0,0 +1,82 @@
+#' Format the selected elements of a tree sitter tree for printing
+#'
+#' @ts ts_tree_format_description
+#' (Re)format the selected elements of the document represented by a
+#' tree-sitter tree, if the tree-sitter parser supports formatting.
+#'
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_format_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_format")}
+#'
+#' @ts ts_tree_format_details
+#'
+#' If `tree` does not have a selection, then the whole document is
+#' formatted.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_format_details_no_selection")}
+#'
+#' If `tree` has an empty selection, then it is returned unchanged.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_format_details_empty_selection")}
+#'
+#' Some parsers support options to customize the formatting.
+#' See details in the manual of the specific parser.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_format_details_options")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_format_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_format_param_tree
+#' A `ts_tree` object.
+#'
+#' @ts ts_tree_format_param_options
+#' A list of options for the formatting.
+#'
+#' @param tree
+#' \eval{ts:::doc_insert("ts::ts_tree_format_param_tree")}
+#' @param options
+#' \eval{ts:::doc_insert("ts::ts_tree_format_param_options")}
+#'
+#' See details in the manual of the specific parser.
+#'
+#' @param ... Extra arguments for methods.
+#'
+#' @ts ts_tree_format_return
+#' The `ts_tree` object of the reformatted document.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_format_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_format")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{ "a":true, "b": [1,2,3] }')
+#' tree
+#'
+#' # Format whole document
+#' tree |> ts_tree_format()
+#'
+#' # Format each top element under the document node in one line
+#' tree |> ts_tree_format() |>
+#'   ts_tree_select(TRUE) |>
+#'   ts_tree_format(options = list(format = "oneline"))
+#'
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   [servers]
+#'   alpha = { ip = "127.0.0.1", dc = "eqdc10" }
+#'   beta = { ip = "127.0.0.2", dc = "eqdc20" }
+#' )")
+#'
+#' tree
+#'
+#' tree |> ts_tree_format()
+
+ts_tree_format <- function(tree, options, ...) {
+  UseMethod("ts_tree_format")
+}
diff --git a/src/library/ts/R/ts-tree-insert.R b/src/library/ts/R/ts-tree-insert.R
new file mode 100644
index 0000000000..26c4f1b997
--- /dev/null
+++ b/src/library/ts/R/ts-tree-insert.R
@@ -0,0 +1,94 @@
+#' Insert a new element into a tree-sitter tree
+#'
+#' @ts ts_tree_insert_description
+#' Insert a new element into each selected element.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_insert_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_insert")}
+#'
+#' @ts ts_tree_insert_details
+#' It is not always possible to insert a new element into a selected
+#' element. For example in a JSONC document you can only insert a new
+#' element into an array or an object, but not into scalar elements.
+#' If the insertion is not possible, an error is raised.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_insert_details_errors")}
+#'
+#' If `tree` does not have a selection, the new element is inserted into
+#' at the top level.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_insert_details_no_selection")}
+#'
+#' If `tree` has an empty selection, then it is returned unchanged, i.e.
+#' no new element is inserted.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_insert_details_empty_selection")}
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_insert_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_insert_param_tree
+#' A `ts_tree` object.
+#' @ts ts_tree_insert_param_new
+#' The new element to insert.
+#' @ts ts_tree_insert_param_key
+#' The key of the new element, if inserting into a keyed element.
+#' @ts ts_tree_insert_param_at
+#' The position to insert the new element at.
+#' @ts ts_tree_insert_param_options
+#' A list of options for the insertion.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_insert_param_tree")}
+#' @param new \eval{ts:::doc_insert("ts::ts_tree_insert_param_new")}
+#'
+#' The type of `new` depends on the parser and the method that implements
+#' the insertion. See details in the manual of the specific parser.
+#' @param key \eval{ts:::doc_insert("ts::ts_tree_insert_param_key")}
+#'
+#' For example a JSON(C) object or a TOML table are keyed elements.
+#' @param at \eval{ts:::doc_insert("ts::ts_tree_insert_param_at")}
+#'
+#' The interpretation of this argument depends on the method that
+#' implements the insertion. Typically the followings are supported:
+#' - `0` inserts at the beginning.
+#' - `Inf` inserts at the end.
+#' - A positive integer `n` inserts _after_ the `n`-th element.
+#' - A character scalar inserts _after_ the element with the given key,
+#'   in keyed elements.
+#'
+#' See the details in the manual of the specific parser.
+#' @param options \eval{ts:::doc_insert("ts::ts_tree_insert_param_options")}
+#'
+#' See details in the manual of the specific parser.
+#' @param ... Extra arguments for methods.
+#'
+#' @ts ts_tree_insert_return
+#' A `ts_tree` object representing the modified parse tree.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_insert_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_insert")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{ "a": true, "b": [1, 2, 3] }')
+#'
+#' tree |> ts_tree_select("b") |> ts_tree_insert(4, at = Inf)
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   [servers]
+#'   alpha = { ip = "127.0.0.1", dc = "eqdc10" }
+#'   beta = { ip = "127.0.0.2", dc = "eqdc20" }
+#' )")
+#'
+#' tree |>
+#'   ts_tree_select("servers", TRUE) |>
+#'   ts_tree_insert(key = "active", TRUE)
+
+ts_tree_insert <- function(tree, new, key, at, options, ...) {
+  UseMethod("ts_tree_insert")
+}
diff --git a/src/library/ts/R/ts-tree-new.R b/src/library/ts/R/ts-tree-new.R
new file mode 100644
index 0000000000..cf1dd8149e
--- /dev/null
+++ b/src/library/ts/R/ts-tree-new.R
@@ -0,0 +1,167 @@
+#' Create tree-sitter tree from file or string
+#'
+#' @ts ts_tree_new_description
+#' The result is a `ts_tree` object. A `ts_tree` object may be queried,
+#' edited, formatted, written to file, etc. using `ts_tree` methods.
+#' @description
+#' This is the main function to create a tree-sitter parse tree, using a
+#' ts parser implemented in another package.
+#' \eval{ts:::doc_insert("ts_tree_new_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers())}
+#'
+#' @ts ts_tree_new_details
+#' \eval{ts:::doc_tabs("ts_tree_new_examples")}
+#'
+#' @details
+#' A package that implements a tree-sitter parser provides a function that
+#' creates a `ts_language` object for that parser. E.g.
+#' [tsjsonc][tsjsonc::tsjsonc-package] has [tsjsonc::ts_language_jsonc()].
+#' You need to use the returned `ts_language` object as the `language`
+#' argument of \code{\link[ts:ts_tree_new]{ts_tree_new()}}.
+#'
+#' \eval{ts:::doc_insert("ts_tree_new_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_new_param_language
+#' Language of the file or string, a `ts_language` object,e.g. the return
+#' value of [tsjsonc::ts_language_jsonc()].
+#' @ts ts_tree_new_param_file
+#' Path of a file to parse. Use either `file` or `text`, but not both.
+#' @ts ts_tree_new_param_text
+#' String to parse. Use either `file` or `text`, but not both.
+#' @ts ts_tree_new_param_ranges
+#' Can be used to parse part(s) of the input. It must be a data frame with
+#' integer columns `start_row`, `start_col`, `end_row`, `end_col`,
+#' `start_byte`, `end_byte`, in this order.
+#' @ts ts_tree_new_param_fail_on_parse_error
+#' Logical, whether to error if there are parse errors in the document.
+#' Default is `TRUE`.
+#'
+#' @param language
+#' \eval{ts:::doc_insert("ts::ts_tree_new_param_language", "ts")}
+#' @param file
+#' \eval{ts:::doc_insert("ts::ts_tree_new_param_file", "ts")}
+#' @param text
+#' \eval{ts:::doc_insert("ts::ts_tree_new_param_text", "ts")}
+#' @param ranges
+#' \eval{ts:::doc_insert("ts::ts_tree_new_param_ranges", "ts")}
+#' @param fail_on_parse_error
+#' \eval{ts:::doc_insert("ts::ts_tree_new_param_fail_on_parse_error", "ts")}
+#' @param ... Additional arguments for methods.
+#'
+#' @ts ts_tree_new_return
+#' A `ts_tree` object representing the parse tree of the input. You can
+#' use the single bracket \code{\link[ts::ts_tree-brackets]{`[`}}
+#' operator to convert it to a data frame.
+#' @return
+#' \eval{ts:::doc_insert("ts::ts_tree_new_return", "ts")}
+#'
+#' @export
+#' @family ts_tree generics
+#' @seealso The tree-sitter parser packages typically include shortcuts to
+#'   create parse trees from strings and file, e.g.
+#'   [tsjsonc::ts_parse_jsonc()] and [tsjsonc::ts_read_jsonc()].
+#'
+#'   \eval{ts:::doc_seealso("ts_tree_new")}
+#'
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#'
+#' # JSONC example, needs the tsjsonc package -----------------------------
+#' json <- ts_tree_new(
+#'   tsjsonc::ts_language_jsonc(),
+#'   text = '{ "a": 1, "b": 2 }'
+#' )
+#'
+#' json
+#'
+#' json |> ts_tree_format()
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # TOML example, needs the tstoml package -------------------------------
+#' toml <- ts_tree_new(
+#'   tstoml::ts_language_toml(),
+#'   text = '[section]\nkey = "value"\nnumber = 42\n'
+#' )
+#'
+#' toml
+#'
+#' toml |> ts_tree_format()
+
+ts_tree_new <- function(
+  language,
+  file = NULL,
+  text = NULL,
+  ranges = NULL,
+  fail_on_parse_error = TRUE,
+  ...
+) {
+  UseMethod("ts_tree_new")
+}
+
+#' @export
+
+ts_tree_new.ts_language <- function(
+  language,
+  file = NULL,
+  text = NULL,
+  ranges = NULL,
+  fail_on_parse_error = TRUE,
+  ...
+) {
+  if (is.null(text) + is.null(file) != 1) {
+    stop(ts_cnd(
+      "Invalid arguments in `ts_tree_new()`: exactly one of `file` \\
+       and `text` must be given."
+    ))
+  }
+  if (is.null(text)) {
+    text <- readBin(file, "raw", n = file.size(file))
+  }
+  if (is.character(text)) {
+    text <- charToRaw(paste(text, collapse = "\n"))
+  }
+
+  tree <- call_with_cleanup(c_parse, text, language, ranges)
+
+  lvls <- seq_len(nrow(tree))
+  tree$children <- I(unname(split(
+    lvls,
+    factor(tree$parent, levels = lvls)
+  )))
+
+  # trailing whitespace for each token
+  # first we add the leading whitespace to the document token
+  # this way printing $code and $tws will print the whole document
+  tree$tws <- rep("", nrow(tree))
+  if ((lead <- tree$start_byte[1]) > 0) {
+    tree$tws[1] <- rawToChar(text[1:lead])
+  }
+
+  # then the whitespace of the terminal nodes
+  term <- which(!is.na(tree$code))
+  from <- tree$end_byte[term] + 1L
+  to <- c(tree$start_byte[term][-1], tree$end_byte[1])
+  for (i in seq_along(term)) {
+    if (from[i] <= to[i]) {
+      tree$tws[term[i]] <- rawToChar(text[from[i]:to[i]])
+    }
+  }
+
+  attr(tree, "text") <- text
+  attr(tree, "file") <- if (!is.null(file)) normalizePath(file)
+  cls <- sub("^ts_language_", "ts_tree_", class(language)[1])
+  class(tree) <- c(cls, "ts_tree", class(tree))
+
+  if (fail_on_parse_error && (tree$has_error[1] || any(tree$is_missing))) {
+    stop(ts_parse_error_cnd(tree = tree, text = text))
+  }
+
+  language <- structure(
+    list(language = language, tree = tree),
+    class = class(tree)
+  )
+
+  tree
+}
diff --git a/src/library/ts/R/ts-tree-query.R b/src/library/ts/R/ts-tree-query.R
new file mode 100644
index 0000000000..19b5919702
--- /dev/null
+++ b/src/library/ts/R/ts-tree-query.R
@@ -0,0 +1,103 @@
+#' Run tree-sitter queries on tree-sitter trees
+#'
+#' @ts ts_tree_query_description
+#' Use \href{https://tree-sitter.github.io/tree-sitter/}{
+#' tree-sitter's query language} to find nodes in a tree-sitter tree.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_query_description")}
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_query")}
+#'
+#' @ts ts_tree_query_details
+#' You probably need to know some details about the specific tree-sitter
+#' parser you are using, to write effective queries. See the documentation
+#' of the parser package you are using for details about the node types
+#' and the query language support. See links below.
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_query_details")}
+#' \eval{ts:::doc_tabs("ts_tree_query_details_examples")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_query_param_tree
+#' A `ts_tree` object.
+#' @ts ts_tree_query_param_query
+#' Character string, the tree-sitter query to run.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_query_param_tree")}
+#' @param query \eval{ts:::doc_insert("ts::ts_tree_query_param_query")}
+#'
+#' @ts ts_tree_query_return
+#' A list with entries `patterns` and `matched_captures`.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' `patterns` contains information about all patterns in the queries and
+#' it is a data frame with columns: `id`, `name`, `pattern`, `match_count`.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' `matched_captures` contains information about all matches, and it has
+#' columns `id`, `pattern`, `match`, `start_byte`, `end_byte`, `start_row`,
+#' `start_column`, `end_row`, `end_column`, `name`, `code`.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' The `pattern` column of `matched_captured` refers to the `id` column of
+#' `patterns`.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_query_return")}
+#'
+#' @seealso [ts_tree_select()] to select the nodes matching a query.
+#'
+#'  \eval{ts:::doc_seealso("ts_tree_query")}
+#' @export
+#' @family ts_tree exploration
+#' @family ts_tree generics
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Select all numbers in a JSONC document ------------------------------------
+#' json <- tsjsonc::ts_parse_jsonc(
+#'   '{ "a": 1, "b": [10, 20, 30], "c": { "c1": true, "c2": 100 } }'
+#' )
+#' json |> ts_tree_query("(number) @number")
+
+ts_tree_query <- function(tree, query) {
+  UseMethod("ts_tree_query")
+}
+
+#' @export
+
+ts_tree_query.default <- function(tree, query) {
+  qlen <- nchar(query, type = "bytes") + 1L # + \n
+  qbeg <- c(1L, cumsum(qlen))
+  qnms <- names(query) %||% rep(NA_character_, length(query))
+  query1 <- paste0(query, "\n", collapse = "")
+
+  res <- call_with_cleanup(c_code_query, tree, query1)
+
+  qorig <- as.integer(cut(res[[1]][[3]], breaks = qbeg, include.lowest = TRUE))
+  list(
+    patterns = data_frame(
+      id = seq_along(res[[1]][[1]]),
+      name = qnms[qorig],
+      pattern = res[[1]][[1]],
+      match_count = res[[1]][[2]]
+    ),
+    captures = data_frame(
+      id = seq_along(res[[2]]),
+      name = res[[2]]
+    ),
+    matched_captures = data_frame(
+      id = map_int(res[[3]], "[[", 3L),
+      pattern = map_int(res[[3]], "[[", 1L),
+      match = map_int(res[[3]], "[[", 2L),
+      type = map_chr(res[[3]], "[[", 12L),
+      start_byte = map_int(res[[3]], "[[", 6L),
+      end_byte = map_int(res[[3]], "[[", 7L),
+      start_row = map_int(res[[3]], "[[", 8L),
+      start_column = map_int(res[[3]], "[[", 9L),
+      end_row = map_int(res[[3]], "[[", 10L),
+      end_column = map_int(res[[3]], "[[", 11L),
+      name = map_chr(res[[3]], "[[", 4L),
+      code = map_chr(res[[3]], "[[", 5L)
+    )
+  )
+}
diff --git a/src/library/ts/R/ts-tree-select.R b/src/library/ts/R/ts-tree-select.R
new file mode 100644
index 0000000000..0399bb1139
--- /dev/null
+++ b/src/library/ts/R/ts-tree-select.R
@@ -0,0 +1,816 @@
+#' @ts ts_tree_select_details
+#' The selection process is iterative. Selection expressions (selectors)
+#' are applied one by one, and each selector selects nodes from the
+#' currently selected nodes. For each selector, it is applied individually
+#' to each currently selected node, and the results are concatenated.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' The selection process starts from the root of the DOM tree, the document
+#' node (see \code{\link[ts:ts_tree_dom]{ts_tree_dom()}}), unless
+#' `refine = TRUE` is set, in which case it starts from the current
+#' selection.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' See the various types of selection expressions below.
+#'
+#' ## Selectors
+#'
+#' ### All elements: `TRUE`
+#'
+#' Selects all child nodes of the current nodes.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_true")}
+#'
+#' ### Specific keys: character vector
+#'
+#' Selects child nodes with the given names from nodes with named children.
+#' If a node has no named children, it selects nothing from that node.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_character")}
+#'
+#' ### By position: integer vector
+#'
+#' Selects child nodes by position. Positive indices count from the start,
+#' negative indices count from the end. Zero indices are not allowed.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_integer")}
+#'
+#' ### Matching keys: regular expression
+#'
+#' A character scalar named `regex` can be used to select child nodes
+#' whose names match the given regular expression, from nodes with named
+#' children. If a node has no named children, it selects nothing from that
+#' node.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_regex")}
+#'
+#' ### Tree sitter query matches
+#'
+#' A character scalar named `query` can be used to select nodes matching
+#' a tree-sitter query. See \code{\link[ts:ts_tree_query]{ts_tree_query()}}
+#' for details on tree-sitter queries.
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' Instead of a character scalar this can also be a two-element list, where
+#' the first element is the query string and the second element is a
+#' character vector of capture names to select. In this case only nodes
+#' matching the given capture names will be selected.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_tsquery")}
+#'
+#' ### Explicit node ids
+#'
+#' You can use `I(c(...))` to select nodes by their ids directly. This is
+#' for advanced use cases only.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_ids")}
+#'
+#' ## Refining selections
+#'
+#' If the `refine` argument of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} is `TRUE`, then
+#' the selection starts from the already selected elements (all of them
+#' simultanously), instead of starting from the document element.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_refine")}
+#'
+#' ## The `ts_tree_select<-()` replacement function
+#'
+#' The \code{\link[ts:ts_tree_select<-]{ts_tree_select<-()}} replacement
+#' function works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_update]{ts_tree_update()}}, but it might be more
+#' readable.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_set")}
+#'
+#' ## The `[[` and `[[<-` operators
+#
+#' The `[[` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_unserialize]{ts_tree_unserialize()}}, but it
+#' might be more readable.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_brackets")}
+#'
+#' The `[[<-` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_update]{ts_tree_update()}}, (and also to the
+#' replacement function \code{\link[ts:ts_tree_select<-]{ts_tree_select<-()}}),
+#' but it might be more readable.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_brackets_set")}
+NULL
+
+#' Select elements of a tree-sitter tree
+#'
+#' @ts ts_tree_select_description
+#' This function is the heart of ts. To edit a tree-sitter tree, you first
+#' need to select the parts you want to delete or update.
+#' @description
+#' \eval{ts:::doc_insert("ts::ts_tree_select_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_select")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_select_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_select_param_tree
+#' A `ts_tree` object as returned by
+#' \code{\link[ts:ts_tree_new]{ts_tree_new()}}.
+#' @ts ts_tree_select_param_dots
+#' Selection expressions, see details.
+#' @ts ts_tree_select_param_refine
+#' Logical, whether to refine the current selection or start
+#' a new selection.
+#' @param tree \eval{ts:::doc_insert("ts_tree_select_param_tree")}
+#' @param ... \eval{ts:::doc_insert("ts_tree_select_param_dots")}
+#' @param refine \eval{ts:::doc_insert("ts_tree_select_param_refine")}
+#' @ts ts_tree_select_return
+#' A `ts_tree` object with the selected parts.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_select_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_select")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # ----------------------------------------------------------------------
+#' # Create a JSONC tree, needs the tsjsonc package
+#' json <- ts_tree_new(
+#'   tsjsonc::ts_language_jsonc(),
+#'   text = '{ "a": 1, "b": 2, "c": { "d": 3, "e": 4 } }'
+#' )
+#'
+#' json |> ts_tree_select("c", "d")
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # ----------------------------------------------------------------------
+#' # Create a TOML tree, needs the tstoml package
+#' toml <- ts_tree_new(
+#'   tstoml::ts_language_toml(),
+#'   text = tstoml::toml_example_text()
+#' )
+#'
+#' toml |> ts_tree_select("servers", TRUE, "ip")
+
+ts_tree_select <- function(tree, ..., refine = FALSE) {
+  slts <- normalize_selectors(tree, list(...))
+  if (length(slts) == 1 && is.null(slts[[1]])) {
+    attr(tree, "selection") <- NULL
+    return(tree)
+  }
+  current <- if (refine) {
+    ts_tree_selection(tree)
+  } else {
+    ts_tree_selector_default(tree)
+  }
+  cnodes <- current[[length(current)]]$nodes
+
+  for (idx in seq_along(slts)) {
+    slt <- slts[[idx]]
+    nxt <- integer()
+    for (cur in cnodes) {
+      nxt <- unique(c(nxt, ts_tree_select1(tree, cur, slt)))
+    }
+    current[[length(current) + 1L]] <- list(
+      selector = slt,
+      nodes = sort(nxt)
+    )
+    cnodes <- current[[length(current)]]$nodes
+  }
+  attr(tree, "selection") <- current
+  tree
+}
+
+normalize_selectors <- function(tree, slts) {
+  names(slts) <- names(slts) %||% rep("", length(slts))
+  slts <- imap(slts, function(x, nm) {
+    if (nm == "regex") {
+      x <- structure(
+        list(pattern = x),
+        class = c("ts_tree_selector_regex", "ts_tree_selector", "list")
+      )
+    } else if (nm == "query") {
+      # we do the query up front, so we don't rerun it for every node
+      x <- structure(
+        list(
+          query = if (is.character(x)) x else x[[1]],
+          captures = if (!is.character(x)) x[[2]] else NULL
+        ),
+        class = c("ts_tree_selector_tsquery", "ts_tree_selector", "list")
+      )
+      x$nodes <- select_query(tree, x$query, x$captures)
+    } else if (inherits(x, "AsIs")) {
+      x <- structure(
+        list(ids = unclass(x)),
+        class = c("ts_tree_selector_ids", "ts_tree_selector", "list")
+      )
+    }
+    x <- if (inherits(x, "ts_tree_selector") || !is.list(x)) list(x) else x
+    x
+  })
+  unlist(slts, recursive = FALSE, use.names = FALSE)
+}
+
+#' Select nodes from a tree-sitter tree (internal)
+#'
+#' This function is for packages implementing new parsers based on the ts
+#' package. It is very unlikely that you will need to call this function
+#' directly.
+#'
+#' A parser package may implement methods for this generic to change the
+#' behavior of \code{\link[ts:ts_tree_select]{ts_tree_select()}} for a
+#' certain selector type, or even add new selector types.
+#'
+#' Each new method should be named as
+#' ```
+#' ts_tree_select.<ts_tree_class>.<selector_class>
+#' ```
+#'
+#' The ts package implement deault methods for the selector types described
+#' in the \code{\link[ts:ts_tree_select]{ts_tree_select()}} manual page.
+#'
+#' @param tree A `ts_tree` object as returned by [ts_tree_new()].
+#' @param node Integer scalar, the node id to select from.
+#' @param slt A selector object, see details in [ts_tree_select()].
+#'
+#' @return Must return an integer vector of selected node ids.
+#'
+#' @export
+#' @examples
+#' # This is an internal generic for parser implementations, see the
+#' # tsjsonc and tstoml packages for examples of methods implementing
+#' # selector types.
+
+ts_tree_select1 <- function(tree, node, slt) {
+  treesel <- structure(
+    list(tree = tree, slt = slt),
+    class = paste0(class(tree), ".", class(slt)[1])
+  )
+  UseMethod("ts_tree_select1", treesel)
+}
+
+#' @export
+
+ts_tree_select1.default <- function(tree, node, slt) {
+  lang <- toupper(get_tree_lang(tree))
+  stop(ts_cnd(
+    "Don't know how to select nodes from a `ts_tree` ({lang}) object \\
+     using selector of class `{class(slt)[1]}`."
+  ))
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `ts_tree_selector_default` selector
+#'
+#' Method: `ts_tree_select1.ts_tree.ts_tree_selector_default`
+#'
+#' This method is used to select the default element(s), when there is no
+#' selected element. E.g. when starting a new selection from the root of
+#' the DOM tree.
+#'
+#' The default implementation returns the ids of all children of the
+#' document root in the AST, except comments. If there are no such
+#' children, it returns the id of the document root of the AST itself
+#' (always id 1).
+#' @export
+
+ts_tree_select1.ts_tree.ts_tree_selector_default <- function(tree, node, slt) {
+  top <- tree$children[[1]]
+  top <- top[tree$type[top] != "comment"]
+  if (length(top) > 0) top else 1L
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `NULL` selector
+#'
+#' Method: `ts_tree_select1.ts_tree.NULL`
+#'
+#' This method is used for the  `NULL` selector, that is supposed to
+#' clear the selection. You probably do not need to override this method.
+#' The default implementation returns an empty integer vector.
+#' @export
+
+ts_tree_select1.ts_tree.NULL <- function(tree, node, slt) {
+  integer()
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `ts_tree_selector_ids` selector
+#'
+#' Method: `ts_tree_select1.ts_tree.ts_tree_selector_ids`
+#'
+#' This method is used to select nodes by their ids directly.
+#' You probably do not need to override this method.
+#' The default implementation returns the ids stored in the selector.
+#'
+#' ### Note
+#'
+#' This behaviour may change in the future to select only nodes
+#' in the subtree of the current node.
+#' @export
+
+ts_tree_select1.ts_tree.ts_tree_selector_ids <- function(tree, node, slt) {
+  # TODO: should we select in subtree of node? Probably.
+  slt$ids
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `ts_tree_selector_tsquery` selector
+#'
+#' Method: `ts_tree_select1.ts_tree.ts_tree_selector_tsquery`
+#'
+#' This method is used to select nodes matching a tree-sitter query.
+#' You probably do not need to override this method.
+#' The default implementation returns the ids stored in the selector.
+#'
+#' ### Note
+#'
+#' This behaviour may change in the future to select only nodes
+#' in the subtree of the current node.
+#' @export
+
+ts_tree_select1.ts_tree.ts_tree_selector_tsquery <- function(tree, node, slt) {
+  # TODO: should we select in subtree of node? Probably.
+  slt$nodes
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `character` (character vector) selector
+#'
+#' Method: `ts_tree_select1.ts_tree.character`
+#'
+#' This method is used when the selector is a character vector.
+#' The default implementation selects DOM children of `node` whose names
+#' are in the character vector. If not all children o `node` are named,
+#' it returns an empty integer vector. (E.g. in a JSONC document it returns
+#' an empty integer vector when nodes is an array.)
+#' @export
+
+ts_tree_select1.ts_tree.character <- function(tree, node, slt) {
+  chdn <- tree$dom_children[[node]]
+  if (!is_named(chdn)) {
+    return(integer())
+  }
+  chdn[names(chdn) %in% slt]
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `integer` (integer vector) selector
+#'
+#' Method: `ts_tree_select1.ts_tree.integer`
+#'
+#' This method is used when the selector is an integer vector.
+#' The default implementation selects DOM children of `node` by position.
+#' Positive indices count from the start, negative indices count from the
+#' end. Zero indices are not allowed and an error is raised if any are
+#' used.
+#' @export
+
+ts_tree_select1.ts_tree.integer <- function(tree, node, slt) {
+  if (any(slt == 0)) {
+    stop(ts_cnd("Zero indices are not allowed in ts selectors."))
+  }
+  chdn <- tree$dom_children[[node]]
+  slt <- slt[slt <= length(chdn) & slt >= -length(chdn)]
+
+  res <- integer(length(slt))
+  pos <- slt >= 0
+  if (any(pos)) {
+    res[pos] <- chdn[slt[pos]]
+  }
+  if (any(!pos)) {
+    res[!pos] <- rev(rev(chdn)[abs(slt[!pos])])
+  }
+  res
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `numeric` (numeric, double vector) selector
+#'
+#' Method: `ts_tree_select1.ts_tree.numeric`
+#'
+#' This method is used when the selector is a numeric (double) vector.
+#' It currrently coerces the numeric vector to integer and calls the
+#' integer method.
+#' @export
+
+ts_tree_select1.ts_tree.numeric <- function(tree, node, slt) {
+  ts_tree_select1.ts_tree.integer(tree, node, as.integer(slt))
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `ts_tree_selector_regex` (regular expression) selector
+#'
+#' Method: `ts_tree_select1.ts_tree.ts_tree_selector_regex`
+#'
+#' This method is used when the selector is a regular expression.
+#' The default implementation selects DOM children of `node` whose names
+#' match the regular expression. If not all children o `node` are named,
+#' it returns an empty integer vector. (E.g. in a JSONC document it
+#' returns an empty integer vector when nodes is an array.)
+#' @export
+
+ts_tree_select1.ts_tree.ts_tree_selector_regex <- function(tree, node, slt) {
+  chdn <- tree$dom_children[[node]]
+  if (!is_named(chdn)) {
+    return(integer())
+  }
+  chdn[grepl(slt$pattern, names(chdn))]
+}
+
+#' @rdname ts_tree_select1
+#' @details
+#' ## `logical` (logical vector) selector
+#'
+#' Method: `ts_tree_select1.ts_tree.logical`
+#'
+#' This method is used when the selector is a logical vector.
+#' The default implementation only supports scalar `TRUE`, which selects
+#' all DOM children of `node`. Other values raise an error.
+#' @export
+
+ts_tree_select1.ts_tree.logical <- function(tree, node, slt) {
+  if (isTRUE(slt)) {
+    tree$dom_children[[node]]
+  } else {
+    stop(ts_cnd(
+      "Invalid logical selector in `ts_tree_select()`: only scalar `TRUE` is \\
+       supported."
+    ))
+  }
+}
+
+#' Unserialize parts of a tree-sitter tree
+#'
+#' @ts ts_tree_double_bracket_description
+#' The `[[` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_unserialize]{ts_tree_unserialize()}}, but it
+#' might be more readable.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_double_bracket_description")}
+#'
+#' @ts ts_tree_double_bracket_details
+#' The following two expressions are equivalent:
+#' ```r
+#' ts_tree_select(tree, <selectors>) |> ts_tree_unserialize()
+#' ```
+#' and
+#' ```r
+#' tree[[list(<selectors>)]]
+#' ```
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_brackets")}
+#'
+#' ## The `[[<-` replacement operator
+#'
+#' The `[[<-` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_update]{ts_tree_update()}}, (and also to the
+#' replacement function \code{\link[ts:ts_tree_select<-]{ts_tree_select<-()}}),
+#' but it might be more readable.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_brackets_set")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_double_bracket_param_x
+#' A `ts_tree` object.
+#' @ts ts_tree_double_bracket_param_i
+#' Selection expressions in a list, see details in
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}}.
+#' @ts ts_tree_double_bracket_param_dots
+#' Additional arguments, passed to
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}}.
+#'
+#'
+#' @param x \eval{ts:::doc_insert("ts::ts_tree_double_bracket_param_x")}
+#' @param i \eval{ts:::doc_insert("ts::ts_tree_double_bracket_param_i")}
+#' @param ...
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_param_dots")}
+#'
+#' @ts ts_tree_double_bracket_return
+#' List of R objects, with one entry for each selected element.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_double_bracket_return")}
+#'
+#' @family ts_tree generics
+#' @family serialization functions
+#' @rdname double-bracket-ts-tree
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"a": 13, "b": [1, 2, 3], "c": "x"}')
+#'
+#' tree
+#'
+#' tree[[list("a")]]
+#'
+#' # Last two elements of "b"
+#' tree[[list("b", -(1:2))]]
+
+`[[.ts_tree` <- function(x, i, ...) {
+  if (missing(i)) {
+    i <- list()
+  }
+  ts_tree_unserialize(ts_tree_select(x, i, ...))
+}
+
+select_query <- function(tree, query, captures = NULL) {
+  mch <- ts_tree_query(tree, query)
+
+  if (!is.null(captures)) {
+    bad <- !captures %in% mch$captures$name
+    if (any(bad)) {
+      stop(ts_cnd(
+        "Invalid capture names in `select_query()`: \\
+         {ts_collapse(captures[bad])}."
+      ))
+    }
+    mc <- mch$matched_captures[
+      mch$matched_captures$name %in% captures,
+    ]
+  } else {
+    mc <- mch$matched_captures
+  }
+
+  ids <- if (nrow(mc) == 0) {
+    integer()
+  } else {
+    toml0 <- tree[
+      tree$start_byte %in% mc$start_byte & tree$end_byte %in% mc$end_byte,
+    ]
+    mkeys <- paste0(mc$type, ":", mc$start_byte, ":", mc$end_byte)
+    jkeys <- paste0(toml0$type, ":", toml0$start_byte, ":", toml0$end_byte)
+    toml0$id[match(mkeys, jkeys)]
+  }
+  # TODO: should we do this?
+  minimize_selection(tree, ids)
+}
+
+# remove nodes that are in the subtree of other selected nodes
+# start from the last nodes and go up
+
+minimize_selection <- function(tree, ids) {
+  ids <- sort(unique(ids))
+  sel <- logical(nrow(tree))
+  sel[ids] <- TRUE
+  for (id in rev(ids)) {
+    parent <- tree$parent[id]
+    while (!is.na(parent)) {
+      if (sel[parent]) {
+        sel[id] <- FALSE
+        break
+      }
+      parent <- tree$parent[parent]
+    }
+  }
+  which(sel)
+}
+
+# A section is a list of records. Each record has a selector
+# and a list of selected nodes.
+#
+# 1. there is an explicit selection
+# 2. otherwise the top element is selected (or elements if many)
+# 3. otherwise the document node is selected
+
+#' Helper functions for tree-sitter tree selections (internal)
+#'
+#' These functions are for packages implementing new parsers based on the ts
+#' package. It is very unlikely that you will need to call these functions
+#' directly.
+#'
+#' @param tree A `ts_tree` object as returned by [ts_tree_new()].
+#' @param default Logical, whether to return the default selection if there
+#'   is no explicit selection, or `NULL`.
+#' @return `ts_tree_selection()` returns a list of selection records.
+#'
+#' @details `ts_tree_selection()` returns the current selection, as a list
+#'   of selectors.
+#'
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"a": 13, "b": [1, 2, 3], "c": "x"}')
+#' tree <- ts_tree_select(tree, "b", -1)
+#' ts_tree_selection(tree)
+
+ts_tree_selection <- function(tree, default = TRUE) {
+  sel <- attr(tree, "selection")
+  if (!is.null(sel)) {
+    sel
+  } else if (default) {
+    ts_tree_selector_default(tree)
+  } else {
+    NULL
+  }
+}
+
+#' @rdname ts_tree_selection
+#' @return `ts_tree_selected_nodes()` returns the ids of the currently
+#'   selected nodes.
+#' @details `ts_tree_selected_nodes()` returns the ids of the currently
+#'   selected nodes.
+#' @export
+
+ts_tree_selected_nodes <- function(tree, default = TRUE) {
+  sel <- ts_tree_selection(tree, default = default)
+  if (is.null(sel)) {
+    return(integer())
+  } else {
+    sel[[length(sel)]]$nodes
+  }
+}
+
+ts_tree_selector_default <- function(tree) {
+  slt <- structure(
+    list(),
+    class = c("ts_tree_selector_default", "ts_tree_selector", "list")
+  )
+  list(list(
+    selector = slt,
+    nodes = ts_tree_select1(tree, NULL, slt)
+  ))
+}
+
+#' Edit parts of a tree-sitter tree
+#'
+#' @ts ts_tree_select_set_description
+#' The \code{\link[ts:ts_tree_select<-]{ts_tree_select<-()}} replacement
+#' function works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_update]{ts_tree_update()}}, but
+#' it might be more readable.
+#' @description \eval{ts:::doc_insert("ts_tree_select_set_description")}
+#'
+#' @ts ts_tree_select_set_details
+#' The following two expressions are equivalent:
+#' ```r
+#' tree <- ts_tree_select(tree, <selectors>) |> ts_tree_update(value)
+#' ```
+#' and
+#' ```r
+#' ts_tree_select(tree, <selectors>) <- value
+#' ```
+#' \eval{ts:::doc_tabs("ts_tree_select_set")}
+#' @details \eval{ts:::doc_insert("ts::ts_tree_select_set_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_select_set_param_tree
+#' A `ts_tree` object as returned by
+#' \code{\link[ts:ts_tree_new]{ts_tree_new()}}.
+#' @ts ts_tree_select_set_param_dots
+#' Selection expressions, see \code{\link[ts:ts_tree_select]{ts_tree_select()}}.
+#' @ts ts_tree_select_set_param_value
+#' An R expression to serialize or
+#' \code{\link[ts:ts_tree_deleted]{ts_tree_deleted()}}.
+#' @param tree \eval{ts:::doc_insert("ts_tree_select_set_param_tree")}
+#' @param ... \eval{ts:::doc_insert("ts_tree_select_set_param_dots")}
+#' @param value \eval{ts:::doc_insert("ts_tree_select_set_param_value")}
+#'
+#' @ts ts_tree_select_set_return
+#' A `ts_tree` object with the selected parts updated.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_select_set_return")}
+#'
+#' @name select-set
+#' @rdname select-set
+#' @family ts_tree generics
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"a": 13, "b": [1, 2, 3], "c": "x"}')
+#
+#' tree
+#'
+#' ts_tree_select(tree, "a") <- 42
+#' ts_tree_select(tree, "b", -1) <- ts_tree_deleted()
+#'
+#' tree
+
+`ts_tree_select<-` <- function(tree, ..., value) {
+  UseMethod("ts_tree_select<-")
+}
+
+#' @export
+
+`ts_tree_select<-.ts_tree` <- function(tree, ..., value) {
+  res <- if (inherits(value, "ts_tree")) {
+    value # nocov
+  } else if (inherits(value, "ts_tree_action_delete")) {
+    ts_tree_delete(ts_tree_select(tree, ..., refine = TRUE))
+  } else {
+    ts_tree_update(ts_tree_select(tree, ..., refine = TRUE), value)
+  }
+  attr(res, "selection") <- NULL
+  res
+}
+
+#' Edit parts of a tree-sitter tree
+#'
+#' @ts ts_tree_double_bracket_set_description
+#' The `[[<-` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' \code{\link[ts:ts_tree_update]{ts_tree_update()}}, (and also to the
+#' replacement function \code{\link[ts:ts_tree_select<-]{ts_tree_select<-()}}),
+#' but it might be more readable.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_double_bracket_set_description")}
+#'
+#' @ts ts_tree_double_bracket_set_details
+#' The following two expressions are equivalent:
+#' ```r
+#' tree <- ts_tree_select(tree, <selectors>) |> ts_tree_update(value)
+#' ```
+#' and
+#' ```r
+#' tree[[list(<selectors>)]] <- value
+#' ```
+#' \eval{ts:::doc_tabs("ts_tree_double_brackets_set")}
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_set_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_double_bracket_set_param_x
+#' A `ts_tree` object.
+#' @ts ts_tree_double_bracket_set_param_i
+#' A list with selection expressions, see
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} for details.
+#' @ts ts_tree_double_bracket_set_param_value
+#' An R expression to serialize or
+#' \code{\link[ts:ts_tree_deleted]{ts_tree_deleted()}}.
+#'
+#' @param x
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_set_param_x")}
+#' @param i
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_set_param_i")}
+#' @param value
+#' \eval{ts:::doc_insert("ts::ts_tree_double_bracket_set_param_value")}
+#'
+#' @ts ts_tree_double_bracket_set_return
+#' The modified `ts_tree` object.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_double_bracket_set_return")}
+#' @rdname double-bracket-set-ts-tree
+#' @family ts_tree generics
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"a": 13, "b": [1, 2, 3], "c": "x"}')
+#'
+#' tree
+#'
+#' tree[[list("a")]] <- 42
+#' tree[[list("b", -1)]] <- ts_tree_deleted()
+#'
+#' tree
+
+`[[<-.ts_tree` <- function(x, i, value) {
+  # nocov start -- not sure if still is still needed, if [[ are not nested
+  if (missing(i)) {
+    i <- list()
+  }
+  # nocov end
+  res <- if (inherits(value, "ts_tree")) {
+    value # nocov
+  } else if (inherits(value, "ts_tree_action_delete")) {
+    ts_tree_delete(ts_tree_select(x, i, refine = TRUE))
+  } else {
+    ts_tree_update(ts_tree_select(x, i, refine = TRUE), value)
+  }
+  attr(res, "selection") <- NULL
+  res
+}
+
+#' @rdname select-set
+#' @usage NULL
+#' @details
+#' `ts_tree_deleted()` is a special marker to delete elements from a
+#' ts_tree object with `ts_tree_select<-` or the double bracket operator.
+#'
+#' @return `ts_tree_deleted()` returns a marker object to be used at the right
+#'   hand side of the `ts_tree_select<-` or the double bracket replacement
+#'   functions, see examples below.
+#'
+#' @export
+
+ts_tree_deleted <- function() {
+  structure(
+    list(),
+    class = c("ts_tree_action_delete", "ts_tree_action", "list")
+  )
+}
diff --git a/src/library/ts/R/ts-tree-sexpr.R b/src/library/ts/R/ts-tree-sexpr.R
new file mode 100644
index 0000000000..a5936f3e6c
--- /dev/null
+++ b/src/library/ts/R/ts-tree-sexpr.R
@@ -0,0 +1,52 @@
+#' Show the syntax tree of a tree-sitter tree
+#'
+#' @ts ts_tree_sexpr_description
+#' Show the structure of a tree-sitter tree as an S-expression.
+#' @description \eval{ts:::doc_insert("ts_tree_sexpr_description")}
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_sexpr")}
+#'
+#' @ts ts_tree_sexpr_details
+#' This function returns a nested list representation of the syntax tree,
+#' where each node is represented as a list with its type and children.
+#' @details \eval{ts:::doc_insert("ts_tree_sexpr_details")}
+#'
+#' @ts ts_tree_sexpr_param_tree
+#' A `ts_tree` object.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_sexpr_param_tree")}
+#'
+#' @ts ts_tree_sexpr_return
+#' A string representing the S-expression of the syntax tree.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_sexpr_return")}
+#'
+#' @export
+#' @family ts_tree exploration
+#' @family ts_tree generics
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc(
+#'   "{ \"a\": //comment\ntrue, \"b\": [1, 2, 3] }"
+#' )
+#'
+#' ts_tree_sexpr(tree)
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#'
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   [servers]
+#'   alpha = { ip = "127.0.0.1", dc = "eqdc10" }
+#'   beta = { ip = "127.0.0.2", dc = "eqdc20" }
+#' )")
+#'
+#' ts_tree_sexpr(tree)
+
+ts_tree_sexpr <- function(tree) {
+  UseMethod("ts_tree_sexpr")
+}
+
+#' @export
+
+ts_tree_sexpr.default <- function(tree) {
+  call_with_cleanup(c_s_expr, tree)
+}
diff --git a/src/library/ts/R/ts-tree-unserialize.R b/src/library/ts/R/ts-tree-unserialize.R
new file mode 100644
index 0000000000..f602cad67d
--- /dev/null
+++ b/src/library/ts/R/ts-tree-unserialize.R
@@ -0,0 +1,61 @@
+#' Unserialize selected elements of a tree-sitter tree
+#'
+#' @ts ts_tree_unserialize_description
+#' Unserialize the selected elements of a `ts_tree` object, i.e. convert
+#' them to R objects.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_unserialize_description")}
+#'
+#' \eval{ts:::format_rd_parser_list(ts:::ts_list_parsers(), "ts_tree_unserialize")}
+#'
+#' @ts ts_tree_unserialize_details
+#' If no elements are selected in the tree, then the whole document is
+#' unserialized.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_unserialize_details_no_selection")}
+#'
+#' If the tree has an empty selection, then an empty list is returned.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_unserialize_details_empty_selection")}
+#'
+#' ## The `[[` operator
+#'
+#' The `[[` operator works similarly to the combination of
+#' \code{\link[ts:ts_tree_select]{ts_tree_select()}} and
+#' `ts_tree_unserialize()`, but it might be more readable.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_select_brackets")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_unserialize_details")}
+#' \eval{ts:::doc_extra()}
+#' For the details on how the selected elements are mapped to R objects,
+#' see the documentation of the methods in the parser packages. The methods
+#' in the installed parser packages are linked below.
+#'
+#' @ts ts_tree_unserialize_param_tree
+#' A `ts_tree` object.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_unserialize_param_tree")}
+#'
+#' @ts ts_tree_unserialize_return
+#' List of R objects, with one entry for each selected element.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_unserialize_return")}
+#'
+#' @family ts_tree generics
+#' @family serialization functions
+#' @seealso \eval{ts:::doc_seealso("ts_tree_unserialize")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"a": 13, "b": [1, 2, 3], "c": "x"}')
+#'
+#' tree
+#'
+#' tree |> ts_tree_select(c("b", "c")) |> ts_tree_unserialize()
+#'
+#' tree |> ts_tree_select("b") |> ts_tree_unserialize()
+
+ts_tree_unserialize <- function(tree) {
+  UseMethod("ts_tree_unserialize")
+}
diff --git a/src/library/ts/R/ts-tree-update.R b/src/library/ts/R/ts-tree-update.R
new file mode 100644
index 0000000000..cef22ac83c
--- /dev/null
+++ b/src/library/ts/R/ts-tree-update.R
@@ -0,0 +1,76 @@
+#' Replace selected elements with a new element in a tree-sitter tree
+#'
+#' @ts ts_tree_update_description
+#' Replace all selected elements with a new element.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_update_description")}
+#'
+#' @ts ts_tree_update_details
+#' If the tree does not have a selection, the new element replaces the
+#' whole document.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_update_details_no_selection")}
+#'
+#' If the tree has an empty selection, the new element is inserted at the
+#' position of where the selected elements would be.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_update_details_empty_selection")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_update_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_update_param_tree
+#' A `ts_tree` object.
+#' @ts ts_tree_update_param_new
+#' The new element to replace the selected elements with.
+#' @ts ts_tree_update_param_options
+#' A list of options for the update.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_update_param_tree")}
+#' @param new \eval{ts:::doc_insert("ts::ts_tree_update_param_new")}
+#'
+#' The type of `new` depends on the parser and the method that implements
+#' the insertion. See details in the manual of the specific parser.
+#' @param options \eval{ts:::doc_insert("ts::ts_tree_update_param_options")}
+#'
+#' See details in the manual of the specific parser.
+#' @param ... Extra arguments for methods.
+#'
+#' @ts ts_tree_update_return
+#' The modified `ts_tree` object with the selected elements replaced
+#' by the new element.
+#'
+#' @return \eval{ts:::doc_insert("ts::ts_tree_update_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_update")}
+#' @export
+#' @examplesIf requireNamespace("tsjsonc", quietly = TRUE)
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc(r"(
+#'   {
+#'     "name": "example",
+#'     "version": "1.0.0",
+#'     "dependencies": {
+#'       "tsjsonc": "^0.1.0"
+#'     }
+#'   }
+#' )")
+#'
+#' tree |> ts_tree_select("version") |> ts_tree_update("2.0.0")
+#'
+#' @examplesIf requireNamespace("tstoml", quietly = TRUE)
+#' # Create a parse tree with tstoml --------------------------------------
+#' tree <- tstoml::ts_parse_toml(r"(
+#'   [package]
+#'   name = "example"
+#'   version = "1.0.0"
+#'   depdendencies = { tstoml = "0.1.0" }
+#' )")
+#'
+#' tree |> ts_tree_select("package", "version") |> ts_tree_update("2.0.0")
+
+ts_tree_update <- function(tree, new, options, ...) {
+  UseMethod("ts_tree_update")
+}
diff --git a/src/library/ts/R/ts-tree-write.R b/src/library/ts/R/ts-tree-write.R
new file mode 100644
index 0000000000..5cbfb13358
--- /dev/null
+++ b/src/library/ts/R/ts-tree-write.R
@@ -0,0 +1,86 @@
+#' Write a tree-sitter tree to a file
+#'
+#' @ts ts_tree_write_description
+#' Writes the document of a ts `ts_tree` object to a file or connection.
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_write_description")}
+#'
+#' @ts ts_tree_write_details
+#' If `tree` was created from a file, then `ts_tree_write()` by default
+#' writes it back to the same file. Otherwise, the `file` argument must be
+#' specified.
+#'
+#' \eval{ts:::doc_tabs("ts_tree_write_details_file")}
+#'
+#' To write to a connection, pass a connection object to the `file`
+#' argument. If the connection is opened in binary mode, the raw bytes
+#' are written using [base::writeBin()]. Otherwise, the raw bytes are
+#' converted to characters using the system encoding before writing using
+#' [base::rawToChar()].
+#'
+#' </p><p><!-- ------------------------------------------------------>
+#'
+#' Use `file = stdout()` to write to the standard output, i.e. to the
+#' console in an interactive R session.
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_write_details")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_write_param_tree
+#' A `ts_tree` object as returned by
+#' \code{\link[ts:ts_tree_new]{ts_tree_new()}}.
+#' @ts ts_tree_write_param_file
+#' Character string, connection, or `NULL`. The file or connection
+#' to write to. By default it writes to the same file that was used in
+#' \code{\link[ts:ts_tree_new]{ts_tree_new()}}, if `tree` was read from a
+#' file.
+#'
+#' @param tree \eval{ts:::doc_insert("ts::ts_tree_write_param_tree")}
+#' @param file \eval{ts:::doc_insert("ts::ts_tree_write_param_file")}
+#'
+#' @ts ts_tree_write_return
+#' Invisibly returns `NULL`.
+#' @return \eval{ts:::doc_insert("ts::ts_tree_write_return")}
+#'
+#' @family ts_tree generics
+#' @seealso \eval{ts:::doc_seealso("ts_tree_write")}
+#' @export
+#' @examplesIf Sys.getenv("IN_PKGDOWN") == "true"
+#' # Create a parse tree with tsjsonc -------------------------------------
+#' tree <- tsjsonc::ts_parse_jsonc('{"foo": 42, "bar": [1, 2, 3]}')
+#'
+#' # Format and write to file
+#' tree |> ts_tree_format() |> ts_tree_write("example.json")
+
+ts_tree_write <- function(tree, file = NULL) {
+  UseMethod("ts_tree_write")
+}
+
+#' @export
+
+ts_tree_write.default <- function(tree, file = NULL) {
+  file <- file %||% attr(tree, "file")
+  if (is.null(file)) {
+    lang <- toupper(get_tree_lang(tree))
+    stop(ts_cnd(
+      "Don't know which file to save {lang} document to. You need to \\
+       specify the `file` argument."
+    ))
+  }
+
+  text <- attr(tree, "text")
+  if (length(text) > 0 && text[length(text)] != 0xa) {
+    text <- c(text, as.raw(0xa))
+  }
+  if (inherits(file, "connection")) {
+    if (grepl("b", summary(file)$mode)) {
+      writeBin(text, con = file)
+    } else {
+      cat(rawToChar(text), file = file)
+    }
+  } else {
+    writeBin(text, con = file)
+  }
+  invisible()
+}
diff --git a/src/library/ts/R/utils.R b/src/library/ts/R/utils.R
new file mode 100644
index 0000000000..f0ac6e3f2f
--- /dev/null
+++ b/src/library/ts/R/utils.R
@@ -0,0 +1,71 @@
+`%||%` <- function(l, r) {
+  if (is.null(l)) {
+    r
+  } else {
+    l
+  }
+}
+
+`%&&%` <- function(l, r) {
+  if (is.null(l)) {
+    NULL
+  } else {
+    r
+  }
+}
+
+map_int <- function(.x, .f, ...) {
+  vapply(.x, .f, integer(1), ...)
+}
+
+map_chr <- function(.x, .f, ...) {
+  vapply(.x, .f, character(1), ...)
+}
+
+map_lgl <- function(.x, .f, ...) {
+  vapply(.x, .f, logical(1), ...)
+}
+
+pmap <- function(.l, .f) {
+  do.call(mapply, c(list(FUN = .f, SIMPLIFY = FALSE, USE.NAMES = FALSE), .l))
+}
+
+imap <- function(.x, .f) {
+  idx <- names(.x) %||% seq_along(.x)
+  mapply(.f, .x, idx, SIMPLIFY = FALSE, USE.NAMES = FALSE)
+}
+
+get_tree_lang <- function(tree) {
+  cls <- grep("^ts_tree_", class(tree), value = TRUE)
+  if (length(cls) == 0) {
+    "<unknown>"
+  } else {
+    sub("^ts_tree_", "", cls[1])
+  }
+}
+
+middle <- function(x) {
+  if (length(x) <= 2) {
+    x[numeric()]
+  } else {
+    x[-c(1, length(x))]
+  }
+}
+
+is_named <- function(x) {
+  nms <- names(x)
+  length(x) == length(nms) && !anyNA(nms) && all(nms != "")
+}
+
+get_env <- function(x) {
+  ev <- Sys.getenv(x, unset = NA_character_)
+  if (is.na(ev)) {
+    NULL
+  } else {
+    ev
+  }
+}
+
+read_char <- function(fn) {
+  paste0(readLines(fn, warn = FALSE, encoding = "UTF-8"), collapse = "\n")
+}
diff --git a/src/library/ts/cleanup b/src/library/ts/cleanup
new file mode 100755
index 0000000000..bd70ed08ff
--- /dev/null
+++ b/src/library/ts/cleanup
@@ -0,0 +1,3 @@
+#! /usr/bin/env sh
+
+rm -f man/macros/eval2.Rd man/macros/examples.Rd
diff --git a/src/library/ts/configure b/src/library/ts/configure
new file mode 100755
index 0000000000..58647b7060
--- /dev/null
+++ b/src/library/ts/configure
@@ -0,0 +1,19 @@
+#! /usr/bin/env sh
+
+echo "** Running ./configure"
+
+# Check that this is not just ./configure. We need to run this
+# from R CMD INSTALL, to have the R env vars set.
+
+if [ -z "$R_HOME" ]; then
+  echo >&2 R_HOME is not set, are you running R CMD INSTALL?
+  exit 1
+fi
+
+# Find the R binary we need to use. This is a bit trickier on
+# Windows, because it has two architectures. On windows R_ARCH_BIN
+# is set, so this should work everywhere.
+export RBIN="${R_HOME}/bin${R_ARCH_BIN}/R"
+
+"$RBIN" --vanilla --slave -f tools/dynamic-help.R
+"$RBIN" --vanilla --slave -f tools/examples.R
diff --git a/src/library/ts/configure.win b/src/library/ts/configure.win
new file mode 100755
index 0000000000..994f9fdcd9
--- /dev/null
+++ b/src/library/ts/configure.win
@@ -0,0 +1,3 @@
+#! /usr/bin/env sh
+
+sh ./configure
diff --git a/src/library/ts/man/macros/eval.Rd b/src/library/ts/man/macros/eval.Rd
new file mode 100644
index 0000000000..3b9a267675
--- /dev/null
+++ b/src/library/ts/man/macros/eval.Rd
@@ -0,0 +1 @@
+\newcommand{\eval}{\code{#1}}
diff --git a/src/library/ts/man/roxygen/meta.R b/src/library/ts/man/roxygen/meta.R
new file mode 100644
index 0000000000..1c6f987354
--- /dev/null
+++ b/src/library/ts/man/roxygen/meta.R
@@ -0,0 +1,34 @@
+if (exists(".knitr_asciicast_process", envir = .GlobalEnv)) {
+  rm(list = ".knitr_asciicast_process", envir = .GlobalEnv)
+}
+
+asciicast::init_knitr_engine(
+  echo = TRUE,
+  echo_input = FALSE,
+  timeout = as.integer(Sys.getenv("ASCIICAST_TIMEOUT", 10)),
+  startup = quote({
+    library(ts)
+    loadNamespace("pillar")
+    options(width = 70)
+    options(cli.width = 70)
+    options(cli.num_colors = 256)
+  })
+)
+
+knitr::opts_chunk$set(
+  asciicast_knitr_output = "html",
+  asciicast_include_style = FALSE,
+  cache = FALSE,
+  cache.path = file.path(getwd(), "man/_cache/"),
+  fig.path = file.path(getwd(), "man/figures"),
+  error = FALSE
+)
+
+Sys.unsetenv("R_TS_PACKAGE")
+ts:::ts_roclet_register()
+
+list(
+  markdown = TRUE,
+  restrict_image_formats = TRUE,
+  roclets = c("rd", "namespace", "collate", "ts:::roclet_ts")
+)
diff --git a/src/library/ts/src/Makevars b/src/library/ts/src/Makevars
new file mode 100644
index 0000000000..ebd3d482bc
--- /dev/null
+++ b/src/library/ts/src/Makevars
@@ -0,0 +1,28 @@
+PKG_CPPFLAGS = \
+        -I./tree-sitter/lib/include \
+        -I./tree-sitter/lib/src \
+
+tree-sitter-files = \
+        tree-sitter/lib/src/lib.o
+
+lib-files = \
+        init.o tree-sitter.o cleancall.o glue.o
+
+PKG_LIBS = -L. tree-sitter.a
+
+OBJECTS =  $(lib-files)
+
+all: $(SHLIB) mrproper
+
+$(SHLIB): tree-sitter.a
+
+tree-sitter.a: $(tree-sitter-files)
+	$(AR) rs tree-sitter.a $^
+
+clean:
+	rm -rf $(SHLIB) $(OBJECTS)
+
+mrproper: $(SHLIB)
+	@rm -rf *.a
+
+.PHONY: all clean
diff --git a/src/library/ts/src/cleancall.c b/src/library/ts/src/cleancall.c
new file mode 100644
index 0000000000..494e85847b
--- /dev/null
+++ b/src/library/ts/src/cleancall.c
@@ -0,0 +1,169 @@
+#define R_NO_REMAP
+#include <Rinternals.h>
+
+#include "cleancall.h"
+
+
+#if (defined(R_VERSION) && R_VERSION < R_Version(3, 4, 0))
+ SEXP R_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot) {
+   fn_ptr ptr;
+   ptr.fn = p;
+   return R_MakeExternalPtr(ptr.p, tag, prot);
+ }
+ DL_FUNC R_ExternalPtrAddrFn(SEXP s) {
+   fn_ptr ptr;
+   ptr.p = R_ExternalPtrAddr(s);
+   return ptr.fn;
+ }
+#endif
+
+// The R API does not have a setter for function pointers
+
+SEXP cleancall_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot) {
+    fn_ptr tmp;
+    tmp.fn = p;
+    return R_MakeExternalPtr(tmp.p, tag, prot);
+}
+
+void cleancall_SetExternalPtrAddrFn(SEXP s, DL_FUNC p) {
+    fn_ptr ptr;
+    ptr.fn = p;
+    R_SetExternalPtrAddr(s, ptr.p);
+}
+
+
+// Initialised at load time with the `.Call` primitive
+SEXP cleancall_fns_dot_call = NULL;
+
+static SEXP callbacks = NULL;
+
+#if (defined(R_VERSION) && R_VERSION < R_Version(4, 5, 0))
+#define R_getVar(x,y,z) Rf_findVar(x,y)
+#endif
+
+void cleancall_init(void) {
+  cleancall_fns_dot_call = R_getVar(Rf_install(".Call"), R_BaseEnv, TRUE);
+  callbacks = R_NilValue;
+}
+
+struct eval_args {
+  SEXP call;
+  SEXP env;
+};
+
+static SEXP eval_wrap(void* data) {
+  struct eval_args* args = (struct eval_args*) data;
+  return Rf_eval(args->call, args->env);
+}
+
+
+SEXP cleancall_call(SEXP args, SEXP env) {
+  SEXP call = PROTECT(Rf_lcons(cleancall_fns_dot_call, args));
+  struct eval_args data = { call, env };
+
+  SEXP out = r_with_cleanup_context(&eval_wrap, &data);
+
+  UNPROTECT(1);
+  return out;
+}
+
+
+// Preallocate a callback
+static void push_callback(SEXP stack) {
+  SEXP top = CDR(stack);
+
+  SEXP early_handler = PROTECT(Rf_allocVector(LGLSXP, 1));
+  SEXP fn_extptr = PROTECT(cleancall_MakeExternalPtrFn(NULL, R_NilValue,
+                                                       R_NilValue));
+  SEXP data_extptr = PROTECT(R_MakeExternalPtr(NULL, early_handler,
+                                               R_NilValue));
+  SEXP cb = Rf_cons(Rf_cons(fn_extptr, data_extptr), top);
+
+  SETCDR(stack, cb);
+
+  UNPROTECT(3);
+}
+
+struct data_wrapper {
+  SEXP (*fn)(void* data);
+  void *data;
+  SEXP callbacks;
+  int success;
+};
+
+static void call_exits(void* data) {
+  // Remove protecting node. Don't remove the preallocated callback on
+  // the top as it might contain a handler when something went wrong.
+  SEXP top = CDR(callbacks);
+
+  // Restore old stack
+  struct data_wrapper* state = data;
+  callbacks = (SEXP) state->callbacks;
+
+  // Handlers should not jump
+  while (top != R_NilValue) {
+    SEXP cb = CAR(top);
+    top = CDR(top);
+
+    void (*fn)(void*) = (void (*)(void*)) R_ExternalPtrAddrFn(CAR(cb));
+    void *data = (void*) R_ExternalPtrAddr(CDR(cb));
+    int early_handler = LOGICAL(R_ExternalPtrTag(CDR(cb)))[0];
+
+    // Check for empty pointer in preallocated callbacks
+    if (fn) {
+      if (!early_handler || !state->success) fn(data);
+    }
+  }
+}
+
+static SEXP with_cleanup_context_wrap(void *data) {
+  struct data_wrapper* cdata = data;
+  SEXP ret = cdata->fn(cdata->data);
+  cdata->success = 1;
+  return ret;
+}
+
+SEXP r_with_cleanup_context(SEXP (*fn)(void* data), void* data) {
+  // Preallocate new stack before changing `callbacks` to avoid
+  // leaving the global variable in a bad state if alloc fails
+  SEXP new = PROTECT(Rf_cons(R_NilValue, R_NilValue));
+  push_callback(new);
+
+  SEXP old = callbacks;
+  callbacks = new;
+
+  struct data_wrapper state = { fn, data, old, 0 };
+
+  SEXP out = R_ExecWithCleanup(with_cleanup_context_wrap, &state,
+                               &call_exits, &state);
+
+  UNPROTECT(1);
+  return out;
+}
+
+static void call_save_handler(void (*fn)(void *data), void* data,
+                              int early) {
+  if (Rf_isNull(callbacks)) {
+    fn(data);
+    Rf_error("Internal error: Exit handler pushed outside "
+             "of an exit context");
+  }
+
+  SEXP cb = CADR(callbacks);
+
+  // Update pointers
+  cleancall_SetExternalPtrAddrFn(CAR(cb), (DL_FUNC) fn);
+  R_SetExternalPtrAddr(CDR(cb), data);
+  LOGICAL(R_ExternalPtrTag(CDR(cb)))[0] = early;
+
+  // Preallocate the next callback in case the allocator jumps
+  push_callback(callbacks);
+}
+
+void r_call_on_exit(void (*fn)(void* data), void* data) {
+  call_save_handler(fn, data, /* early = */ 0);
+}
+
+void r_call_on_early_exit(void (*fn)(void* data), void* data) {
+  call_save_handler(fn, data, /* early = */ 1);
+}
diff --git a/src/library/ts/src/cleancall.h b/src/library/ts/src/cleancall.h
new file mode 100644
index 0000000000..bb8f4349ce
--- /dev/null
+++ b/src/library/ts/src/cleancall.h
@@ -0,0 +1,54 @@
+#ifndef CLEANCALL_H
+#define CLEANCALL_H
+
+#include <Rversion.h>
+#include <Rinternals.h>
+#include <R_ext/Rdynload.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --------------------------------------------------------------------
+// Internals
+// --------------------------------------------------------------------
+
+typedef union {void* p; DL_FUNC fn;} fn_ptr;
+
+#if (defined(R_VERSION) && R_VERSION < R_Version(3, 4, 0))
+ SEXP R_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot);
+ DL_FUNC R_ExternalPtrAddrFn(SEXP s);
+#endif
+
+// --------------------------------------------------------------------
+// API for packages that embed cleancall
+// --------------------------------------------------------------------
+
+// The R API does not have a setter for external function pointers
+SEXP cleancall_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot);
+void cleancall_SetExternalPtrAddrFn(SEXP s, DL_FUNC p);
+
+typedef void (*cleanup_fn_t)(void * data);
+typedef void *cleanup_data_t;
+
+#define CLEANCALL_METHOD_RECORD  \
+  {"cleancall_call", (DL_FUNC) &cleancall_call, 2}
+
+SEXP cleancall_call(SEXP args, SEXP env);
+void cleancall_init(void);
+
+// --------------------------------------------------------------------
+// Public API
+// --------------------------------------------------------------------
+
+#define R_CLEANCALL_SUPPORT 1
+
+SEXP r_with_cleanup_context(SEXP (*fn)(void* data), void* data);
+void r_call_on_exit(void (*fn)(void* data), void* data);
+void r_call_on_early_exit(void (*fn)(void* data), void* data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/library/ts/src/glue.c b/src/library/ts/src/glue.c
new file mode 100644
index 0000000000..483b080ff4
--- /dev/null
+++ b/src/library/ts/src/glue.c
@@ -0,0 +1,359 @@
+
+#define STRICT_R_HEADERS
+#define R_NO_REMAP
+#include "Rinternals.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+SEXP set(SEXP x, int i, SEXP val) {
+  R_xlen_t len = Rf_xlength(x);
+  if (i >= len) {
+    len *= 2;
+    x = Rf_lengthgets(x, len);
+  }
+  SET_VECTOR_ELT(x, i, val);
+  return x;
+}
+
+SEXP resize(SEXP out, R_xlen_t n) {
+  if (n == Rf_xlength(out)) {
+    return out;
+  }
+  return Rf_xlengthgets(out, n);
+}
+
+// This is almost like the original glue parser, except that
+// - no comment_char (always empty string)
+// - no literal_arg
+// - If cli_arg is FALSE, then literal = 1, always
+// - If cli_arg is TRUE, then we use literal = 1, except in {}
+//   evaluations (as opposed to {.} for cli styles), where literal = 0 is
+//   used.
+
+SEXP glue(SEXP x, SEXP f, SEXP open_arg, SEXP close_arg, SEXP cli_arg) {
+
+  typedef enum {
+    text,
+    escape,
+    single_quote,
+    double_quote,
+    backtick,
+    delim,
+    comment
+  } states;
+
+  const char* xx = Rf_translateCharUTF8(STRING_ELT(x, 0));
+  size_t str_len = strlen(xx);
+
+  char* str = (char*)malloc(str_len + 1);
+
+  const char* open = CHAR(STRING_ELT(open_arg, 0));
+  size_t open_len = strlen(open);
+
+  const char* close = CHAR(STRING_ELT(close_arg, 0));
+  size_t close_len = strlen(close);
+
+  char comment_char = '\0';
+
+  Rboolean cli = LOGICAL(cli_arg)[0];
+
+  Rboolean literal = 1;
+
+  int delim_equal = strncmp(open, close, open_len) == 0;
+
+  SEXP out = Rf_allocVector(VECSXP, 1);
+  PROTECT_INDEX out_idx;
+  PROTECT_WITH_INDEX(out, &out_idx);
+
+  size_t j = 0;
+  size_t k = 0;
+  int delim_level = 0;
+  size_t start = 0;
+  states state = text;
+  states prev_state = text;
+  size_t i = 0;
+  for (i = 0; i < str_len; ++i) {
+    switch (state) {
+    case text: {
+      if (strncmp(&xx[i], open, open_len) == 0) {
+        /* check for open delim doubled */
+        if (strncmp(&xx[i + open_len], open, open_len) == 0) {
+          i += open_len;
+        } else {
+          state = delim;
+          delim_level = 1;
+          start = i + open_len;
+          // In cli mode we switch to literal = FALSE for a {} block
+          if (cli && xx[i + open_len] != '.') literal = 0;
+          break;
+        }
+      }
+      if (strncmp(&xx[i], close, close_len) == 0 &&
+          strncmp(&xx[i + close_len], close, close_len) == 0) {
+        i += close_len;
+      }
+
+      str[j++] = xx[i];
+      break;
+    }
+    case escape: {
+      state = prev_state;
+      break;
+    }
+    case single_quote: {
+      if (xx[i] == '\\') {
+        prev_state = single_quote;
+        state = escape;
+      } else if (xx[i] == '\'') {
+        state = delim;
+      }
+      break;
+    }
+    case double_quote: {
+      if (xx[i] == '\\') {
+        prev_state = double_quote;
+        state = escape;
+      } else if (xx[i] == '\"') {
+        state = delim;
+      }
+      break;
+    }
+    case backtick: {
+      if (xx[i] == '\\') {
+        prev_state = backtick;
+        state = escape;
+      } else if (xx[i] == '`') {
+        state = delim;
+      }
+      break;
+    }
+    // # nocov start LCOV_EXCL_START
+    case comment: {
+      if (xx[i] == '\n') {
+        state = delim;
+      }
+      break;
+    }
+    // # nocov end LCOV_EXCL_STOP
+    case delim: {
+      if (!delim_equal && strncmp(&xx[i], open, open_len) == 0) {
+        ++delim_level;
+        // In cli mode we switch to literal = FALSE for a {} block
+        if (cli && xx[i + open_len] != '.') literal = 0;
+        i += open_len - 1;
+      } else if (strncmp(&xx[i], close, close_len) == 0) {
+        // in non-{} blocks (i.e. {.}) we need literal = 1. We can always
+        // switch to literal = 1 here, because {} blocks cannot be nested.
+        literal = 1;
+        --delim_level;
+        i += close_len - 1;
+      } else {
+        // # nocov start LCOV_EXCL_START
+        if (!literal && xx[i] == comment_char) {
+          state = comment;
+        } else {
+        // # nocov end LCOV_EXCL_STOP
+          switch (xx[i]) {
+          case '\'':
+            if (!literal) {
+              state = single_quote;
+            }
+            break;
+          case '"':
+            if (!literal) {
+              state = double_quote;
+            }
+            break;
+          case '`':
+            if (!literal) {
+              state = backtick;
+            }
+            break;
+          };
+        }
+      }
+      if (delim_level == 0) {
+        /* Result of the current glue statement */
+        SEXP expr = PROTECT(Rf_ScalarString(
+            Rf_mkCharLenCE(&xx[start], (i - close_len) + 1 - start, CE_UTF8)));
+        SEXP call = PROTECT(Rf_lang2(f, expr));
+        SEXP result = PROTECT(Rf_eval(call, R_EmptyEnv));
+
+        /* text in between last glue statement */
+        if (j > 0) {
+          str[j] = '\0';
+          SEXP str_ = PROTECT(Rf_ScalarString(Rf_mkCharLenCE(str, j, CE_UTF8)));
+          REPROTECT(out = set(out, k++, str_), out_idx);
+          UNPROTECT(1);
+        }
+
+        REPROTECT(out = set(out, k++, result), out_idx);
+
+        /* Clear the string buffer */
+        memset(str, 0, j);
+        j = 0;
+        UNPROTECT(3);
+        state = text;
+      }
+      break;
+    }
+    };
+  }
+
+  if (k == 0 || j > 0) {
+    str[j] = '\0';
+    SEXP str_ = PROTECT(Rf_ScalarString(Rf_mkCharLenCE(str, j, CE_UTF8)));
+    REPROTECT(out = set(out, k++, str_), out_idx);
+    UNPROTECT(1);
+  }
+
+  if (state == delim) {
+    free(str);
+    Rf_error("Expecting '%s'", close);
+  } else if (state == single_quote) {
+    free(str);
+    Rf_error("Unterminated quote (')");
+  } else if (state == double_quote) {
+    free(str);
+    Rf_error("Unterminated quote (\")");
+  } else if (state == backtick) {
+    free(str);
+    Rf_error("Unterminated quote (`)");
+  } else if (state == comment) {
+    // # nocov start LCOV_EXCL_START
+    free(str);
+    Rf_error("Unterminated comment");
+    // # nocov end LCOV_EXCL_STOP
+  }
+
+  free(str);
+
+  out = resize(out, k);
+
+  UNPROTECT(1);
+
+  return out;
+}
+
+SEXP trim(SEXP x) {
+  size_t len = LENGTH(x);
+
+  SEXP out = PROTECT(Rf_allocVector(STRSXP, len));
+  size_t num;
+  for (num = 0; num < len; ++num) {
+    const char* xx = Rf_translateCharUTF8(STRING_ELT(x, num));
+    size_t str_len = strlen(xx);
+
+    char* str = (char*)malloc(str_len + 1);
+    size_t i = 0, start = 0;
+    bool new_line = false;
+
+    /* skip leading blanks on first line */
+    while (start < str_len && (xx[start] == ' ' || xx[start] == '\t')) {
+      ++start;
+    }
+
+    /* Skip first newline */
+    if (start < str_len && xx[start] == '\n') {
+      new_line = true;
+      ++start;
+    }
+
+    i = start;
+
+    /* Ignore first line */
+    if (!new_line) {
+      while (i < str_len && xx[i] != '\n') {
+        ++i;
+      }
+      new_line = true;
+    }
+
+    size_t indent = 0;
+
+    /* Maximum size of size_t */
+    size_t min_indent = (size_t)-1;
+
+    /* find minimum indent */
+    while (i < str_len) {
+      if (xx[i] == '\n') {
+        new_line = true;
+        indent = 0;
+      } else if (new_line) {
+        if (xx[i] == ' ' || xx[i] == '\t') {
+          ++indent;
+        } else {
+          if (indent < min_indent) {
+            min_indent = indent;
+          }
+          indent = 0;
+          new_line = false;
+        }
+      }
+      ++i;
+    }
+
+    /* if string ends with '\n', `indent = 0` only because we made it so */
+    if (xx[str_len - 1] != '\n' && new_line && indent < min_indent) {
+      min_indent = indent;
+    }
+
+    new_line = true;
+    i = start;
+    size_t j = 0;
+
+    /*Rprintf("start: %i\nindent: %i\nmin_indent: %i", start, indent,
+     * min_indent);*/
+
+    /* copy the string removing the minimum indent from new lines */
+    while (i < str_len) {
+      if (xx[i] == '\n') {
+        new_line = true;
+      } else if (xx[i] == '\\' && i + 1 < str_len && xx[i + 1] == '\n') {
+        new_line = true;
+        i += 2;
+        continue;
+      } else if (new_line) {
+        size_t skipped = strspn(xx + i, "\t ");
+        /*
+         * if the line consists only of tabs and spaces, and if the line is
+         * shorter than min_indent, copy the entire line and proceed to the
+         * next
+         */
+        if (*(xx + i + skipped) == '\n' && skipped < min_indent) {
+          strncpy(str + j, xx + i, skipped);
+          i += skipped;
+          j += skipped;
+        } else {
+          if (i + min_indent < str_len && (xx[i] == ' ' || xx[i] == '\t')) {
+            i += min_indent;
+          }
+        }
+        new_line = false;
+        continue;
+      }
+      str[j++] = xx[i++];
+    }
+    str[j] = '\0';
+
+    /* Remove trailing whitespace up to the first newline */
+    size_t end = j;
+    while (j > 0) {
+      if (str[j] == '\n') {
+        end = j;
+        break;
+      } else if (str[j] == '\0' || str[j] == ' ' || str[j] == '\t') {
+        --j;
+      } else {
+        break;
+      }
+    }
+    str[end] = '\0';
+    SET_STRING_ELT(out, num, Rf_mkCharCE(str, CE_UTF8));
+    free(str);
+  }
+
+  UNPROTECT(1);
+  return out;
+}
diff --git a/src/library/ts/src/init.c b/src/library/ts/src/init.c
new file mode 100644
index 0000000000..a341e63d60
--- /dev/null
+++ b/src/library/ts/src/init.c
@@ -0,0 +1,29 @@
+#define R_NO_REMAP
+#include <R.h>
+#include <Rinternals.h>
+
+#include "cleancall.h"
+
+SEXP code_query(SEXP tree, SEXP query);
+SEXP s_expr(SEXP tree);
+SEXP parse(SEXP input, SEXP rlanguage, SEXP rranges);
+
+SEXP glue(SEXP x, SEXP f, SEXP open_arg, SEXP close_arg, SEXP cli_arg);
+SEXP trim(SEXP x);
+
+static const R_CallMethodDef callMethods[]  = {
+  CLEANCALL_METHOD_RECORD,
+  { "code_query",        (DL_FUNC) &code_query,        2 },
+  { "s_expr",            (DL_FUNC) &s_expr,            1 },
+  { "parse",             (DL_FUNC) &parse,             3 },
+  { "glue",              (DL_FUNC) &glue,              5 },
+  { "trim",              (DL_FUNC) &trim,              1 },
+  { NULL, NULL, 0 }
+};
+
+void R_init_ts(DllInfo *dll) {
+  R_registerRoutines(dll, NULL, callMethods, NULL, NULL);
+  R_useDynamicSymbols(dll, FALSE);
+  R_forceSymbols(dll, TRUE);
+  cleancall_init();
+}
diff --git a/src/library/ts/src/tree-sitter.c b/src/library/ts/src/tree-sitter.c
new file mode 100644
index 0000000000..4d3c8ca44d
--- /dev/null
+++ b/src/library/ts/src/tree-sitter.c
@@ -0,0 +1,734 @@
+#include <stdio.h>
+
+#define R_NO_REMAP
+#include "R.h"
+#include "Rinternals.h"
+#include "cleancall.h"
+
+#include "tree_sitter/api.h"
+
+static void r_free(void *data) {
+  free(data);
+}
+
+static SEXP new_lookahead_sym(
+  TSSymbol sym,
+  const char *csym,
+  TSSymbolType symtype
+) {
+  const char *nms[] = {
+    "symbol", "name", "type", ""
+  };
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  SET_VECTOR_ELT(res, 0, Rf_ScalarInteger((int) sym));
+  SET_VECTOR_ELT(res, 1, Rf_mkString(csym));
+  SET_VECTOR_ELT(res, 2, Rf_ScalarInteger((int) symtype));
+  UNPROTECT(1);
+  return res;
+}
+
+static TSRange *get_ranges(SEXP rranges, uint32_t *count) {
+  TSRange *ranges = NULL;
+  *count = 0;
+  if (!Rf_isNull(rranges)) {
+    if (Rf_length(rranges) != 6) {
+      Rf_error("Invalid ranges, must be a data frame of 6 integer columns");
+    }
+    for (int i = 0; i < 6; i++) {
+      if (TYPEOF(VECTOR_ELT(rranges, i)) != INTSXP) {
+        Rf_error("Invalid ranges, must be a data frame of 6 integer columns");
+      }
+    }
+    *count = Rf_length(VECTOR_ELT(rranges, 0));
+    ranges = malloc(sizeof(TSRange) * (*count));
+    if (!ranges) {
+      Rf_error("Out of memory"); // # nocov
+    }
+    int *start_row = INTEGER(VECTOR_ELT(rranges, 0));
+    int *start_col = INTEGER(VECTOR_ELT(rranges, 1));
+    int *end_row = INTEGER(VECTOR_ELT(rranges, 2));
+    int *end_col = INTEGER(VECTOR_ELT(rranges, 3));
+    int *start_byte = INTEGER(VECTOR_ELT(rranges, 4));
+    int *end_byte = INTEGER(VECTOR_ELT(rranges, 5));
+    r_call_on_exit(r_free, ranges);
+    for (uint32_t i = 0; i < *count; i++) {
+      ranges[i].start_point.row = start_row[i] - 1;
+      ranges[i].start_point.column = start_col[i] - 1;
+      ranges[i].end_point.row = end_row[i] - 1;
+      ranges[i].end_point.column = end_col[i];    // no -1!
+      ranges[i].start_byte = start_byte[i] - 1;
+      ranges[i].end_byte = end_byte[i];           // no -1!
+    }
+  }
+  return ranges;
+}
+
+struct ts_xtree {
+  const TSLanguage *language;
+  TSParser *parser;
+  TSTree *tree;
+};
+
+void ts_xtree_free(SEXP rxtree) {
+  struct ts_xtree *tree = (struct ts_xtree*) R_ExternalPtrAddr(rxtree);
+  if (tree->tree) {
+    ts_tree_delete(tree->tree);
+  }
+  if (tree->parser) {
+    ts_parser_delete(tree->parser);
+  }
+  if (tree->language) {
+    // languages are static, do not delete here
+  }
+}
+
+SEXP s_expr(SEXP rotree) {
+  SEXP rtree = Rf_getAttrib(rotree, Rf_install("tree"));
+  struct ts_xtree *xtree = (struct ts_xtree*) R_ExternalPtrAddr(rtree);
+  TSTree *tree = xtree->tree;
+  TSNode root = ts_tree_root_node(tree);
+  char *code = ts_node_string(root);
+
+  SEXP result = Rf_mkString(code);
+  r_free(code);
+  return result;
+}
+
+SEXP parse(SEXP input, SEXP rlanguage, SEXP rranges) {
+  if (TYPEOF(rlanguage) != EXTPTRSXP) {
+    Rf_error("ts `language` must be an external pointer");
+  }
+  const TSLanguage *language = (const TSLanguage*)
+    R_ExternalPtrAddr(rlanguage);
+  if (!language) {
+    Rf_error("ts `language` cannot be a NULL pointer"); // # nocov
+  }
+  TSParser *parser = NULL;
+
+  parser = ts_parser_new();
+  if (!ts_parser_set_language(parser, language)) {
+    Rf_error("Failed to set R language, internal error."); // # nocov
+  }
+  r_call_on_early_exit((cleanup_fn_t) ts_parser_delete, parser);
+
+  uint32_t count;
+  TSRange *ranges = get_ranges(rranges, &count);
+  if (ranges) {
+    if (!ts_parser_set_included_ranges(parser, ranges, count)) {
+      Rf_error("Invalid ranges for tree-sitter parser");
+    }
+  }
+
+  const char *c_input = (const char*) RAW(input);
+  uint32_t length = Rf_length(input);
+  TSTree *tree = ts_parser_parse_string(parser, NULL, c_input, length);
+  r_call_on_early_exit((cleanup_fn_t) ts_tree_delete, tree);
+  TSNode root = ts_tree_root_node(tree);
+  uint32_t num_nodes = ts_node_descendant_count(root);
+  const char *nms[] = {
+    "id", "parent", "field_name", "type", "code", "start_byte", "end_byte",
+    "start_row", "start_column", "end_row", "end_column", "is_missing",
+    "has_error", "expected", ""
+  };
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  SET_VECTOR_ELT(res, 0, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_id = VECTOR_ELT(res, 0);
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_parent = VECTOR_ELT(res, 1);
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(STRSXP, num_nodes));
+  SEXP res_field_name = VECTOR_ELT(res, 2);
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(STRSXP, num_nodes));
+  SEXP res_type = VECTOR_ELT(res, 3);
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(STRSXP, num_nodes));
+  SEXP res_code = VECTOR_ELT(res, 4);
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_start_byte = VECTOR_ELT(res, 5);
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_end_byte = VECTOR_ELT(res, 6);
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_start_row = VECTOR_ELT(res, 7);
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_start_column = VECTOR_ELT(res, 8);
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_end_row = VECTOR_ELT(res, 9);
+  SET_VECTOR_ELT(res, 10, Rf_allocVector(INTSXP, num_nodes));
+  SEXP res_end_column = VECTOR_ELT(res, 10);
+  SET_VECTOR_ELT(res, 11, Rf_allocVector(LGLSXP, num_nodes));
+  SEXP res_is_missing = VECTOR_ELT(res, 11);
+  SET_VECTOR_ELT(res, 12, Rf_allocVector(LGLSXP, num_nodes));
+  SEXP res_has_error = VECTOR_ELT(res, 12);
+  SET_VECTOR_ELT(res, 13, Rf_allocVector(VECSXP, num_nodes));
+  SEXP res_expected = VECTOR_ELT(res, 13);
+
+  TSTreeCursor cursor = ts_tree_cursor_new(root);
+  r_call_on_exit((cleanup_fn_t) ts_tree_cursor_delete, &cursor);
+
+  size_t idx = 0;
+  bool ok = true;
+  uint32_t parent = 0;
+  while (ok) {
+    // record current node
+    TSNode crnt = ts_tree_cursor_current_node(&cursor);
+    INTEGER(res_id)[idx] = idx + 1;
+    INTEGER(res_parent)[idx] = parent + 1;
+    const char *field_name = ts_tree_cursor_current_field_name(&cursor);
+    SET_STRING_ELT(res_field_name, idx,
+      field_name ? Rf_mkChar(field_name) : R_NaString);
+    const char *type = ts_node_type(crnt);
+    SET_STRING_ELT(res_type, idx, Rf_mkChar(type));
+    uint32_t sb = ts_node_start_byte(crnt);
+    INTEGER(res_start_byte)[idx] = sb;
+    uint32_t eb = ts_node_end_byte(crnt);
+    INTEGER(res_end_byte)[idx] = eb;
+    TSPoint spt = ts_node_start_point(crnt);
+    INTEGER(res_start_row)[idx] = spt.row;
+    INTEGER(res_start_column)[idx] = spt.column;
+    TSPoint ept = ts_node_end_point(crnt);
+    INTEGER(res_end_row)[idx] = ept.row;
+    INTEGER(res_end_column)[idx] = ept.column;
+    if (ts_node_named_child_count(crnt) == 0) {
+      SET_STRING_ELT(res_code, idx, Rf_mkCharLen(c_input + sb, eb - sb));
+    } else {
+      SET_STRING_ELT(res_code, idx, R_NaString);
+    }
+    LOGICAL(res_is_missing)[idx] = ts_node_is_missing(crnt);
+    LOGICAL(res_has_error)[idx] = ts_node_has_error(crnt);
+
+    if (ts_node_is_missing(crnt)) {
+      TSStateId state = ts_node_parse_state(crnt);
+      TSLookaheadIterator *lait = ts_lookahead_iterator_new(language, state);
+      size_t laidx = 0;
+      do {
+        laidx++;
+      } while (ts_lookahead_iterator_next(lait));
+      SET_VECTOR_ELT(res_expected, idx, Rf_allocVector(VECSXP, laidx));
+      SEXP exp = VECTOR_ELT(res_expected, idx);
+
+      laidx = 0;
+      ts_lookahead_iterator_reset_state(lait, state);
+      do {
+        TSSymbol sym = ts_lookahead_iterator_current_symbol(lait);
+        const char *csym = ts_lookahead_iterator_current_symbol_name(lait);
+        TSSymbolType symtype = ts_language_symbol_type(language, sym);
+        SET_VECTOR_ELT(exp, laidx++, new_lookahead_sym(sym, csym, symtype));
+      } while (ts_lookahead_iterator_next(lait));
+
+      ts_lookahead_iterator_delete(lait);
+    }
+
+    // find next node. if there is a child, use that.
+    // otherwise if there is a sibling use that.
+    // otherwise go up until there is a sibling. or until cannot go up.
+    ok = ts_tree_cursor_goto_first_child(&cursor);
+    if (ok) {
+      parent = idx;
+    } else {
+      // parent stays the same
+      ok = ts_tree_cursor_goto_next_sibling(&cursor);
+    }
+    while (!ok) {
+      ok = ts_tree_cursor_goto_parent(&cursor);
+      if (!ok) break;
+      parent = INTEGER(res_parent)[parent] - 1;
+      ok = ts_tree_cursor_goto_next_sibling(&cursor);
+    }
+
+    idx++;
+  }
+
+  // no parent for root node
+  INTEGER(res_parent)[0] = NA_INTEGER;
+
+  SEXP rnms = PROTECT(Rf_allocVector(INTSXP, 2));
+  INTEGER(rnms)[0] = NA_INTEGER;
+  INTEGER(rnms)[1] = - num_nodes;
+  Rf_setAttrib(res, R_RowNamesSymbol, rnms);
+  UNPROTECT(1);
+
+  SEXP cls = PROTECT(Rf_allocVector(STRSXP, 2));
+  SET_STRING_ELT(cls, 0, Rf_mkChar("tbl"));
+  SET_STRING_ELT(cls, 1, Rf_mkChar("data.frame"));
+  Rf_setAttrib(res, R_ClassSymbol, cls);
+
+  struct ts_xtree *rxtree = malloc(sizeof(struct ts_xtree));
+  *rxtree = (struct ts_xtree){ language, parser, tree };
+  SEXP rtree = Rf_protect(R_MakeExternalPtr(
+    (void*) rxtree,
+    R_NilValue,
+    R_NilValue
+  ));
+  R_RegisterCFinalizerEx(rtree, (R_CFinalizer_t) ts_xtree_free, TRUE);
+  SEXP sym_tree = Rf_protect(Rf_install("tree"));
+  Rf_setAttrib(res, sym_tree, rtree);
+
+  UNPROTECT(4);
+  return res;
+}
+
+typedef enum {
+  EQ = 0,
+  NOT_EQ,
+  ANY_EQ,
+  ANY_NOT_EQ,
+  MATCH,
+  NOT_MATCH,
+  ANY_MATCH,
+  ANY_NOT_MATCH,
+  ANY_OF,
+  NOT_ANY_OF
+} predicate_type;
+
+struct query_match_t {
+  const TSQuery *query;
+  const TSQueryMatch *match;
+  uint32_t pattern_index;
+  const TSQueryPredicateStep *preds;
+  uint32_t num_pred_steps;
+  const char *text;
+  uint32_t text_length;
+  const uint32_t *capture_map;
+  const uint32_t *capture_map_pattern;
+};
+
+#define CODEEQ(s1, l1, s2, l2) \
+  (((l1) == (l2)) && !strncmp(qm->text + (s1), qm->text + (s2), (l1)))
+
+bool check_predicate_eq(const struct query_match_t *qm, predicate_type op,
+                        uint32_t st, uint32_t first_id,
+                        uint32_t first_nodes_count) {
+
+  if (qm->preds[st].type == TSQueryPredicateStepTypeCapture) {
+    uint32_t second_id = qm->preds[st].value_id;
+    uint32_t second_nodes_count = 0;
+    if (qm->capture_map_pattern[second_id] == qm->pattern_index + 1) {
+      second_nodes_count++;
+      uint32_t second_idx = qm->capture_map[second_id];
+      for (uint32_t i = second_idx + 1; i < qm->match->capture_count; i++) {
+        if (qm->match->captures[i].index != second_id) break;
+        second_nodes_count++;
+      }
+    }
+    // Need to compare two sets of nodes
+    uint32_t first_idx = qm->capture_map[first_id];
+    uint32_t second_idx = qm->capture_map[second_id];
+    // TODO: this is simpler for EQ etc., no need to cross-compare all
+    for (uint32_t i = first_idx; i < first_idx + first_nodes_count; i++) {
+      TSNode first_node = qm->match->captures[i].node;
+      uint32_t first_start = ts_node_start_byte(first_node);
+      uint32_t first_end = ts_node_end_byte(first_node);
+      uint32_t first_length = first_end - first_start;
+      for (uint32_t j = second_idx; j < second_idx + second_nodes_count; j++) {
+        TSNode second_node = qm->match->captures[j].node;
+        uint32_t second_start = ts_node_start_byte(second_node);
+        uint32_t second_end = ts_node_end_byte(second_node);
+        uint32_t second_length = second_end - second_start;
+        bool eq = CODEEQ(first_start, first_length, second_start, second_length);
+        if (op == EQ) {
+          if (!eq) return false;
+        } else if (op == NOT_EQ) {
+          if (eq) return false;
+        } else if (op == ANY_EQ) {
+          if (eq) return true;
+        } else if (op == ANY_NOT_EQ) {
+          if (!eq) return true;
+        }
+      }
+    }
+    // all combinarions checked, no evidence found against
+    if (op == EQ || op == NOT_EQ) {
+      return true;
+    } else { // op == ANY_EQ || op == ANY_NOT_EQ
+      return false;
+    }
+
+  } else if (qm->preds[st].type == TSQueryPredicateStepTypeString) {
+    uint32_t str_length;
+    const char *str = ts_query_string_value_for_id(
+      qm->query,
+      qm->preds[st].value_id,
+      &str_length
+    );
+    uint32_t first_idx = qm->capture_map[first_id];
+    for (uint32_t i = first_idx; i < first_idx + first_nodes_count; i++) {
+      TSNode first_node = qm->match->captures[i].node;
+      uint32_t first_start = ts_node_start_byte(first_node);
+      uint32_t first_end = ts_node_end_byte(first_node);
+      uint32_t first_length = first_end - first_start;
+      bool eq = first_length == str_length &&
+        !strncmp(qm->text + first_start, str, first_length);
+      if (op == EQ) {
+        if (!eq) return false;
+      } else if (op == NOT_EQ) {
+        if (eq) return false;
+      } else if (op == ANY_EQ) {
+        if (eq) return true;
+      } else if (op == ANY_NOT_EQ) {
+        if (!eq) return true;
+      }
+    }
+    // all combinarions checked, no evidence found against
+    if (op == EQ || op == NOT_EQ) {
+      return true;
+    } else { // op == ANY_EQ || op == ANY_NOT_EQ
+      return false;
+    }
+
+  } else {
+    // this should not happen
+    // # nocov start
+    Rf_error("Missing second argument for tree-sitter query");
+    // # nocov end
+  }
+}
+
+bool r_grepl(const char *text, uint32_t text_length, const char *pattern,
+             uint32_t pattern_length) {
+  SEXP rtext = PROTECT(Rf_ScalarString(Rf_mkCharLenCE(
+    text, text_length, CE_UTF8)));
+  SEXP rpattern = PROTECT(Rf_ScalarString(Rf_mkCharLenCE(
+    pattern, pattern_length, CE_UTF8)));
+  SEXP f = PROTECT(Rf_ScalarLogical(0));
+  SEXP t = PROTECT(Rf_ScalarLogical(1));
+  SEXP call = PROTECT(Rf_lang5(Rf_install("grepl"), rpattern, rtext, f, t));
+  SEXP ans = PROTECT(Rf_eval(call, R_BaseEnv));
+  bool cans = LOGICAL(ans)[0];
+  UNPROTECT(6);
+  return cans;
+}
+
+bool check_predicate_match(const struct query_match_t *qm,
+                           predicate_type op, uint32_t st,
+                           uint32_t first_id,
+                           uint32_t first_nodes_count) {
+  uint32_t pattern_length;
+  const char *pattern = ts_query_string_value_for_id(
+    qm->query,
+    qm->preds[st].value_id,
+    &pattern_length
+  );
+
+  uint32_t first_idx = qm->capture_map[first_id];
+  for (uint32_t i = first_idx; i < first_idx + first_nodes_count; i++) {
+    TSNode first_node = qm->match->captures[i].node;
+    uint32_t first_start = ts_node_start_byte(first_node);
+    uint32_t first_end = ts_node_end_byte(first_node);
+    uint32_t first_length = first_end - first_start;
+    bool eq = r_grepl(
+      qm->text + first_start, first_length, pattern, pattern_length);
+    if (op == MATCH) {
+      if (!eq) return false;
+    } else if (op == NOT_MATCH) {
+      if (eq) return false;
+    } else if (op == ANY_MATCH) {
+      if (eq) return true;
+    } else if (op == ANY_NOT_MATCH) {
+      if (!eq) return true;
+    }
+  }
+  // all combinarions checked, no evidence found against
+  if (op == MATCH || op == NOT_MATCH) {
+    return true;
+  } else { // op == ANY_MATCH || op == ANY_NOT_MATCH
+    return false;
+  }
+}
+
+bool check_predicate_any_of(const struct query_match_t *qm,
+                            predicate_type op, uint32_t st,
+                            uint32_t first_id,
+                            uint32_t first_nodes_count) {
+
+  uint32_t first_idx = qm->capture_map[first_id];
+  for (uint32_t i = first_idx; i < first_idx + first_nodes_count; i++) {
+    TSNode first_node = qm->match->captures[i].node;
+    uint32_t first_start = ts_node_start_byte(first_node);
+    uint32_t first_end = ts_node_end_byte(first_node);
+    uint32_t first_length = first_end - first_start;
+    bool ifound = false;
+    for (uint32_t sti = st;
+         qm->preds[sti].type != TSQueryPredicateStepTypeDone;
+         sti++) {
+      uint32_t str_length;
+      const char *str = ts_query_string_value_for_id(
+        qm->query,
+        qm->preds[sti].value_id,
+        &str_length
+      );
+
+      bool eq = first_length == str_length &&
+        !strncmp(qm->text + first_start, str, first_length);
+      if (eq) {
+        ifound = true;
+        break;
+      }
+    }
+    if (op == ANY_OF) {
+      if (!ifound) return false;
+    } else { // op == NOT_ANY_OF
+      if (ifound) return false;
+    }
+  }
+  // all nodes are ok
+  return true;
+}
+
+bool check_predicates(const struct query_match_t *qm) {
+  for (uint32_t st = 0; st < qm->num_pred_steps; st++) {
+    // Operation, like #eq? etc. ------------------------------------------
+    if (qm->preds[st].type != TSQueryPredicateStepTypeString) {
+      Rf_error("First predicate step must be a string");
+    }
+    uint32_t l;
+    const char *ops = ts_query_string_value_for_id(
+      qm->query,
+      qm->preds[st].value_id,
+      &l
+    );
+    st++;
+    predicate_type op;
+    if (!strcasecmp("eq?", ops)) {
+      op = EQ;
+    } else if (!strcasecmp("not-eq?", ops)) {
+      op = NOT_EQ;
+    } else if (!strcasecmp("any-eq?", ops)) {
+      op = ANY_EQ;
+    } else if (!strcasecmp("any-not-eq?", ops)) {
+      op = ANY_NOT_EQ;
+    } else if (!strcasecmp("match?", ops)) {
+      op = MATCH;
+    } else if (!strcasecmp("not-match?", ops)) {
+      op = NOT_MATCH;
+    } else if (!strcasecmp("any-match?", ops)) {
+      op = ANY_MATCH;
+    } else if (!strcasecmp("any-not-match?", ops)) {
+      op = ANY_NOT_MATCH;
+    } else if (!strcasecmp("any-of?", ops)) {
+      op = ANY_OF;
+    } else if (!strcasecmp("not-any-of?", ops)) {
+      op = NOT_ANY_OF;
+    } else {
+      Rf_error("Unknown predicate: #%s", ops);
+    }
+
+    // First argument must be a capture. ----------------------------------
+    // Possibly 0-n nodes
+    if (qm->preds[st].type != TSQueryPredicateStepTypeCapture) {
+      Rf_error("First argument of a predicate must be a capture");
+    }
+    uint32_t first_id = qm->preds[st].value_id;
+    uint32_t first_nodes_count = 0;
+    if (qm->capture_map_pattern[first_id] == qm->pattern_index + 1) {
+      first_nodes_count++;
+      uint32_t first_idx = qm->capture_map[first_id];
+      for (uint32_t i = first_idx + 1; i < qm->match->capture_count; i++) {
+        if (qm->match->captures[i].index != first_id) break;
+        first_nodes_count++;
+      }
+    }
+    st++;
+
+    if (op == ANY_OF || op == NOT_ANY_OF) {
+      if (! check_predicate_any_of(qm, op, st, first_id, first_nodes_count)) {
+        return false;
+      }
+
+    } else if (op == MATCH || op == NOT_MATCH ||
+               op == ANY_MATCH || op == ANY_NOT_MATCH) {
+      if (!check_predicate_match(qm, op, st, first_id, first_nodes_count)) {
+        return false;
+      }
+
+    } else {
+      if (!check_predicate_eq(qm, op, st, first_id, first_nodes_count)) {
+        return false;
+      }
+    }
+    // move to the next predicate;
+    while (st < qm->num_pred_steps &&
+           qm->preds[st].type != TSQueryPredicateStepTypeDone) st++;
+  }
+  return true;
+}
+
+SEXP code_query(SEXP rotree, SEXP rquery) {
+  SEXP rtree = Rf_getAttrib(rotree, Rf_install("tree"));
+  struct ts_xtree *xtree = (struct ts_xtree*) R_ExternalPtrAddr(rtree);
+  const TSLanguage *language = xtree->language;
+  TSTree *tree = xtree->tree;
+
+  SEXP rinput = Rf_getAttrib(rotree, Rf_install("text"));
+  const char *c_input = (const char*) RAW(rinput);
+  uint32_t length = Rf_length(rinput);
+
+  const char *cpattern = CHAR(STRING_ELT(rquery, 0));
+  uint32_t error_offset;
+  TSQueryError error_type;
+  TSQuery *query = ts_query_new(
+    language,
+    cpattern,
+    strlen(cpattern),
+    &error_offset,
+    &error_type
+  );
+  if (!query) {
+    Rf_error("Failed to parse TS query at char %d.", (int) error_offset);
+  }
+  r_call_on_exit((cleanup_fn_t) ts_query_delete, query);
+
+  uint32_t num_patterns = ts_query_pattern_count(query);
+  const TSQueryPredicateStep **preds =
+    malloc(sizeof(TSQueryPredicateStep*) * num_patterns);
+  if (!preds) {
+    Rf_error("Out of memory");
+  }
+  r_call_on_exit(r_free, preds);
+  uint32_t *num_steps = malloc(sizeof(uint32_t) * num_patterns);
+  for (uint32_t pt = 0; pt < num_patterns; pt++) {
+    preds[pt] = ts_query_predicates_for_pattern(query, pt, num_steps + pt);
+  }
+
+  uint32_t capture_count = ts_query_capture_count(query);
+  uint32_t *capture_map = malloc(sizeof(uint32_t) * capture_count);
+  if (!capture_map) {
+    Rf_error("Out of memory");
+  }
+  r_call_on_exit(r_free, capture_map);
+  uint32_t *capture_map_pattern = malloc(sizeof(uint32_t) * capture_count);
+  if (!capture_map_pattern) {
+    Rf_error("Out of memory");
+  }
+  r_call_on_exit(r_free, capture_map_pattern);
+  memset(capture_map_pattern, 0, sizeof(uint32_t) * capture_count);
+
+  TSNode root = ts_tree_root_node(tree);
+
+  uint32_t pattern_count = ts_query_pattern_count(query);
+  SEXP result_matches = PROTECT(Rf_allocVector(VECSXP, 3));
+  SET_VECTOR_ELT(result_matches, 0, Rf_allocVector(STRSXP, pattern_count));
+  SET_VECTOR_ELT(result_matches, 1, Rf_allocVector(INTSXP, pattern_count));
+  SET_VECTOR_ELT(result_matches, 2, Rf_allocVector(INTSXP, pattern_count));
+  for (uint32_t i = 0; i < pattern_count; i++) {
+    uint32_t start = ts_query_start_byte_for_pattern(query, i);
+    uint32_t end = ts_query_end_byte_for_pattern(query, i);
+    SET_STRING_ELT(
+      VECTOR_ELT(result_matches, 0), i,
+      Rf_mkCharLenCE(cpattern + start, end - start, CE_UTF8)
+    );
+    INTEGER(VECTOR_ELT(result_matches, 2))[i] = start + 1;
+  }
+  memset(
+    INTEGER(VECTOR_ELT(result_matches, 1)),
+    0,
+    sizeof(int) * pattern_count
+  );
+
+  // TODO: we should allocate a DF here, probably
+  PROTECT_INDEX rpi;
+  SEXP result_matched_captures = Rf_allocVector(VECSXP, 100);
+  PROTECT_WITH_INDEX(result_matched_captures, &rpi);
+  uint32_t total_capture_count = 0, residx = 0;
+
+  TSQueryCursor *cursor = ts_query_cursor_new();
+  ts_query_cursor_exec(cursor, query, root);
+  r_call_on_exit((cleanup_fn_t) ts_query_cursor_delete, cursor);
+  TSQueryMatch match;
+  uint32_t match_idx = 0;
+  while (ts_query_cursor_next_match(cursor, &match)) {
+    // Create a capture id -> capture_idx in match mapping
+    // We point to the last node that has this capture id, and then we can
+    // work backwards
+    for (uint16_t cc = 0; cc < match.capture_count; cc++) {
+      uint32_t cidx = match.captures[cc].index;
+      // point to the first node
+      if (capture_map_pattern[cidx] != match.pattern_index + 1) {
+        capture_map_pattern[cidx] = match.pattern_index + 1;
+        capture_map[cidx] = cc;
+      }
+    }
+
+    // evaluate the predicates
+    const TSQueryPredicateStep *mpreds = preds[match.pattern_index];
+    uint32_t mnum_steps = num_steps[match.pattern_index];
+    struct query_match_t qm = {
+      query, &match, match.pattern_index, mpreds, mnum_steps, c_input,
+      length, capture_map, capture_map_pattern
+    };
+    if (!check_predicates(&qm)) continue;
+
+    match_idx++;
+    INTEGER(VECTOR_ELT(result_matches, 1))[match.pattern_index] += 1;
+    total_capture_count += match.capture_count;
+    if (total_capture_count > Rf_length(result_matched_captures)) {
+      REPROTECT(
+        result_matched_captures = Rf_xlengthgets(
+          result_matched_captures,
+          total_capture_count * 2
+        ),
+        rpi
+      );
+    }
+
+    // collect the results
+    for (uint16_t cc = 0; cc < match.capture_count; cc++) {
+      SEXP res1 = PROTECT(Rf_allocVector(VECSXP, 12));
+      SET_VECTOR_ELT(result_matched_captures, residx++, res1);
+      UNPROTECT(1);
+
+      SET_VECTOR_ELT(res1, 0, Rf_ScalarInteger(match.pattern_index + 1));
+      SET_VECTOR_ELT(res1, 1, Rf_ScalarInteger(match_idx));
+      SET_VECTOR_ELT(res1, 2, Rf_ScalarInteger(match.captures[cc].index + 1));
+
+      uint32_t cnl;
+      const char *cn = ts_query_capture_name_for_id(
+        query,
+        match.captures[cc].index,
+        &cnl
+      );
+      SET_VECTOR_ELT(res1, 3, Rf_ScalarString(Rf_mkCharLenCE(
+        cn,
+        cnl,
+        CE_UTF8
+      )));
+
+      TSNode node = match.captures[cc].node;
+      uint32_t start_byte = ts_node_start_byte(node);
+      uint32_t end_byte = ts_node_end_byte(node);
+      SET_VECTOR_ELT(res1, 4, Rf_ScalarString(Rf_mkCharLenCE(
+        c_input + start_byte,
+        end_byte - start_byte,
+        CE_UTF8
+      )));
+      SET_VECTOR_ELT(res1, 5, Rf_ScalarInteger(start_byte));
+      SET_VECTOR_ELT(res1, 6, Rf_ScalarInteger(end_byte));
+      TSPoint start_point = ts_node_start_point(node);
+      SET_VECTOR_ELT(res1, 7, Rf_ScalarInteger(start_point.row));
+      SET_VECTOR_ELT(res1, 8, Rf_ScalarInteger(start_point.column));
+      TSPoint end_point = ts_node_end_point(node);
+      SET_VECTOR_ELT(res1, 9, Rf_ScalarInteger(end_point.row));
+      SET_VECTOR_ELT(res1, 10, Rf_ScalarInteger(end_point.column));
+      SET_VECTOR_ELT(res1, 11, Rf_mkString(ts_node_type(node)));
+    }
+  }
+
+  REPROTECT(
+    result_matched_captures = Rf_xlengthgets(
+      result_matched_captures,
+      total_capture_count),
+    rpi
+  );
+
+  uint32_t query_capture_count = ts_query_capture_count(query);
+  SEXP result_captures = Rf_protect(Rf_allocVector(STRSXP, query_capture_count));
+  for (uint32_t i = 0; i < query_capture_count; i++) {
+    uint32_t len;
+    const char *cn = ts_query_capture_name_for_id(query, i, &len);
+    SET_STRING_ELT(result_captures, i, Rf_mkCharLenCE(cn, len, CE_UTF8));
+  }
+
+  SEXP result = PROTECT(Rf_allocVector(VECSXP, 3));
+  SET_VECTOR_ELT(result, 0, result_matches);
+  SET_VECTOR_ELT(result, 1, result_captures);
+  SET_VECTOR_ELT(result, 2, result_matched_captures);
+  UNPROTECT(4);
+  return result;
+}
diff --git a/src/library/ts/src/tree-sitter/lib/include/tree_sitter/api.h b/src/library/ts/src/tree-sitter/lib/include/tree_sitter/api.h
new file mode 100644
index 0000000000..1b9dbf7337
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/include/tree_sitter/api.h
@@ -0,0 +1,1423 @@
+#ifndef TREE_SITTER_API_H_
+#define TREE_SITTER_API_H_
+
+#ifndef TREE_SITTER_HIDE_SYMBOLS
+#if defined(__GNUC__) || defined(__clang__)
+# pragma GCC visibility push(default)
+#endif
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/****************************/
+/* Section - ABI Versioning */
+/****************************/
+
+/**
+ * The latest ABI version that is supported by the current version of the
+ * library. When Languages are generated by the Tree-sitter CLI, they are
+ * assigned an ABI version number that corresponds to the current CLI version.
+ * The Tree-sitter library is generally backwards-compatible with languages
+ * generated using older CLI versions, but is not forwards-compatible.
+ */
+#define TREE_SITTER_LANGUAGE_VERSION 15
+
+/**
+ * The earliest ABI version that is supported by the current version of the
+ * library.
+ */
+#define TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION 13
+
+/*******************/
+/* Section - Types */
+/*******************/
+
+typedef uint16_t TSStateId;
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+typedef struct TSParser TSParser;
+typedef struct TSTree TSTree;
+typedef struct TSQuery TSQuery;
+typedef struct TSQueryCursor TSQueryCursor;
+typedef struct TSLookaheadIterator TSLookaheadIterator;
+
+// This function signature reads one code point from the given string,
+// returning the number of bytes consumed. It should write the code point
+// to the `code_point` pointer, or write -1 if the input is invalid.
+typedef uint32_t (*TSDecodeFunction)(
+  const uint8_t *string,
+  uint32_t length,
+  int32_t *code_point
+);
+
+// Deprecated alias to be removed in ABI 16
+typedef TSDecodeFunction DecodeFunction;
+
+typedef enum TSInputEncoding {
+  TSInputEncodingUTF8,
+  TSInputEncodingUTF16LE,
+  TSInputEncodingUTF16BE,
+  TSInputEncodingCustom
+} TSInputEncoding;
+
+typedef enum TSSymbolType {
+  TSSymbolTypeRegular,
+  TSSymbolTypeAnonymous,
+  TSSymbolTypeSupertype,
+  TSSymbolTypeAuxiliary,
+} TSSymbolType;
+
+typedef struct TSPoint {
+  uint32_t row;
+  uint32_t column;
+} TSPoint;
+
+typedef struct TSRange {
+  TSPoint start_point;
+  TSPoint end_point;
+  uint32_t start_byte;
+  uint32_t end_byte;
+} TSRange;
+
+typedef struct TSInput {
+  void *payload;
+  const char *(*read)(void *payload, uint32_t byte_index, TSPoint position, uint32_t *bytes_read);
+  TSInputEncoding encoding;
+  TSDecodeFunction decode;
+} TSInput;
+
+typedef struct TSParseState {
+  void *payload;
+  uint32_t current_byte_offset;
+  bool has_error;
+} TSParseState;
+
+typedef struct TSParseOptions {
+  void *payload;
+  bool (*progress_callback)(TSParseState *state);
+} TSParseOptions;
+
+typedef enum TSLogType {
+  TSLogTypeParse,
+  TSLogTypeLex,
+} TSLogType;
+
+typedef struct TSLogger {
+  void *payload;
+  void (*log)(void *payload, TSLogType log_type, const char *buffer);
+} TSLogger;
+
+typedef struct TSInputEdit {
+  uint32_t start_byte;
+  uint32_t old_end_byte;
+  uint32_t new_end_byte;
+  TSPoint start_point;
+  TSPoint old_end_point;
+  TSPoint new_end_point;
+} TSInputEdit;
+
+typedef struct TSNode {
+  uint32_t context[4];
+  const void *id;
+  const TSTree *tree;
+} TSNode;
+
+typedef struct TSTreeCursor {
+  const void *tree;
+  const void *id;
+  uint32_t context[3];
+} TSTreeCursor;
+
+typedef struct TSQueryCapture {
+  TSNode node;
+  uint32_t index;
+} TSQueryCapture;
+
+typedef enum TSQuantifier {
+  TSQuantifierZero = 0, // must match the array initialization value
+  TSQuantifierZeroOrOne,
+  TSQuantifierZeroOrMore,
+  TSQuantifierOne,
+  TSQuantifierOneOrMore,
+} TSQuantifier;
+
+typedef struct TSQueryMatch {
+  uint32_t id;
+  uint16_t pattern_index;
+  uint16_t capture_count;
+  const TSQueryCapture *captures;
+} TSQueryMatch;
+
+typedef enum TSQueryPredicateStepType {
+  TSQueryPredicateStepTypeDone,
+  TSQueryPredicateStepTypeCapture,
+  TSQueryPredicateStepTypeString,
+} TSQueryPredicateStepType;
+
+typedef struct TSQueryPredicateStep {
+  TSQueryPredicateStepType type;
+  uint32_t value_id;
+} TSQueryPredicateStep;
+
+typedef enum TSQueryError {
+  TSQueryErrorNone = 0,
+  TSQueryErrorSyntax,
+  TSQueryErrorNodeType,
+  TSQueryErrorField,
+  TSQueryErrorCapture,
+  TSQueryErrorStructure,
+  TSQueryErrorLanguage,
+} TSQueryError;
+
+typedef struct TSQueryCursorState {
+  void *payload;
+  uint32_t current_byte_offset;
+} TSQueryCursorState;
+
+typedef struct TSQueryCursorOptions {
+  void *payload;
+  bool (*progress_callback)(TSQueryCursorState *state);
+} TSQueryCursorOptions;
+
+/**
+ * The metadata associated with a language.
+ *
+ * Currently, this metadata can be used to check the [Semantic Version](https://semver.org/)
+ * of the language. This version information should be used to signal if a given parser might
+ * be incompatible with existing queries when upgrading between major versions, or minor versions
+ * if it's in zerover.
+ */
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
+} TSLanguageMetadata;
+
+/********************/
+/* Section - Parser */
+/********************/
+
+/**
+ * Create a new parser.
+ */
+TSParser *ts_parser_new(void);
+
+/**
+ * Delete the parser, freeing all of the memory that it used.
+ */
+void ts_parser_delete(TSParser *self);
+
+/**
+ * Get the parser's current language.
+ */
+const TSLanguage *ts_parser_language(const TSParser *self);
+
+/**
+ * Set the language that the parser should use for parsing.
+ *
+ * Returns a boolean indicating whether or not the language was successfully
+ * assigned. True means assignment succeeded. False means there was a version
+ * mismatch: the language was generated with an incompatible version of the
+ * Tree-sitter CLI. Check the language's ABI version using [`ts_language_abi_version`]
+ * and compare it to this library's [`TREE_SITTER_LANGUAGE_VERSION`] and
+ * [`TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION`] constants.
+ */
+bool ts_parser_set_language(TSParser *self, const TSLanguage *language);
+
+/**
+ * Set the ranges of text that the parser should include when parsing.
+ *
+ * By default, the parser will always include entire documents. This function
+ * allows you to parse only a *portion* of a document but still return a syntax
+ * tree whose ranges match up with the document as a whole. You can also pass
+ * multiple disjoint ranges.
+ *
+ * The second and third parameters specify the location and length of an array
+ * of ranges. The parser does *not* take ownership of these ranges; it copies
+ * the data, so it doesn't matter how these ranges are allocated.
+ *
+ * If `count` is zero, then the entire document will be parsed. Otherwise,
+ * the given ranges must be ordered from earliest to latest in the document,
+ * and they must not overlap. That is, the following must hold for all:
+ *
+ * `i < count - 1`: `ranges[i].end_byte <= ranges[i + 1].start_byte`
+ *
+ * If this requirement is not satisfied, the operation will fail, the ranges
+ * will not be assigned, and this function will return `false`. On success,
+ * this function returns `true`
+ */
+bool ts_parser_set_included_ranges(
+  TSParser *self,
+  const TSRange *ranges,
+  uint32_t count
+);
+
+/**
+ * Get the ranges of text that the parser will include when parsing.
+ *
+ * The returned pointer is owned by the parser. The caller should not free it
+ * or write to it. The length of the array will be written to the given
+ * `count` pointer.
+ */
+const TSRange *ts_parser_included_ranges(
+  const TSParser *self,
+  uint32_t *count
+);
+
+/**
+ * Use the parser to parse some source code and create a syntax tree.
+ *
+ * If you are parsing this document for the first time, pass `NULL` for the
+ * `old_tree` parameter. Otherwise, if you have already parsed an earlier
+ * version of this document and the document has since been edited, pass the
+ * previous syntax tree so that the unchanged parts of it can be reused.
+ * This will save time and memory. For this to work correctly, you must have
+ * already edited the old syntax tree using the [`ts_tree_edit`] function in a
+ * way that exactly matches the source code changes.
+ *
+ * The [`TSInput`] parameter lets you specify how to read the text. It has the
+ * following three fields:
+ * 1. [`read`]: A function to retrieve a chunk of text at a given byte offset
+ *    and (row, column) position. The function should return a pointer to the
+ *    text and write its length to the [`bytes_read`] pointer. The parser does
+ *    not take ownership of this buffer; it just borrows it until it has
+ *    finished reading it. The function should write a zero value to the
+ *    [`bytes_read`] pointer to indicate the end of the document.
+ * 2. [`payload`]: An arbitrary pointer that will be passed to each invocation
+ *    of the [`read`] function.
+ * 3. [`encoding`]: An indication of how the text is encoded. Either
+ *    `TSInputEncodingUTF8` or `TSInputEncodingUTF16`.
+ *
+ * This function returns a syntax tree on success, and `NULL` on failure. There
+ * are four possible reasons for failure:
+ * 1. The parser does not have a language assigned. Check for this using the
+      [`ts_parser_language`] function.
+ * 2. Parsing was cancelled due to the progress callback returning true. This callback
+ *    is passed in [`ts_parser_parse_with_options`] inside the [`TSParseOptions`] struct.
+ *
+ * [`read`]: TSInput::read
+ * [`payload`]: TSInput::payload
+ * [`encoding`]: TSInput::encoding
+ * [`bytes_read`]: TSInput::read
+ */
+TSTree *ts_parser_parse(
+  TSParser *self,
+  const TSTree *old_tree,
+  TSInput input
+);
+
+/**
+ * Use the parser to parse some source code and create a syntax tree, with some options.
+ *
+ * See [`ts_parser_parse`] for more details.
+ *
+ * See [`TSParseOptions`] for more details on the options.
+ */
+TSTree* ts_parser_parse_with_options(
+  TSParser *self,
+  const TSTree *old_tree,
+  TSInput input,
+  TSParseOptions parse_options
+);
+
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer.
+ * The first two parameters are the same as in the [`ts_parser_parse`] function
+ * above. The second two parameters indicate the location of the buffer and its
+ * length in bytes.
+ */
+TSTree *ts_parser_parse_string(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length
+);
+
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer with
+ * a given encoding. The first four parameters work the same as in the
+ * [`ts_parser_parse_string`] method above. The final parameter indicates whether
+ * the text is encoded as UTF8 or UTF16.
+ */
+TSTree *ts_parser_parse_string_encoding(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length,
+  TSInputEncoding encoding
+);
+
+/**
+ * Instruct the parser to start the next parse from the beginning.
+ *
+ * If the parser previously failed because of the progress callback, then
+ * by default, it will resume where it left off on the next call to
+ * [`ts_parser_parse`] or other parsing functions. If you don't want to resume,
+ * and instead intend to use this parser to parse some other document, you must
+ * call [`ts_parser_reset`] first.
+ */
+void ts_parser_reset(TSParser *self);
+
+/**
+ * Set the logger that a parser should use during parsing.
+ *
+ * The parser does not take ownership over the logger payload. If a logger was
+ * previously assigned, the caller is responsible for releasing any memory
+ * owned by the previous logger.
+ */
+void ts_parser_set_logger(TSParser *self, TSLogger logger);
+
+/**
+ * Get the parser's current logger.
+ */
+TSLogger ts_parser_logger(const TSParser *self);
+
+/**
+ * Set the file descriptor to which the parser should write debugging graphs
+ * during parsing. The graphs are formatted in the DOT language. You may want
+ * to pipe these graphs directly to a `dot(1)` process in order to generate
+ * SVG output. You can turn off this logging by passing a negative number.
+ */
+void ts_parser_print_dot_graphs(TSParser *self, int fd);
+
+/******************/
+/* Section - Tree */
+/******************/
+
+/**
+ * Create a shallow copy of the syntax tree. This is very fast.
+ *
+ * You need to copy a syntax tree in order to use it on more than one thread at
+ * a time, as syntax trees are not thread safe.
+ */
+TSTree *ts_tree_copy(const TSTree *self);
+
+/**
+ * Delete the syntax tree, freeing all of the memory that it used.
+ */
+void ts_tree_delete(TSTree *self);
+
+/**
+ * Get the root node of the syntax tree.
+ */
+TSNode ts_tree_root_node(const TSTree *self);
+
+/**
+ * Get the root node of the syntax tree, but with its position
+ * shifted forward by the given offset.
+ */
+TSNode ts_tree_root_node_with_offset(
+  const TSTree *self,
+  uint32_t offset_bytes,
+  TSPoint offset_extent
+);
+
+/**
+ * Get the language that was used to parse the syntax tree.
+ */
+const TSLanguage *ts_tree_language(const TSTree *self);
+
+/**
+ * Get the array of included ranges that was used to parse the syntax tree.
+ *
+ * The returned pointer must be freed by the caller.
+ */
+TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length);
+
+/**
+ * Edit the syntax tree to keep it in sync with source code that has been
+ * edited.
+ *
+ * You must describe the edit both in terms of byte offsets and in terms of
+ * (row, column) coordinates.
+ */
+void ts_tree_edit(TSTree *self, const TSInputEdit *edit);
+
+/**
+ * Compare an old edited syntax tree to a new syntax tree representing the same
+ * document, returning an array of ranges whose syntactic structure has changed.
+ *
+ * For this to work correctly, the old syntax tree must have been edited such
+ * that its ranges match up to the new tree. Generally, you'll want to call
+ * this function right after calling one of the [`ts_parser_parse`] functions.
+ * You need to pass the old tree that was passed to parse, as well as the new
+ * tree that was returned from that function.
+ *
+ * The returned ranges indicate areas where the hierarchical structure of syntax
+ * nodes (from root to leaf) has changed between the old and new trees. Characters
+ * outside these ranges have identical ancestor nodes in both trees.
+ *
+ * Note that the returned ranges may be slightly larger than the exact changed areas,
+ * but Tree-sitter attempts to make them as small as possible.
+ *
+ * The returned array is allocated using `malloc` and the caller is responsible
+ * for freeing it using `free`. The length of the array will be written to the
+ * given `length` pointer.
+ */
+TSRange *ts_tree_get_changed_ranges(
+  const TSTree *old_tree,
+  const TSTree *new_tree,
+  uint32_t *length
+);
+
+/**
+ * Write a DOT graph describing the syntax tree to the given file.
+ */
+void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor);
+
+/******************/
+/* Section - Node */
+/******************/
+
+/**
+ * Get the node's type as a null-terminated string.
+ */
+const char *ts_node_type(TSNode self);
+
+/**
+ * Get the node's type as a numerical id.
+ */
+TSSymbol ts_node_symbol(TSNode self);
+
+/**
+ * Get the node's language.
+ */
+const TSLanguage *ts_node_language(TSNode self);
+
+/**
+ * Get the node's type as it appears in the grammar ignoring aliases as a
+ * null-terminated string.
+ */
+const char *ts_node_grammar_type(TSNode self);
+
+/**
+ * Get the node's type as a numerical id as it appears in the grammar ignoring
+ * aliases. This should be used in [`ts_language_next_state`] instead of
+ * [`ts_node_symbol`].
+ */
+TSSymbol ts_node_grammar_symbol(TSNode self);
+
+/**
+ * Get the node's start byte.
+ */
+uint32_t ts_node_start_byte(TSNode self);
+
+/**
+ * Get the node's start position in terms of rows and columns.
+ */
+TSPoint ts_node_start_point(TSNode self);
+
+/**
+ * Get the node's end byte.
+ */
+uint32_t ts_node_end_byte(TSNode self);
+
+/**
+ * Get the node's end position in terms of rows and columns.
+ */
+TSPoint ts_node_end_point(TSNode self);
+
+/**
+ * Get an S-expression representing the node as a string.
+ *
+ * This string is allocated with `malloc` and the caller is responsible for
+ * freeing it using `free`.
+ */
+char *ts_node_string(TSNode self);
+
+/**
+ * Check if the node is null. Functions like [`ts_node_child`] and
+ * [`ts_node_next_sibling`] will return a null node to indicate that no such node
+ * was found.
+ */
+bool ts_node_is_null(TSNode self);
+
+/**
+ * Check if the node is *named*. Named nodes correspond to named rules in the
+ * grammar, whereas *anonymous* nodes correspond to string literals in the
+ * grammar.
+ */
+bool ts_node_is_named(TSNode self);
+
+/**
+ * Check if the node is *missing*. Missing nodes are inserted by the parser in
+ * order to recover from certain kinds of syntax errors.
+ */
+bool ts_node_is_missing(TSNode self);
+
+/**
+ * Check if the node is *extra*. Extra nodes represent things like comments,
+ * which are not required the grammar, but can appear anywhere.
+ */
+bool ts_node_is_extra(TSNode self);
+
+/**
+ * Check if a syntax node has been edited.
+ */
+bool ts_node_has_changes(TSNode self);
+
+/**
+ * Check if the node is a syntax error or contains any syntax errors.
+ */
+bool ts_node_has_error(TSNode self);
+
+/**
+ * Check if the node is a syntax error.
+*/
+bool ts_node_is_error(TSNode self);
+
+/**
+ * Get this node's parse state.
+*/
+TSStateId ts_node_parse_state(TSNode self);
+
+/**
+ * Get the parse state after this node.
+*/
+TSStateId ts_node_next_parse_state(TSNode self);
+
+/**
+ * Get the node's immediate parent.
+ * Prefer [`ts_node_child_with_descendant`] for
+ * iterating over the node's ancestors.
+ */
+TSNode ts_node_parent(TSNode self);
+
+/**
+ * Get the node that contains `descendant`.
+ *
+ * Note that this can return `descendant` itself.
+ */
+TSNode ts_node_child_with_descendant(TSNode self, TSNode descendant);
+
+/**
+ * Get the node's child at the given index, where zero represents the first
+ * child.
+ */
+TSNode ts_node_child(TSNode self, uint32_t child_index);
+
+/**
+ * Get the field name for node's child at the given index, where zero represents
+ * the first child. Returns NULL, if no field is found.
+ */
+const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index);
+
+/**
+ * Get the field name for node's named child at the given index, where zero
+ * represents the first named child. Returns NULL, if no field is found.
+ */
+const char *ts_node_field_name_for_named_child(TSNode self, uint32_t named_child_index);
+
+/**
+ * Get the node's number of children.
+ */
+uint32_t ts_node_child_count(TSNode self);
+
+/**
+ * Get the node's *named* child at the given index.
+ *
+ * See also [`ts_node_is_named`].
+ */
+TSNode ts_node_named_child(TSNode self, uint32_t child_index);
+
+/**
+ * Get the node's number of *named* children.
+ *
+ * See also [`ts_node_is_named`].
+ */
+uint32_t ts_node_named_child_count(TSNode self);
+
+/**
+ * Get the node's child with the given field name.
+ */
+TSNode ts_node_child_by_field_name(
+  TSNode self,
+  const char *name,
+  uint32_t name_length
+);
+
+/**
+ * Get the node's child with the given numerical field id.
+ *
+ * You can convert a field name to an id using the
+ * [`ts_language_field_id_for_name`] function.
+ */
+TSNode ts_node_child_by_field_id(TSNode self, TSFieldId field_id);
+
+/**
+ * Get the node's next / previous sibling.
+ */
+TSNode ts_node_next_sibling(TSNode self);
+TSNode ts_node_prev_sibling(TSNode self);
+
+/**
+ * Get the node's next / previous *named* sibling.
+ */
+TSNode ts_node_next_named_sibling(TSNode self);
+TSNode ts_node_prev_named_sibling(TSNode self);
+
+/**
+ * Get the node's first child that contains or starts after the given byte offset.
+ */
+TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte);
+
+/**
+ * Get the node's first named child that contains or starts after the given byte offset.
+ */
+TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte);
+
+/**
+ * Get the node's number of descendants, including one for the node itself.
+ */
+uint32_t ts_node_descendant_count(TSNode self);
+
+/**
+ * Get the smallest node within this node that spans the given range of bytes
+ * or (row, column) positions.
+ */
+TSNode ts_node_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
+TSNode ts_node_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
+
+/**
+ * Get the smallest named node within this node that spans the given range of
+ * bytes or (row, column) positions.
+ */
+TSNode ts_node_named_descendant_for_byte_range(TSNode self, uint32_t start, uint32_t end);
+TSNode ts_node_named_descendant_for_point_range(TSNode self, TSPoint start, TSPoint end);
+
+/**
+ * Edit the node to keep it in-sync with source code that has been edited.
+ *
+ * This function is only rarely needed. When you edit a syntax tree with the
+ * [`ts_tree_edit`] function, all of the nodes that you retrieve from the tree
+ * afterward will already reflect the edit. You only need to use [`ts_node_edit`]
+ * when you have a [`TSNode`] instance that you want to keep and continue to use
+ * after an edit.
+ */
+void ts_node_edit(TSNode *self, const TSInputEdit *edit);
+
+/**
+ * Check if two nodes are identical.
+ */
+bool ts_node_eq(TSNode self, TSNode other);
+
+/**
+ * Edit a point to keep it in-sync with source code that has been edited.
+ *
+ * This function updates a single point's byte offset and row/column position
+ * based on an edit operation. This is useful for editing points without
+ * requiring a tree or node instance.
+ */
+void ts_point_edit(TSPoint *point, uint32_t *point_byte, const TSInputEdit *edit);
+
+/**
+ * Edit a range to keep it in-sync with source code that has been edited.
+ *
+ * This function updates a range's start and end positions based on an edit
+ * operation. This is useful for editing ranges without requiring a tree
+ * or node instance.
+ */
+void ts_range_edit(TSRange *range, const TSInputEdit *edit);
+
+/************************/
+/* Section - TreeCursor */
+/************************/
+
+/**
+ * Create a new tree cursor starting from the given node.
+ *
+ * A tree cursor allows you to walk a syntax tree more efficiently than is
+ * possible using the [`TSNode`] functions. It is a mutable object that is always
+ * on a certain syntax node, and can be moved imperatively to different nodes.
+ *
+ * Note that the given node is considered the root of the cursor,
+ * and the cursor cannot walk outside this node.
+ */
+TSTreeCursor ts_tree_cursor_new(TSNode node);
+
+/**
+ * Delete a tree cursor, freeing all of the memory that it used.
+ */
+void ts_tree_cursor_delete(TSTreeCursor *self);
+
+/**
+ * Re-initialize a tree cursor to start at the original node that the cursor was
+ * constructed with.
+ */
+void ts_tree_cursor_reset(TSTreeCursor *self, TSNode node);
+
+/**
+ * Re-initialize a tree cursor to the same position as another cursor.
+ *
+ * Unlike [`ts_tree_cursor_reset`], this will not lose parent information and
+ * allows reusing already created cursors.
+*/
+void ts_tree_cursor_reset_to(TSTreeCursor *dst, const TSTreeCursor *src);
+
+/**
+ * Get the tree cursor's current node.
+ */
+TSNode ts_tree_cursor_current_node(const TSTreeCursor *self);
+
+/**
+ * Get the field name of the tree cursor's current node.
+ *
+ * This returns `NULL` if the current node doesn't have a field.
+ * See also [`ts_node_child_by_field_name`].
+ */
+const char *ts_tree_cursor_current_field_name(const TSTreeCursor *self);
+
+/**
+ * Get the field id of the tree cursor's current node.
+ *
+ * This returns zero if the current node doesn't have a field.
+ * See also [`ts_node_child_by_field_id`], [`ts_language_field_id_for_name`].
+ */
+TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *self);
+
+/**
+ * Move the cursor to the parent of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there was no parent node (the cursor was already on the root node).
+ *
+ * Note that the node the cursor was constructed with is considered the root
+ * of the cursor, and the cursor cannot walk outside this node.
+ */
+bool ts_tree_cursor_goto_parent(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the next sibling of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there was no next sibling node.
+ *
+ * Note that the node the cursor was constructed with is considered the root
+ * of the cursor, and the cursor cannot walk outside this node.
+ */
+bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the previous sibling of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false` if
+ * there was no previous sibling node.
+ *
+ * Note, that this function may be slower than
+ * [`ts_tree_cursor_goto_next_sibling`] due to how node positions are stored. In
+ * the worst case, this will need to iterate through all the children up to the
+ * previous sibling node to recalculate its position. Also note that the node the cursor
+ * was constructed with is considered the root of the cursor, and the cursor cannot
+ * walk outside this node.
+ */
+bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the first child of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false`
+ * if there were no children.
+ */
+bool ts_tree_cursor_goto_first_child(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the last child of its current node.
+ *
+ * This returns `true` if the cursor successfully moved, and returns `false` if
+ * there were no children.
+ *
+ * Note that this function may be slower than [`ts_tree_cursor_goto_first_child`]
+ * because it needs to iterate through all the children to compute the child's
+ * position.
+ */
+bool ts_tree_cursor_goto_last_child(TSTreeCursor *self);
+
+/**
+ * Move the cursor to the node that is the nth descendant of
+ * the original node that the cursor was constructed with, where
+ * zero represents the original node itself.
+ */
+void ts_tree_cursor_goto_descendant(TSTreeCursor *self, uint32_t goal_descendant_index);
+
+/**
+ * Get the index of the cursor's current node out of all of the
+ * descendants of the original node that the cursor was constructed with.
+ */
+uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *self);
+
+/**
+ * Get the depth of the cursor's current node relative to the original
+ * node that the cursor was constructed with.
+ */
+uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *self);
+
+/**
+ * Move the cursor to the first child of its current node that contains or starts after
+ * the given byte offset or point.
+ *
+ * This returns the index of the child node if one was found, and returns -1
+ * if no such child was found.
+ */
+int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte);
+int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point);
+
+TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *cursor);
+
+/*******************/
+/* Section - Query */
+/*******************/
+
+/**
+ * Create a new query from a string containing one or more S-expression
+ * patterns. The query is associated with a particular language, and can
+ * only be run on syntax nodes parsed with that language.
+ *
+ * If all of the given patterns are valid, this returns a [`TSQuery`].
+ * If a pattern is invalid, this returns `NULL`, and provides two pieces
+ * of information about the problem:
+ * 1. The byte offset of the error is written to the `error_offset` parameter.
+ * 2. The type of error is written to the `error_type` parameter.
+ */
+TSQuery *ts_query_new(
+  const TSLanguage *language,
+  const char *source,
+  uint32_t source_len,
+  uint32_t *error_offset,
+  TSQueryError *error_type
+);
+
+/**
+ * Delete a query, freeing all of the memory that it used.
+ */
+void ts_query_delete(TSQuery *self);
+
+/**
+ * Get the number of patterns, captures, or string literals in the query.
+ */
+uint32_t ts_query_pattern_count(const TSQuery *self);
+uint32_t ts_query_capture_count(const TSQuery *self);
+uint32_t ts_query_string_count(const TSQuery *self);
+
+/**
+ * Get the byte offset where the given pattern starts in the query's source.
+ *
+ * This can be useful when combining queries by concatenating their source
+ * code strings.
+ */
+uint32_t ts_query_start_byte_for_pattern(const TSQuery *self, uint32_t pattern_index);
+
+/**
+ * Get the byte offset where the given pattern ends in the query's source.
+ *
+ * This can be useful when combining queries by concatenating their source
+ * code strings.
+ */
+uint32_t ts_query_end_byte_for_pattern(const TSQuery *self, uint32_t pattern_index);
+
+/**
+ * Get all of the predicates for the given pattern in the query.
+ *
+ * The predicates are represented as a single array of steps. There are three
+ * types of steps in this array, which correspond to the three legal values for
+ * the `type` field:
+ * - `TSQueryPredicateStepTypeCapture` - Steps with this type represent names
+ *    of captures. Their `value_id` can be used with the
+ *   [`ts_query_capture_name_for_id`] function to obtain the name of the capture.
+ * - `TSQueryPredicateStepTypeString` - Steps with this type represent literal
+ *    strings. Their `value_id` can be used with the
+ *    [`ts_query_string_value_for_id`] function to obtain their string value.
+ * - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*
+ *    that represent the end of an individual predicate. If a pattern has two
+ *    predicates, then there will be two steps with this `type` in the array.
+ */
+const TSQueryPredicateStep *ts_query_predicates_for_pattern(
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t *step_count
+);
+
+/*
+ * Check if the given pattern in the query has a single root node.
+ */
+bool ts_query_is_pattern_rooted(const TSQuery *self, uint32_t pattern_index);
+
+/*
+ * Check if the given pattern in the query is 'non local'.
+ *
+ * A non-local pattern has multiple root nodes and can match within a
+ * repeating sequence of nodes, as specified by the grammar. Non-local
+ * patterns disable certain optimizations that would otherwise be possible
+ * when executing a query on a specific range of a syntax tree.
+ */
+bool ts_query_is_pattern_non_local(const TSQuery *self, uint32_t pattern_index);
+
+/*
+ * Check if a given pattern is guaranteed to match once a given step is reached.
+ * The step is specified by its byte offset in the query's source code.
+ */
+bool ts_query_is_pattern_guaranteed_at_step(const TSQuery *self, uint32_t byte_offset);
+
+/**
+ * Get the name and length of one of the query's captures, or one of the
+ * query's string literals. Each capture and string is associated with a
+ * numeric id based on the order that it appeared in the query's source.
+ */
+const char *ts_query_capture_name_for_id(
+  const TSQuery *self,
+  uint32_t index,
+  uint32_t *length
+);
+
+/**
+ * Get the quantifier of the query's captures. Each capture is * associated
+ * with a numeric id based on the order that it appeared in the query's source.
+ */
+TSQuantifier ts_query_capture_quantifier_for_id(
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t capture_index
+);
+
+const char *ts_query_string_value_for_id(
+  const TSQuery *self,
+  uint32_t index,
+  uint32_t *length
+);
+
+/**
+ * Disable a certain capture within a query.
+ *
+ * This prevents the capture from being returned in matches, and also avoids
+ * any resource usage associated with recording the capture. Currently, there
+ * is no way to undo this.
+ */
+void ts_query_disable_capture(TSQuery *self, const char *name, uint32_t length);
+
+/**
+ * Disable a certain pattern within a query.
+ *
+ * This prevents the pattern from matching and removes most of the overhead
+ * associated with the pattern. Currently, there is no way to undo this.
+ */
+void ts_query_disable_pattern(TSQuery *self, uint32_t pattern_index);
+
+/**
+ * Create a new cursor for executing a given query.
+ *
+ * The cursor stores the state that is needed to iteratively search
+ * for matches. To use the query cursor, first call [`ts_query_cursor_exec`]
+ * to start running a given query on a given syntax node. Then, there are
+ * two options for consuming the results of the query:
+ * 1. Repeatedly call [`ts_query_cursor_next_match`] to iterate over all of the
+ *    *matches* in the order that they were found. Each match contains the
+ *    index of the pattern that matched, and an array of captures. Because
+ *    multiple patterns can match the same set of nodes, one match may contain
+ *    captures that appear *before* some of the captures from a previous match.
+ * 2. Repeatedly call [`ts_query_cursor_next_capture`] to iterate over all of the
+ *    individual *captures* in the order that they appear. This is useful if
+ *    don't care about which pattern matched, and just want a single ordered
+ *    sequence of captures.
+ *
+ * If you don't care about consuming all of the results, you can stop calling
+ * [`ts_query_cursor_next_match`] or [`ts_query_cursor_next_capture`] at any point.
+ *  You can then start executing another query on another node by calling
+ *  [`ts_query_cursor_exec`] again.
+ */
+TSQueryCursor *ts_query_cursor_new(void);
+
+/**
+ * Delete a query cursor, freeing all of the memory that it used.
+ */
+void ts_query_cursor_delete(TSQueryCursor *self);
+
+/**
+ * Start running a given query on a given node.
+ */
+void ts_query_cursor_exec(TSQueryCursor *self, const TSQuery *query, TSNode node);
+
+/**
+ * Start running a given query on a given node, with some options.
+ */
+void ts_query_cursor_exec_with_options(
+  TSQueryCursor *self,
+  const TSQuery *query,
+  TSNode node,
+  const TSQueryCursorOptions *query_options
+);
+
+/**
+ * Manage the maximum number of in-progress matches allowed by this query
+ * cursor.
+ *
+ * Query cursors have an optional maximum capacity for storing lists of
+ * in-progress captures. If this capacity is exceeded, then the
+ * earliest-starting match will silently be dropped to make room for further
+ * matches. This maximum capacity is optional — by default, query cursors allow
+ * any number of pending matches, dynamically allocating new space for them as
+ * needed as the query is executed.
+ */
+bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *self);
+uint32_t ts_query_cursor_match_limit(const TSQueryCursor *self);
+void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit);
+
+/**
+ * Set the range of bytes in which the query will be executed.
+ *
+ * The query cursor will return matches that intersect with the given point range.
+ * This means that a match may be returned even if some of its captures fall
+ * outside the specified range, as long as at least part of the match
+ * overlaps with the range.
+ *
+ * For example, if a query pattern matches a node that spans a larger area
+ * than the specified range, but part of that node intersects with the range,
+ * the entire match will be returned.
+ *
+ * This will return `false` if the start byte is greater than the end byte, otherwise
+ * it will return `true`.
+ */
+bool ts_query_cursor_set_byte_range(TSQueryCursor *self, uint32_t start_byte, uint32_t end_byte);
+
+/**
+ * Set the range of (row, column) positions in which the query will be executed.
+ *
+ * The query cursor will return matches that intersect with the given point range.
+ * This means that a match may be returned even if some of its captures fall
+ * outside the specified range, as long as at least part of the match
+ * overlaps with the range.
+ *
+ * For example, if a query pattern matches a node that spans a larger area
+ * than the specified range, but part of that node intersects with the range,
+ * the entire match will be returned.
+ *
+ * This will return `false` if the start point is greater than the end point, otherwise
+ * it will return `true`.
+ */
+bool ts_query_cursor_set_point_range(TSQueryCursor *self, TSPoint start_point, TSPoint end_point);
+
+/**
+ * Advance to the next match of the currently running query.
+ *
+ * If there is a match, write it to `*match` and return `true`.
+ * Otherwise, return `false`.
+ */
+bool ts_query_cursor_next_match(TSQueryCursor *self, TSQueryMatch *match);
+void ts_query_cursor_remove_match(TSQueryCursor *self, uint32_t match_id);
+
+/**
+ * Advance to the next capture of the currently running query.
+ *
+ * If there is a capture, write its match to `*match` and its index within
+ * the match's capture list to `*capture_index`. Otherwise, return `false`.
+ */
+bool ts_query_cursor_next_capture(
+  TSQueryCursor *self,
+  TSQueryMatch *match,
+  uint32_t *capture_index
+);
+
+/**
+ * Set the maximum start depth for a query cursor.
+ *
+ * This prevents cursors from exploring children nodes at a certain depth.
+ * Note if a pattern includes many children, then they will still be checked.
+ *
+ * The zero max start depth value can be used as a special behavior and
+ * it helps to destructure a subtree by staying on a node and using captures
+ * for interested parts. Note that the zero max start depth only limit a search
+ * depth for a pattern's root node but other nodes that are parts of the pattern
+ * may be searched at any depth what defined by the pattern structure.
+ *
+ * Set to `UINT32_MAX` to remove the maximum start depth.
+ */
+void ts_query_cursor_set_max_start_depth(TSQueryCursor *self, uint32_t max_start_depth);
+
+/**********************/
+/* Section - Language */
+/**********************/
+
+/**
+ * Get another reference to the given language.
+ */
+const TSLanguage *ts_language_copy(const TSLanguage *self);
+
+/**
+ * Free any dynamically-allocated resources for this language, if
+ * this is the last reference.
+ */
+void ts_language_delete(const TSLanguage *self);
+
+/**
+ * Get the number of distinct node types in the language.
+ */
+uint32_t ts_language_symbol_count(const TSLanguage *self);
+
+/**
+ * Get the number of valid states in this language.
+*/
+uint32_t ts_language_state_count(const TSLanguage *self);
+
+/**
+ * Get the numerical id for the given node type string.
+ */
+TSSymbol ts_language_symbol_for_name(
+  const TSLanguage *self,
+  const char *string,
+  uint32_t length,
+  bool is_named
+);
+
+/**
+ * Get the number of distinct field names in the language.
+ */
+uint32_t ts_language_field_count(const TSLanguage *self);
+
+/**
+ * Get the field name string for the given numerical id.
+ */
+const char *ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id);
+
+/**
+ * Get the numerical id for the given field name string.
+ */
+TSFieldId ts_language_field_id_for_name(const TSLanguage *self, const char *name, uint32_t name_length);
+
+/**
+ * Get a list of all supertype symbols for the language.
+*/
+const TSSymbol *ts_language_supertypes(const TSLanguage *self, uint32_t *length);
+
+/**
+ * Get a list of all subtype symbol ids for a given supertype symbol.
+ *
+ * See [`ts_language_supertypes`] for fetching all supertype symbols.
+ */
+const TSSymbol *ts_language_subtypes(
+  const TSLanguage *self,
+  TSSymbol supertype,
+  uint32_t *length
+);
+
+/**
+ * Get a node type string for the given numerical id.
+ */
+const char *ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol);
+
+/**
+ * Check whether the given node type id belongs to named nodes, anonymous nodes,
+ * or a hidden nodes.
+ *
+ * See also [`ts_node_is_named`]. Hidden nodes are never returned from the API.
+ */
+TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol);
+
+/**
+ * Get the ABI version number for this language. This version number is used
+ * to ensure that languages were generated by a compatible version of
+ * Tree-sitter.
+ *
+ * See also [`ts_parser_set_language`].
+ */
+uint32_t ts_language_abi_version(const TSLanguage *self);
+
+/**
+ * Get the metadata for this language. This information is generated by the
+ * CLI, and relies on the language author providing the correct metadata in
+ * the language's `tree-sitter.json` file.
+ *
+ * See also [`TSMetadata`].
+ */
+const TSLanguageMetadata *ts_language_metadata(const TSLanguage *self);
+
+/**
+ * Get the next parse state. Combine this with lookahead iterators to generate
+ * completion suggestions or valid symbols in error nodes. Use
+ * [`ts_node_grammar_symbol`] for valid symbols.
+*/
+TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state, TSSymbol symbol);
+
+/**
+ * Get the name of this language. This returns `NULL` in older parsers.
+ */
+const char *ts_language_name(const TSLanguage *self);
+
+/********************************/
+/* Section - Lookahead Iterator */
+/********************************/
+
+/**
+ * Create a new lookahead iterator for the given language and parse state.
+ *
+ * This returns `NULL` if state is invalid for the language.
+ *
+ * Repeatedly using [`ts_lookahead_iterator_next`] and
+ * [`ts_lookahead_iterator_current_symbol`] will generate valid symbols in the
+ * given parse state. Newly created lookahead iterators will contain the `ERROR`
+ * symbol.
+ *
+ * Lookahead iterators can be useful to generate suggestions and improve syntax
+ * error diagnostics. To get symbols valid in an ERROR node, use the lookahead
+ * iterator on its first leaf node state. For `MISSING` nodes, a lookahead
+ * iterator created on the previous non-extra leaf node may be appropriate.
+*/
+TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state);
+
+/**
+ * Delete a lookahead iterator freeing all the memory used.
+*/
+void ts_lookahead_iterator_delete(TSLookaheadIterator *self);
+
+/**
+ * Reset the lookahead iterator to another state.
+ *
+ * This returns `true` if the iterator was reset to the given state and `false`
+ * otherwise.
+*/
+bool ts_lookahead_iterator_reset_state(TSLookaheadIterator *self, TSStateId state);
+
+/**
+ * Reset the lookahead iterator.
+ *
+ * This returns `true` if the language was set successfully and `false`
+ * otherwise.
+*/
+bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state);
+
+/**
+ * Get the current language of the lookahead iterator.
+*/
+const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self);
+
+/**
+ * Advance the lookahead iterator to the next symbol.
+ *
+ * This returns `true` if there is a new symbol and `false` otherwise.
+*/
+bool ts_lookahead_iterator_next(TSLookaheadIterator *self);
+
+/**
+ * Get the current symbol of the lookahead iterator;
+*/
+TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self);
+
+/**
+ * Get the current symbol type of the lookahead iterator as a null terminated
+ * string.
+*/
+const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self);
+
+/*************************************/
+/* Section - WebAssembly Integration */
+/************************************/
+
+typedef struct wasm_engine_t TSWasmEngine;
+typedef struct TSWasmStore TSWasmStore;
+
+typedef enum {
+  TSWasmErrorKindNone = 0,
+  TSWasmErrorKindParse,
+  TSWasmErrorKindCompile,
+  TSWasmErrorKindInstantiate,
+  TSWasmErrorKindAllocate,
+} TSWasmErrorKind;
+
+typedef struct {
+  TSWasmErrorKind kind;
+  char *message;
+} TSWasmError;
+
+/**
+ * Create a Wasm store.
+ */
+TSWasmStore *ts_wasm_store_new(
+  TSWasmEngine *engine,
+  TSWasmError *error
+);
+
+/**
+ * Free the memory associated with the given Wasm store.
+ */
+void ts_wasm_store_delete(TSWasmStore *);
+
+/**
+ * Create a language from a buffer of Wasm. The resulting language behaves
+ * like any other Tree-sitter language, except that in order to use it with
+ * a parser, that parser must have a Wasm store. Note that the language
+ * can be used with any Wasm store, it doesn't need to be the same store that
+ * was used to originally load it.
+ */
+const TSLanguage *ts_wasm_store_load_language(
+  TSWasmStore *,
+  const char *name,
+  const char *wasm,
+  uint32_t wasm_len,
+  TSWasmError *error
+);
+
+/**
+ * Get the number of languages instantiated in the given Wasm store.
+ */
+size_t ts_wasm_store_language_count(const TSWasmStore *);
+
+/**
+ * Check if the language came from a Wasm module. If so, then in order to use
+ * this language with a Parser, that parser must have a Wasm store assigned.
+ */
+bool ts_language_is_wasm(const TSLanguage *);
+
+/**
+ * Assign the given Wasm store to the parser. A parser must have a Wasm store
+ * in order to use Wasm languages.
+ */
+void ts_parser_set_wasm_store(TSParser *, TSWasmStore *);
+
+/**
+ * Remove the parser's current Wasm store and return it. This returns NULL if
+ * the parser doesn't have a Wasm store.
+ */
+TSWasmStore *ts_parser_take_wasm_store(TSParser *);
+
+/**********************************/
+/* Section - Global Configuration */
+/**********************************/
+
+/**
+ * Set the allocation functions used by the library.
+ *
+ * By default, Tree-sitter uses the standard libc allocation functions,
+ * but aborts the process when an allocation fails. This function lets
+ * you supply alternative allocation functions at runtime.
+ *
+ * If you pass `NULL` for any parameter, Tree-sitter will switch back to
+ * its default implementation of that function.
+ *
+ * If you call this function after the library has already been used, then
+ * you must ensure that either:
+ *  1. All the existing objects have been freed.
+ *  2. The new allocator shares its state with the old one, so it is capable
+ *     of freeing memory that was allocated by the old allocator.
+ */
+void ts_set_allocator(
+  void *(*new_malloc)(size_t),
+	void *(*new_calloc)(size_t, size_t),
+	void *(*new_realloc)(void *, size_t),
+	void (*new_free)(void *)
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef TREE_SITTER_HIDE_SYMBOLS
+#if defined(__GNUC__) || defined(__clang__)
+# pragma GCC visibility pop
+#endif
+#endif
+
+#endif  // TREE_SITTER_API_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/alloc.c b/src/library/ts/src/tree-sitter/lib/src/alloc.c
new file mode 100644
index 0000000000..e5cb1d5eab
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/alloc.c
@@ -0,0 +1,48 @@
+#include "alloc.h"
+#include "tree_sitter/api.h"
+#include <stdlib.h>
+
+static void *ts_malloc_default(size_t size) {
+  void *result = malloc(size);
+  if (size > 0 && !result) {
+    fprintf(stderr, "tree-sitter failed to allocate %zu bytes", size);
+    abort();
+  }
+  return result;
+}
+
+static void *ts_calloc_default(size_t count, size_t size) {
+  void *result = calloc(count, size);
+  if (count > 0 && !result) {
+    fprintf(stderr, "tree-sitter failed to allocate %zu bytes", count * size);
+    abort();
+  }
+  return result;
+}
+
+static void *ts_realloc_default(void *buffer, size_t size) {
+  void *result = realloc(buffer, size);
+  if (size > 0 && !result) {
+    fprintf(stderr, "tree-sitter failed to reallocate %zu bytes", size);
+    abort();
+  }
+  return result;
+}
+
+// Allow clients to override allocation functions dynamically
+TS_PUBLIC void *(*ts_current_malloc)(size_t) = ts_malloc_default;
+TS_PUBLIC void *(*ts_current_calloc)(size_t, size_t) = ts_calloc_default;
+TS_PUBLIC void *(*ts_current_realloc)(void *, size_t) = ts_realloc_default;
+TS_PUBLIC void (*ts_current_free)(void *) = free;
+
+void ts_set_allocator(
+  void *(*new_malloc)(size_t size),
+  void *(*new_calloc)(size_t count, size_t size),
+  void *(*new_realloc)(void *ptr, size_t size),
+  void (*new_free)(void *ptr)
+) {
+  ts_current_malloc = new_malloc ? new_malloc : ts_malloc_default;
+  ts_current_calloc = new_calloc ? new_calloc : ts_calloc_default;
+  ts_current_realloc = new_realloc ? new_realloc : ts_realloc_default;
+  ts_current_free = new_free ? new_free : free;
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/alloc.h b/src/library/ts/src/tree-sitter/lib/src/alloc.h
new file mode 100644
index 0000000000..a27b8a6334
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/alloc.h
@@ -0,0 +1,41 @@
+#ifndef TREE_SITTER_ALLOC_H_
+#define TREE_SITTER_ALLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(TREE_SITTER_HIDDEN_SYMBOLS) || defined(_WIN32)
+#define TS_PUBLIC
+#else
+#define TS_PUBLIC __attribute__((visibility("default")))
+#endif
+
+TS_PUBLIC extern void *(*ts_current_malloc)(size_t size);
+TS_PUBLIC extern void *(*ts_current_calloc)(size_t count, size_t size);
+TS_PUBLIC extern void *(*ts_current_realloc)(void *ptr, size_t size);
+TS_PUBLIC extern void (*ts_current_free)(void *ptr);
+
+// Allow clients to override allocation functions
+#ifndef ts_malloc
+#define ts_malloc  ts_current_malloc
+#endif
+#ifndef ts_calloc
+#define ts_calloc  ts_current_calloc
+#endif
+#ifndef ts_realloc
+#define ts_realloc ts_current_realloc
+#endif
+#ifndef ts_free
+#define ts_free    ts_current_free
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_SITTER_ALLOC_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/array.h b/src/library/ts/src/tree-sitter/lib/src/array.h
new file mode 100644
index 0000000000..1c767a4757
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/array.h
@@ -0,0 +1,291 @@
+#ifndef TREE_SITTER_ARRAY_H_
+#define TREE_SITTER_ARRAY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./alloc.h"
+#include "./ts_assert.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4101)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#define Array(T)       \
+  struct {             \
+    T *contents;       \
+    uint32_t size;     \
+    uint32_t capacity; \
+  }
+
+/// Initialize an array.
+#define array_init(self) \
+  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
+
+/// Create an empty array.
+#define array_new() \
+  { NULL, 0, 0 }
+
+/// Get a pointer to the element at a given `index` in the array.
+#define array_get(self, _index) \
+  (ts_assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
+
+/// Get a pointer to the first element in the array.
+#define array_front(self) array_get(self, 0)
+
+/// Get a pointer to the last element in the array.
+#define array_back(self) array_get(self, (self)->size - 1)
+
+/// Clear the array, setting its size to zero. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_clear(self) ((self)->size = 0)
+
+/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
+/// less than the array's current capacity, this function has no effect.
+#define array_reserve(self, new_capacity) \
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
+
+/// Free any memory allocated for this array. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_delete(self) _array__delete((Array *)(self))
+
+/// Push a new `element` onto the end of the array.
+#define array_push(self, element)                            \
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
+
+/// Increase the array's size by `count` elements.
+/// New elements are zero-initialized.
+#define array_grow_by(self, count) \
+  do { \
+    if ((count) == 0) break; \
+    _array__grow((Array *)(self), count, array_elem_size(self)); \
+    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
+    (self)->size += (count); \
+  } while (0)
+
+/// Append all elements from one array to the end of another.
+#define array_push_all(self, other)                                       \
+  array_extend((self), (other)->size, (other)->contents)
+
+/// Append `count` elements to the end of the array, reading their values from the
+/// `contents` pointer.
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
+  )
+
+/// Remove `old_count` elements from the array starting at the given `index`. At
+/// the same index, insert `new_count` new elements, reading their values from the
+/// `new_contents` pointer.
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
+  )
+
+/// Insert one `element` into the array at the given `index`.
+#define array_insert(self, _index, element) \
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
+
+/// Remove one element from the array at the given `index`.
+#define array_erase(self, _index) \
+  _array__erase((Array *)(self), array_elem_size(self), _index)
+
+/// Pop the last element off the array, returning the element by value.
+#define array_pop(self) ((self)->contents[--(self)->size])
+
+/// Assign the contents of one array to another, reallocating if necessary.
+#define array_assign(self, other) \
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
+
+/// Swap one array with another
+#define array_swap(self, other) \
+  _array__swap((Array *)(self), (Array *)(other))
+
+/// Get the size of the array contents
+#define array_elem_size(self) (sizeof *(self)->contents)
+
+/// Search a sorted array for a given `needle` value, using the given `compare`
+/// callback to determine the order.
+///
+/// If an existing element is found to be equal to `needle`, then the `index`
+/// out-parameter is set to the existing value's index, and the `exists`
+/// out-parameter is set to true. Otherwise, `index` is set to an index where
+/// `needle` should be inserted in order to preserve the sorting, and `exists`
+/// is set to false.
+#define array_search_sorted_with(self, compare, needle, _index, _exists) \
+  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
+
+/// Search a sorted array for a given `needle` value, using integer comparisons
+/// of a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_with`.
+#define array_search_sorted_by(self, field, needle, _index, _exists) \
+  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
+
+/// Insert a given `value` into a sorted array, using the given `compare`
+/// callback to determine the order.
+#define array_insert_sorted_with(self, compare, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+/// Insert a given `value` into a sorted array, using integer comparisons of
+/// a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_by`.
+#define array_insert_sorted_by(self, field, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+// Private
+
+typedef Array(void) Array;
+
+/// This is not what you're looking for, see `array_delete`.
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
+}
+
+/// This is not what you're looking for, see `array_erase`.
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  ts_assert(index < self->size);
+  char *contents = (char *)self->contents;
+  memmove(contents + index * element_size, contents + (index + 1) * element_size,
+          (self->size - index - 1) * element_size);
+  self->size--;
+}
+
+/// This is not what you're looking for, see `array_reserve`.
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = ts_realloc(self->contents, new_capacity * element_size);
+    } else {
+      self->contents = ts_malloc(new_capacity * element_size);
+    }
+    self->capacity = new_capacity;
+  }
+}
+
+/// This is not what you're looking for, see `array_assign`.
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
+}
+
+/// This is not what you're looking for, see `array_swap`.
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
+}
+
+/// This is not what you're looking for, see `array_push` or `array_grow_by`.
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
+    if (new_capacity < 8) new_capacity = 8;
+    if (new_capacity < new_size) new_capacity = new_size;
+    _array__reserve(self, element_size, new_capacity);
+  }
+}
+
+/// This is not what you're looking for, see `array_splice`.
+static inline void _array__splice(Array *self, size_t element_size,
+                                 uint32_t index, uint32_t old_count,
+                                 uint32_t new_count, const void *elements) {
+  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t old_end = index + old_count;
+  uint32_t new_end = index + new_count;
+  ts_assert(old_end <= self->size);
+
+  _array__reserve(self, element_size, new_size);
+
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
+    memmove(
+      contents + new_end * element_size,
+      contents + old_end * element_size,
+      (self->size - old_end) * element_size
+    );
+  }
+  if (new_count > 0) {
+    if (elements) {
+      memcpy(
+        (contents + index * element_size),
+        elements,
+        new_count * element_size
+      );
+    } else {
+      memset(
+        (contents + index * element_size),
+        0,
+        new_count * element_size
+      );
+    }
+  }
+  self->size += new_count - old_count;
+}
+
+/// A binary search routine, based on Rust's `std::slice::binary_search_by`.
+/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
+#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
+  do { \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
+    if (size == 0) break; \
+    int comparison; \
+    while (size > 1) { \
+      uint32_t half_size = size / 2; \
+      uint32_t mid_index = *(_index) + half_size; \
+      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
+      if (comparison <= 0) *(_index) = mid_index; \
+      size -= half_size; \
+    } \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
+  } while (0)
+
+/// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
+/// parameter by reference in order to work with the generic sorting function above.
+#define _compare_int(a, b) ((int)*(a) - (int)(b))
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic pop
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_ARRAY_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/atomic.h b/src/library/ts/src/tree-sitter/lib/src/atomic.h
new file mode 100644
index 0000000000..e680b60e52
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/atomic.h
@@ -0,0 +1,68 @@
+#ifndef TREE_SITTER_ATOMIC_H_
+#define TREE_SITTER_ATOMIC_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __TINYC__
+
+static inline size_t atomic_load(const volatile size_t *p) {
+  return *p;
+}
+
+static inline uint32_t atomic_inc(volatile uint32_t *p) {
+  *p += 1;
+  return *p;
+}
+
+static inline uint32_t atomic_dec(volatile uint32_t *p) {
+  *p-= 1;
+  return *p;
+}
+
+#elif defined(_WIN32)
+
+#include <windows.h>
+
+static inline size_t atomic_load(const volatile size_t *p) {
+  return *p;
+}
+
+static inline uint32_t atomic_inc(volatile uint32_t *p) {
+  return InterlockedIncrement((long volatile *)p);
+}
+
+static inline uint32_t atomic_dec(volatile uint32_t *p) {
+  return InterlockedDecrement((long volatile *)p);
+}
+
+#else
+
+static inline size_t atomic_load(const volatile size_t *p) {
+#ifdef __ATOMIC_RELAXED
+  return __atomic_load_n(p, __ATOMIC_RELAXED);
+#else
+  return __sync_fetch_and_add((volatile size_t *)p, 0);
+#endif
+}
+
+static inline uint32_t atomic_inc(volatile uint32_t *p) {
+  #ifdef __ATOMIC_RELAXED
+    return __atomic_add_fetch(p, 1U, __ATOMIC_SEQ_CST);
+  #else
+    return __sync_add_and_fetch(p, 1U);
+  #endif
+}
+
+static inline uint32_t atomic_dec(volatile uint32_t *p) {
+  #ifdef __ATOMIC_RELAXED
+    return __atomic_sub_fetch(p, 1U, __ATOMIC_SEQ_CST);
+  #else
+    return __sync_sub_and_fetch(p, 1U);
+  #endif
+}
+
+#endif
+
+#endif  // TREE_SITTER_ATOMIC_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/clock.h b/src/library/ts/src/tree-sitter/lib/src/clock.h
new file mode 100644
index 0000000000..7a13185ec7
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/clock.h
@@ -0,0 +1,146 @@
+#ifndef TREE_SITTER_CLOCK_H_
+#define TREE_SITTER_CLOCK_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef uint64_t TSDuration;
+
+#ifdef _WIN32
+
+// Windows:
+// * Represent a time as a performance counter value.
+// * Represent a duration as a number of performance counter ticks.
+
+#include <windows.h>
+typedef uint64_t TSClock;
+
+static inline TSDuration duration_from_micros(uint64_t micros) {
+  LARGE_INTEGER frequency;
+  QueryPerformanceFrequency(&frequency);
+  return micros * (uint64_t)frequency.QuadPart / 1000000;
+}
+
+static inline uint64_t duration_to_micros(TSDuration self) {
+  LARGE_INTEGER frequency;
+  QueryPerformanceFrequency(&frequency);
+  return self * 1000000 / (uint64_t)frequency.QuadPart;
+}
+
+static inline TSClock clock_null(void) {
+  return 0;
+}
+
+static inline TSClock clock_now(void) {
+  LARGE_INTEGER result;
+  QueryPerformanceCounter(&result);
+  return (uint64_t)result.QuadPart;
+}
+
+static inline TSClock clock_after(TSClock base, TSDuration duration) {
+  return base + duration;
+}
+
+static inline bool clock_is_null(TSClock self) {
+  return !self;
+}
+
+static inline bool clock_is_gt(TSClock self, TSClock other) {
+  return self > other;
+}
+
+#elif defined(CLOCK_MONOTONIC)
+
+// POSIX with monotonic clock support (Linux, macOS)
+// * Represent a time as a monotonic (seconds, nanoseconds) pair.
+// * Represent a duration as a number of microseconds.
+//
+// On these platforms, parse timeouts will correspond accurately to
+// real time, regardless of what other processes are running.
+
+#include <time.h>
+typedef struct timespec TSClock;
+
+static inline TSDuration duration_from_micros(uint64_t micros) {
+  return micros;
+}
+
+static inline uint64_t duration_to_micros(TSDuration self) {
+  return self;
+}
+
+static inline TSClock clock_now(void) {
+  TSClock result;
+  clock_gettime(CLOCK_MONOTONIC, &result);
+  return result;
+}
+
+static inline TSClock clock_null(void) {
+  return (TSClock) {0, 0};
+}
+
+static inline TSClock clock_after(TSClock base, TSDuration duration) {
+  TSClock result = base;
+  result.tv_sec += duration / 1000000;
+  result.tv_nsec += (duration % 1000000) * 1000;
+  if (result.tv_nsec >= 1000000000) {
+    result.tv_nsec -= 1000000000;
+    ++(result.tv_sec);
+  }
+  return result;
+}
+
+static inline bool clock_is_null(TSClock self) {
+  return !self.tv_sec && !self.tv_nsec;
+}
+
+static inline bool clock_is_gt(TSClock self, TSClock other) {
+  if (self.tv_sec > other.tv_sec) return true;
+  if (self.tv_sec < other.tv_sec) return false;
+  return self.tv_nsec > other.tv_nsec;
+}
+
+#else
+
+// POSIX without monotonic clock support
+// * Represent a time as a process clock value.
+// * Represent a duration as a number of process clock ticks.
+//
+// On these platforms, parse timeouts may be affected by other processes,
+// which is not ideal, but is better than using a non-monotonic time API
+// like `gettimeofday`.
+
+#include <time.h>
+typedef uint64_t TSClock;
+
+static inline TSDuration duration_from_micros(uint64_t micros) {
+  return micros * (uint64_t)CLOCKS_PER_SEC / 1000000;
+}
+
+static inline uint64_t duration_to_micros(TSDuration self) {
+  return self * 1000000 / (uint64_t)CLOCKS_PER_SEC;
+}
+
+static inline TSClock clock_null(void) {
+  return 0;
+}
+
+static inline TSClock clock_now(void) {
+  return (uint64_t)clock();
+}
+
+static inline TSClock clock_after(TSClock base, TSDuration duration) {
+  return base + duration;
+}
+
+static inline bool clock_is_null(TSClock self) {
+  return !self;
+}
+
+static inline bool clock_is_gt(TSClock self, TSClock other) {
+  return self > other;
+}
+
+#endif
+
+#endif  // TREE_SITTER_CLOCK_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/error_costs.h b/src/library/ts/src/tree-sitter/lib/src/error_costs.h
new file mode 100644
index 0000000000..32d3666a66
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/error_costs.h
@@ -0,0 +1,11 @@
+#ifndef TREE_SITTER_ERROR_COSTS_H_
+#define TREE_SITTER_ERROR_COSTS_H_
+
+#define ERROR_STATE 0
+#define ERROR_COST_PER_RECOVERY 500
+#define ERROR_COST_PER_MISSING_TREE 110
+#define ERROR_COST_PER_SKIPPED_TREE 100
+#define ERROR_COST_PER_SKIPPED_LINE 30
+#define ERROR_COST_PER_SKIPPED_CHAR 1
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.c b/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.c
new file mode 100644
index 0000000000..c4c63653d5
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.c
@@ -0,0 +1,557 @@
+#include "./get_changed_ranges.h"
+#include "./subtree.h"
+#include "./language.h"
+#include "./error_costs.h"
+#include "./tree_cursor.h"
+#include "./ts_assert.h"
+
+// #define DEBUG_GET_CHANGED_RANGES
+
+static void ts_range_array_add(
+  TSRangeArray *self,
+  Length start,
+  Length end
+) {
+  if (self->size > 0) {
+    TSRange *last_range = array_back(self);
+    if (start.bytes <= last_range->end_byte) {
+      last_range->end_byte = end.bytes;
+      last_range->end_point = end.extent;
+      return;
+    }
+  }
+
+  if (start.bytes < end.bytes) {
+    TSRange range = { start.extent, end.extent, start.bytes, end.bytes };
+    array_push(self, range);
+  }
+}
+
+bool ts_range_array_intersects(
+  const TSRangeArray *self,
+  unsigned start_index,
+  uint32_t start_byte,
+  uint32_t end_byte
+) {
+  for (unsigned i = start_index; i < self->size; i++) {
+    TSRange *range = array_get(self, i);
+    if (range->end_byte > start_byte) {
+      if (range->start_byte >= end_byte) break;
+      return true;
+    }
+  }
+  return false;
+}
+
+void ts_range_array_get_changed_ranges(
+  const TSRange *old_ranges, unsigned old_range_count,
+  const TSRange *new_ranges, unsigned new_range_count,
+  TSRangeArray *differences
+) {
+  unsigned new_index = 0;
+  unsigned old_index = 0;
+  Length current_position = length_zero();
+  bool in_old_range = false;
+  bool in_new_range = false;
+
+  while (old_index < old_range_count || new_index < new_range_count) {
+    const TSRange *old_range = &old_ranges[old_index];
+    const TSRange *new_range = &new_ranges[new_index];
+
+    Length next_old_position;
+    if (in_old_range) {
+      next_old_position = (Length) {old_range->end_byte, old_range->end_point};
+    } else if (old_index < old_range_count) {
+      next_old_position = (Length) {old_range->start_byte, old_range->start_point};
+    } else {
+      next_old_position = LENGTH_MAX;
+    }
+
+    Length next_new_position;
+    if (in_new_range) {
+      next_new_position = (Length) {new_range->end_byte, new_range->end_point};
+    } else if (new_index < new_range_count) {
+      next_new_position = (Length) {new_range->start_byte, new_range->start_point};
+    } else {
+      next_new_position = LENGTH_MAX;
+    }
+
+    if (next_old_position.bytes < next_new_position.bytes) {
+      if (in_old_range != in_new_range) {
+        ts_range_array_add(differences, current_position, next_old_position);
+      }
+      if (in_old_range) old_index++;
+      current_position = next_old_position;
+      in_old_range = !in_old_range;
+    } else if (next_new_position.bytes < next_old_position.bytes) {
+      if (in_old_range != in_new_range) {
+        ts_range_array_add(differences, current_position, next_new_position);
+      }
+      if (in_new_range) new_index++;
+      current_position = next_new_position;
+      in_new_range = !in_new_range;
+    } else {
+      if (in_old_range != in_new_range) {
+        ts_range_array_add(differences, current_position, next_new_position);
+      }
+      if (in_old_range) old_index++;
+      if (in_new_range) new_index++;
+      in_old_range = !in_old_range;
+      in_new_range = !in_new_range;
+      current_position = next_new_position;
+    }
+  }
+}
+
+void ts_range_edit(TSRange *range, const TSInputEdit *edit) {
+  if (range->end_byte >= edit->old_end_byte) {
+    if (range->end_byte != UINT32_MAX) {
+      range->end_byte = edit->new_end_byte + (range->end_byte - edit->old_end_byte);
+      range->end_point = point_add(
+        edit->new_end_point,
+        point_sub(range->end_point, edit->old_end_point)
+      );
+      if (range->end_byte < edit->new_end_byte) {
+        range->end_byte = UINT32_MAX;
+        range->end_point = POINT_MAX;
+      }
+    }
+  } else if (range->end_byte > edit->start_byte) {
+    range->end_byte = edit->start_byte;
+    range->end_point = edit->start_point;
+  }
+
+  if (range->start_byte >= edit->old_end_byte) {
+    range->start_byte = edit->new_end_byte + (range->start_byte - edit->old_end_byte);
+    range->start_point = point_add(
+      edit->new_end_point,
+      point_sub(range->start_point, edit->old_end_point)
+    );
+    if (range->start_byte < edit->new_end_byte) {
+      range->start_byte = UINT32_MAX;
+      range->start_point = POINT_MAX;
+    }
+  } else if (range->start_byte > edit->start_byte) {
+    range->start_byte = edit->start_byte;
+    range->start_point = edit->start_point;
+  }
+}
+
+typedef struct {
+  TreeCursor cursor;
+  const TSLanguage *language;
+  unsigned visible_depth;
+  bool in_padding;
+  Subtree prev_external_token;
+} Iterator;
+
+static Iterator iterator_new(
+  TreeCursor *cursor,
+  const Subtree *tree,
+  const TSLanguage *language
+) {
+  array_clear(&cursor->stack);
+  array_push(&cursor->stack, ((TreeCursorEntry) {
+    .subtree = tree,
+    .position = length_zero(),
+    .child_index = 0,
+    .structural_child_index = 0,
+  }));
+  return (Iterator) {
+    .cursor = *cursor,
+    .language = language,
+    .visible_depth = 1,
+    .in_padding = false,
+    .prev_external_token = NULL_SUBTREE,
+  };
+}
+
+static bool iterator_done(Iterator *self) {
+  return self->cursor.stack.size == 0;
+}
+
+static Length iterator_start_position(Iterator *self) {
+  TreeCursorEntry entry = *array_back(&self->cursor.stack);
+  if (self->in_padding) {
+    return entry.position;
+  } else {
+    return length_add(entry.position, ts_subtree_padding(*entry.subtree));
+  }
+}
+
+static Length iterator_end_position(Iterator *self) {
+  TreeCursorEntry entry = *array_back(&self->cursor.stack);
+  Length result = length_add(entry.position, ts_subtree_padding(*entry.subtree));
+  if (self->in_padding) {
+    return result;
+  } else {
+    return length_add(result, ts_subtree_size(*entry.subtree));
+  }
+}
+
+static bool iterator_tree_is_visible(const Iterator *self) {
+  TreeCursorEntry entry = *array_back(&self->cursor.stack);
+  if (ts_subtree_visible(*entry.subtree)) return true;
+  if (self->cursor.stack.size > 1) {
+    Subtree parent = *array_get(&self->cursor.stack, self->cursor.stack.size - 2)->subtree;
+    return ts_language_alias_at(
+      self->language,
+      parent.ptr->production_id,
+      entry.structural_child_index
+    ) != 0;
+  }
+  return false;
+}
+
+static void iterator_get_visible_state(
+  const Iterator *self,
+  Subtree *tree,
+  TSSymbol *alias_symbol,
+  uint32_t *start_byte
+) {
+  uint32_t i = self->cursor.stack.size - 1;
+
+  if (self->in_padding) {
+    if (i == 0) return;
+    i--;
+  }
+
+  for (; i + 1 > 0; i--) {
+    TreeCursorEntry entry = *array_get(&self->cursor.stack, i);
+
+    if (i > 0) {
+      const Subtree *parent = array_get(&self->cursor.stack, i - 1)->subtree;
+      *alias_symbol = ts_language_alias_at(
+        self->language,
+        parent->ptr->production_id,
+        entry.structural_child_index
+      );
+    }
+
+    if (ts_subtree_visible(*entry.subtree) || *alias_symbol) {
+      *tree = *entry.subtree;
+      *start_byte = entry.position.bytes;
+      break;
+    }
+  }
+}
+
+static void iterator_ascend(Iterator *self) {
+  if (iterator_done(self)) return;
+  if (iterator_tree_is_visible(self) && !self->in_padding) self->visible_depth--;
+  if (array_back(&self->cursor.stack)->child_index > 0) self->in_padding = false;
+  self->cursor.stack.size--;
+}
+
+static bool iterator_descend(Iterator *self, uint32_t goal_position) {
+  if (self->in_padding) return false;
+
+  bool did_descend = false;
+  do {
+    did_descend = false;
+    TreeCursorEntry entry = *array_back(&self->cursor.stack);
+    Length position = entry.position;
+    uint32_t structural_child_index = 0;
+    for (uint32_t i = 0, n = ts_subtree_child_count(*entry.subtree); i < n; i++) {
+      const Subtree *child = &ts_subtree_children(*entry.subtree)[i];
+      Length child_left = length_add(position, ts_subtree_padding(*child));
+      Length child_right = length_add(child_left, ts_subtree_size(*child));
+
+      if (child_right.bytes > goal_position) {
+        array_push(&self->cursor.stack, ((TreeCursorEntry) {
+          .subtree = child,
+          .position = position,
+          .child_index = i,
+          .structural_child_index = structural_child_index,
+        }));
+
+        if (iterator_tree_is_visible(self)) {
+          if (child_left.bytes > goal_position) {
+            self->in_padding = true;
+          } else {
+            self->visible_depth++;
+          }
+          return true;
+        }
+
+        did_descend = true;
+        break;
+      }
+
+      position = child_right;
+      if (!ts_subtree_extra(*child)) structural_child_index++;
+      Subtree last_external_token = ts_subtree_last_external_token(*child);
+      if (last_external_token.ptr) {
+        self->prev_external_token = last_external_token;
+      }
+    }
+  } while (did_descend);
+
+  return false;
+}
+
+static void iterator_advance(Iterator *self) {
+  if (self->in_padding) {
+    self->in_padding = false;
+    if (iterator_tree_is_visible(self)) {
+      self->visible_depth++;
+    } else {
+      iterator_descend(self, 0);
+    }
+    return;
+  }
+
+  for (;;) {
+    if (iterator_tree_is_visible(self)) self->visible_depth--;
+    TreeCursorEntry entry = array_pop(&self->cursor.stack);
+    if (iterator_done(self)) return;
+
+    const Subtree *parent = array_back(&self->cursor.stack)->subtree;
+    uint32_t child_index = entry.child_index + 1;
+    Subtree last_external_token = ts_subtree_last_external_token(*entry.subtree);
+    if (last_external_token.ptr) {
+      self->prev_external_token = last_external_token;
+    }
+    if (ts_subtree_child_count(*parent) > child_index) {
+      Length position = length_add(entry.position, ts_subtree_total_size(*entry.subtree));
+      uint32_t structural_child_index = entry.structural_child_index;
+      if (!ts_subtree_extra(*entry.subtree)) structural_child_index++;
+      const Subtree *next_child = &ts_subtree_children(*parent)[child_index];
+
+      array_push(&self->cursor.stack, ((TreeCursorEntry) {
+        .subtree = next_child,
+        .position = position,
+        .child_index = child_index,
+        .structural_child_index = structural_child_index,
+      }));
+
+      if (iterator_tree_is_visible(self)) {
+        if (ts_subtree_padding(*next_child).bytes > 0) {
+          self->in_padding = true;
+        } else {
+          self->visible_depth++;
+        }
+      } else {
+        iterator_descend(self, 0);
+      }
+      break;
+    }
+  }
+}
+
+typedef enum {
+  IteratorDiffers,
+  IteratorMayDiffer,
+  IteratorMatches,
+} IteratorComparison;
+
+static IteratorComparison iterator_compare(
+  const Iterator *old_iter,
+  const Iterator *new_iter
+) {
+  Subtree old_tree = NULL_SUBTREE;
+  Subtree new_tree = NULL_SUBTREE;
+  uint32_t old_start = 0;
+  uint32_t new_start = 0;
+  TSSymbol old_alias_symbol = 0;
+  TSSymbol new_alias_symbol = 0;
+  iterator_get_visible_state(old_iter, &old_tree, &old_alias_symbol, &old_start);
+  iterator_get_visible_state(new_iter, &new_tree, &new_alias_symbol, &new_start);
+  TSSymbol old_symbol = ts_subtree_symbol(old_tree);
+  TSSymbol new_symbol = ts_subtree_symbol(new_tree);
+
+  if (!old_tree.ptr && !new_tree.ptr) return IteratorMatches;
+  if (!old_tree.ptr || !new_tree.ptr) return IteratorDiffers;
+  if (old_alias_symbol != new_alias_symbol || old_symbol != new_symbol) return IteratorDiffers;
+
+  uint32_t old_size = ts_subtree_size(old_tree).bytes;
+  uint32_t new_size = ts_subtree_size(new_tree).bytes;
+  TSStateId old_state = ts_subtree_parse_state(old_tree);
+  TSStateId new_state = ts_subtree_parse_state(new_tree);
+  bool old_has_external_tokens = ts_subtree_has_external_tokens(old_tree);
+  bool new_has_external_tokens = ts_subtree_has_external_tokens(new_tree);
+  uint32_t old_error_cost = ts_subtree_error_cost(old_tree);
+  uint32_t new_error_cost = ts_subtree_error_cost(new_tree);
+
+  if (
+    old_start != new_start ||
+    old_symbol == ts_builtin_sym_error ||
+    old_size != new_size ||
+    old_state == TS_TREE_STATE_NONE ||
+    new_state == TS_TREE_STATE_NONE ||
+    ((old_state == ERROR_STATE) != (new_state == ERROR_STATE)) ||
+    old_error_cost != new_error_cost ||
+    old_has_external_tokens != new_has_external_tokens ||
+    ts_subtree_has_changes(old_tree) ||
+    (
+      old_has_external_tokens &&
+      !ts_subtree_external_scanner_state_eq(old_iter->prev_external_token, new_iter->prev_external_token)
+    )
+  ) {
+    return IteratorMayDiffer;
+  }
+
+  return IteratorMatches;
+}
+
+#ifdef DEBUG_GET_CHANGED_RANGES
+static inline void iterator_print_state(Iterator *self) {
+  TreeCursorEntry entry = *array_back(&self->cursor.stack);
+  TSPoint start = iterator_start_position(self).extent;
+  TSPoint end = iterator_end_position(self).extent;
+  const char *name = ts_language_symbol_name(self->language, ts_subtree_symbol(*entry.subtree));
+  printf(
+    "(%-25s %s\t depth:%u [%u, %u] - [%u, %u])",
+    name, self->in_padding ? "(p)" : "   ",
+    self->visible_depth,
+    start.row, start.column,
+    end.row, end.column
+  );
+}
+#endif
+
+unsigned ts_subtree_get_changed_ranges(
+  const Subtree *old_tree, const Subtree *new_tree,
+  TreeCursor *cursor1, TreeCursor *cursor2,
+  const TSLanguage *language,
+  const TSRangeArray *included_range_differences,
+  TSRange **ranges
+) {
+  TSRangeArray results = array_new();
+
+  Iterator old_iter = iterator_new(cursor1, old_tree, language);
+  Iterator new_iter = iterator_new(cursor2, new_tree, language);
+
+  unsigned included_range_difference_index = 0;
+
+  Length position = iterator_start_position(&old_iter);
+  Length next_position = iterator_start_position(&new_iter);
+  if (position.bytes < next_position.bytes) {
+    ts_range_array_add(&results, position, next_position);
+    position = next_position;
+  } else if (position.bytes > next_position.bytes) {
+    ts_range_array_add(&results, next_position, position);
+    next_position = position;
+  }
+
+  do {
+    #ifdef DEBUG_GET_CHANGED_RANGES
+    printf("At [%-2u, %-2u] Compare ", position.extent.row, position.extent.column);
+    iterator_print_state(&old_iter);
+    printf("\tvs\t");
+    iterator_print_state(&new_iter);
+    puts("");
+    #endif
+
+    // Compare the old and new subtrees.
+    IteratorComparison comparison = iterator_compare(&old_iter, &new_iter);
+
+    // Even if the two subtrees appear to be identical, they could differ
+    // internally if they contain a range of text that was previously
+    // excluded from the parse, and is now included, or vice-versa.
+    if (comparison == IteratorMatches && ts_range_array_intersects(
+      included_range_differences,
+      included_range_difference_index,
+      position.bytes,
+      iterator_end_position(&old_iter).bytes
+    )) {
+      comparison = IteratorMayDiffer;
+    }
+
+    bool is_changed = false;
+    switch (comparison) {
+      // If the subtrees are definitely identical, move to the end
+      // of both subtrees.
+      case IteratorMatches:
+        next_position = iterator_end_position(&old_iter);
+        break;
+
+      // If the subtrees might differ internally, descend into both
+      // subtrees, finding the first child that spans the current position.
+      case IteratorMayDiffer:
+        if (iterator_descend(&old_iter, position.bytes)) {
+          if (!iterator_descend(&new_iter, position.bytes)) {
+            is_changed = true;
+            next_position = iterator_end_position(&old_iter);
+          }
+        } else if (iterator_descend(&new_iter, position.bytes)) {
+          is_changed = true;
+          next_position = iterator_end_position(&new_iter);
+        } else {
+          next_position = length_min(
+            iterator_end_position(&old_iter),
+            iterator_end_position(&new_iter)
+          );
+        }
+        break;
+
+      // If the subtrees are different, record a change and then move
+      // to the end of both subtrees.
+      case IteratorDiffers:
+        is_changed = true;
+        next_position = length_min(
+          iterator_end_position(&old_iter),
+          iterator_end_position(&new_iter)
+        );
+        break;
+    }
+
+    // Ensure that both iterators are caught up to the current position.
+    while (
+      !iterator_done(&old_iter) &&
+      iterator_end_position(&old_iter).bytes <= next_position.bytes
+    ) iterator_advance(&old_iter);
+    while (
+      !iterator_done(&new_iter) &&
+      iterator_end_position(&new_iter).bytes <= next_position.bytes
+    ) iterator_advance(&new_iter);
+
+    // Ensure that both iterators are at the same depth in the tree.
+    while (old_iter.visible_depth > new_iter.visible_depth) {
+      iterator_ascend(&old_iter);
+    }
+    while (new_iter.visible_depth > old_iter.visible_depth) {
+      iterator_ascend(&new_iter);
+    }
+
+    if (is_changed) {
+      #ifdef DEBUG_GET_CHANGED_RANGES
+      printf(
+        "  change: [[%u, %u] - [%u, %u]]\n",
+        position.extent.row + 1, position.extent.column,
+        next_position.extent.row + 1, next_position.extent.column
+      );
+      #endif
+
+      ts_range_array_add(&results, position, next_position);
+    }
+
+    position = next_position;
+
+    // Keep track of the current position in the included range differences
+    // array in order to avoid scanning the entire array on each iteration.
+    while (included_range_difference_index < included_range_differences->size) {
+      const TSRange *range = array_get(included_range_differences,
+        included_range_difference_index
+      );
+      if (range->end_byte <= position.bytes) {
+        included_range_difference_index++;
+      } else {
+        break;
+      }
+    }
+  } while (!iterator_done(&old_iter) && !iterator_done(&new_iter));
+
+  Length old_size = ts_subtree_total_size(*old_tree);
+  Length new_size = ts_subtree_total_size(*new_tree);
+  if (old_size.bytes < new_size.bytes) {
+    ts_range_array_add(&results, old_size, new_size);
+  } else if (new_size.bytes < old_size.bytes) {
+    ts_range_array_add(&results, new_size, old_size);
+  }
+
+  *cursor1 = old_iter.cursor;
+  *cursor2 = new_iter.cursor;
+  *ranges = results.contents;
+  return results.size;
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.h b/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.h
new file mode 100644
index 0000000000..a1f1dbb430
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/get_changed_ranges.h
@@ -0,0 +1,36 @@
+#ifndef TREE_SITTER_GET_CHANGED_RANGES_H_
+#define TREE_SITTER_GET_CHANGED_RANGES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./tree_cursor.h"
+#include "./subtree.h"
+
+typedef Array(TSRange) TSRangeArray;
+
+void ts_range_array_get_changed_ranges(
+  const TSRange *old_ranges, unsigned old_range_count,
+  const TSRange *new_ranges, unsigned new_range_count,
+  TSRangeArray *differences
+);
+
+bool ts_range_array_intersects(
+  const TSRangeArray *self, unsigned start_index,
+  uint32_t start_byte, uint32_t end_byte
+);
+
+unsigned ts_subtree_get_changed_ranges(
+  const Subtree *old_tree, const Subtree *new_tree,
+  TreeCursor *cursor1, TreeCursor *cursor2,
+  const TSLanguage *language,
+  const TSRangeArray *included_range_differences,
+  TSRange **ranges
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_GET_CHANGED_RANGES_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/host.h b/src/library/ts/src/tree-sitter/lib/src/host.h
new file mode 100644
index 0000000000..a07e9f8949
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/host.h
@@ -0,0 +1,21 @@
+
+// Determine endian and pointer size based on known defines.
+// TS_BIG_ENDIAN and TS_PTR_SIZE can be set as -D compiler arguments
+// to override this.
+
+#if !defined(TS_BIG_ENDIAN)
+#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
+  || (defined( __APPLE_CC__) && (defined(__ppc__) || defined(__ppc64__)))
+#define TS_BIG_ENDIAN 1
+#else
+#define TS_BIG_ENDIAN 0
+#endif
+#endif
+
+#if !defined(TS_PTR_SIZE)
+#if UINTPTR_MAX == 0xFFFFFFFF
+#define TS_PTR_SIZE 32
+#else
+#define TS_PTR_SIZE 64
+#endif
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/language.c b/src/library/ts/src/tree-sitter/lib/src/language.c
new file mode 100644
index 0000000000..de5e1f9105
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/language.c
@@ -0,0 +1,289 @@
+#include "./language.h"
+#include "./wasm_store.h"
+#include "tree_sitter/api.h"
+#include <string.h>
+
+const TSLanguage *ts_language_copy(const TSLanguage *self) {
+  if (self && ts_language_is_wasm(self)) {
+    ts_wasm_language_retain(self);
+  }
+  return self;
+}
+
+void ts_language_delete(const TSLanguage *self) {
+  if (self && ts_language_is_wasm(self)) {
+    ts_wasm_language_release(self);
+  }
+}
+
+uint32_t ts_language_symbol_count(const TSLanguage *self) {
+  return self->symbol_count + self->alias_count;
+}
+
+uint32_t ts_language_state_count(const TSLanguage *self) {
+  return self->state_count;
+}
+
+const TSSymbol *ts_language_supertypes(const TSLanguage *self, uint32_t *length) {
+  if (self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS) {
+    *length = self->supertype_count;
+    return self->supertype_symbols;
+  } else {
+    *length = 0;
+    return NULL;
+  }
+}
+
+const TSSymbol *ts_language_subtypes(
+  const TSLanguage *self,
+  TSSymbol supertype,
+  uint32_t *length
+) {
+  if (self->abi_version < LANGUAGE_VERSION_WITH_RESERVED_WORDS || !ts_language_symbol_metadata(self, supertype).supertype) {
+    *length = 0;
+    return NULL;
+  }
+
+  TSMapSlice slice = self->supertype_map_slices[supertype];
+  *length = slice.length;
+  return &self->supertype_map_entries[slice.index];
+}
+
+uint32_t ts_language_abi_version(const TSLanguage *self) {
+  return self->abi_version;
+}
+
+const TSLanguageMetadata *ts_language_metadata(const TSLanguage *self) {
+    return self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS ? &self->metadata : NULL;
+}
+
+const char *ts_language_name(const TSLanguage *self) {
+  return self->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS ? self->name : NULL;
+}
+
+uint32_t ts_language_field_count(const TSLanguage *self) {
+  return self->field_count;
+}
+
+void ts_language_table_entry(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol,
+  TableEntry *result
+) {
+  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
+    result->action_count = 0;
+    result->is_reusable = false;
+    result->actions = NULL;
+  } else {
+    ts_assert(symbol < self->token_count);
+    uint32_t action_index = ts_language_lookup(self, state, symbol);
+    const TSParseActionEntry *entry = &self->parse_actions[action_index];
+    result->action_count = entry->entry.count;
+    result->is_reusable = entry->entry.reusable;
+    result->actions = (const TSParseAction *)(entry + 1);
+  }
+}
+
+TSLexerMode ts_language_lex_mode_for_state(
+   const TSLanguage *self,
+   TSStateId state
+) {
+  if (self->abi_version < 15) {
+    TSLexMode mode = ((const TSLexMode *)self->lex_modes)[state];
+    return (TSLexerMode) {
+      .lex_state = mode.lex_state,
+      .external_lex_state = mode.external_lex_state,
+      .reserved_word_set_id = 0,
+    };
+  } else {
+    return self->lex_modes[state];
+  }
+}
+
+bool ts_language_is_reserved_word(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  TSLexerMode lex_mode = ts_language_lex_mode_for_state(self, state);
+  if (lex_mode.reserved_word_set_id > 0) {
+    unsigned start = lex_mode.reserved_word_set_id * self->max_reserved_word_set_size;
+    unsigned end = start + self->max_reserved_word_set_size;
+    for (unsigned i = start; i < end; i++) {
+      if (self->reserved_words[i] == symbol) return true;
+      if (self->reserved_words[i] == 0) break;
+    }
+  }
+  return false;
+}
+
+TSSymbolMetadata ts_language_symbol_metadata(
+  const TSLanguage *self,
+  TSSymbol symbol
+) {
+  if (symbol == ts_builtin_sym_error)  {
+    return (TSSymbolMetadata) {.visible = true, .named = true};
+  } else if (symbol == ts_builtin_sym_error_repeat) {
+    return (TSSymbolMetadata) {.visible = false, .named = false};
+  } else {
+    return self->symbol_metadata[symbol];
+  }
+}
+
+TSSymbol ts_language_public_symbol(
+  const TSLanguage *self,
+  TSSymbol symbol
+) {
+  if (symbol == ts_builtin_sym_error) return symbol;
+  return self->public_symbol_map[symbol];
+}
+
+TSStateId ts_language_next_state(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
+    return 0;
+  } else if (symbol < self->token_count) {
+    uint32_t count;
+    const TSParseAction *actions = ts_language_actions(self, state, symbol, &count);
+    if (count > 0) {
+      TSParseAction action = actions[count - 1];
+      if (action.type == TSParseActionTypeShift) {
+        return action.shift.extra ? state : action.shift.state;
+      }
+    }
+    return 0;
+  } else {
+    return ts_language_lookup(self, state, symbol);
+  }
+}
+
+const char *ts_language_symbol_name(
+  const TSLanguage *self,
+  TSSymbol symbol
+) {
+  if (symbol == ts_builtin_sym_error) {
+    return "ERROR";
+  } else if (symbol == ts_builtin_sym_error_repeat) {
+    return "_ERROR";
+  } else if (symbol < ts_language_symbol_count(self)) {
+    return self->symbol_names[symbol];
+  } else {
+    return NULL;
+  }
+}
+
+TSSymbol ts_language_symbol_for_name(
+  const TSLanguage *self,
+  const char *string,
+  uint32_t length,
+  bool is_named
+) {
+  if (is_named && !strncmp(string, "ERROR", length)) return ts_builtin_sym_error;
+  uint16_t count = (uint16_t)ts_language_symbol_count(self);
+  for (TSSymbol i = 0; i < count; i++) {
+    TSSymbolMetadata metadata = ts_language_symbol_metadata(self, i);
+    if ((!metadata.visible && !metadata.supertype) || metadata.named != is_named) continue;
+    const char *symbol_name = self->symbol_names[i];
+    if (!strncmp(symbol_name, string, length) && !symbol_name[length]) {
+      return self->public_symbol_map[i];
+    }
+  }
+  return 0;
+}
+
+TSSymbolType ts_language_symbol_type(
+  const TSLanguage *self,
+  TSSymbol symbol
+) {
+  TSSymbolMetadata metadata = ts_language_symbol_metadata(self, symbol);
+  if (metadata.named && metadata.visible) {
+    return TSSymbolTypeRegular;
+  } else if (metadata.visible) {
+    return TSSymbolTypeAnonymous;
+  } else if (metadata.supertype) {
+    return TSSymbolTypeSupertype;
+  } else {
+    return TSSymbolTypeAuxiliary;
+  }
+}
+
+const char *ts_language_field_name_for_id(
+  const TSLanguage *self,
+  TSFieldId id
+) {
+  uint32_t count = ts_language_field_count(self);
+  if (count && id <= count) {
+    return self->field_names[id];
+  } else {
+    return NULL;
+  }
+}
+
+TSFieldId ts_language_field_id_for_name(
+  const TSLanguage *self,
+  const char *name,
+  uint32_t name_length
+) {
+  uint16_t count = (uint16_t)ts_language_field_count(self);
+  for (TSSymbol i = 1; i < count + 1; i++) {
+    switch (strncmp(name, self->field_names[i], name_length)) {
+      case 0:
+        if (self->field_names[i][name_length] == 0) return i;
+        break;
+      case -1:
+        return 0;
+      default:
+        break;
+    }
+  }
+  return 0;
+}
+
+TSLookaheadIterator *ts_lookahead_iterator_new(const TSLanguage *self, TSStateId state) {
+  if (state >= self->state_count) return NULL;
+  LookaheadIterator *iterator = ts_malloc(sizeof(LookaheadIterator));
+  *iterator = ts_language_lookaheads(self, state);
+  return (TSLookaheadIterator *)iterator;
+}
+
+void ts_lookahead_iterator_delete(TSLookaheadIterator *self) {
+  ts_free(self);
+}
+
+bool ts_lookahead_iterator_reset_state(TSLookaheadIterator * self, TSStateId state) {
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  if (state >= iterator->language->state_count) return false;
+  *iterator = ts_language_lookaheads(iterator->language, state);
+  return true;
+}
+
+const TSLanguage *ts_lookahead_iterator_language(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return iterator->language;
+}
+
+bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const TSLanguage *language, TSStateId state) {
+  if (state >= language->state_count) return false;
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  *iterator = ts_language_lookaheads(language, state);
+  return true;
+}
+
+bool ts_lookahead_iterator_next(TSLookaheadIterator *self) {
+  LookaheadIterator *iterator = (LookaheadIterator *)self;
+  return ts_lookahead_iterator__next(iterator);
+}
+
+TSSymbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return iterator->symbol;
+}
+
+const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) {
+  const LookaheadIterator *iterator = (const LookaheadIterator *)self;
+  return ts_language_symbol_name(iterator->language, iterator->symbol);
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/language.h b/src/library/ts/src/tree-sitter/lib/src/language.h
new file mode 100644
index 0000000000..518c06bfc5
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/language.h
@@ -0,0 +1,293 @@
+#ifndef TREE_SITTER_LANGUAGE_H_
+#define TREE_SITTER_LANGUAGE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./subtree.h"
+#include "./parser.h"
+
+#define ts_builtin_sym_error_repeat (ts_builtin_sym_error - 1)
+
+#define LANGUAGE_VERSION_WITH_RESERVED_WORDS 15
+#define LANGUAGE_VERSION_WITH_PRIMARY_STATES 14
+
+typedef struct {
+  const TSParseAction *actions;
+  uint32_t action_count;
+  bool is_reusable;
+} TableEntry;
+
+typedef struct {
+  const TSLanguage *language;
+  const uint16_t *data;
+  const uint16_t *group_end;
+  TSStateId state;
+  uint16_t table_value;
+  uint16_t section_index;
+  uint16_t group_count;
+  bool is_small_state;
+
+  const TSParseAction *actions;
+  TSSymbol symbol;
+  TSStateId next_state;
+  uint16_t action_count;
+} LookaheadIterator;
+
+void ts_language_table_entry(const TSLanguage *self, TSStateId state, TSSymbol symbol, TableEntry *result);
+TSLexerMode ts_language_lex_mode_for_state(const TSLanguage *self, TSStateId state);
+bool ts_language_is_reserved_word(const TSLanguage *self, TSStateId state, TSSymbol symbol);
+TSSymbolMetadata ts_language_symbol_metadata(const TSLanguage *self, TSSymbol symbol);
+TSSymbol ts_language_public_symbol(const TSLanguage *self, TSSymbol symbol);
+
+static inline const TSParseAction *ts_language_actions(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol,
+  uint32_t *count
+) {
+  TableEntry entry;
+  ts_language_table_entry(self, state, symbol, &entry);
+  *count = entry.action_count;
+  return entry.actions;
+}
+
+static inline bool ts_language_has_reduce_action(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  TableEntry entry;
+  ts_language_table_entry(self, state, symbol, &entry);
+  return entry.action_count > 0 && entry.actions[0].type == TSParseActionTypeReduce;
+}
+
+// Lookup the table value for a given symbol and state.
+//
+// For non-terminal symbols, the table value represents a successor state.
+// For terminal symbols, it represents an index in the actions table.
+// For 'large' parse states, this is a direct lookup. For 'small' parse
+// states, this requires searching through the symbol groups to find
+// the given symbol.
+static inline uint16_t ts_language_lookup(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  if (state >= self->large_state_count) {
+    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
+    const uint16_t *data = &self->small_parse_table[index];
+    uint16_t group_count = *(data++);
+    for (unsigned i = 0; i < group_count; i++) {
+      uint16_t section_value = *(data++);
+      uint16_t symbol_count = *(data++);
+      for (unsigned j = 0; j < symbol_count; j++) {
+        if (*(data++) == symbol) return section_value;
+      }
+    }
+    return 0;
+  } else {
+    return self->parse_table[state * self->symbol_count + symbol];
+  }
+}
+
+static inline bool ts_language_has_actions(
+  const TSLanguage *self,
+  TSStateId state,
+  TSSymbol symbol
+) {
+  return ts_language_lookup(self, state, symbol) != 0;
+}
+
+// Iterate over all of the symbols that are valid in the given state.
+//
+// For 'large' parse states, this just requires iterating through
+// all possible symbols and checking the parse table for each one.
+// For 'small' parse states, this exploits the structure of the
+// table to only visit the valid symbols.
+static inline LookaheadIterator ts_language_lookaheads(
+  const TSLanguage *self,
+  TSStateId state
+) {
+  bool is_small_state = state >= self->large_state_count;
+  const uint16_t *data;
+  const uint16_t *group_end = NULL;
+  uint16_t group_count = 0;
+  if (is_small_state) {
+    uint32_t index = self->small_parse_table_map[state - self->large_state_count];
+    data = &self->small_parse_table[index];
+    group_end = data + 1;
+    group_count = *data;
+  } else {
+    data = &self->parse_table[state * self->symbol_count] - 1;
+  }
+  return (LookaheadIterator) {
+    .language = self,
+    .data = data,
+    .group_end = group_end,
+    .group_count = group_count,
+    .is_small_state = is_small_state,
+    .symbol = UINT16_MAX,
+    .next_state = 0,
+  };
+}
+
+static inline bool ts_lookahead_iterator__next(LookaheadIterator *self) {
+  // For small parse states, valid symbols are listed explicitly,
+  // grouped by their value. There's no need to look up the actions
+  // again until moving to the next group.
+  if (self->is_small_state) {
+    self->data++;
+    if (self->data == self->group_end) {
+      if (self->group_count == 0) return false;
+      self->group_count--;
+      self->table_value = *(self->data++);
+      unsigned symbol_count = *(self->data++);
+      self->group_end = self->data + symbol_count;
+      self->symbol = *self->data;
+    } else {
+      self->symbol = *self->data;
+      return true;
+    }
+  }
+
+  // For large parse states, iterate through every symbol until one
+  // is found that has valid actions.
+  else {
+    do {
+      self->data++;
+      self->symbol++;
+      if (self->symbol >= self->language->symbol_count) return false;
+      self->table_value = *self->data;
+    } while (!self->table_value);
+  }
+
+  // Depending on if the symbols is terminal or non-terminal, the table value either
+  // represents a list of actions or a successor state.
+  if (self->symbol < self->language->token_count) {
+    const TSParseActionEntry *entry = &self->language->parse_actions[self->table_value];
+    self->action_count = entry->entry.count;
+    self->actions = (const TSParseAction *)(entry + 1);
+    self->next_state = 0;
+  } else {
+    self->action_count = 0;
+    self->next_state = self->table_value;
+  }
+  return true;
+}
+
+// Whether the state is a "primary state". If this returns false, it indicates that there exists
+// another state that behaves identically to this one with respect to query analysis.
+static inline bool ts_language_state_is_primary(
+  const TSLanguage *self,
+  TSStateId state
+) {
+  if (self->abi_version >= LANGUAGE_VERSION_WITH_PRIMARY_STATES) {
+    return state == self->primary_state_ids[state];
+  } else {
+    return true;
+  }
+}
+
+static inline const bool *ts_language_enabled_external_tokens(
+  const TSLanguage *self,
+  unsigned external_scanner_state
+) {
+  if (external_scanner_state == 0) {
+    return NULL;
+  } else {
+    return self->external_scanner.states + self->external_token_count * external_scanner_state;
+  }
+}
+
+static inline const TSSymbol *ts_language_alias_sequence(
+  const TSLanguage *self,
+  uint32_t production_id
+) {
+  return production_id ?
+    &self->alias_sequences[production_id * self->max_alias_sequence_length] :
+    NULL;
+}
+
+static inline TSSymbol ts_language_alias_at(
+  const TSLanguage *self,
+  uint32_t production_id,
+  uint32_t child_index
+) {
+  return production_id ?
+    self->alias_sequences[production_id * self->max_alias_sequence_length + child_index] :
+    0;
+}
+
+static inline void ts_language_field_map(
+  const TSLanguage *self,
+  uint32_t production_id,
+  const TSFieldMapEntry **start,
+  const TSFieldMapEntry **end
+) {
+  if (self->field_count == 0) {
+    *start = NULL;
+    *end = NULL;
+    return;
+  }
+
+  TSMapSlice slice = self->field_map_slices[production_id];
+  *start = &self->field_map_entries[slice.index];
+  *end = &self->field_map_entries[slice.index] + slice.length;
+}
+
+static inline void ts_language_aliases_for_symbol(
+  const TSLanguage *self,
+  TSSymbol original_symbol,
+  const TSSymbol **start,
+  const TSSymbol **end
+) {
+  *start = &self->public_symbol_map[original_symbol];
+  *end = *start + 1;
+
+  unsigned idx = 0;
+  for (;;) {
+    TSSymbol symbol = self->alias_map[idx++];
+    if (symbol == 0 || symbol > original_symbol) break;
+    uint16_t count = self->alias_map[idx++];
+    if (symbol == original_symbol) {
+      *start = &self->alias_map[idx];
+      *end = &self->alias_map[idx + count];
+      break;
+    }
+    idx += count;
+  }
+}
+
+static inline void ts_language_write_symbol_as_dot_string(
+  const TSLanguage *self,
+  FILE *f,
+  TSSymbol symbol
+) {
+  const char *name = ts_language_symbol_name(self, symbol);
+  for (const char *chr = name; *chr; chr++) {
+    switch (*chr) {
+      case '"':
+      case '\\':
+        fputc('\\', f);
+        fputc(*chr, f);
+        break;
+      case '\n':
+        fputs("\\n", f);
+        break;
+      case '\t':
+        fputs("\\t", f);
+        break;
+      default:
+        fputc(*chr, f);
+        break;
+    }
+  }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_LANGUAGE_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/length.h b/src/library/ts/src/tree-sitter/lib/src/length.h
new file mode 100644
index 0000000000..ddf156ce09
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/length.h
@@ -0,0 +1,52 @@
+#ifndef TREE_SITTER_LENGTH_H_
+#define TREE_SITTER_LENGTH_H_
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include "./point.h"
+#include "tree_sitter/api.h"
+
+typedef struct {
+  uint32_t bytes;
+  TSPoint extent;
+} Length;
+
+static const Length LENGTH_UNDEFINED = {0, {0, 1}};
+static const Length LENGTH_MAX = {UINT32_MAX, {UINT32_MAX, UINT32_MAX}};
+
+static inline bool length_is_undefined(Length length) {
+  return length.bytes == 0 && length.extent.column != 0;
+}
+
+static inline Length length_min(Length len1, Length len2) {
+  return (len1.bytes < len2.bytes) ? len1 : len2;
+}
+
+static inline Length length_add(Length len1, Length len2) {
+  Length result;
+  result.bytes = len1.bytes + len2.bytes;
+  result.extent = point_add(len1.extent, len2.extent);
+  return result;
+}
+
+static inline Length length_sub(Length len1, Length len2) {
+  Length result;
+  result.bytes = (len1.bytes >= len2.bytes) ? len1.bytes - len2.bytes : 0;
+  result.extent = point_sub(len1.extent, len2.extent);
+  return result;
+}
+
+static inline Length length_zero(void) {
+  Length result = {0, {0, 0}};
+  return result;
+}
+
+static inline Length length_saturating_sub(Length len1, Length len2) {
+  if (len1.bytes > len2.bytes) {
+    return length_sub(len1, len2);
+  } else {
+    return length_zero();
+  }
+}
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/lexer.c b/src/library/ts/src/tree-sitter/lib/src/lexer.c
new file mode 100644
index 0000000000..1709c418fd
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/lexer.c
@@ -0,0 +1,483 @@
+#include "./length.h"
+#include "./lexer.h"
+#include "./unicode.h"
+
+#include "tree_sitter/api.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#define LOG(message, character)              \
+  if (self->logger.log) {                    \
+    snprintf(                                \
+      self->debug_buffer,                    \
+      TREE_SITTER_SERIALIZATION_BUFFER_SIZE, \
+      32 <= character && character < 127 ?   \
+        message " character:'%c'" :          \
+        message " character:%d",             \
+      character                              \
+    );                                       \
+    self->logger.log(                        \
+      self->logger.payload,                  \
+      TSLogTypeLex,                          \
+      self->debug_buffer                     \
+    );                                       \
+  }
+
+static const int32_t BYTE_ORDER_MARK = 0xFEFF;
+
+static const TSRange DEFAULT_RANGE = {
+  .start_point = {
+    .row = 0,
+    .column = 0,
+  },
+  .end_point = {
+    .row = UINT32_MAX,
+    .column = UINT32_MAX,
+  },
+  .start_byte = 0,
+  .end_byte = UINT32_MAX
+};
+
+/**
+ * Sets the column data to the given value and marks it valid.
+ * @param self The lexer state.
+ * @param val The new value of the column data.
+ */
+static void ts_lexer__set_column_data(Lexer *self, uint32_t val) {
+  self->column_data.valid = true;
+  self->column_data.value = val;
+}
+
+/**
+ * Increments the value of the column data; no-op if invalid.
+ * @param self The lexer state.
+ */
+static void ts_lexer__increment_column_data(Lexer *self) {
+  if (self->column_data.valid) {
+    self->column_data.value++;
+  }
+}
+
+/**
+ * Marks the column data as invalid.
+ * @param self The lexer state.
+ */
+static void ts_lexer__invalidate_column_data(Lexer *self) {
+  self->column_data.valid = false;
+  self->column_data.value = 0;
+}
+
+// Check if the lexer has reached EOF. This state is stored
+// by setting the lexer's `current_included_range_index` such that
+// it has consumed all of its available ranges.
+static bool ts_lexer__eof(const TSLexer *_self) {
+  Lexer *self = (Lexer *)_self;
+  return self->current_included_range_index == self->included_range_count;
+}
+
+// Clear the currently stored chunk of source code, because the lexer's
+// position has changed.
+static void ts_lexer__clear_chunk(Lexer *self) {
+  self->chunk = NULL;
+  self->chunk_size = 0;
+  self->chunk_start = 0;
+}
+
+// Call the lexer's input callback to obtain a new chunk of source code
+// for the current position.
+static void ts_lexer__get_chunk(Lexer *self) {
+  self->chunk_start = self->current_position.bytes;
+  self->chunk = self->input.read(
+    self->input.payload,
+    self->current_position.bytes,
+    self->current_position.extent,
+    &self->chunk_size
+  );
+  if (!self->chunk_size) {
+    self->current_included_range_index = self->included_range_count;
+    self->chunk = NULL;
+  }
+}
+
+// Decode the next unicode character in the current chunk of source code.
+// This assumes that the lexer has already retrieved a chunk of source
+// code that spans the current position.
+static void ts_lexer__get_lookahead(Lexer *self) {
+  uint32_t position_in_chunk = self->current_position.bytes - self->chunk_start;
+  uint32_t size = self->chunk_size - position_in_chunk;
+
+  if (size == 0) {
+    self->lookahead_size = 1;
+    self->data.lookahead = '\0';
+    return;
+  }
+
+  const uint8_t *chunk = (const uint8_t *)self->chunk + position_in_chunk;
+  TSDecodeFunction decode =
+    self->input.encoding == TSInputEncodingUTF8    ? ts_decode_utf8     :
+    self->input.encoding == TSInputEncodingUTF16LE ? ts_decode_utf16_le :
+    self->input.encoding == TSInputEncodingUTF16BE ? ts_decode_utf16_be : self->input.decode;
+
+  self->lookahead_size = decode(chunk, size, &self->data.lookahead);
+
+  // If this chunk ended in the middle of a multi-byte character,
+  // try again with a fresh chunk.
+  if (self->data.lookahead == TS_DECODE_ERROR && size < 4) {
+    ts_lexer__get_chunk(self);
+    chunk = (const uint8_t *)self->chunk;
+    size = self->chunk_size;
+    self->lookahead_size = decode(chunk, size, &self->data.lookahead);
+  }
+
+  if (self->data.lookahead == TS_DECODE_ERROR) {
+    self->lookahead_size = 1;
+  }
+}
+
+static void ts_lexer_goto(Lexer *self, Length position) {
+  if (position.bytes != self->current_position.bytes) {
+    ts_lexer__invalidate_column_data(self);
+  }
+
+  self->current_position = position;
+
+  // Move to the first valid position at or after the given position.
+  bool found_included_range = false;
+  for (unsigned i = 0; i < self->included_range_count; i++) {
+    TSRange *included_range = &self->included_ranges[i];
+    if (
+      included_range->end_byte > self->current_position.bytes &&
+      included_range->end_byte > included_range->start_byte
+    ) {
+      if (included_range->start_byte >= self->current_position.bytes) {
+        self->current_position = (Length) {
+          .bytes = included_range->start_byte,
+          .extent = included_range->start_point,
+        };
+      }
+
+      self->current_included_range_index = i;
+      found_included_range = true;
+      break;
+    }
+  }
+
+  if (found_included_range) {
+    // If the current position is outside of the current chunk of text,
+    // then clear out the current chunk of text.
+    if (self->chunk && (
+      self->current_position.bytes < self->chunk_start ||
+      self->current_position.bytes >= self->chunk_start + self->chunk_size
+    )) {
+      ts_lexer__clear_chunk(self);
+    }
+
+    self->lookahead_size = 0;
+    self->data.lookahead = '\0';
+  }
+
+  // If the given position is beyond any of included ranges, move to the EOF
+  // state - past the end of the included ranges.
+  else {
+    self->current_included_range_index = self->included_range_count;
+    TSRange *last_included_range = &self->included_ranges[self->included_range_count - 1];
+    self->current_position = (Length) {
+      .bytes = last_included_range->end_byte,
+      .extent = last_included_range->end_point,
+    };
+    ts_lexer__clear_chunk(self);
+    self->lookahead_size = 1;
+    self->data.lookahead = '\0';
+  }
+}
+
+/**
+ * Actually advances the lexer. Does not log anything.
+ * @param self The lexer state.
+ * @param skip Whether to mark the consumed codepoint as whitespace.
+ */
+static void ts_lexer__do_advance(Lexer *self, bool skip) {
+  if (self->lookahead_size) {
+    if (self->data.lookahead == '\n') {
+      self->current_position.extent.row++;
+      self->current_position.extent.column = 0;
+      ts_lexer__set_column_data(self, 0);
+    } else {
+      bool is_bom = self->current_position.bytes == 0 && 
+        self->data.lookahead == BYTE_ORDER_MARK;
+      if (!is_bom) ts_lexer__increment_column_data(self);
+      self->current_position.extent.column += self->lookahead_size;
+    }
+    self->current_position.bytes += self->lookahead_size;
+  }
+
+  const TSRange *current_range = &self->included_ranges[self->current_included_range_index];
+  while (
+    self->current_position.bytes >= current_range->end_byte ||
+    current_range->end_byte == current_range->start_byte
+  ) {
+    if (self->current_included_range_index < self->included_range_count) {
+      self->current_included_range_index++;
+    }
+    if (self->current_included_range_index < self->included_range_count) {
+      current_range++;
+      self->current_position = (Length) {
+        current_range->start_byte,
+        current_range->start_point,
+      };
+    } else {
+      current_range = NULL;
+      break;
+    }
+  }
+
+  if (skip) self->token_start_position = self->current_position;
+
+  if (current_range) {
+    if (
+      self->current_position.bytes < self->chunk_start ||
+      self->current_position.bytes >= self->chunk_start + self->chunk_size
+    ) {
+      ts_lexer__get_chunk(self);
+    }
+    ts_lexer__get_lookahead(self);
+  } else {
+    ts_lexer__clear_chunk(self);
+    self->data.lookahead = '\0';
+    self->lookahead_size = 1;
+  }
+}
+
+// Advance to the next character in the source code, retrieving a new
+// chunk of source code if needed.
+static void ts_lexer__advance(TSLexer *_self, bool skip) {
+  Lexer *self = (Lexer *)_self;
+  if (!self->chunk) return;
+
+  if (skip) {
+    LOG("skip", self->data.lookahead)
+  } else {
+    LOG("consume", self->data.lookahead)
+  }
+
+  ts_lexer__do_advance(self, skip);
+}
+
+// Mark that a token match has completed. This can be called multiple
+// times if a longer match is found later.
+static void ts_lexer__mark_end(TSLexer *_self) {
+  Lexer *self = (Lexer *)_self;
+  if (!ts_lexer__eof(&self->data)) {
+    // If the lexer is right at the beginning of included range,
+    // then the token should be considered to end at the *end* of the
+    // previous included range, rather than here.
+    TSRange *current_included_range = &self->included_ranges[
+      self->current_included_range_index
+    ];
+    if (
+      self->current_included_range_index > 0 &&
+      self->current_position.bytes == current_included_range->start_byte
+    ) {
+      TSRange *previous_included_range = current_included_range - 1;
+      self->token_end_position = (Length) {
+        previous_included_range->end_byte,
+        previous_included_range->end_point,
+      };
+      return;
+    }
+  }
+  self->token_end_position = self->current_position;
+}
+
+static uint32_t ts_lexer__get_column(TSLexer *_self) {
+  Lexer *self = (Lexer *)_self;
+
+  self->did_get_column = true;
+
+  if (!self->column_data.valid) {
+    // Record current position
+    uint32_t goal_byte = self->current_position.bytes;
+
+    // Back up to the beginning of the line
+    Length start_of_col = {
+      self->current_position.bytes - self->current_position.extent.column,
+      {self->current_position.extent.row, 0},
+    };
+    ts_lexer_goto(self, start_of_col);
+    ts_lexer__set_column_data(self, 0);
+    ts_lexer__get_chunk(self);
+
+    if (!ts_lexer__eof(_self)) {
+      ts_lexer__get_lookahead(self);
+
+      // Advance to the recorded position
+      while (self->current_position.bytes < goal_byte && !ts_lexer__eof(_self) && self->chunk) {
+        ts_lexer__do_advance(self, false);
+        if (ts_lexer__eof(_self)) break;
+      }
+    }
+  }
+
+  return self->column_data.value;
+}
+
+// Is the lexer at a boundary between two disjoint included ranges of
+// source code? This is exposed as an API because some languages' external
+// scanners need to perform custom actions at these boundaries.
+static bool ts_lexer__is_at_included_range_start(const TSLexer *_self) {
+  const Lexer *self = (const Lexer *)_self;
+  if (self->current_included_range_index < self->included_range_count) {
+    TSRange *current_range = &self->included_ranges[self->current_included_range_index];
+    return self->current_position.bytes == current_range->start_byte;
+  } else {
+    return false;
+  }
+}
+
+static void ts_lexer__log(const TSLexer *_self, const char *fmt, ...) {
+  Lexer *self = (Lexer *)_self;
+  va_list args;
+  va_start(args, fmt);
+  if (self->logger.log) {
+    vsnprintf(self->debug_buffer, TREE_SITTER_SERIALIZATION_BUFFER_SIZE, fmt, args);
+    self->logger.log(self->logger.payload, TSLogTypeLex, self->debug_buffer);
+  }
+  va_end(args);
+}
+
+void ts_lexer_init(Lexer *self) {
+  *self = (Lexer) {
+    .data = {
+      // The lexer's methods are stored as struct fields so that generated
+      // parsers can call them without needing to be linked against this
+      // library.
+      .advance = ts_lexer__advance,
+      .mark_end = ts_lexer__mark_end,
+      .get_column = ts_lexer__get_column,
+      .is_at_included_range_start = ts_lexer__is_at_included_range_start,
+      .eof = ts_lexer__eof,
+      .log = ts_lexer__log,
+      .lookahead = 0,
+      .result_symbol = 0,
+    },
+    .chunk = NULL,
+    .chunk_size = 0,
+    .chunk_start = 0,
+    .current_position = {0, {0, 0}},
+    .logger = {
+      .payload = NULL,
+      .log = NULL
+    },
+    .included_ranges = NULL,
+    .included_range_count = 0,
+    .current_included_range_index = 0,
+    .did_get_column = false,
+    .column_data = {
+      .valid = false,
+      .value = 0
+    }
+  };
+  ts_lexer_set_included_ranges(self, NULL, 0);
+}
+
+void ts_lexer_delete(Lexer *self) {
+  ts_free(self->included_ranges);
+}
+
+void ts_lexer_set_input(Lexer *self, TSInput input) {
+  self->input = input;
+  ts_lexer__clear_chunk(self);
+  ts_lexer_goto(self, self->current_position);
+}
+
+// Move the lexer to the given position. This doesn't do any work
+// if the parser is already at the given position.
+void ts_lexer_reset(Lexer *self, Length position) {
+  if (position.bytes != self->current_position.bytes) {
+    ts_lexer_goto(self, position);
+  }
+}
+
+void ts_lexer_start(Lexer *self) {
+  self->token_start_position = self->current_position;
+  self->token_end_position = LENGTH_UNDEFINED;
+  self->data.result_symbol = 0;
+  self->did_get_column = false;
+  if (!ts_lexer__eof(&self->data)) {
+    if (!self->chunk_size) ts_lexer__get_chunk(self);
+    if (!self->lookahead_size) ts_lexer__get_lookahead(self);
+    if (self->current_position.bytes == 0) {
+      if (self->data.lookahead == BYTE_ORDER_MARK) {
+        ts_lexer__advance(&self->data, true);
+      }
+      ts_lexer__set_column_data(self, 0);
+    }
+  }
+}
+
+void ts_lexer_finish(Lexer *self, uint32_t *lookahead_end_byte) {
+  if (length_is_undefined(self->token_end_position)) {
+    ts_lexer__mark_end(&self->data);
+  }
+
+  // If the token ended at an included range boundary, then its end position
+  // will have been reset to the end of the preceding range. Reset the start
+  // position to match.
+  if (self->token_end_position.bytes < self->token_start_position.bytes) {
+    self->token_start_position = self->token_end_position;
+  }
+
+  uint32_t current_lookahead_end_byte = self->current_position.bytes + 1;
+
+  // In order to determine that a byte sequence is invalid UTF8 or UTF16,
+  // the character decoding algorithm may have looked at the following byte.
+  // Therefore, the next byte *after* the current (invalid) character
+  // affects the interpretation of the current character.
+  if (self->data.lookahead == TS_DECODE_ERROR) {
+    current_lookahead_end_byte += 4; // the maximum number of bytes read to identify an invalid code point
+  }
+
+  if (current_lookahead_end_byte > *lookahead_end_byte) {
+    *lookahead_end_byte = current_lookahead_end_byte;
+  }
+}
+
+void ts_lexer_mark_end(Lexer *self) {
+  ts_lexer__mark_end(&self->data);
+}
+
+bool ts_lexer_set_included_ranges(
+  Lexer *self,
+  const TSRange *ranges,
+  uint32_t count
+) {
+  if (count == 0 || !ranges) {
+    ranges = &DEFAULT_RANGE;
+    count = 1;
+  } else {
+    uint32_t previous_byte = 0;
+    for (unsigned i = 0; i < count; i++) {
+      const TSRange *range = &ranges[i];
+      if (
+        range->start_byte < previous_byte ||
+        range->end_byte < range->start_byte
+      ) return false;
+      previous_byte = range->end_byte;
+    }
+  }
+
+  size_t size = count * sizeof(TSRange);
+  self->included_ranges = ts_realloc(self->included_ranges, size);
+  memcpy(self->included_ranges, ranges, size);
+  self->included_range_count = count;
+  ts_lexer_goto(self, self->current_position);
+  return true;
+}
+
+TSRange *ts_lexer_included_ranges(const Lexer *self, uint32_t *count) {
+  *count = self->included_range_count;
+  return self->included_ranges;
+}
+
+#undef LOG
diff --git a/src/library/ts/src/tree-sitter/lib/src/lexer.h b/src/library/ts/src/tree-sitter/lib/src/lexer.h
new file mode 100644
index 0000000000..7f451e3f93
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/lexer.h
@@ -0,0 +1,54 @@
+#ifndef TREE_SITTER_LEXER_H_
+#define TREE_SITTER_LEXER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./length.h"
+#include "./subtree.h"
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+typedef struct {
+  uint32_t value;
+  bool valid;
+} ColumnData;
+
+typedef struct {
+  TSLexer data;
+  Length current_position;
+  Length token_start_position;
+  Length token_end_position;
+
+  TSRange *included_ranges;
+  const char *chunk;
+  TSInput input;
+  TSLogger logger;
+
+  uint32_t included_range_count;
+  uint32_t current_included_range_index;
+  uint32_t chunk_start;
+  uint32_t chunk_size;
+  uint32_t lookahead_size;
+  bool did_get_column;
+  ColumnData column_data;
+
+  char debug_buffer[TREE_SITTER_SERIALIZATION_BUFFER_SIZE];
+} Lexer;
+
+void ts_lexer_init(Lexer *self);
+void ts_lexer_delete(Lexer *self);
+void ts_lexer_set_input(Lexer *self, TSInput input);
+void ts_lexer_reset(Lexer *self, Length position);
+void ts_lexer_start(Lexer *self);
+void ts_lexer_finish(Lexer *self, uint32_t *lookahead_end_byte);
+void ts_lexer_mark_end(Lexer *self);
+bool ts_lexer_set_included_ranges(Lexer *self, const TSRange *ranges, uint32_t count);
+TSRange *ts_lexer_included_ranges(const Lexer *self, uint32_t *count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_LEXER_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/lib.c b/src/library/ts/src/tree-sitter/lib/src/lib.c
new file mode 100644
index 0000000000..f56be97a94
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/lib.c
@@ -0,0 +1,13 @@
+#include "./alloc.c"
+#include "./get_changed_ranges.c"
+#include "./language.c"
+#include "./lexer.c"
+#include "./node.c"
+#include "./parser.c"
+#include "./point.c"
+#include "./query.c"
+#include "./stack.c"
+#include "./subtree.c"
+#include "./tree_cursor.c"
+#include "./tree.c"
+#include "./wasm_store.c"
diff --git a/src/library/ts/src/tree-sitter/lib/src/node.c b/src/library/ts/src/tree-sitter/lib/src/node.c
new file mode 100644
index 0000000000..84ffed28cf
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/node.c
@@ -0,0 +1,869 @@
+#include <stdbool.h>
+#include "./point.h"
+#include "./subtree.h"
+#include "./tree.h"
+#include "./language.h"
+
+typedef struct {
+  Subtree parent;
+  const TSTree *tree;
+  Length position;
+  uint32_t child_index;
+  uint32_t structural_child_index;
+  const TSSymbol *alias_sequence;
+} NodeChildIterator;
+
+static inline bool ts_node__is_relevant(TSNode self, bool include_anonymous);
+
+// TSNode - constructors
+
+TSNode ts_node_new(
+  const TSTree *tree,
+  const Subtree *subtree,
+  Length position,
+  TSSymbol alias
+) {
+  return (TSNode) {
+    {position.bytes, position.extent.row, position.extent.column, alias},
+    subtree,
+    tree,
+  };
+}
+
+static inline TSNode ts_node__null(void) {
+  return ts_node_new(NULL, NULL, length_zero(), 0);
+}
+
+// TSNode - accessors
+
+uint32_t ts_node_start_byte(TSNode self) {
+  return self.context[0];
+}
+
+TSPoint ts_node_start_point(TSNode self) {
+  return (TSPoint) {self.context[1], self.context[2]};
+}
+
+static inline uint32_t ts_node__alias(const TSNode *self) {
+  return self->context[3];
+}
+
+static inline Subtree ts_node__subtree(TSNode self) {
+  return *(const Subtree *)self.id;
+}
+
+// NodeChildIterator
+
+static inline NodeChildIterator ts_node_iterate_children(const TSNode *node) {
+  Subtree subtree = ts_node__subtree(*node);
+  if (ts_subtree_child_count(subtree) == 0) {
+    return (NodeChildIterator) {NULL_SUBTREE, node->tree, length_zero(), 0, 0, NULL};
+  }
+  const TSSymbol *alias_sequence = ts_language_alias_sequence(
+    node->tree->language,
+    subtree.ptr->production_id
+  );
+  return (NodeChildIterator) {
+    .tree = node->tree,
+    .parent = subtree,
+    .position = {ts_node_start_byte(*node), ts_node_start_point(*node)},
+    .child_index = 0,
+    .structural_child_index = 0,
+    .alias_sequence = alias_sequence,
+  };
+}
+
+static inline bool ts_node_child_iterator_done(NodeChildIterator *self) {
+  return self->child_index == self->parent.ptr->child_count;
+}
+
+static inline bool ts_node_child_iterator_next(
+  NodeChildIterator *self,
+  TSNode *result
+) {
+  if (!self->parent.ptr || ts_node_child_iterator_done(self)) return false;
+  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
+  TSSymbol alias_symbol = 0;
+  if (!ts_subtree_extra(*child)) {
+    if (self->alias_sequence) {
+      alias_symbol = self->alias_sequence[self->structural_child_index];
+    }
+    self->structural_child_index++;
+  }
+  if (self->child_index > 0) {
+    self->position = length_add(self->position, ts_subtree_padding(*child));
+  }
+  *result = ts_node_new(
+    self->tree,
+    child,
+    self->position,
+    alias_symbol
+  );
+  self->position = length_add(self->position, ts_subtree_size(*child));
+  self->child_index++;
+  return true;
+}
+
+// TSNode - private
+
+static inline bool ts_node__is_relevant(TSNode self, bool include_anonymous) {
+  Subtree tree = ts_node__subtree(self);
+  if (include_anonymous) {
+    return ts_subtree_visible(tree) || ts_node__alias(&self);
+  } else {
+    TSSymbol alias = ts_node__alias(&self);
+    if (alias) {
+      return ts_language_symbol_metadata(self.tree->language, alias).named;
+    } else {
+      return ts_subtree_visible(tree) && ts_subtree_named(tree);
+    }
+  }
+}
+
+static inline uint32_t ts_node__relevant_child_count(
+  TSNode self,
+  bool include_anonymous
+) {
+  Subtree tree = ts_node__subtree(self);
+  if (ts_subtree_child_count(tree) > 0) {
+    if (include_anonymous) {
+      return tree.ptr->visible_child_count;
+    } else {
+      return tree.ptr->named_child_count;
+    }
+  } else {
+    return 0;
+  }
+}
+
+static inline TSNode ts_node__child(
+  TSNode self,
+  uint32_t child_index,
+  bool include_anonymous
+) {
+  TSNode result = self;
+  bool did_descend = true;
+
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    uint32_t index = 0;
+    NodeChildIterator iterator = ts_node_iterate_children(&result);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (ts_node__is_relevant(child, include_anonymous)) {
+        if (index == child_index) {
+          return child;
+        }
+        index++;
+      } else {
+        uint32_t grandchild_index = child_index - index;
+        uint32_t grandchild_count = ts_node__relevant_child_count(child, include_anonymous);
+        if (grandchild_index < grandchild_count) {
+          did_descend = true;
+          result = child;
+          child_index = grandchild_index;
+          break;
+        }
+        index += grandchild_count;
+      }
+    }
+  }
+
+  return ts_node__null();
+}
+
+static bool ts_subtree_has_trailing_empty_descendant(
+  Subtree self,
+  Subtree other
+) {
+  for (unsigned i = ts_subtree_child_count(self) - 1; i + 1 > 0; i--) {
+    Subtree child = ts_subtree_children(self)[i];
+    if (ts_subtree_total_bytes(child) > 0) break;
+    if (child.ptr == other.ptr || ts_subtree_has_trailing_empty_descendant(child, other)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static inline TSNode ts_node__prev_sibling(TSNode self, bool include_anonymous) {
+  Subtree self_subtree = ts_node__subtree(self);
+  bool self_is_empty = ts_subtree_total_bytes(self_subtree) == 0;
+  uint32_t target_end_byte = ts_node_end_byte(self);
+
+  TSNode node = ts_node_parent(self);
+  TSNode earlier_node = ts_node__null();
+  bool earlier_node_is_relevant = false;
+
+  while (!ts_node_is_null(node)) {
+    TSNode earlier_child = ts_node__null();
+    bool earlier_child_is_relevant = false;
+    bool found_child_containing_target = false;
+
+    TSNode child;
+    NodeChildIterator iterator = ts_node_iterate_children(&node);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (child.id == self.id) break;
+      if (iterator.position.bytes > target_end_byte) {
+        found_child_containing_target = true;
+        break;
+      }
+
+      if (iterator.position.bytes == target_end_byte &&
+          (!self_is_empty ||
+           ts_subtree_has_trailing_empty_descendant(ts_node__subtree(child), self_subtree))) {
+        found_child_containing_target = true;
+        break;
+      }
+
+      if (ts_node__is_relevant(child, include_anonymous)) {
+        earlier_child = child;
+        earlier_child_is_relevant = true;
+      } else if (ts_node__relevant_child_count(child, include_anonymous) > 0) {
+        earlier_child = child;
+        earlier_child_is_relevant = false;
+      }
+    }
+
+    if (found_child_containing_target) {
+      if (!ts_node_is_null(earlier_child)) {
+        earlier_node = earlier_child;
+        earlier_node_is_relevant = earlier_child_is_relevant;
+      }
+      node = child;
+    } else if (earlier_child_is_relevant) {
+      return earlier_child;
+    } else if (!ts_node_is_null(earlier_child)) {
+      node = earlier_child;
+    } else if (earlier_node_is_relevant) {
+      return earlier_node;
+    } else {
+      node = earlier_node;
+      earlier_node = ts_node__null();
+      earlier_node_is_relevant = false;
+    }
+  }
+
+  return ts_node__null();
+}
+
+static inline TSNode ts_node__next_sibling(TSNode self, bool include_anonymous) {
+  uint32_t target_end_byte = ts_node_end_byte(self);
+
+  TSNode node = ts_node_parent(self);
+  TSNode later_node = ts_node__null();
+  bool later_node_is_relevant = false;
+
+  while (!ts_node_is_null(node)) {
+    TSNode later_child = ts_node__null();
+    bool later_child_is_relevant = false;
+    TSNode child_containing_target = ts_node__null();
+
+    TSNode child;
+    NodeChildIterator iterator = ts_node_iterate_children(&node);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (iterator.position.bytes <= target_end_byte) continue;
+      uint32_t start_byte = ts_node_start_byte(self);
+      uint32_t child_start_byte = ts_node_start_byte(child);
+
+      bool is_empty = start_byte == target_end_byte;
+      bool contains_target = is_empty ?
+        child_start_byte < start_byte :
+        child_start_byte <= start_byte;
+
+      if (contains_target) {
+        if (ts_node__subtree(child).ptr != ts_node__subtree(self).ptr) {
+          child_containing_target = child;
+        }
+      } else if (ts_node__is_relevant(child, include_anonymous)) {
+        later_child = child;
+        later_child_is_relevant = true;
+        break;
+      } else if (ts_node__relevant_child_count(child, include_anonymous) > 0) {
+        later_child = child;
+        later_child_is_relevant = false;
+        break;
+      }
+    }
+
+    if (!ts_node_is_null(child_containing_target)) {
+      if (!ts_node_is_null(later_child)) {
+        later_node = later_child;
+        later_node_is_relevant = later_child_is_relevant;
+      }
+      node = child_containing_target;
+    } else if (later_child_is_relevant) {
+      return later_child;
+    } else if (!ts_node_is_null(later_child)) {
+      node = later_child;
+    } else if (later_node_is_relevant) {
+      return later_node;
+    } else {
+      node = later_node;
+    }
+  }
+
+  return ts_node__null();
+}
+
+static inline TSNode ts_node__first_child_for_byte(
+  TSNode self,
+  uint32_t goal,
+  bool include_anonymous
+) {
+  TSNode node = self;
+  bool did_descend = true;
+
+  NodeChildIterator last_iterator;
+  bool has_last_iterator = false;
+
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    NodeChildIterator iterator = ts_node_iterate_children(&node);
+  loop:
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (ts_node_end_byte(child) > goal) {
+        if (ts_node__is_relevant(child, include_anonymous)) {
+          return child;
+        } else if (ts_node_child_count(child) > 0) {
+          if (iterator.child_index < ts_subtree_child_count(ts_node__subtree(child))) {
+            last_iterator = iterator;
+            has_last_iterator = true;
+          }
+          did_descend = true;
+          node = child;
+          break;
+        }
+      }
+    }
+
+    if (!did_descend && has_last_iterator) {
+      iterator = last_iterator;
+      has_last_iterator = false;
+      goto loop;
+    }
+  }
+
+  return ts_node__null();
+}
+
+static inline TSNode ts_node__descendant_for_byte_range(
+  TSNode self,
+  uint32_t range_start,
+  uint32_t range_end,
+  bool include_anonymous
+) {
+  if (range_start > range_end) {
+    return ts_node__null();
+  }
+  TSNode node = self;
+  TSNode last_visible_node = self;
+
+  bool did_descend = true;
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    NodeChildIterator iterator = ts_node_iterate_children(&node);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      uint32_t node_end = iterator.position.bytes;
+
+      // The end of this node must extend far enough forward to touch
+      // the end of the range
+      if (node_end < range_end) continue;
+
+      // ...and exceed the start of the range, unless the node itself is
+      // empty, in which case it must at least be equal to the start of the range.
+      bool is_empty = ts_node_start_byte(child) == node_end;
+      if (is_empty ? node_end < range_start : node_end <= range_start) continue;
+
+      // The start of this node must extend far enough backward to
+      // touch the start of the range.
+      if (range_start < ts_node_start_byte(child)) break;
+
+      node = child;
+      if (ts_node__is_relevant(node, include_anonymous)) {
+        last_visible_node = node;
+      }
+      did_descend = true;
+      break;
+    }
+  }
+
+  return last_visible_node;
+}
+
+static inline TSNode ts_node__descendant_for_point_range(
+  TSNode self,
+  TSPoint range_start,
+  TSPoint range_end,
+  bool include_anonymous
+) {
+  if (point_gt(range_start, range_end)) {
+    return ts_node__null();
+  }
+  TSNode node = self;
+  TSNode last_visible_node = self;
+
+  bool did_descend = true;
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    NodeChildIterator iterator = ts_node_iterate_children(&node);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      TSPoint node_end = iterator.position.extent;
+
+      // The end of this node must extend far enough forward to touch
+      // the end of the range
+      if (point_lt(node_end, range_end)) continue;
+
+      // ...and exceed the start of the range, unless the node itself is
+      // empty, in which case it must at least be equal to the start of the range.
+      bool is_empty =  point_eq(ts_node_start_point(child), node_end);
+      if (is_empty ? point_lt(node_end, range_start) : point_lte(node_end, range_start)) {
+        continue;
+      }
+
+      // The start of this node must extend far enough backward to
+      // touch the start of the range.
+      if (point_lt(range_start, ts_node_start_point(child))) break;
+
+      node = child;
+      if (ts_node__is_relevant(node, include_anonymous)) {
+        last_visible_node = node;
+      }
+      did_descend = true;
+      break;
+    }
+  }
+
+  return last_visible_node;
+}
+
+// TSNode - public
+
+uint32_t ts_node_end_byte(TSNode self) {
+  return ts_node_start_byte(self) + ts_subtree_size(ts_node__subtree(self)).bytes;
+}
+
+TSPoint ts_node_end_point(TSNode self) {
+  return point_add(ts_node_start_point(self), ts_subtree_size(ts_node__subtree(self)).extent);
+}
+
+TSSymbol ts_node_symbol(TSNode self) {
+  TSSymbol symbol = ts_node__alias(&self);
+  if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
+  return ts_language_public_symbol(self.tree->language, symbol);
+}
+
+const char *ts_node_type(TSNode self) {
+  TSSymbol symbol = ts_node__alias(&self);
+  if (!symbol) symbol = ts_subtree_symbol(ts_node__subtree(self));
+  return ts_language_symbol_name(self.tree->language, symbol);
+}
+
+const TSLanguage *ts_node_language(TSNode self) {
+  return self.tree->language;
+}
+
+TSSymbol ts_node_grammar_symbol(TSNode self) {
+  return ts_subtree_symbol(ts_node__subtree(self));
+}
+
+const char *ts_node_grammar_type(TSNode self) {
+  TSSymbol symbol = ts_subtree_symbol(ts_node__subtree(self));
+  return ts_language_symbol_name(self.tree->language, symbol);
+}
+
+char *ts_node_string(TSNode self) {
+  TSSymbol alias_symbol = ts_node__alias(&self);
+  return ts_subtree_string(
+    ts_node__subtree(self),
+    alias_symbol,
+    ts_language_symbol_metadata(self.tree->language, alias_symbol).visible,
+    self.tree->language,
+    false
+  );
+}
+
+bool ts_node_eq(TSNode self, TSNode other) {
+  return self.tree == other.tree && self.id == other.id;
+}
+
+bool ts_node_is_null(TSNode self) {
+  return self.id == 0;
+}
+
+bool ts_node_is_extra(TSNode self) {
+  return ts_subtree_extra(ts_node__subtree(self));
+}
+
+bool ts_node_is_named(TSNode self) {
+  TSSymbol alias = ts_node__alias(&self);
+  return alias
+    ? ts_language_symbol_metadata(self.tree->language, alias).named
+    : ts_subtree_named(ts_node__subtree(self));
+}
+
+bool ts_node_is_missing(TSNode self) {
+  return ts_subtree_missing(ts_node__subtree(self));
+}
+
+bool ts_node_has_changes(TSNode self) {
+  return ts_subtree_has_changes(ts_node__subtree(self));
+}
+
+bool ts_node_has_error(TSNode self) {
+  return ts_subtree_error_cost(ts_node__subtree(self)) > 0;
+}
+
+bool ts_node_is_error(TSNode self) {
+  TSSymbol symbol = ts_node_symbol(self);
+  return symbol == ts_builtin_sym_error;
+}
+
+uint32_t ts_node_descendant_count(TSNode self) {
+  return ts_subtree_visible_descendant_count(ts_node__subtree(self)) + 1;
+}
+
+TSStateId ts_node_parse_state(TSNode self) {
+  return ts_subtree_parse_state(ts_node__subtree(self));
+}
+
+TSStateId ts_node_next_parse_state(TSNode self) {
+  const TSLanguage *language = self.tree->language;
+  uint16_t state = ts_node_parse_state(self);
+  if (state == TS_TREE_STATE_NONE) {
+    return TS_TREE_STATE_NONE;
+  }
+  uint16_t symbol = ts_node_grammar_symbol(self);
+  return ts_language_next_state(language, state, symbol);
+}
+
+TSNode ts_node_parent(TSNode self) {
+  TSNode node = ts_tree_root_node(self.tree);
+  if (node.id == self.id) return ts_node__null();
+
+  while (true) {
+    TSNode next_node = ts_node_child_with_descendant(node, self);
+    if (next_node.id == self.id || ts_node_is_null(next_node)) break;
+    node = next_node;
+  }
+
+  return node;
+}
+
+TSNode ts_node_child_with_descendant(TSNode self, TSNode descendant) {
+  uint32_t start_byte = ts_node_start_byte(descendant);
+  uint32_t end_byte = ts_node_end_byte(descendant);
+  bool is_empty = start_byte == end_byte;
+
+  do {
+    NodeChildIterator iter = ts_node_iterate_children(&self);
+    do {
+      if (
+        !ts_node_child_iterator_next(&iter, &self)
+        || ts_node_start_byte(self) > start_byte
+      ) {
+        return ts_node__null();
+      }
+      if (self.id == descendant.id) {
+        return self;
+      }
+
+      // If the descendant is empty, and the end byte is within `self`,
+      // we check whether `self` contains it or not.
+      if (is_empty && iter.position.bytes >= end_byte && ts_node_child_count(self) > 0) {
+        TSNode child = ts_node_child_with_descendant(self, descendant);
+        // If the child is not null, return self if it's relevant, else return the child
+        if (!ts_node_is_null(child)) {
+          return ts_node__is_relevant(self, true) ? self : child;
+        }
+      }
+    } while ((is_empty ? iter.position.bytes <= end_byte : iter.position.bytes < end_byte) || ts_node_child_count(self) == 0);
+  } while (!ts_node__is_relevant(self, true));
+
+  return self;
+}
+
+TSNode ts_node_child(TSNode self, uint32_t child_index) {
+  return ts_node__child(self, child_index, true);
+}
+
+TSNode ts_node_named_child(TSNode self, uint32_t child_index) {
+  return ts_node__child(self, child_index, false);
+}
+
+TSNode ts_node_child_by_field_id(TSNode self, TSFieldId field_id) {
+recur:
+  if (!field_id || ts_node_child_count(self) == 0) return ts_node__null();
+
+  const TSFieldMapEntry *field_map, *field_map_end;
+  ts_language_field_map(
+    self.tree->language,
+    ts_node__subtree(self).ptr->production_id,
+    &field_map,
+    &field_map_end
+  );
+  if (field_map == field_map_end) return ts_node__null();
+
+  // The field mappings are sorted by their field id. Scan all
+  // the mappings to find the ones for the given field id.
+  while (field_map->field_id < field_id) {
+    field_map++;
+    if (field_map == field_map_end) return ts_node__null();
+  }
+  while (field_map_end[-1].field_id > field_id) {
+    field_map_end--;
+    if (field_map == field_map_end) return ts_node__null();
+  }
+
+  TSNode child;
+  NodeChildIterator iterator = ts_node_iterate_children(&self);
+  while (ts_node_child_iterator_next(&iterator, &child)) {
+    if (!ts_subtree_extra(ts_node__subtree(child))) {
+      uint32_t index = iterator.structural_child_index - 1;
+      if (index < field_map->child_index) continue;
+
+      // Hidden nodes' fields are "inherited" by their visible parent.
+      if (field_map->inherited) {
+
+        // If this is the *last* possible child node for this field,
+        // then perform a tail call to avoid recursion.
+        if (field_map + 1 == field_map_end) {
+          self = child;
+          goto recur;
+        }
+
+        // Otherwise, descend into this child, but if it doesn't contain
+        // the field, continue searching subsequent children.
+        else {
+          TSNode result = ts_node_child_by_field_id(child, field_id);
+          if (result.id) return result;
+          field_map++;
+          if (field_map == field_map_end) return ts_node__null();
+        }
+      }
+
+      else if (ts_node__is_relevant(child, true)) {
+        return child;
+      }
+
+      // If the field refers to a hidden node with visible children,
+      // return the first visible child.
+      else if (ts_node_child_count(child) > 0 ) {
+        return ts_node_child(child, 0);
+      }
+
+      // Otherwise, continue searching subsequent children.
+      else {
+        field_map++;
+        if (field_map == field_map_end) return ts_node__null();
+      }
+    }
+  }
+
+  return ts_node__null();
+}
+
+static inline const char *ts_node__field_name_from_language(TSNode self, uint32_t structural_child_index) {
+    const TSFieldMapEntry *field_map, *field_map_end;
+    ts_language_field_map(
+      self.tree->language,
+      ts_node__subtree(self).ptr->production_id,
+      &field_map,
+      &field_map_end
+    );
+    for (; field_map != field_map_end; field_map++) {
+      if (!field_map->inherited && field_map->child_index == structural_child_index) {
+        return self.tree->language->field_names[field_map->field_id];
+      }
+    }
+    return NULL;
+}
+
+const char *ts_node_field_name_for_child(TSNode self, uint32_t child_index) {
+  TSNode result = self;
+  bool did_descend = true;
+  const char *inherited_field_name = NULL;
+
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    uint32_t index = 0;
+    NodeChildIterator iterator = ts_node_iterate_children(&result);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (ts_node__is_relevant(child, true)) {
+        if (index == child_index) {
+          if (ts_node_is_extra(child)) {
+            return NULL;
+          }
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) return field_name;
+          return inherited_field_name;
+        }
+        index++;
+      } else {
+        uint32_t grandchild_index = child_index - index;
+        uint32_t grandchild_count = ts_node__relevant_child_count(child, true);
+        if (grandchild_index < grandchild_count) {
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) inherited_field_name = field_name;
+
+          did_descend = true;
+          result = child;
+          child_index = grandchild_index;
+          break;
+        }
+        index += grandchild_count;
+      }
+    }
+  }
+
+  return NULL;
+}
+
+const char *ts_node_field_name_for_named_child(TSNode self, uint32_t named_child_index) {
+  TSNode result = self;
+  bool did_descend = true;
+  const char *inherited_field_name = NULL;
+
+  while (did_descend) {
+    did_descend = false;
+
+    TSNode child;
+    uint32_t index = 0;
+    NodeChildIterator iterator = ts_node_iterate_children(&result);
+    while (ts_node_child_iterator_next(&iterator, &child)) {
+      if (ts_node__is_relevant(child, false)) {
+        if (index == named_child_index) {
+          if (ts_node_is_extra(child)) {
+            return NULL;
+          }
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) return field_name;
+          return inherited_field_name;
+        }
+        index++;
+      } else {
+        uint32_t named_grandchild_index = named_child_index - index;
+        uint32_t grandchild_count = ts_node__relevant_child_count(child, false);
+        if (named_grandchild_index < grandchild_count) {
+          const char *field_name = ts_node__field_name_from_language(result, iterator.structural_child_index - 1);
+          if (field_name) inherited_field_name = field_name;
+
+          did_descend = true;
+          result = child;
+          named_child_index = named_grandchild_index;
+          break;
+        }
+        index += grandchild_count;
+      }
+    }
+  }
+
+  return NULL;
+}
+
+TSNode ts_node_child_by_field_name(
+  TSNode self,
+  const char *name,
+  uint32_t name_length
+) {
+  TSFieldId field_id = ts_language_field_id_for_name(
+    self.tree->language,
+    name,
+    name_length
+  );
+  return ts_node_child_by_field_id(self, field_id);
+}
+
+uint32_t ts_node_child_count(TSNode self) {
+  Subtree tree = ts_node__subtree(self);
+  if (ts_subtree_child_count(tree) > 0) {
+    return tree.ptr->visible_child_count;
+  } else {
+    return 0;
+  }
+}
+
+uint32_t ts_node_named_child_count(TSNode self) {
+  Subtree tree = ts_node__subtree(self);
+  if (ts_subtree_child_count(tree) > 0) {
+    return tree.ptr->named_child_count;
+  } else {
+    return 0;
+  }
+}
+
+TSNode ts_node_next_sibling(TSNode self) {
+  return ts_node__next_sibling(self, true);
+}
+
+TSNode ts_node_next_named_sibling(TSNode self) {
+  return ts_node__next_sibling(self, false);
+}
+
+TSNode ts_node_prev_sibling(TSNode self) {
+  return ts_node__prev_sibling(self, true);
+}
+
+TSNode ts_node_prev_named_sibling(TSNode self) {
+  return ts_node__prev_sibling(self, false);
+}
+
+TSNode ts_node_first_child_for_byte(TSNode self, uint32_t byte) {
+  return ts_node__first_child_for_byte(self, byte, true);
+}
+
+TSNode ts_node_first_named_child_for_byte(TSNode self, uint32_t byte) {
+  return ts_node__first_child_for_byte(self, byte, false);
+}
+
+TSNode ts_node_descendant_for_byte_range(
+  TSNode self,
+  uint32_t start,
+  uint32_t end
+) {
+  return ts_node__descendant_for_byte_range(self, start, end, true);
+}
+
+TSNode ts_node_named_descendant_for_byte_range(
+  TSNode self,
+  uint32_t start,
+  uint32_t end
+) {
+  return ts_node__descendant_for_byte_range(self, start, end, false);
+}
+
+TSNode ts_node_descendant_for_point_range(
+  TSNode self,
+  TSPoint start,
+  TSPoint end
+) {
+  return ts_node__descendant_for_point_range(self, start, end, true);
+}
+
+TSNode ts_node_named_descendant_for_point_range(
+  TSNode self,
+  TSPoint start,
+  TSPoint end
+) {
+  return ts_node__descendant_for_point_range(self, start, end, false);
+}
+
+void ts_node_edit(TSNode *self, const TSInputEdit *edit) {
+  uint32_t start_byte = ts_node_start_byte(*self);
+  TSPoint start_point = ts_node_start_point(*self);
+
+  ts_point_edit(&start_point, &start_byte, edit);
+
+  self->context[0] = start_byte;
+  self->context[1] = start_point.row;
+  self->context[2] = start_point.column;
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/parser.c b/src/library/ts/src/tree-sitter/lib/src/parser.c
new file mode 100644
index 0000000000..d869fd4a32
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/parser.c
@@ -0,0 +1,2263 @@
+#include <stdio.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include "tree_sitter/api.h"
+#include "./alloc.h"
+#include "./array.h"
+#include "./error_costs.h"
+#include "./get_changed_ranges.h"
+#include "./language.h"
+#include "./length.h"
+#include "./lexer.h"
+#include "./reduce_action.h"
+#include "./reusable_node.h"
+#include "./stack.h"
+#include "./subtree.h"
+#include "./tree.h"
+#include "./ts_assert.h"
+#include "./wasm_store.h"
+
+#define LOG(...)                                                                            \
+  if (self->lexer.logger.log || self->dot_graph_file) {                                     \
+    snprintf(self->lexer.debug_buffer, TREE_SITTER_SERIALIZATION_BUFFER_SIZE, __VA_ARGS__); \
+    ts_parser__log(self);                                                                   \
+  }
+
+#define LOG_LOOKAHEAD(symbol_name, size)                      \
+  if (self->lexer.logger.log || self->dot_graph_file) {       \
+    char *buf = self->lexer.debug_buffer;                     \
+    const char *symbol = symbol_name;                         \
+    int off = snprintf(                                       \
+      buf,                                                    \
+      TREE_SITTER_SERIALIZATION_BUFFER_SIZE,                  \
+      "lexed_lookahead sym:"                                  \
+    );                                                        \
+    for (                                                     \
+      int i = 0;                                              \
+      symbol[i] != '\0'                                       \
+      && off < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;         \
+      i++                                                     \
+    ) {                                                       \
+      switch (symbol[i]) {                                    \
+      case '\t': buf[off++] = '\\'; buf[off++] = 't'; break;  \
+      case '\n': buf[off++] = '\\'; buf[off++] = 'n'; break;  \
+      case '\v': buf[off++] = '\\'; buf[off++] = 'v'; break;  \
+      case '\f': buf[off++] = '\\'; buf[off++] = 'f'; break;  \
+      case '\r': buf[off++] = '\\'; buf[off++] = 'r'; break;  \
+      case '\\': buf[off++] = '\\'; buf[off++] = '\\'; break; \
+      default:   buf[off++] = symbol[i]; break;               \
+      }                                                       \
+    }                                                         \
+    snprintf(                                                 \
+      buf + off,                                              \
+      TREE_SITTER_SERIALIZATION_BUFFER_SIZE - off,            \
+      ", size:%u",                                            \
+      size                                                    \
+    );                                                        \
+    ts_parser__log(self);                                     \
+  }
+
+#define LOG_STACK()                                                              \
+  if (self->dot_graph_file) {                                                    \
+    ts_stack_print_dot_graph(self->stack, self->language, self->dot_graph_file); \
+    fputs("\n\n", self->dot_graph_file);                                         \
+  }
+
+#define LOG_TREE(tree)                                                      \
+  if (self->dot_graph_file) {                                               \
+    ts_subtree_print_dot_graph(tree, self->language, self->dot_graph_file); \
+    fputs("\n", self->dot_graph_file);                                      \
+  }
+
+#define SYM_NAME(symbol) ts_language_symbol_name(self->language, symbol)
+
+#define TREE_NAME(tree) SYM_NAME(ts_subtree_symbol(tree))
+
+static const unsigned MAX_VERSION_COUNT = 6;
+static const unsigned MAX_VERSION_COUNT_OVERFLOW = 4;
+static const unsigned MAX_SUMMARY_DEPTH = 16;
+static const unsigned MAX_COST_DIFFERENCE = 18 * ERROR_COST_PER_SKIPPED_TREE;
+static const unsigned OP_COUNT_PER_PARSER_CALLBACK_CHECK = 100;
+
+typedef struct {
+  Subtree token;
+  Subtree last_external_token;
+  uint32_t byte_index;
+} TokenCache;
+
+struct TSParser {
+  Lexer lexer;
+  Stack *stack;
+  SubtreePool tree_pool;
+  const TSLanguage *language;
+  TSWasmStore *wasm_store;
+  ReduceActionSet reduce_actions;
+  Subtree finished_tree;
+  SubtreeArray trailing_extras;
+  SubtreeArray trailing_extras2;
+  SubtreeArray scratch_trees;
+  TokenCache token_cache;
+  ReusableNode reusable_node;
+  void *external_scanner_payload;
+  FILE *dot_graph_file;
+  unsigned accept_count;
+  unsigned operation_count;
+  Subtree old_tree;
+  TSRangeArray included_range_differences;
+  TSParseOptions parse_options;
+  TSParseState parse_state;
+  unsigned included_range_difference_index;
+  bool has_scanner_error;
+  bool canceled_balancing;
+  bool has_error;
+};
+
+typedef struct {
+  unsigned cost;
+  unsigned node_count;
+  int dynamic_precedence;
+  bool is_in_error;
+} ErrorStatus;
+
+typedef enum {
+  ErrorComparisonTakeLeft,
+  ErrorComparisonPreferLeft,
+  ErrorComparisonNone,
+  ErrorComparisonPreferRight,
+  ErrorComparisonTakeRight,
+} ErrorComparison;
+
+typedef struct {
+  const char *string;
+  uint32_t length;
+} TSStringInput;
+
+// StringInput
+
+static const char *ts_string_input_read(
+  void *_self,
+  uint32_t byte,
+  TSPoint point,
+  uint32_t *length
+) {
+  (void)point;
+  TSStringInput *self = (TSStringInput *)_self;
+  if (byte >= self->length) {
+    *length = 0;
+    return "";
+  } else {
+    *length = self->length - byte;
+    return self->string + byte;
+  }
+}
+
+// Parser - Private
+
+static void ts_parser__log(TSParser *self) {
+  if (self->lexer.logger.log) {
+    self->lexer.logger.log(
+      self->lexer.logger.payload,
+      TSLogTypeParse,
+      self->lexer.debug_buffer
+    );
+  }
+
+  if (self->dot_graph_file) {
+    fprintf(self->dot_graph_file, "graph {\nlabel=\"");
+    for (char *chr = &self->lexer.debug_buffer[0]; *chr != 0; chr++) {
+      if (*chr == '"' || *chr == '\\') fputc('\\', self->dot_graph_file);
+      fputc(*chr, self->dot_graph_file);
+    }
+    fprintf(self->dot_graph_file, "\"\n}\n\n");
+  }
+}
+
+static bool ts_parser__breakdown_top_of_stack(
+  TSParser *self,
+  StackVersion version
+) {
+  bool did_break_down = false;
+  bool pending = false;
+
+  do {
+    StackSliceArray pop = ts_stack_pop_pending(self->stack, version);
+    if (!pop.size) break;
+
+    did_break_down = true;
+    pending = false;
+    for (uint32_t i = 0; i < pop.size; i++) {
+      StackSlice slice = *array_get(&pop, i);
+      TSStateId state = ts_stack_state(self->stack, slice.version);
+      Subtree parent = *array_front(&slice.subtrees);
+
+      for (uint32_t j = 0, n = ts_subtree_child_count(parent); j < n; j++) {
+        Subtree child = ts_subtree_children(parent)[j];
+        pending = ts_subtree_child_count(child) > 0;
+
+        if (ts_subtree_is_error(child)) {
+          state = ERROR_STATE;
+        } else if (!ts_subtree_extra(child)) {
+          state = ts_language_next_state(self->language, state, ts_subtree_symbol(child));
+        }
+
+        ts_subtree_retain(child);
+        ts_stack_push(self->stack, slice.version, child, pending, state);
+      }
+
+      for (uint32_t j = 1; j < slice.subtrees.size; j++) {
+        Subtree tree = *array_get(&slice.subtrees, j);
+        ts_stack_push(self->stack, slice.version, tree, false, state);
+      }
+
+      ts_subtree_release(&self->tree_pool, parent);
+      array_delete(&slice.subtrees);
+
+      LOG("breakdown_top_of_stack tree:%s", TREE_NAME(parent));
+      LOG_STACK();
+    }
+  } while (pending);
+
+  return did_break_down;
+}
+
+static void ts_parser__breakdown_lookahead(
+  TSParser *self,
+  Subtree *lookahead,
+  TSStateId state,
+  ReusableNode *reusable_node
+) {
+  bool did_descend = false;
+  Subtree tree = reusable_node_tree(reusable_node);
+  while (ts_subtree_child_count(tree) > 0 && ts_subtree_parse_state(tree) != state) {
+    LOG("state_mismatch sym:%s", TREE_NAME(tree));
+    reusable_node_descend(reusable_node);
+    tree = reusable_node_tree(reusable_node);
+    did_descend = true;
+  }
+
+  if (did_descend) {
+    ts_subtree_release(&self->tree_pool, *lookahead);
+    *lookahead = tree;
+    ts_subtree_retain(*lookahead);
+  }
+}
+
+static ErrorComparison ts_parser__compare_versions(
+  TSParser *self,
+  ErrorStatus a,
+  ErrorStatus b
+) {
+  (void)self;
+  if (!a.is_in_error && b.is_in_error) {
+    if (a.cost < b.cost) {
+      return ErrorComparisonTakeLeft;
+    } else {
+      return ErrorComparisonPreferLeft;
+    }
+  }
+
+  if (a.is_in_error && !b.is_in_error) {
+    if (b.cost < a.cost) {
+      return ErrorComparisonTakeRight;
+    } else {
+      return ErrorComparisonPreferRight;
+    }
+  }
+
+  if (a.cost < b.cost) {
+    if ((b.cost - a.cost) * (1 + a.node_count) > MAX_COST_DIFFERENCE) {
+      return ErrorComparisonTakeLeft;
+    } else {
+      return ErrorComparisonPreferLeft;
+    }
+  }
+
+  if (b.cost < a.cost) {
+    if ((a.cost - b.cost) * (1 + b.node_count) > MAX_COST_DIFFERENCE) {
+      return ErrorComparisonTakeRight;
+    } else {
+      return ErrorComparisonPreferRight;
+    }
+  }
+
+  if (a.dynamic_precedence > b.dynamic_precedence) return ErrorComparisonPreferLeft;
+  if (b.dynamic_precedence > a.dynamic_precedence) return ErrorComparisonPreferRight;
+  return ErrorComparisonNone;
+}
+
+static ErrorStatus ts_parser__version_status(
+  TSParser *self,
+  StackVersion version
+) {
+  unsigned cost = ts_stack_error_cost(self->stack, version);
+  bool is_paused = ts_stack_is_paused(self->stack, version);
+  if (is_paused) cost += ERROR_COST_PER_SKIPPED_TREE;
+  return (ErrorStatus) {
+    .cost = cost,
+    .node_count = ts_stack_node_count_since_error(self->stack, version),
+    .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version),
+    .is_in_error = is_paused || ts_stack_state(self->stack, version) == ERROR_STATE
+  };
+}
+
+static bool ts_parser__better_version_exists(
+  TSParser *self,
+  StackVersion version,
+  bool is_in_error,
+  unsigned cost
+) {
+  if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) <= cost) {
+    return true;
+  }
+
+  Length position = ts_stack_position(self->stack, version);
+  ErrorStatus status = {
+    .cost = cost,
+    .is_in_error = is_in_error,
+    .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version),
+    .node_count = ts_stack_node_count_since_error(self->stack, version),
+  };
+
+  for (StackVersion i = 0, n = ts_stack_version_count(self->stack); i < n; i++) {
+    if (i == version ||
+        !ts_stack_is_active(self->stack, i) ||
+        ts_stack_position(self->stack, i).bytes < position.bytes) continue;
+    ErrorStatus status_i = ts_parser__version_status(self, i);
+    switch (ts_parser__compare_versions(self, status, status_i)) {
+      case ErrorComparisonTakeRight:
+        return true;
+      case ErrorComparisonPreferRight:
+        if (ts_stack_can_merge(self->stack, i, version)) return true;
+        break;
+      default:
+        break;
+    }
+  }
+
+  return false;
+}
+
+static bool ts_parser__call_main_lex_fn(TSParser *self, TSLexerMode lex_mode) {
+  if (ts_language_is_wasm(self->language)) {
+    return ts_wasm_store_call_lex_main(self->wasm_store, lex_mode.lex_state);
+  } else {
+    return self->language->lex_fn(&self->lexer.data, lex_mode.lex_state);
+  }
+}
+
+static bool ts_parser__call_keyword_lex_fn(TSParser *self) {
+  if (ts_language_is_wasm(self->language)) {
+    return ts_wasm_store_call_lex_keyword(self->wasm_store, 0);
+  } else {
+    return self->language->keyword_lex_fn(&self->lexer.data, 0);
+  }
+}
+
+static void ts_parser__external_scanner_create(
+  TSParser *self
+) {
+  if (self->language && self->language->external_scanner.states) {
+    if (ts_language_is_wasm(self->language)) {
+      self->external_scanner_payload = (void *)(uintptr_t)ts_wasm_store_call_scanner_create(
+        self->wasm_store
+      );
+      if (ts_wasm_store_has_error(self->wasm_store)) {
+        self->has_scanner_error = true;
+      }
+    } else if (self->language->external_scanner.create) {
+      self->external_scanner_payload = self->language->external_scanner.create();
+    }
+  }
+}
+
+static void ts_parser__external_scanner_destroy(
+  TSParser *self
+) {
+  if (
+    self->language &&
+    self->external_scanner_payload &&
+    self->language->external_scanner.destroy &&
+    !ts_language_is_wasm(self->language)
+  ) {
+    self->language->external_scanner.destroy(
+      self->external_scanner_payload
+    );
+  }
+  self->external_scanner_payload = NULL;
+}
+
+static unsigned ts_parser__external_scanner_serialize(
+  TSParser *self
+) {
+  uint32_t length;
+  if (ts_language_is_wasm(self->language)) {
+    length = ts_wasm_store_call_scanner_serialize(
+      self->wasm_store,
+      (uintptr_t)self->external_scanner_payload,
+      self->lexer.debug_buffer
+    );
+    if (ts_wasm_store_has_error(self->wasm_store)) {
+      self->has_scanner_error = true;
+    }
+  } else {
+    length = self->language->external_scanner.serialize(
+      self->external_scanner_payload,
+      self->lexer.debug_buffer
+    );
+  }
+  ts_assert(length <= TREE_SITTER_SERIALIZATION_BUFFER_SIZE);
+  return length;
+}
+
+static void ts_parser__external_scanner_deserialize(
+  TSParser *self,
+  Subtree external_token
+) {
+  const char *data = NULL;
+  uint32_t length = 0;
+  if (external_token.ptr) {
+    data = ts_external_scanner_state_data(&external_token.ptr->external_scanner_state);
+    length = external_token.ptr->external_scanner_state.length;
+  }
+
+  if (ts_language_is_wasm(self->language)) {
+    ts_wasm_store_call_scanner_deserialize(
+      self->wasm_store,
+      (uintptr_t)self->external_scanner_payload,
+      data,
+      length
+    );
+    if (ts_wasm_store_has_error(self->wasm_store)) {
+      self->has_scanner_error = true;
+    }
+  } else {
+    self->language->external_scanner.deserialize(
+      self->external_scanner_payload,
+      data,
+      length
+    );
+  }
+}
+
+static bool ts_parser__external_scanner_scan(
+  TSParser *self,
+  TSStateId external_lex_state
+) {
+  if (ts_language_is_wasm(self->language)) {
+    bool result = ts_wasm_store_call_scanner_scan(
+      self->wasm_store,
+      (uintptr_t)self->external_scanner_payload,
+      external_lex_state * self->language->external_token_count
+    );
+    if (ts_wasm_store_has_error(self->wasm_store)) {
+      self->has_scanner_error = true;
+    }
+    return result;
+  } else {
+    const bool *valid_external_tokens = ts_language_enabled_external_tokens(
+      self->language,
+      external_lex_state
+    );
+    return self->language->external_scanner.scan(
+      self->external_scanner_payload,
+      &self->lexer.data,
+      valid_external_tokens
+    );
+  }
+}
+
+static bool ts_parser__can_reuse_first_leaf(
+  TSParser *self,
+  TSStateId state,
+  Subtree tree,
+  TableEntry *table_entry
+) {
+  TSSymbol leaf_symbol = ts_subtree_leaf_symbol(tree);
+  TSStateId leaf_state = ts_subtree_leaf_parse_state(tree);
+  TSLexerMode current_lex_mode = ts_language_lex_mode_for_state(self->language, state);
+  TSLexerMode leaf_lex_mode = ts_language_lex_mode_for_state(self->language, leaf_state);
+
+  // At the end of a non-terminal extra node, the lexer normally returns
+  // NULL, which indicates that the parser should look for a reduce action
+  // at symbol `0`. Avoid reusing tokens in this situation to ensure that
+  // the same thing happens when incrementally reparsing.
+  if (current_lex_mode.lex_state == (uint16_t)(-1)) return false;
+
+  // If the token was created in a state with the same set of lookaheads, it is reusable.
+  if (
+    table_entry->action_count > 0 &&
+    memcmp(&leaf_lex_mode, &current_lex_mode, sizeof(TSLexerMode)) == 0 &&
+    (
+      leaf_symbol != self->language->keyword_capture_token ||
+      (!ts_subtree_is_keyword(tree) && ts_subtree_parse_state(tree) == state)
+    )
+  ) return true;
+
+  // Empty tokens are not reusable in states with different lookaheads.
+  if (ts_subtree_size(tree).bytes == 0 && leaf_symbol != ts_builtin_sym_end) return false;
+
+  // If the current state allows external tokens or other tokens that conflict with this
+  // token, this token is not reusable.
+  return current_lex_mode.external_lex_state == 0 && table_entry->is_reusable;
+}
+
+static Subtree ts_parser__lex(
+  TSParser *self,
+  StackVersion version,
+  TSStateId parse_state
+) {
+  TSLexerMode lex_mode = ts_language_lex_mode_for_state(self->language, parse_state);
+  if (lex_mode.lex_state == (uint16_t)-1) {
+    LOG("no_lookahead_after_non_terminal_extra");
+    return NULL_SUBTREE;
+  }
+
+  const Length start_position = ts_stack_position(self->stack, version);
+  const Subtree external_token = ts_stack_last_external_token(self->stack, version);
+
+  bool found_external_token = false;
+  bool error_mode = parse_state == ERROR_STATE;
+  bool skipped_error = false;
+  bool called_get_column = false;
+  int32_t first_error_character = 0;
+  Length error_start_position = length_zero();
+  Length error_end_position = length_zero();
+  uint32_t lookahead_end_byte = 0;
+  uint32_t external_scanner_state_len = 0;
+  bool external_scanner_state_changed = false;
+  ts_lexer_reset(&self->lexer, start_position);
+
+  for (;;) {
+    bool found_token = false;
+    Length current_position = self->lexer.current_position;
+    ColumnData column_data = self->lexer.column_data;
+
+    if (lex_mode.external_lex_state != 0) {
+      LOG(
+        "lex_external state:%d, row:%u, column:%u",
+        lex_mode.external_lex_state,
+        current_position.extent.row,
+        current_position.extent.column
+      );
+      ts_lexer_start(&self->lexer);
+      ts_parser__external_scanner_deserialize(self, external_token);
+      found_token = ts_parser__external_scanner_scan(self, lex_mode.external_lex_state);
+      if (self->has_scanner_error) return NULL_SUBTREE;
+      ts_lexer_finish(&self->lexer, &lookahead_end_byte);
+
+      if (found_token) {
+        external_scanner_state_len = ts_parser__external_scanner_serialize(self);
+        external_scanner_state_changed = !ts_external_scanner_state_eq(
+          ts_subtree_external_scanner_state(external_token),
+          self->lexer.debug_buffer,
+          external_scanner_state_len
+        );
+
+        // Avoid infinite loops caused by the external scanner returning empty tokens.
+        // Empty tokens are needed in some circumstances, e.g. indent/dedent tokens
+        // in Python. Ignore the following classes of empty tokens:
+        //
+        // * Tokens produced during error recovery. When recovering from an error,
+        //   all tokens are allowed, so it's easy to accidentally return unwanted
+        //   empty tokens.
+        // * Tokens that are marked as 'extra' in the grammar. These don't change
+        //   the parse state, so they would definitely cause an infinite loop.
+        if (
+          self->lexer.token_end_position.bytes <= current_position.bytes &&
+          !external_scanner_state_changed
+        ) {
+          TSSymbol symbol = self->language->external_scanner.symbol_map[self->lexer.data.result_symbol];
+          TSStateId next_parse_state = ts_language_next_state(self->language, parse_state, symbol);
+          bool token_is_extra = (next_parse_state == parse_state);
+          if (error_mode || !ts_stack_has_advanced_since_error(self->stack, version) || token_is_extra) {
+            LOG(
+              "ignore_empty_external_token symbol:%s",
+              SYM_NAME(self->language->external_scanner.symbol_map[self->lexer.data.result_symbol])
+            );
+            found_token = false;
+          }
+        }
+      }
+
+      if (found_token) {
+        found_external_token = true;
+        called_get_column = self->lexer.did_get_column;
+        break;
+      }
+
+      ts_lexer_reset(&self->lexer, current_position);
+      self->lexer.column_data = column_data;
+    }
+
+    LOG(
+      "lex_internal state:%d, row:%u, column:%u",
+      lex_mode.lex_state,
+      current_position.extent.row,
+      current_position.extent.column
+    );
+    ts_lexer_start(&self->lexer);
+    found_token = ts_parser__call_main_lex_fn(self, lex_mode);
+    ts_lexer_finish(&self->lexer, &lookahead_end_byte);
+    if (found_token) break;
+
+    if (!error_mode) {
+      error_mode = true;
+      lex_mode = ts_language_lex_mode_for_state(self->language, ERROR_STATE);
+      ts_lexer_reset(&self->lexer, start_position);
+      continue;
+    }
+
+    if (!skipped_error) {
+      LOG("skip_unrecognized_character");
+      skipped_error = true;
+      error_start_position = self->lexer.token_start_position;
+      error_end_position = self->lexer.token_start_position;
+      first_error_character = self->lexer.data.lookahead;
+    }
+
+    if (self->lexer.current_position.bytes == error_end_position.bytes) {
+      if (self->lexer.data.eof(&self->lexer.data)) {
+        self->lexer.data.result_symbol = ts_builtin_sym_error;
+        break;
+      }
+      self->lexer.data.advance(&self->lexer.data, false);
+    }
+
+    error_end_position = self->lexer.current_position;
+  }
+
+  Subtree result;
+  if (skipped_error) {
+    Length padding = length_sub(error_start_position, start_position);
+    Length size = length_sub(error_end_position, error_start_position);
+    uint32_t lookahead_bytes = lookahead_end_byte - error_end_position.bytes;
+    result = ts_subtree_new_error(
+      &self->tree_pool,
+      first_error_character,
+      padding,
+      size,
+      lookahead_bytes,
+      parse_state,
+      self->language
+    );
+  } else {
+    bool is_keyword = false;
+    TSSymbol symbol = self->lexer.data.result_symbol;
+    Length padding = length_sub(self->lexer.token_start_position, start_position);
+    Length size = length_sub(self->lexer.token_end_position, self->lexer.token_start_position);
+    uint32_t lookahead_bytes = lookahead_end_byte - self->lexer.token_end_position.bytes;
+
+    if (found_external_token) {
+      symbol = self->language->external_scanner.symbol_map[symbol];
+    } else if (symbol == self->language->keyword_capture_token && symbol != 0) {
+      uint32_t end_byte = self->lexer.token_end_position.bytes;
+      ts_lexer_reset(&self->lexer, self->lexer.token_start_position);
+      ts_lexer_start(&self->lexer);
+
+      is_keyword = ts_parser__call_keyword_lex_fn(self);
+
+      if (
+        is_keyword &&
+        self->lexer.token_end_position.bytes == end_byte &&
+        (
+          ts_language_has_actions(self->language, parse_state, self->lexer.data.result_symbol) ||
+          ts_language_is_reserved_word(self->language, parse_state, self->lexer.data.result_symbol)
+        )
+      ) {
+        symbol = self->lexer.data.result_symbol;
+      }
+    }
+
+    result = ts_subtree_new_leaf(
+      &self->tree_pool,
+      symbol,
+      padding,
+      size,
+      lookahead_bytes,
+      parse_state,
+      found_external_token,
+      called_get_column,
+      is_keyword,
+      self->language
+    );
+
+    if (found_external_token) {
+      MutableSubtree mut_result = ts_subtree_to_mut_unsafe(result);
+      ts_external_scanner_state_init(
+        &mut_result.ptr->external_scanner_state,
+        self->lexer.debug_buffer,
+        external_scanner_state_len
+      );
+      mut_result.ptr->has_external_scanner_state_change = external_scanner_state_changed;
+    }
+  }
+
+  LOG_LOOKAHEAD(
+    SYM_NAME(ts_subtree_symbol(result)),
+    ts_subtree_total_size(result).bytes
+  );
+  return result;
+}
+
+static Subtree ts_parser__get_cached_token(
+  TSParser *self,
+  TSStateId state,
+  size_t position,
+  Subtree last_external_token,
+  TableEntry *table_entry
+) {
+  TokenCache *cache = &self->token_cache;
+  if (
+    cache->token.ptr && cache->byte_index == position &&
+    ts_subtree_external_scanner_state_eq(cache->last_external_token, last_external_token)
+  ) {
+    ts_language_table_entry(self->language, state, ts_subtree_symbol(cache->token), table_entry);
+    if (ts_parser__can_reuse_first_leaf(self, state, cache->token, table_entry)) {
+      ts_subtree_retain(cache->token);
+      return cache->token;
+    }
+  }
+  return NULL_SUBTREE;
+}
+
+static void ts_parser__set_cached_token(
+  TSParser *self,
+  uint32_t byte_index,
+  Subtree last_external_token,
+  Subtree token
+) {
+  TokenCache *cache = &self->token_cache;
+  if (token.ptr) ts_subtree_retain(token);
+  if (last_external_token.ptr) ts_subtree_retain(last_external_token);
+  if (cache->token.ptr) ts_subtree_release(&self->tree_pool, cache->token);
+  if (cache->last_external_token.ptr) ts_subtree_release(&self->tree_pool, cache->last_external_token);
+  cache->token = token;
+  cache->byte_index = byte_index;
+  cache->last_external_token = last_external_token;
+}
+
+static bool ts_parser__has_included_range_difference(
+  const TSParser *self,
+  uint32_t start_position,
+  uint32_t end_position
+) {
+  return ts_range_array_intersects(
+    &self->included_range_differences,
+    self->included_range_difference_index,
+    start_position,
+    end_position
+  );
+}
+
+static Subtree ts_parser__reuse_node(
+  TSParser *self,
+  StackVersion version,
+  TSStateId *state,
+  uint32_t position,
+  Subtree last_external_token,
+  TableEntry *table_entry
+) {
+  Subtree result;
+  while ((result = reusable_node_tree(&self->reusable_node)).ptr) {
+    uint32_t byte_offset = reusable_node_byte_offset(&self->reusable_node);
+    uint32_t end_byte_offset = byte_offset + ts_subtree_total_bytes(result);
+
+    // Do not reuse an EOF node if the included ranges array has changes
+    // later on in the file.
+    if (ts_subtree_is_eof(result)) end_byte_offset = UINT32_MAX;
+
+    if (byte_offset > position) {
+      LOG("before_reusable_node symbol:%s", TREE_NAME(result));
+      break;
+    }
+
+    if (byte_offset < position) {
+      LOG("past_reusable_node symbol:%s", TREE_NAME(result));
+      if (end_byte_offset <= position || !reusable_node_descend(&self->reusable_node)) {
+        reusable_node_advance(&self->reusable_node);
+      }
+      continue;
+    }
+
+    if (!ts_subtree_external_scanner_state_eq(self->reusable_node.last_external_token, last_external_token)) {
+      LOG("reusable_node_has_different_external_scanner_state symbol:%s", TREE_NAME(result));
+      reusable_node_advance(&self->reusable_node);
+      continue;
+    }
+
+    const char *reason = NULL;
+    if (ts_subtree_has_changes(result)) {
+      reason = "has_changes";
+    } else if (ts_subtree_is_error(result)) {
+      reason = "is_error";
+    } else if (ts_subtree_missing(result)) {
+      reason = "is_missing";
+    } else if (ts_subtree_is_fragile(result)) {
+      reason = "is_fragile";
+    } else if (ts_parser__has_included_range_difference(self, byte_offset, end_byte_offset)) {
+      reason = "contains_different_included_range";
+    }
+
+    if (reason) {
+      LOG("cant_reuse_node_%s tree:%s", reason, TREE_NAME(result));
+      if (!reusable_node_descend(&self->reusable_node)) {
+        reusable_node_advance(&self->reusable_node);
+        ts_parser__breakdown_top_of_stack(self, version);
+        *state = ts_stack_state(self->stack, version);
+      }
+      continue;
+    }
+
+    TSSymbol leaf_symbol = ts_subtree_leaf_symbol(result);
+    ts_language_table_entry(self->language, *state, leaf_symbol, table_entry);
+    if (!ts_parser__can_reuse_first_leaf(self, *state, result, table_entry)) {
+      LOG(
+        "cant_reuse_node symbol:%s, first_leaf_symbol:%s",
+        TREE_NAME(result),
+        SYM_NAME(leaf_symbol)
+      );
+      reusable_node_advance_past_leaf(&self->reusable_node);
+      break;
+    }
+
+    LOG("reuse_node symbol:%s", TREE_NAME(result));
+    ts_subtree_retain(result);
+    return result;
+  }
+
+  return NULL_SUBTREE;
+}
+
+// Determine if a given tree should be replaced by an alternative tree.
+//
+// The decision is based on the trees' error costs (if any), their dynamic precedence,
+// and finally, as a default, by a recursive comparison of the trees' symbols.
+static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right) {
+  if (!left.ptr) return true;
+  if (!right.ptr) return false;
+
+  if (ts_subtree_error_cost(right) < ts_subtree_error_cost(left)) {
+    LOG("select_smaller_error symbol:%s, over_symbol:%s", TREE_NAME(right), TREE_NAME(left));
+    return true;
+  }
+
+  if (ts_subtree_error_cost(left) < ts_subtree_error_cost(right)) {
+    LOG("select_smaller_error symbol:%s, over_symbol:%s", TREE_NAME(left), TREE_NAME(right));
+    return false;
+  }
+
+  if (ts_subtree_dynamic_precedence(right) > ts_subtree_dynamic_precedence(left)) {
+    LOG("select_higher_precedence symbol:%s, prec:%" PRId32 ", over_symbol:%s, other_prec:%" PRId32,
+        TREE_NAME(right), ts_subtree_dynamic_precedence(right), TREE_NAME(left),
+        ts_subtree_dynamic_precedence(left));
+    return true;
+  }
+
+  if (ts_subtree_dynamic_precedence(left) > ts_subtree_dynamic_precedence(right)) {
+    LOG("select_higher_precedence symbol:%s, prec:%" PRId32 ", over_symbol:%s, other_prec:%" PRId32,
+        TREE_NAME(left), ts_subtree_dynamic_precedence(left), TREE_NAME(right),
+        ts_subtree_dynamic_precedence(right));
+    return false;
+  }
+
+  if (ts_subtree_error_cost(left) > 0) return true;
+
+  int comparison = ts_subtree_compare(left, right, &self->tree_pool);
+  switch (comparison) {
+    case -1:
+      LOG("select_earlier symbol:%s, over_symbol:%s", TREE_NAME(left), TREE_NAME(right));
+      return false;
+      break;
+    case 1:
+      LOG("select_earlier symbol:%s, over_symbol:%s", TREE_NAME(right), TREE_NAME(left));
+      return true;
+    default:
+      LOG("select_existing symbol:%s, over_symbol:%s", TREE_NAME(left), TREE_NAME(right));
+      return false;
+  }
+}
+
+// Determine if a given tree's children should be replaced by an alternative
+// array of children.
+static bool ts_parser__select_children(
+  TSParser *self,
+  Subtree left,
+  const SubtreeArray *children
+) {
+  array_assign(&self->scratch_trees, children);
+
+  // Create a temporary subtree using the scratch trees array. This node does
+  // not perform any allocation except for possibly growing the array to make
+  // room for its own heap data. The scratch tree is never explicitly released,
+  // so the same 'scratch trees' array can be reused again later.
+  MutableSubtree scratch_tree = ts_subtree_new_node(
+    ts_subtree_symbol(left),
+    &self->scratch_trees,
+    0,
+    self->language
+  );
+
+  return ts_parser__select_tree(
+    self,
+    left,
+    ts_subtree_from_mut(scratch_tree)
+  );
+}
+
+static void ts_parser__shift(
+  TSParser *self,
+  StackVersion version,
+  TSStateId state,
+  Subtree lookahead,
+  bool extra
+) {
+  bool is_leaf = ts_subtree_child_count(lookahead) == 0;
+  Subtree subtree_to_push = lookahead;
+  if (extra != ts_subtree_extra(lookahead) && is_leaf) {
+    MutableSubtree result = ts_subtree_make_mut(&self->tree_pool, lookahead);
+    ts_subtree_set_extra(&result, extra);
+    subtree_to_push = ts_subtree_from_mut(result);
+  }
+
+  ts_stack_push(self->stack, version, subtree_to_push, !is_leaf, state);
+  if (ts_subtree_has_external_tokens(subtree_to_push)) {
+    ts_stack_set_last_external_token(
+      self->stack, version, ts_subtree_last_external_token(subtree_to_push)
+    );
+  }
+}
+
+static StackVersion ts_parser__reduce(
+  TSParser *self,
+  StackVersion version,
+  TSSymbol symbol,
+  uint32_t count,
+  int dynamic_precedence,
+  uint16_t production_id,
+  bool is_fragile,
+  bool end_of_non_terminal_extra
+) {
+  uint32_t initial_version_count = ts_stack_version_count(self->stack);
+
+  // Pop the given number of nodes from the given version of the parse stack.
+  // If stack versions have previously merged, then there may be more than one
+  // path back through the stack. For each path, create a new parent node to
+  // contain the popped children, and push it onto the stack in place of the
+  // children.
+  StackSliceArray pop = ts_stack_pop_count(self->stack, version, count);
+  uint32_t removed_version_count = 0;
+  uint32_t halted_version_count = ts_stack_halted_version_count(self->stack);
+  for (uint32_t i = 0; i < pop.size; i++) {
+    StackSlice slice = *array_get(&pop, i);
+    StackVersion slice_version = slice.version - removed_version_count;
+
+    // This is where new versions are added to the parse stack. The versions
+    // will all be sorted and truncated at the end of the outer parsing loop.
+    // Allow the maximum version count to be temporarily exceeded, but only
+    // by a limited threshold.
+    if (slice_version > MAX_VERSION_COUNT + MAX_VERSION_COUNT_OVERFLOW + halted_version_count) {
+      ts_stack_remove_version(self->stack, slice_version);
+      ts_subtree_array_delete(&self->tree_pool, &slice.subtrees);
+      removed_version_count++;
+      while (i + 1 < pop.size) {
+        LOG("aborting reduce with too many versions")
+        StackSlice next_slice = *array_get(&pop, i + 1);
+        if (next_slice.version != slice.version) break;
+        ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees);
+        i++;
+      }
+      continue;
+    }
+
+    // Extra tokens on top of the stack should not be included in this new parent
+    // node. They will be re-pushed onto the stack after the parent node is
+    // created and pushed.
+    SubtreeArray children = slice.subtrees;
+    ts_subtree_array_remove_trailing_extras(&children, &self->trailing_extras);
+
+    MutableSubtree parent = ts_subtree_new_node(
+      symbol, &children, production_id, self->language
+    );
+
+    // This pop operation may have caused multiple stack versions to collapse
+    // into one, because they all diverged from a common state. In that case,
+    // choose one of the arrays of trees to be the parent node's children, and
+    // delete the rest of the tree arrays.
+    while (i + 1 < pop.size) {
+      StackSlice next_slice = *array_get(&pop, i + 1);
+      if (next_slice.version != slice.version) break;
+      i++;
+
+      SubtreeArray next_slice_children = next_slice.subtrees;
+      ts_subtree_array_remove_trailing_extras(&next_slice_children, &self->trailing_extras2);
+
+      if (ts_parser__select_children(
+        self,
+        ts_subtree_from_mut(parent),
+        &next_slice_children
+      )) {
+        ts_subtree_array_clear(&self->tree_pool, &self->trailing_extras);
+        ts_subtree_release(&self->tree_pool, ts_subtree_from_mut(parent));
+        array_swap(&self->trailing_extras, &self->trailing_extras2);
+        parent = ts_subtree_new_node(
+          symbol, &next_slice_children, production_id, self->language
+        );
+      } else {
+        array_clear(&self->trailing_extras2);
+        ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees);
+      }
+    }
+
+    TSStateId state = ts_stack_state(self->stack, slice_version);
+    TSStateId next_state = ts_language_next_state(self->language, state, symbol);
+    if (end_of_non_terminal_extra && next_state == state) {
+      parent.ptr->extra = true;
+    }
+    if (is_fragile || pop.size > 1 || initial_version_count > 1) {
+      parent.ptr->fragile_left = true;
+      parent.ptr->fragile_right = true;
+      parent.ptr->parse_state = TS_TREE_STATE_NONE;
+    } else {
+      parent.ptr->parse_state = state;
+    }
+    parent.ptr->dynamic_precedence += dynamic_precedence;
+
+    // Push the parent node onto the stack, along with any extra tokens that
+    // were previously on top of the stack.
+    ts_stack_push(self->stack, slice_version, ts_subtree_from_mut(parent), false, next_state);
+    for (uint32_t j = 0; j < self->trailing_extras.size; j++) {
+      ts_stack_push(self->stack, slice_version, *array_get(&self->trailing_extras, j), false, next_state);
+    }
+
+    for (StackVersion j = 0; j < slice_version; j++) {
+      if (j == version) continue;
+      if (ts_stack_merge(self->stack, j, slice_version)) {
+        removed_version_count++;
+        break;
+      }
+    }
+  }
+
+  // Return the first new stack version that was created.
+  return ts_stack_version_count(self->stack) > initial_version_count
+    ? initial_version_count
+    : STACK_VERSION_NONE;
+}
+
+static void ts_parser__accept(
+  TSParser *self,
+  StackVersion version,
+  Subtree lookahead
+) {
+  ts_assert(ts_subtree_is_eof(lookahead));
+  ts_stack_push(self->stack, version, lookahead, false, 1);
+
+  StackSliceArray pop = ts_stack_pop_all(self->stack, version);
+  for (uint32_t i = 0; i < pop.size; i++) {
+    SubtreeArray trees = array_get(&pop, i)->subtrees;
+
+    Subtree root = NULL_SUBTREE;
+    for (uint32_t j = trees.size - 1; j + 1 > 0; j--) {
+      Subtree tree = *array_get(&trees, j);
+      if (!ts_subtree_extra(tree)) {
+        ts_assert(!tree.data.is_inline);
+        uint32_t child_count = ts_subtree_child_count(tree);
+        const Subtree *children = ts_subtree_children(tree);
+        for (uint32_t k = 0; k < child_count; k++) {
+          ts_subtree_retain(children[k]);
+        }
+        array_splice(&trees, j, 1, child_count, children);
+        root = ts_subtree_from_mut(ts_subtree_new_node(
+          ts_subtree_symbol(tree),
+          &trees,
+          tree.ptr->production_id,
+          self->language
+        ));
+        ts_subtree_release(&self->tree_pool, tree);
+        break;
+      }
+    }
+
+    ts_assert(root.ptr);
+    self->accept_count++;
+
+    if (self->finished_tree.ptr) {
+      if (ts_parser__select_tree(self, self->finished_tree, root)) {
+        ts_subtree_release(&self->tree_pool, self->finished_tree);
+        self->finished_tree = root;
+      } else {
+        ts_subtree_release(&self->tree_pool, root);
+      }
+    } else {
+      self->finished_tree = root;
+    }
+  }
+
+  ts_stack_remove_version(self->stack, array_get(&pop, 0)->version);
+  ts_stack_halt(self->stack, version);
+}
+
+static bool ts_parser__do_all_potential_reductions(
+  TSParser *self,
+  StackVersion starting_version,
+  TSSymbol lookahead_symbol
+) {
+  uint32_t initial_version_count = ts_stack_version_count(self->stack);
+
+  bool can_shift_lookahead_symbol = false;
+  StackVersion version = starting_version;
+  for (unsigned i = 0; true; i++) {
+    uint32_t version_count = ts_stack_version_count(self->stack);
+    if (version >= version_count) break;
+
+    bool merged = false;
+    for (StackVersion j = initial_version_count; j < version; j++) {
+      if (ts_stack_merge(self->stack, j, version)) {
+        merged = true;
+        break;
+      }
+    }
+    if (merged) continue;
+
+    TSStateId state = ts_stack_state(self->stack, version);
+    bool has_shift_action = false;
+    array_clear(&self->reduce_actions);
+
+    TSSymbol first_symbol, end_symbol;
+    if (lookahead_symbol != 0) {
+      first_symbol = lookahead_symbol;
+      end_symbol = lookahead_symbol + 1;
+    } else {
+      first_symbol = 1;
+      end_symbol = self->language->token_count;
+    }
+
+    for (TSSymbol symbol = first_symbol; symbol < end_symbol; symbol++) {
+      TableEntry entry;
+      ts_language_table_entry(self->language, state, symbol, &entry);
+      for (uint32_t j = 0; j < entry.action_count; j++) {
+        TSParseAction action = entry.actions[j];
+        switch (action.type) {
+          case TSParseActionTypeShift:
+          case TSParseActionTypeRecover:
+            if (!action.shift.extra && !action.shift.repetition) has_shift_action = true;
+            break;
+          case TSParseActionTypeReduce:
+            if (action.reduce.child_count > 0)
+              ts_reduce_action_set_add(&self->reduce_actions, (ReduceAction) {
+                .symbol = action.reduce.symbol,
+                .count = action.reduce.child_count,
+                .dynamic_precedence = action.reduce.dynamic_precedence,
+                .production_id = action.reduce.production_id,
+              });
+            break;
+          default:
+            break;
+        }
+      }
+    }
+
+    StackVersion reduction_version = STACK_VERSION_NONE;
+    for (uint32_t j = 0; j < self->reduce_actions.size; j++) {
+      ReduceAction action = *array_get(&self->reduce_actions, j);
+
+      reduction_version = ts_parser__reduce(
+        self, version, action.symbol, action.count,
+        action.dynamic_precedence, action.production_id,
+        true, false
+      );
+    }
+
+    if (has_shift_action) {
+      can_shift_lookahead_symbol = true;
+    } else if (reduction_version != STACK_VERSION_NONE && i < MAX_VERSION_COUNT) {
+      ts_stack_renumber_version(self->stack, reduction_version, version);
+      continue;
+    } else if (lookahead_symbol != 0) {
+      ts_stack_remove_version(self->stack, version);
+    }
+
+    if (version == starting_version) {
+      version = version_count;
+    } else {
+      version++;
+    }
+  }
+
+  return can_shift_lookahead_symbol;
+}
+
+static bool ts_parser__recover_to_state(
+  TSParser *self,
+  StackVersion version,
+  unsigned depth,
+  TSStateId goal_state
+) {
+  StackSliceArray pop = ts_stack_pop_count(self->stack, version, depth);
+  StackVersion previous_version = STACK_VERSION_NONE;
+
+  for (unsigned i = 0; i < pop.size; i++) {
+    StackSlice slice = *array_get(&pop, i);
+
+    if (slice.version == previous_version) {
+      ts_subtree_array_delete(&self->tree_pool, &slice.subtrees);
+      array_erase(&pop, i--);
+      continue;
+    }
+
+    if (ts_stack_state(self->stack, slice.version) != goal_state) {
+      ts_stack_halt(self->stack, slice.version);
+      ts_subtree_array_delete(&self->tree_pool, &slice.subtrees);
+      array_erase(&pop, i--);
+      continue;
+    }
+
+    SubtreeArray error_trees = ts_stack_pop_error(self->stack, slice.version);
+    if (error_trees.size > 0) {
+      ts_assert(error_trees.size == 1);
+      Subtree error_tree = *array_get(&error_trees, 0);
+      uint32_t error_child_count = ts_subtree_child_count(error_tree);
+      if (error_child_count > 0) {
+        array_splice(&slice.subtrees, 0, 0, error_child_count, ts_subtree_children(error_tree));
+        for (unsigned j = 0; j < error_child_count; j++) {
+          ts_subtree_retain(*array_get(&slice.subtrees, j));
+        }
+      }
+      ts_subtree_array_delete(&self->tree_pool, &error_trees);
+    }
+
+    ts_subtree_array_remove_trailing_extras(&slice.subtrees, &self->trailing_extras);
+
+    if (slice.subtrees.size > 0) {
+      Subtree error = ts_subtree_new_error_node(&slice.subtrees, true, self->language);
+      ts_stack_push(self->stack, slice.version, error, false, goal_state);
+    } else {
+      array_delete(&slice.subtrees);
+    }
+
+    for (unsigned j = 0; j < self->trailing_extras.size; j++) {
+      Subtree tree = *array_get(&self->trailing_extras, j);
+      ts_stack_push(self->stack, slice.version, tree, false, goal_state);
+    }
+
+    previous_version = slice.version;
+  }
+
+  return previous_version != STACK_VERSION_NONE;
+}
+
+static void ts_parser__recover(
+  TSParser *self,
+  StackVersion version,
+  Subtree lookahead
+) {
+  bool did_recover = false;
+  unsigned previous_version_count = ts_stack_version_count(self->stack);
+  Length position = ts_stack_position(self->stack, version);
+  StackSummary *summary = ts_stack_get_summary(self->stack, version);
+  unsigned node_count_since_error = ts_stack_node_count_since_error(self->stack, version);
+  unsigned current_error_cost = ts_stack_error_cost(self->stack, version);
+
+  // When the parser is in the error state, there are two strategies for recovering with a
+  // given lookahead token:
+  // 1. Find a previous state on the stack in which that lookahead token would be valid. Then,
+  //    create a new stack version that is in that state again. This entails popping all of the
+  //    subtrees that have been pushed onto the stack since that previous state, and wrapping
+  //    them in an ERROR node.
+  // 2. Wrap the lookahead token in an ERROR node, push that ERROR node onto the stack, and
+  //    move on to the next lookahead token, remaining in the error state.
+  //
+  // First, try the strategy 1. Upon entering the error state, the parser recorded a summary
+  // of the previous parse states and their depths. Look at each state in the summary, to see
+  // if the current lookahead token would be valid in that state.
+  if (summary && !ts_subtree_is_error(lookahead)) {
+    for (unsigned i = 0; i < summary->size; i++) {
+      StackSummaryEntry entry = *array_get(summary, i);
+
+      if (entry.state == ERROR_STATE) continue;
+      if (entry.position.bytes == position.bytes) continue;
+      unsigned depth = entry.depth;
+      if (node_count_since_error > 0) depth++;
+
+      // Do not recover in ways that create redundant stack versions.
+      bool would_merge = false;
+      for (unsigned j = 0; j < previous_version_count; j++) {
+        if (
+          ts_stack_state(self->stack, j) == entry.state &&
+          ts_stack_position(self->stack, j).bytes == position.bytes
+        ) {
+          would_merge = true;
+          break;
+        }
+      }
+      if (would_merge) continue;
+
+      // Do not recover if the result would clearly be worse than some existing stack version.
+      unsigned new_cost =
+        current_error_cost +
+        entry.depth * ERROR_COST_PER_SKIPPED_TREE +
+        (position.bytes - entry.position.bytes) * ERROR_COST_PER_SKIPPED_CHAR +
+        (position.extent.row - entry.position.extent.row) * ERROR_COST_PER_SKIPPED_LINE;
+      if (ts_parser__better_version_exists(self, version, false, new_cost)) break;
+
+      // If the current lookahead token is valid in some previous state, recover to that state.
+      // Then stop looking for further recoveries.
+      if (ts_language_has_actions(self->language, entry.state, ts_subtree_symbol(lookahead))) {
+        if (ts_parser__recover_to_state(self, version, depth, entry.state)) {
+          did_recover = true;
+          LOG("recover_to_previous state:%u, depth:%u", entry.state, depth);
+          LOG_STACK();
+          break;
+        }
+      }
+    }
+  }
+
+  // In the process of attempting to recover, some stack versions may have been created
+  // and subsequently halted. Remove those versions.
+  for (unsigned i = previous_version_count; i < ts_stack_version_count(self->stack); i++) {
+    if (!ts_stack_is_active(self->stack, i)) {
+      LOG("removed paused version:%u", i);
+      ts_stack_remove_version(self->stack, i--);
+      LOG_STACK();
+    }
+  }
+
+  // If the parser is still in the error state at the end of the file, just wrap everything
+  // in an ERROR node and terminate.
+  if (ts_subtree_is_eof(lookahead)) {
+    LOG("recover_eof");
+    SubtreeArray children = array_new();
+    Subtree parent = ts_subtree_new_error_node(&children, false, self->language);
+    ts_stack_push(self->stack, version, parent, false, 1);
+    ts_parser__accept(self, version, lookahead);
+    return;
+  }
+
+  // If strategy 1 succeeded, a new stack version will have been created which is able to handle
+  // the current lookahead token. Now, in addition, try strategy 2 described above: skip the
+  // current lookahead token by wrapping it in an ERROR node.
+
+  // Don't pursue this additional strategy if there are already too many stack versions.
+  if (did_recover && ts_stack_version_count(self->stack) > MAX_VERSION_COUNT) {
+    ts_stack_halt(self->stack, version);
+    ts_subtree_release(&self->tree_pool, lookahead);
+    return;
+  }
+
+  if (
+    did_recover &&
+    ts_subtree_has_external_scanner_state_change(lookahead)
+  ) {
+    ts_stack_halt(self->stack, version);
+    ts_subtree_release(&self->tree_pool, lookahead);
+    return;
+  }
+
+  // Do not recover if the result would clearly be worse than some existing stack version.
+  unsigned new_cost =
+    current_error_cost + ERROR_COST_PER_SKIPPED_TREE +
+    ts_subtree_total_bytes(lookahead) * ERROR_COST_PER_SKIPPED_CHAR +
+    ts_subtree_total_size(lookahead).extent.row * ERROR_COST_PER_SKIPPED_LINE;
+  if (ts_parser__better_version_exists(self, version, false, new_cost)) {
+    ts_stack_halt(self->stack, version);
+    ts_subtree_release(&self->tree_pool, lookahead);
+    return;
+  }
+
+  // If the current lookahead token is an extra token, mark it as extra. This means it won't
+  // be counted in error cost calculations.
+  unsigned n;
+  const TSParseAction *actions = ts_language_actions(self->language, 1, ts_subtree_symbol(lookahead), &n);
+  if (n > 0 && actions[n - 1].type == TSParseActionTypeShift && actions[n - 1].shift.extra) {
+    MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead);
+    ts_subtree_set_extra(&mutable_lookahead, true);
+    lookahead = ts_subtree_from_mut(mutable_lookahead);
+  }
+
+  // Wrap the lookahead token in an ERROR.
+  LOG("skip_token symbol:%s", TREE_NAME(lookahead));
+  SubtreeArray children = array_new();
+  array_reserve(&children, 1);
+  array_push(&children, lookahead);
+  MutableSubtree error_repeat = ts_subtree_new_node(
+    ts_builtin_sym_error_repeat,
+    &children,
+    0,
+    self->language
+  );
+
+  // If other tokens have already been skipped, so there is already an ERROR at the top of the
+  // stack, then pop that ERROR off the stack and wrap the two ERRORs together into one larger
+  // ERROR.
+  if (node_count_since_error > 0) {
+    StackSliceArray pop = ts_stack_pop_count(self->stack, version, 1);
+
+    // TODO: Figure out how to make this condition occur.
+    // See https://github.com/atom/atom/issues/18450#issuecomment-439579778
+    // If multiple stack versions have merged at this point, just pick one of the errors
+    // arbitrarily and discard the rest.
+    if (pop.size > 1) {
+      for (unsigned i = 1; i < pop.size; i++) {
+        ts_subtree_array_delete(&self->tree_pool, &array_get(&pop, i)->subtrees);
+      }
+      while (ts_stack_version_count(self->stack) > array_get(&pop, 0)->version + 1) {
+        ts_stack_remove_version(self->stack, array_get(&pop, 0)->version + 1);
+      }
+    }
+
+    ts_stack_renumber_version(self->stack, array_get(&pop, 0)->version, version);
+    array_push(&array_get(&pop, 0)->subtrees, ts_subtree_from_mut(error_repeat));
+    error_repeat = ts_subtree_new_node(
+      ts_builtin_sym_error_repeat,
+      &array_get(&pop, 0)->subtrees,
+      0,
+      self->language
+    );
+  }
+
+  // Push the new ERROR onto the stack.
+  ts_stack_push(self->stack, version, ts_subtree_from_mut(error_repeat), false, ERROR_STATE);
+  if (ts_subtree_has_external_tokens(lookahead)) {
+    ts_stack_set_last_external_token(
+      self->stack, version, ts_subtree_last_external_token(lookahead)
+    );
+  }
+
+  bool has_error = true;
+  for (unsigned i = 0; i < ts_stack_version_count(self->stack); i++) {
+    ErrorStatus status = ts_parser__version_status(self, i);
+    if (!status.is_in_error) {
+      has_error = false;
+      break;
+    }
+  }
+  self->has_error = has_error;
+}
+
+static void ts_parser__handle_error(
+  TSParser *self,
+  StackVersion version,
+  Subtree lookahead
+) {
+  uint32_t previous_version_count = ts_stack_version_count(self->stack);
+
+  // Perform any reductions that can happen in this state, regardless of the lookahead. After
+  // skipping one or more invalid tokens, the parser might find a token that would have allowed
+  // a reduction to take place.
+  ts_parser__do_all_potential_reductions(self, version, 0);
+  uint32_t version_count = ts_stack_version_count(self->stack);
+  Length position = ts_stack_position(self->stack, version);
+
+  // Push a discontinuity onto the stack. Merge all of the stack versions that
+  // were created in the previous step.
+  bool did_insert_missing_token = false;
+  for (StackVersion v = version; v < version_count;) {
+    if (!did_insert_missing_token) {
+      TSStateId state = ts_stack_state(self->stack, v);
+      for (
+        TSSymbol missing_symbol = 1;
+        missing_symbol < (uint16_t)self->language->token_count;
+        missing_symbol++
+      ) {
+        TSStateId state_after_missing_symbol = ts_language_next_state(
+          self->language, state, missing_symbol
+        );
+        if (state_after_missing_symbol == 0 || state_after_missing_symbol == state) {
+          continue;
+        }
+
+        if (ts_language_has_reduce_action(
+          self->language,
+          state_after_missing_symbol,
+          ts_subtree_leaf_symbol(lookahead)
+        )) {
+          // In case the parser is currently outside of any included range, the lexer will
+          // snap to the beginning of the next included range. The missing token's padding
+          // must be assigned to position it within the next included range.
+          ts_lexer_reset(&self->lexer, position);
+          ts_lexer_mark_end(&self->lexer);
+          Length padding = length_sub(self->lexer.token_end_position, position);
+          uint32_t lookahead_bytes = ts_subtree_total_bytes(lookahead) + ts_subtree_lookahead_bytes(lookahead);
+
+          StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v);
+          Subtree missing_tree = ts_subtree_new_missing_leaf(
+            &self->tree_pool, missing_symbol,
+            padding, lookahead_bytes,
+            self->language,
+            state
+          );
+          ts_stack_push(
+            self->stack, version_with_missing_tree,
+            missing_tree, false,
+            state_after_missing_symbol
+          );
+
+          if (ts_parser__do_all_potential_reductions(
+            self, version_with_missing_tree,
+            ts_subtree_leaf_symbol(lookahead)
+          )) {
+            LOG(
+              "recover_with_missing symbol:%s, state:%u",
+              SYM_NAME(missing_symbol),
+              ts_stack_state(self->stack, version_with_missing_tree)
+            );
+            did_insert_missing_token = true;
+            break;
+          }
+        }
+      }
+    }
+
+    ts_stack_push(self->stack, v, NULL_SUBTREE, false, ERROR_STATE);
+    v = (v == version) ? previous_version_count : v + 1;
+  }
+
+  for (unsigned i = previous_version_count; i < version_count; i++) {
+    bool did_merge = ts_stack_merge(self->stack, version, previous_version_count);
+    ts_assert(did_merge);
+  }
+
+  ts_stack_record_summary(self->stack, version, MAX_SUMMARY_DEPTH);
+
+  // Begin recovery with the current lookahead node, rather than waiting for the
+  // next turn of the parse loop. This ensures that the tree accounts for the
+  // current lookahead token's "lookahead bytes" value, which describes how far
+  // the lexer needed to look ahead beyond the content of the token in order to
+  // recognize it.
+  if (ts_subtree_child_count(lookahead) > 0) {
+    ts_parser__breakdown_lookahead(self, &lookahead, ERROR_STATE, &self->reusable_node);
+  }
+  ts_parser__recover(self, version, lookahead);
+
+  LOG_STACK();
+}
+
+static bool ts_parser__check_progress(TSParser *self, Subtree *lookahead, const uint32_t *position, unsigned operations) {
+  self->operation_count += operations;
+  if (self->operation_count >= OP_COUNT_PER_PARSER_CALLBACK_CHECK) {
+    self->operation_count = 0;
+  }
+  if (position != NULL) {
+    self->parse_state.current_byte_offset = *position;
+    self->parse_state.has_error = self->has_error;
+  }
+  if (
+    self->operation_count == 0 &&
+    (self->parse_options.progress_callback && self->parse_options.progress_callback(&self->parse_state))
+  ) {
+    if (lookahead && lookahead->ptr) {
+      ts_subtree_release(&self->tree_pool, *lookahead);
+    }
+    return false;
+  }
+  return true;
+}
+
+static bool ts_parser__advance(
+  TSParser *self,
+  StackVersion version,
+  bool allow_node_reuse
+) {
+  TSStateId state = ts_stack_state(self->stack, version);
+  uint32_t position = ts_stack_position(self->stack, version).bytes;
+  Subtree last_external_token = ts_stack_last_external_token(self->stack, version);
+
+  bool did_reuse = true;
+  Subtree lookahead = NULL_SUBTREE;
+  TableEntry table_entry = {.action_count = 0};
+
+  // If possible, reuse a node from the previous syntax tree.
+  if (allow_node_reuse) {
+    lookahead = ts_parser__reuse_node(
+      self, version, &state, position, last_external_token, &table_entry
+    );
+  }
+
+  // If no node from the previous syntax tree could be reused, then try to
+  // reuse the token previously returned by the lexer.
+  if (!lookahead.ptr) {
+    did_reuse = false;
+    lookahead = ts_parser__get_cached_token(
+      self, state, position, last_external_token, &table_entry
+    );
+  }
+
+  bool needs_lex = !lookahead.ptr;
+  for (;;) {
+    // Otherwise, re-run the lexer.
+    if (needs_lex) {
+      needs_lex = false;
+      lookahead = ts_parser__lex(self, version, state);
+      if (self->has_scanner_error) return false;
+
+      if (lookahead.ptr) {
+        ts_parser__set_cached_token(self, position, last_external_token, lookahead);
+        ts_language_table_entry(self->language, state, ts_subtree_symbol(lookahead), &table_entry);
+      }
+
+      // When parsing a non-terminal extra, a null lookahead indicates the
+      // end of the rule. The reduction is stored in the EOF table entry.
+      // After the reduction, the lexer needs to be run again.
+      else {
+        ts_language_table_entry(self->language, state, ts_builtin_sym_end, &table_entry);
+      }
+    }
+
+    // If a progress callback was provided, then check every
+    // time a fixed number of parse actions has been processed.
+    if (!ts_parser__check_progress(self, &lookahead, &position, 1)) {
+      return false;
+    }
+
+    // Process each parse action for the current lookahead token in
+    // the current state. If there are multiple actions, then this is
+    // an ambiguous state. REDUCE actions always create a new stack
+    // version, whereas SHIFT actions update the existing stack version
+    // and terminate this loop.
+    bool did_reduce = false;
+    StackVersion last_reduction_version = STACK_VERSION_NONE;
+    for (uint32_t i = 0; i < table_entry.action_count; i++) {
+      TSParseAction action = table_entry.actions[i];
+
+      switch (action.type) {
+        case TSParseActionTypeShift: {
+          if (action.shift.repetition) break;
+          TSStateId next_state;
+          if (action.shift.extra) {
+            next_state = state;
+            LOG("shift_extra");
+          } else {
+            next_state = action.shift.state;
+            LOG("shift state:%u", next_state);
+          }
+
+          if (ts_subtree_child_count(lookahead) > 0) {
+            ts_parser__breakdown_lookahead(self, &lookahead, state, &self->reusable_node);
+            next_state = ts_language_next_state(self->language, state, ts_subtree_symbol(lookahead));
+          }
+
+          ts_parser__shift(self, version, next_state, lookahead, action.shift.extra);
+          if (did_reuse) reusable_node_advance(&self->reusable_node);
+          return true;
+        }
+
+        case TSParseActionTypeReduce: {
+          bool is_fragile = table_entry.action_count > 1;
+          bool end_of_non_terminal_extra = lookahead.ptr == NULL;
+          LOG("reduce sym:%s, child_count:%u", SYM_NAME(action.reduce.symbol), action.reduce.child_count);
+          StackVersion reduction_version = ts_parser__reduce(
+            self, version, action.reduce.symbol, action.reduce.child_count,
+            action.reduce.dynamic_precedence, action.reduce.production_id,
+            is_fragile, end_of_non_terminal_extra
+          );
+          did_reduce = true;
+          if (reduction_version != STACK_VERSION_NONE) {
+            last_reduction_version = reduction_version;
+          }
+          break;
+        }
+
+        case TSParseActionTypeAccept: {
+          LOG("accept");
+          ts_parser__accept(self, version, lookahead);
+          return true;
+        }
+
+        case TSParseActionTypeRecover: {
+          if (ts_subtree_child_count(lookahead) > 0) {
+            ts_parser__breakdown_lookahead(self, &lookahead, ERROR_STATE, &self->reusable_node);
+          }
+
+          ts_parser__recover(self, version, lookahead);
+          if (did_reuse) reusable_node_advance(&self->reusable_node);
+          return true;
+        }
+      }
+    }
+
+    // If a reduction was performed, then replace the current stack version
+    // with one of the stack versions created by a reduction, and continue
+    // processing this version of the stack with the same lookahead symbol.
+    if (last_reduction_version != STACK_VERSION_NONE) {
+      ts_stack_renumber_version(self->stack, last_reduction_version, version);
+      LOG_STACK();
+      state = ts_stack_state(self->stack, version);
+
+      // At the end of a non-terminal extra rule, the lexer will return a
+      // null subtree, because the parser needs to perform a fixed reduction
+      // regardless of the lookahead node. After performing that reduction,
+      // (and completing the non-terminal extra rule) run the lexer again based
+      // on the current parse state.
+      if (!lookahead.ptr) {
+        needs_lex = true;
+      } else {
+        ts_language_table_entry(
+          self->language,
+          state,
+          ts_subtree_leaf_symbol(lookahead),
+          &table_entry
+        );
+      }
+
+      continue;
+    }
+
+    // A reduction was performed, but was merged into an existing stack version.
+    // This version can be discarded.
+    if (did_reduce) {
+      if (lookahead.ptr) {
+        ts_subtree_release(&self->tree_pool, lookahead);
+      }
+      ts_stack_halt(self->stack, version);
+      return true;
+    }
+
+    // If the current lookahead token is a keyword that is not valid, but the
+    // default word token *is* valid, then treat the lookahead token as the word
+    // token instead.
+    if (
+      ts_subtree_is_keyword(lookahead) &&
+      ts_subtree_symbol(lookahead) != self->language->keyword_capture_token &&
+      !ts_language_is_reserved_word(self->language, state, ts_subtree_symbol(lookahead))
+    ) {
+      ts_language_table_entry(
+        self->language,
+        state,
+        self->language->keyword_capture_token,
+        &table_entry
+      );
+      if (table_entry.action_count > 0) {
+        LOG(
+          "switch from_keyword:%s, to_word_token:%s",
+          TREE_NAME(lookahead),
+          SYM_NAME(self->language->keyword_capture_token)
+        );
+
+        MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead);
+        ts_subtree_set_symbol(&mutable_lookahead, self->language->keyword_capture_token, self->language);
+        lookahead = ts_subtree_from_mut(mutable_lookahead);
+        continue;
+      }
+    }
+
+    // If the current lookahead token is not valid and the previous subtree on
+    // the stack was reused from an old tree, then it wasn't actually valid to
+    // reuse that previous subtree. Remove it from the stack, and in its place,
+    // push each of its children. Then try again to process the current lookahead.
+    if (ts_parser__breakdown_top_of_stack(self, version)) {
+      state = ts_stack_state(self->stack, version);
+      ts_subtree_release(&self->tree_pool, lookahead);
+      needs_lex = true;
+      continue;
+    }
+
+    // Otherwise, there is definitely an error in this version of the parse stack.
+    // Mark this version as paused and continue processing any other stack
+    // versions that exist. If some other version advances successfully, then
+    // this version can simply be removed. But if all versions end up paused,
+    // then error recovery is needed.
+    LOG("detect_error lookahead:%s", TREE_NAME(lookahead));
+    ts_stack_pause(self->stack, version, lookahead);
+    return true;
+  }
+}
+
+static unsigned ts_parser__condense_stack(TSParser *self) {
+  bool made_changes = false;
+  unsigned min_error_cost = UINT_MAX;
+  for (StackVersion i = 0; i < ts_stack_version_count(self->stack); i++) {
+    // Prune any versions that have been marked for removal.
+    if (ts_stack_is_halted(self->stack, i)) {
+      ts_stack_remove_version(self->stack, i);
+      i--;
+      continue;
+    }
+
+    // Keep track of the minimum error cost of any stack version so
+    // that it can be returned.
+    ErrorStatus status_i = ts_parser__version_status(self, i);
+    if (!status_i.is_in_error && status_i.cost < min_error_cost) {
+      min_error_cost = status_i.cost;
+    }
+
+    // Examine each pair of stack versions, removing any versions that
+    // are clearly worse than another version. Ensure that the versions
+    // are ordered from most promising to least promising.
+    for (StackVersion j = 0; j < i; j++) {
+      ErrorStatus status_j = ts_parser__version_status(self, j);
+
+      switch (ts_parser__compare_versions(self, status_j, status_i)) {
+        case ErrorComparisonTakeLeft:
+          made_changes = true;
+          ts_stack_remove_version(self->stack, i);
+          i--;
+          j = i;
+          break;
+
+        case ErrorComparisonPreferLeft:
+        case ErrorComparisonNone:
+          if (ts_stack_merge(self->stack, j, i)) {
+            made_changes = true;
+            i--;
+            j = i;
+          }
+          break;
+
+        case ErrorComparisonPreferRight:
+          made_changes = true;
+          if (ts_stack_merge(self->stack, j, i)) {
+            i--;
+            j = i;
+          } else {
+            ts_stack_swap_versions(self->stack, i, j);
+          }
+          break;
+
+        case ErrorComparisonTakeRight:
+          made_changes = true;
+          ts_stack_remove_version(self->stack, j);
+          i--;
+          j--;
+          break;
+      }
+    }
+  }
+
+  // Enforce a hard upper bound on the number of stack versions by
+  // discarding the least promising versions.
+  while (ts_stack_version_count(self->stack) > MAX_VERSION_COUNT) {
+    ts_stack_remove_version(self->stack, MAX_VERSION_COUNT);
+    made_changes = true;
+  }
+
+  // If the best-performing stack version is currently paused, or all
+  // versions are paused, then resume the best paused version and begin
+  // the error recovery process. Otherwise, remove the paused versions.
+  if (ts_stack_version_count(self->stack) > 0) {
+    bool has_unpaused_version = false;
+    for (StackVersion i = 0, n = ts_stack_version_count(self->stack); i < n; i++) {
+      if (ts_stack_is_paused(self->stack, i)) {
+        if (!has_unpaused_version && self->accept_count < MAX_VERSION_COUNT) {
+          LOG("resume version:%u", i);
+          min_error_cost = ts_stack_error_cost(self->stack, i);
+          Subtree lookahead = ts_stack_resume(self->stack, i);
+          ts_parser__handle_error(self, i, lookahead);
+          has_unpaused_version = true;
+        } else {
+          ts_stack_remove_version(self->stack, i);
+          made_changes = true;
+          i--;
+          n--;
+        }
+      } else {
+        has_unpaused_version = true;
+      }
+    }
+  }
+
+  if (made_changes) {
+    LOG("condense");
+    LOG_STACK();
+  }
+
+  return min_error_cost;
+}
+
+static bool ts_parser__balance_subtree(TSParser *self) {
+  Subtree finished_tree = self->finished_tree;
+
+  // If we haven't canceled balancing in progress before, then we want to clear the tree stack and
+  // push the initial finished tree onto it. Otherwise, if we're resuming balancing after a
+  // cancellation, we don't want to clear the tree stack.
+  if (!self->canceled_balancing) {
+    array_clear(&self->tree_pool.tree_stack);
+    if (ts_subtree_child_count(finished_tree) > 0 && finished_tree.ptr->ref_count == 1) {
+      array_push(&self->tree_pool.tree_stack, ts_subtree_to_mut_unsafe(finished_tree));
+    }
+  }
+
+  while (self->tree_pool.tree_stack.size > 0) {
+    if (!ts_parser__check_progress(self, NULL, NULL, 1)) {
+      return false;
+    }
+
+    MutableSubtree tree = *array_get(&self->tree_pool.tree_stack,
+      self->tree_pool.tree_stack.size - 1
+    );
+
+    if (tree.ptr->repeat_depth > 0) {
+      Subtree child1 = ts_subtree_children(tree)[0];
+      Subtree child2 = ts_subtree_children(tree)[tree.ptr->child_count - 1];
+      long repeat_delta = (long)ts_subtree_repeat_depth(child1) - (long)ts_subtree_repeat_depth(child2);
+      if (repeat_delta > 0) {
+        unsigned n = (unsigned)repeat_delta;
+
+        for (unsigned i = n / 2; i > 0; i /= 2) {
+          ts_subtree_compress(tree, i, self->language, &self->tree_pool.tree_stack);
+          n -= i;
+
+          // We scale the operation count increment in `ts_parser__check_progress` proportionately to the compression
+          // size since larger values of i take longer to process. Shifting by 4 empirically provides good check
+          // intervals (e.g. 193 operations when i=3100) to prevent blocking during large compressions.
+          uint8_t operations = i >> 4 > 0 ? i >> 4 : 1;
+          if (!ts_parser__check_progress(self, NULL, NULL, operations)) {
+            return false;
+          }
+        }
+      }
+    }
+
+    (void)array_pop(&self->tree_pool.tree_stack);
+
+    for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
+      Subtree child = ts_subtree_children(tree)[i];
+      if (ts_subtree_child_count(child) > 0 && child.ptr->ref_count == 1) {
+        array_push(&self->tree_pool.tree_stack, ts_subtree_to_mut_unsafe(child));
+      }
+    }
+  }
+
+  return true;
+}
+
+static bool ts_parser_has_outstanding_parse(TSParser *self) {
+  return (
+    self->canceled_balancing ||
+    self->external_scanner_payload ||
+    ts_stack_state(self->stack, 0) != 1 ||
+    ts_stack_node_count_since_error(self->stack, 0) != 0
+  );
+}
+
+// Parser - Public
+
+TSParser *ts_parser_new(void) {
+  TSParser *self = ts_calloc(1, sizeof(TSParser));
+  ts_lexer_init(&self->lexer);
+  array_init(&self->reduce_actions);
+  array_reserve(&self->reduce_actions, 4);
+  self->tree_pool = ts_subtree_pool_new(32);
+  self->stack = ts_stack_new(&self->tree_pool);
+  self->finished_tree = NULL_SUBTREE;
+  self->reusable_node = reusable_node_new();
+  self->dot_graph_file = NULL;
+  self->language = NULL;
+  self->has_scanner_error = false;
+  self->has_error = false;
+  self->canceled_balancing = false;
+  self->external_scanner_payload = NULL;
+  self->operation_count = 0;
+  self->old_tree = NULL_SUBTREE;
+  self->included_range_differences = (TSRangeArray) array_new();
+  self->included_range_difference_index = 0;
+  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
+  return self;
+}
+
+void ts_parser_delete(TSParser *self) {
+  if (!self) return;
+
+  ts_parser_set_language(self, NULL);
+  ts_stack_delete(self->stack);
+  if (self->reduce_actions.contents) {
+    array_delete(&self->reduce_actions);
+  }
+  if (self->included_range_differences.contents) {
+    array_delete(&self->included_range_differences);
+  }
+  if (self->old_tree.ptr) {
+    ts_subtree_release(&self->tree_pool, self->old_tree);
+    self->old_tree = NULL_SUBTREE;
+  }
+  ts_wasm_store_delete(self->wasm_store);
+  ts_lexer_delete(&self->lexer);
+  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
+  ts_subtree_pool_delete(&self->tree_pool);
+  reusable_node_delete(&self->reusable_node);
+  array_delete(&self->trailing_extras);
+  array_delete(&self->trailing_extras2);
+  array_delete(&self->scratch_trees);
+  ts_free(self);
+}
+
+const TSLanguage *ts_parser_language(const TSParser *self) {
+  return self->language;
+}
+
+bool ts_parser_set_language(TSParser *self, const TSLanguage *language) {
+  ts_parser_reset(self);
+  ts_language_delete(self->language);
+  self->language = NULL;
+
+  if (language) {
+    if (
+      language->abi_version > TREE_SITTER_LANGUAGE_VERSION ||
+      language->abi_version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION
+    ) return false;
+
+    if (ts_language_is_wasm(language)) {
+      if (
+        !self->wasm_store ||
+        !ts_wasm_store_start(self->wasm_store, &self->lexer.data, language)
+      ) return false;
+    }
+  }
+
+  self->language = ts_language_copy(language);
+  return true;
+}
+
+TSLogger ts_parser_logger(const TSParser *self) {
+  return self->lexer.logger;
+}
+
+void ts_parser_set_logger(TSParser *self, TSLogger logger) {
+  self->lexer.logger = logger;
+}
+
+void ts_parser_print_dot_graphs(TSParser *self, int fd) {
+  if (self->dot_graph_file) {
+    fclose(self->dot_graph_file);
+  }
+
+  if (fd >= 0) {
+    #ifdef _WIN32
+    self->dot_graph_file = _fdopen(fd, "a");
+    #else
+    self->dot_graph_file = fdopen(fd, "a");
+    #endif
+  } else {
+    self->dot_graph_file = NULL;
+  }
+}
+
+bool ts_parser_set_included_ranges(
+  TSParser *self,
+  const TSRange *ranges,
+  uint32_t count
+) {
+  return ts_lexer_set_included_ranges(&self->lexer, ranges, count);
+}
+
+const TSRange *ts_parser_included_ranges(const TSParser *self, uint32_t *count) {
+  return ts_lexer_included_ranges(&self->lexer, count);
+}
+
+void ts_parser_reset(TSParser *self) {
+  ts_parser__external_scanner_destroy(self);
+  if (self->wasm_store) {
+    ts_wasm_store_reset(self->wasm_store);
+  }
+
+  if (self->old_tree.ptr) {
+    ts_subtree_release(&self->tree_pool, self->old_tree);
+    self->old_tree = NULL_SUBTREE;
+  }
+
+  reusable_node_clear(&self->reusable_node);
+  ts_lexer_reset(&self->lexer, length_zero());
+  ts_stack_clear(self->stack);
+  ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
+  if (self->finished_tree.ptr) {
+    ts_subtree_release(&self->tree_pool, self->finished_tree);
+    self->finished_tree = NULL_SUBTREE;
+  }
+  self->accept_count = 0;
+  self->has_scanner_error = false;
+  self->has_error = false;
+  self->canceled_balancing = false;
+  self->parse_options = (TSParseOptions) {0};
+  self->parse_state = (TSParseState) {0};
+}
+
+TSTree *ts_parser_parse(
+  TSParser *self,
+  const TSTree *old_tree,
+  TSInput input
+) {
+  TSTree *result = NULL;
+  if (!self->language || !input.read) return NULL;
+
+  if (ts_language_is_wasm(self->language)) {
+    if (!self->wasm_store) return NULL;
+    ts_wasm_store_start(self->wasm_store, &self->lexer.data, self->language);
+  }
+
+  ts_lexer_set_input(&self->lexer, input);
+  array_clear(&self->included_range_differences);
+  self->included_range_difference_index = 0;
+
+  self->operation_count = 0;
+
+  if (ts_parser_has_outstanding_parse(self)) {
+    LOG("resume_parsing");
+    if (self->canceled_balancing) goto balance;
+  } else {
+    ts_parser__external_scanner_create(self);
+    if (self->has_scanner_error) goto exit;
+
+    if (old_tree) {
+      ts_subtree_retain(old_tree->root);
+      self->old_tree = old_tree->root;
+      ts_range_array_get_changed_ranges(
+        old_tree->included_ranges, old_tree->included_range_count,
+        self->lexer.included_ranges, self->lexer.included_range_count,
+        &self->included_range_differences
+      );
+      reusable_node_reset(&self->reusable_node, old_tree->root);
+      LOG("parse_after_edit");
+      LOG_TREE(self->old_tree);
+      for (unsigned i = 0; i < self->included_range_differences.size; i++) {
+        TSRange *range = array_get(&self->included_range_differences, i);
+        LOG("different_included_range %u - %u", range->start_byte, range->end_byte);
+      }
+    } else {
+      reusable_node_clear(&self->reusable_node);
+      LOG("new_parse");
+    }
+  }
+
+  uint32_t position = 0, last_position = 0, version_count = 0;
+  do {
+    for (
+      StackVersion version = 0;
+      version_count = ts_stack_version_count(self->stack),
+      version < version_count;
+      version++
+    ) {
+      bool allow_node_reuse = version_count == 1;
+      while (ts_stack_is_active(self->stack, version)) {
+        LOG(
+          "process version:%u, version_count:%u, state:%d, row:%u, col:%u",
+          version,
+          ts_stack_version_count(self->stack),
+          ts_stack_state(self->stack, version),
+          ts_stack_position(self->stack, version).extent.row,
+          ts_stack_position(self->stack, version).extent.column
+        );
+
+        if (!ts_parser__advance(self, version, allow_node_reuse)) {
+          if (self->has_scanner_error) goto exit;
+          return NULL;
+        }
+
+        LOG_STACK();
+
+        position = ts_stack_position(self->stack, version).bytes;
+        if (position > last_position || (version > 0 && position == last_position)) {
+          last_position = position;
+          break;
+        }
+      }
+    }
+
+    // After advancing each version of the stack, re-sort the versions by their cost,
+    // removing any versions that are no longer worth pursuing.
+    unsigned min_error_cost = ts_parser__condense_stack(self);
+
+    // If there's already a finished parse tree that's better than any in-progress version,
+    // then terminate parsing. Clear the parse stack to remove any extra references to subtrees
+    // within the finished tree, ensuring that these subtrees can be safely mutated in-place
+    // for rebalancing.
+    if (self->finished_tree.ptr && ts_subtree_error_cost(self->finished_tree) < min_error_cost) {
+      ts_stack_clear(self->stack);
+      break;
+    }
+
+    while (self->included_range_difference_index < self->included_range_differences.size) {
+      TSRange *range = array_get(&self->included_range_differences, self->included_range_difference_index);
+      if (range->end_byte <= position) {
+        self->included_range_difference_index++;
+      } else {
+        break;
+      }
+    }
+  } while (version_count != 0);
+
+balance:
+  ts_assert(self->finished_tree.ptr);
+  if (!ts_parser__balance_subtree(self)) {
+    self->canceled_balancing = true;
+    return NULL;
+  }
+  self->canceled_balancing = false;
+  LOG("done");
+  LOG_TREE(self->finished_tree);
+
+  result = ts_tree_new(
+    self->finished_tree,
+    self->language,
+    self->lexer.included_ranges,
+    self->lexer.included_range_count
+  );
+  self->finished_tree = NULL_SUBTREE;
+
+exit:
+  ts_parser_reset(self);
+  return result;
+}
+
+TSTree *ts_parser_parse_with_options(
+  TSParser *self,
+  const TSTree *old_tree,
+  TSInput input,
+  TSParseOptions parse_options
+) {
+  self->parse_options = parse_options;
+  self->parse_state.payload = parse_options.payload;
+  TSTree *result = ts_parser_parse(self, old_tree, input);
+  // Reset parser options before further parse calls.
+  self->parse_options = (TSParseOptions) {0};
+  return result;
+}
+
+TSTree *ts_parser_parse_string(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length
+) {
+  return ts_parser_parse_string_encoding(self, old_tree, string, length, TSInputEncodingUTF8);
+}
+
+TSTree *ts_parser_parse_string_encoding(
+  TSParser *self,
+  const TSTree *old_tree,
+  const char *string,
+  uint32_t length,
+  TSInputEncoding encoding
+) {
+  TSStringInput input = {string, length};
+  return ts_parser_parse(self, old_tree, (TSInput) {
+    &input,
+    ts_string_input_read,
+    encoding,
+    NULL,
+  });
+}
+
+void ts_parser_set_wasm_store(TSParser *self, TSWasmStore *store) {
+  if (self->language && ts_language_is_wasm(self->language)) {
+    // Copy the assigned language into the new store.
+    const TSLanguage *copy = ts_language_copy(self->language);
+    ts_parser_set_language(self, copy);
+    ts_language_delete(copy);
+  }
+
+  ts_wasm_store_delete(self->wasm_store);
+  self->wasm_store = store;
+}
+
+TSWasmStore *ts_parser_take_wasm_store(TSParser *self) {
+  if (self->language && ts_language_is_wasm(self->language)) {
+    ts_parser_set_language(self, NULL);
+  }
+
+  TSWasmStore *result = self->wasm_store;
+  self->wasm_store = NULL;
+  return result;
+}
+
+#undef LOG
diff --git a/src/library/ts/src/tree-sitter/lib/src/parser.h b/src/library/ts/src/tree-sitter/lib/src/parser.h
new file mode 100644
index 0000000000..858107deb9
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/parser.h
@@ -0,0 +1,286 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
+} TSLanguageMetadata;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+// Used to index the field and supertype maps.
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+  void (*log)(const TSLexer *, const char *, ...);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+  uint16_t reserved_word_set_id;
+} TSLexerMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+typedef struct {
+  int32_t start;
+  int32_t end;
+} TSCharacterRange;
+
+struct TSLanguage {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexerMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+  const char *name;
+  const TSSymbol *reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  const TSSymbol *supertype_symbols;
+  const TSMapSlice *supertype_map_slices;
+  const TSSymbol *supertype_map_entries;
+  TSLanguageMetadata metadata;
+};
+
+static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
+  uint32_t index = 0;
+  uint32_t size = len - index;
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = index + half_size;
+    const TSCharacterRange *range = &ranges[mid_index];
+    if (lookahead >= range->start && lookahead <= range->end) {
+      return true;
+    } else if (lookahead > range->end) {
+      index = mid_index;
+    }
+    size -= half_size;
+  }
+  const TSCharacterRange *range = &ranges[index];
+  return (lookahead >= range->start && lookahead <= range->end);
+}
+
+/*
+ *  Lexer Macros
+ */
+
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define ADVANCE_MAP(...)                                              \
+  {                                                                   \
+    static const uint16_t map[] = { __VA_ARGS__ };                    \
+    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
+      if (map[i] == lookahead) {                                      \
+        state = map[i + 1];                                           \
+        goto next_state;                                              \
+      }                                                               \
+    }                                                                 \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_name, children, precedence, prod_id) \
+  {{                                                       \
+    .reduce = {                                            \
+      .type = TSParseActionTypeReduce,                     \
+      .symbol = symbol_name,                               \
+      .child_count = children,                             \
+      .dynamic_precedence = precedence,                    \
+      .production_id = prod_id                             \
+    },                                                     \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/point.c b/src/library/ts/src/tree-sitter/lib/src/point.c
new file mode 100644
index 0000000000..da46f61b9f
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/point.c
@@ -0,0 +1,17 @@
+#include "point.h"
+
+void ts_point_edit(TSPoint *point, uint32_t *byte, const TSInputEdit *edit) {
+  uint32_t start_byte = *byte;
+  TSPoint start_point = *point;
+
+  if (start_byte >= edit->old_end_byte) {
+    start_byte = edit->new_end_byte + (start_byte - edit->old_end_byte);
+    start_point = point_add(edit->new_end_point, point_sub(start_point, edit->old_end_point));
+  } else if (start_byte > edit->start_byte) {
+    start_byte = edit->new_end_byte;
+    start_point = edit->new_end_point;
+  }
+
+  *point = start_point;
+  *byte = start_byte;
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/point.h b/src/library/ts/src/tree-sitter/lib/src/point.h
new file mode 100644
index 0000000000..3958198843
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/point.h
@@ -0,0 +1,48 @@
+#ifndef TREE_SITTER_POINT_H_
+#define TREE_SITTER_POINT_H_
+
+#include "tree_sitter/api.h"
+
+#define POINT_ZERO ((TSPoint) {0, 0})
+#define POINT_MAX ((TSPoint) {UINT32_MAX, UINT32_MAX})
+
+static inline TSPoint point__new(unsigned row, unsigned column) {
+  TSPoint result = {row, column};
+  return result;
+}
+
+static inline TSPoint point_add(TSPoint a, TSPoint b) {
+  if (b.row > 0)
+    return point__new(a.row + b.row, b.column);
+  else
+    return point__new(a.row, a.column + b.column);
+}
+
+static inline TSPoint point_sub(TSPoint a, TSPoint b) {
+  if (a.row > b.row)
+    return point__new(a.row - b.row, a.column);
+  else
+    return point__new(0, (a.column >= b.column) ? a.column - b.column : 0);
+}
+
+static inline bool point_lte(TSPoint a, TSPoint b) {
+  return (a.row < b.row) || (a.row == b.row && a.column <= b.column);
+}
+
+static inline bool point_lt(TSPoint a, TSPoint b) {
+  return (a.row < b.row) || (a.row == b.row && a.column < b.column);
+}
+
+static inline bool point_gt(TSPoint a, TSPoint b) {
+  return (a.row > b.row) || (a.row == b.row && a.column > b.column);
+}
+
+static inline bool point_gte(TSPoint a, TSPoint b) {
+  return (a.row > b.row) || (a.row == b.row && a.column >= b.column);
+}
+
+static inline bool point_eq(TSPoint a, TSPoint b) {
+  return a.row == b.row && a.column == b.column;
+}
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/portable/endian.h b/src/library/ts/src/tree-sitter/lib/src/portable/endian.h
new file mode 100644
index 0000000000..a6560826a4
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/portable/endian.h
@@ -0,0 +1,241 @@
+// "License": Public Domain
+// I, Mathias Panzenböck, place this file hereby into the public domain. Use it at your own risk for whatever you like.
+// In case there are jurisdictions that don't support putting things in the public domain you can also consider it to
+// be "dual licensed" under the BSD, MIT and Apache licenses, if you want to. This code is trivial anyway. Consider it
+// an example on how to get the endian conversion functions on different platforms.
+
+// updates from https://github.com/mikepb/endian.h/issues/4
+
+#ifndef ENDIAN_H
+#define ENDIAN_H
+
+#if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__)
+
+#    define __WINDOWS__
+
+#endif
+
+#if defined(HAVE_ENDIAN_H) || \
+    defined(__linux__) || \
+    defined(__GNU__) || \
+    defined(__HAIKU__) || \
+    defined(__illumos__) || \
+    defined(__NetBSD__) || \
+    defined(__OpenBSD__) || \
+    defined(__CYGWIN__) || \
+    defined(__MSYS__) || \
+    defined(__EMSCRIPTEN__) || \
+    defined(__wasi__) || \
+    defined(__wasm__)
+
+#if defined(__NetBSD__)
+#define _NETBSD_SOURCE 1
+#endif
+
+# include <endian.h>
+
+#elif defined(HAVE_SYS_ENDIAN_H) || \
+    defined(__FreeBSD__) || \
+    defined(__DragonFly__)
+
+# include <sys/endian.h>
+
+#elif defined(__APPLE__)
+#    define __BYTE_ORDER    BYTE_ORDER
+#    define __BIG_ENDIAN    BIG_ENDIAN
+#    define __LITTLE_ENDIAN LITTLE_ENDIAN
+#    define __PDP_ENDIAN    PDP_ENDIAN
+
+#    if !defined(_POSIX_C_SOURCE)
+#        include <libkern/OSByteOrder.h>
+
+#        define htobe16(x) OSSwapHostToBigInt16(x)
+#        define htole16(x) OSSwapHostToLittleInt16(x)
+#        define be16toh(x) OSSwapBigToHostInt16(x)
+#        define le16toh(x) OSSwapLittleToHostInt16(x)
+
+#        define htobe32(x) OSSwapHostToBigInt32(x)
+#        define htole32(x) OSSwapHostToLittleInt32(x)
+#        define be32toh(x) OSSwapBigToHostInt32(x)
+#        define le32toh(x) OSSwapLittleToHostInt32(x)
+
+#        define htobe64(x) OSSwapHostToBigInt64(x)
+#        define htole64(x) OSSwapHostToLittleInt64(x)
+#        define be64toh(x) OSSwapBigToHostInt64(x)
+#        define le64toh(x) OSSwapLittleToHostInt64(x)
+#    else
+#        if BYTE_ORDER == LITTLE_ENDIAN
+#            define htobe16(x) __builtin_bswap16(x)
+#            define htole16(x) (x)
+#            define be16toh(x) __builtin_bswap16(x)
+#            define le16toh(x) (x)
+
+#            define htobe32(x) __builtin_bswap32(x)
+#            define htole32(x) (x)
+#            define be32toh(x) __builtin_bswap32(x)
+#            define le32toh(x) (x)
+
+#            define htobe64(x) __builtin_bswap64(x)
+#            define htole64(x) (x)
+#            define be64toh(x) __builtin_bswap64(x)
+#            define le64toh(x) (x)
+#        elif BYTE_ORDER == BIG_ENDIAN
+#            define htobe16(x) (x)
+#            define htole16(x) __builtin_bswap16(x)
+#            define be16toh(x) (x)
+#            define le16toh(x) __builtin_bswap16(x)
+
+#            define htobe32(x) (x)
+#            define htole32(x) __builtin_bswap32(x)
+#            define be32toh(x) (x)
+#            define le32toh(x) __builtin_bswap32(x)
+
+#            define htobe64(x) (x)
+#            define htole64(x) __builtin_bswap64(x)
+#            define be64toh(x) (x)
+#            define le64toh(x) __builtin_bswap64(x)
+#        else
+#            error byte order not supported
+#        endif
+#    endif
+
+#elif defined(__WINDOWS__)
+
+#    if defined(_MSC_VER) && !defined(__clang__)
+#        include <stdlib.h>
+#        define B_SWAP_16(x) _byteswap_ushort(x)
+#        define B_SWAP_32(x) _byteswap_ulong(x)
+#        define B_SWAP_64(x) _byteswap_uint64(x)
+#    else
+#        define B_SWAP_16(x) __builtin_bswap16(x)
+#        define B_SWAP_32(x) __builtin_bswap32(x)
+#        define B_SWAP_64(x) __builtin_bswap64(x)
+#    endif
+
+# if defined(__MINGW32__) || defined(HAVE_SYS_PARAM_H)
+#   include <sys/param.h>
+# endif
+
+#    ifndef BIG_ENDIAN
+#        ifdef __BIG_ENDIAN
+#            define BIG_ENDIAN __BIG_ENDIAN
+#        elif defined(__ORDER_BIG_ENDIAN__)
+#            define BIG_ENDIAN __ORDER_BIG_ENDIAN__
+#        else
+#            define BIG_ENDIAN 4321
+#        endif
+#    endif
+
+#    ifndef LITTLE_ENDIAN
+#        ifdef __LITTLE_ENDIAN
+#            define LITTLE_ENDIAN __LITTLE_ENDIAN
+#        elif defined(__ORDER_LITTLE_ENDIAN__)
+#            define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
+#        else
+#            define LITTLE_ENDIAN 1234
+#        endif
+#    endif
+
+#    ifndef BYTE_ORDER
+#        ifdef __BYTE_ORDER
+#            define BYTE_ORDER __BYTE_ORDER
+#        elif defined(__BYTE_ORDER__)
+#            define BYTE_ORDER __BYTE_ORDER__
+#        else
+             /* assume LE on Windows if nothing was defined */
+#            define BYTE_ORDER LITTLE_ENDIAN
+#        endif
+#    endif
+
+#    if BYTE_ORDER == LITTLE_ENDIAN
+
+#        define htobe16(x) B_SWAP_16(x)
+#        define htole16(x) (x)
+#        define be16toh(x) B_SWAP_16(x)
+#        define le16toh(x) (x)
+
+#        define htobe32(x) B_SWAP_32(x)
+#        define htole32(x) (x)
+#        define be32toh(x) B_SWAP_32(x)
+#        define le32toh(x) (x)
+
+#        define htobe64(x) B_SWAP_64(x)
+#        define htole64(x) (x)
+#        define be64toh(x) B_SWAP_64(x)
+#        define le64toh(x) (x)
+
+#    elif BYTE_ORDER == BIG_ENDIAN
+
+#        define htobe16(x) (x)
+#        define htole16(x) B_SWAP_16(x)
+#        define be16toh(x) (x)
+#        define le16toh(x) B_SWAP_16(x)
+
+#        define htobe32(x) (x)
+#        define htole32(x) B_SWAP_32(x)
+#        define be32toh(x) (x)
+#        define le32toh(x) B_SWAP_32(x)
+
+#        define htobe64(x) (x)
+#        define htole64(x) B_SWAP_64(x)
+#        define be64toh(x) (x)
+#        define le64toh(x) B_SWAP_64(x)
+
+#    else
+
+#        error byte order not supported
+
+#    endif
+
+#elif defined(__QNXNTO__)
+
+#    include <gulliver.h>
+
+#    define __LITTLE_ENDIAN 1234
+#    define __BIG_ENDIAN    4321
+#    define __PDP_ENDIAN    3412
+
+#    if defined(__BIGENDIAN__)
+
+#        define __BYTE_ORDER __BIG_ENDIAN
+
+#        define htobe16(x) (x)
+#        define htobe32(x) (x)
+#        define htobe64(x) (x)
+
+#        define htole16(x) ENDIAN_SWAP16(x)
+#        define htole32(x) ENDIAN_SWAP32(x)
+#        define htole64(x) ENDIAN_SWAP64(x)
+
+#    elif defined(__LITTLEENDIAN__)
+
+#        define __BYTE_ORDER __LITTLE_ENDIAN
+
+#        define htole16(x) (x)
+#        define htole32(x) (x)
+#        define htole64(x) (x)
+
+#        define htobe16(x) ENDIAN_SWAP16(x)
+#        define htobe32(x) ENDIAN_SWAP32(x)
+#        define htobe64(x) ENDIAN_SWAP64(x)
+
+#    else
+
+#        error byte order not supported
+
+#    endif
+
+#    define be16toh(x) ENDIAN_BE16(x)
+#    define be32toh(x) ENDIAN_BE32(x)
+#    define be64toh(x) ENDIAN_BE64(x)
+#    define le16toh(x) ENDIAN_LE16(x)
+#    define le32toh(x) ENDIAN_LE32(x)
+#    define le64toh(x) ENDIAN_LE64(x)
+
+#else
+
+#    error platform not supported
+
+#endif
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/query.c b/src/library/ts/src/tree-sitter/lib/src/query.c
new file mode 100644
index 0000000000..56e3287310
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/query.c
@@ -0,0 +1,4384 @@
+/*
+ * On NetBSD, defining standard requirements like this removes symbols
+ * from the namespace; however, we need non-standard symbols for
+ * endian.h.
+ */
+#if defined(__NetBSD__) && defined(_POSIX_C_SOURCE)
+#undef _POSIX_C_SOURCE
+#endif
+
+#include "tree_sitter/api.h"
+#include "./alloc.h"
+#include "./array.h"
+#include "./language.h"
+#include "./point.h"
+#include "./tree_cursor.h"
+#include "./unicode.h"
+#include <wctype.h>
+
+// #define DEBUG_ANALYZE_QUERY
+// #define DEBUG_EXECUTE_QUERY
+
+#define MAX_STEP_CAPTURE_COUNT 3
+#define MAX_NEGATED_FIELD_COUNT 8
+#define MAX_STATE_PREDECESSOR_COUNT 256
+#define MAX_ANALYSIS_STATE_DEPTH 8
+#define MAX_ANALYSIS_ITERATION_COUNT 256
+
+/*
+ * Stream - A sequence of unicode characters derived from a UTF8 string.
+ * This struct is used in parsing queries from S-expressions.
+ */
+typedef struct {
+  const char *input;
+  const char *start;
+  const char *end;
+  int32_t next;
+  uint8_t next_size;
+} Stream;
+
+/*
+ * QueryStep - A step in the process of matching a query. Each node within
+ * a query S-expression corresponds to one of these steps. An entire pattern
+ * is represented as a sequence of these steps. The basic properties of a
+ * node are represented by these fields:
+ * - `symbol` - The grammar symbol to match. A zero value represents the
+ *    wildcard symbol, '_'.
+ * - `field` - The field name to match. A zero value means that a field name
+ *    was not specified.
+ * - `capture_ids` - An array of integers representing the names of captures
+ *    associated with this node in the pattern, terminated by a `NONE` value.
+ * - `depth` - The depth where this node occurs in the pattern. The root node
+ *    of the pattern has depth zero.
+ * - `negated_field_list_id` - An id representing a set of fields that must
+ *    not be present on a node matching this step.
+ *
+ * Steps have some additional fields in order to handle the `.` (or "anchor") operator,
+ * which forbids additional child nodes:
+ * - `is_immediate` - Indicates that the node matching this step cannot be preceded
+ *   by other sibling nodes that weren't specified in the pattern.
+ * - `is_last_child` - Indicates that the node matching this step cannot have any
+ *   subsequent named siblings.
+ *
+ * For simple patterns, steps are matched in sequential order. But in order to
+ * handle alternative/repeated/optional sub-patterns, query steps are not always
+ * structured as a linear sequence; they sometimes need to split and merge. This
+ * is done using the following fields:
+ *  - `alternative_index` - The index of a different query step that serves as
+ *    an alternative to this step. A `NONE` value represents no alternative.
+ *    When a query state reaches a step with an alternative index, the state
+ *    is duplicated, with one copy remaining at the original step, and one copy
+ *    moving to the alternative step. The alternative may have its own alternative
+ *    step, so this splitting is an iterative process.
+ * - `is_dead_end` - Indicates that this state cannot be passed directly, and
+ *    exists only in order to redirect to an alternative index, with no splitting.
+ * - `is_pass_through` - Indicates that state has no matching logic of its own,
+ *    and exists only to split a state. One copy of the state advances immediately
+ *    to the next step, and one moves to the alternative step.
+ * - `alternative_is_immediate` - Indicates that this step's alternative step
+ *    should be treated as if `is_immediate` is true.
+ *
+ * Steps also store some derived state that summarizes how they relate to other
+ * steps within the same pattern. This is used to optimize the matching process:
+ *  - `contains_captures` - Indicates that this step or one of its child steps
+ *     has a non-empty `capture_ids` list.
+ *  - `parent_pattern_guaranteed` - Indicates that if this step is reached, then
+ *     it and all of its subsequent sibling steps within the same parent pattern
+ *     are guaranteed to match.
+ *  - `root_pattern_guaranteed` - Similar to `parent_pattern_guaranteed`, but
+ *     for the entire top-level pattern. When iterating through a query's
+ *     captures using `ts_query_cursor_next_capture`, this field is used to
+ *     detect that a capture can safely be returned from a match that has not
+ *     even completed yet.
+ */
+typedef struct {
+  TSSymbol symbol;
+  TSSymbol supertype_symbol;
+  TSFieldId field;
+  uint16_t capture_ids[MAX_STEP_CAPTURE_COUNT];
+  uint16_t depth;
+  uint16_t alternative_index;
+  uint16_t negated_field_list_id;
+  bool is_named: 1;
+  bool is_immediate: 1;
+  bool is_last_child: 1;
+  bool is_pass_through: 1;
+  bool is_dead_end: 1;
+  bool alternative_is_immediate: 1;
+  bool contains_captures: 1;
+  bool root_pattern_guaranteed: 1;
+  bool parent_pattern_guaranteed: 1;
+  bool is_missing: 1;
+} QueryStep;
+
+/*
+ * Slice - A slice of an external array. Within a query, capture names,
+ * literal string values, and predicate step information are stored in three
+ * contiguous arrays. Individual captures, string values, and predicates are
+ * represented as slices of these three arrays.
+ */
+typedef struct {
+  uint32_t offset;
+  uint32_t length;
+} Slice;
+
+/*
+ * SymbolTable - a two-way mapping of strings to ids.
+ */
+typedef struct {
+  Array(char) characters;
+  Array(Slice) slices;
+} SymbolTable;
+
+/**
+ * CaptureQuantifiers - a data structure holding the quantifiers of pattern captures.
+ */
+typedef Array(uint8_t) CaptureQuantifiers;
+
+/*
+ * PatternEntry - Information about the starting point for matching a particular
+ * pattern. These entries are stored in a 'pattern map' - a sorted array that
+ * makes it possible to efficiently lookup patterns based on the symbol for their
+ * first step. The entry consists of the following fields:
+ * - `pattern_index` - the index of the pattern within the query
+ * - `step_index` - the index of the pattern's first step in the shared `steps` array
+ * - `is_rooted` - whether or not the pattern has a single root node. This property
+ *   affects decisions about whether or not to start the pattern for nodes outside
+ *   of a QueryCursor's range restriction.
+ */
+typedef struct {
+  uint16_t step_index;
+  uint16_t pattern_index;
+  bool is_rooted;
+} PatternEntry;
+
+typedef struct {
+  Slice steps;
+  Slice predicate_steps;
+  uint32_t start_byte;
+  uint32_t end_byte;
+  bool is_non_local;
+} QueryPattern;
+
+typedef struct {
+  uint32_t byte_offset;
+  uint16_t step_index;
+} StepOffset;
+
+/*
+ * QueryState - The state of an in-progress match of a particular pattern
+ * in a query. While executing, a `TSQueryCursor` must keep track of a number
+ * of possible in-progress matches. Each of those possible matches is
+ * represented as one of these states. Fields:
+ * - `id` - A numeric id that is exposed to the public API. This allows the
+ *    caller to remove a given match, preventing any more of its captures
+ *    from being returned.
+ * - `start_depth` - The depth in the tree where the first step of the state's
+ *    pattern was matched.
+ * - `pattern_index` - The pattern that the state is matching.
+ * - `consumed_capture_count` - The number of captures from this match that
+ *    have already been returned.
+ * - `capture_list_id` - A numeric id that can be used to retrieve the state's
+ *    list of captures from the `CaptureListPool`.
+ * - `seeking_immediate_match` - A flag that indicates that the state's next
+ *    step must be matched by the very next sibling. This is used when
+ *    processing repetitions, or when processing a wildcard node followed by
+ *    an anchor.
+ * - `has_in_progress_alternatives` - A flag that indicates that there is are
+ *    other states that have the same captures as this state, but are at
+ *    different steps in their pattern. This means that in order to obey the
+ *    'longest-match' rule, this state should not be returned as a match until
+ *    it is clear that there can be no other alternative match with more captures.
+ */
+typedef struct {
+  uint32_t id;
+  uint32_t capture_list_id;
+  uint16_t start_depth;
+  uint16_t step_index;
+  uint16_t pattern_index;
+  uint16_t consumed_capture_count: 12;
+  bool seeking_immediate_match: 1;
+  bool has_in_progress_alternatives: 1;
+  bool dead: 1;
+  bool needs_parent: 1;
+} QueryState;
+
+typedef Array(TSQueryCapture) CaptureList;
+
+/*
+ * CaptureListPool - A collection of *lists* of captures. Each query state needs
+ * to maintain its own list of captures. To avoid repeated allocations, this struct
+ * maintains a fixed set of capture lists, and keeps track of which ones are
+ * currently in use by a query state.
+ */
+typedef struct {
+  Array(CaptureList) list;
+  CaptureList empty_list;
+  // The maximum number of capture lists that we are allowed to allocate. We
+  // never allow `list` to allocate more entries than this, dropping pending
+  // matches if needed to stay under the limit.
+  uint32_t max_capture_list_count;
+  // The number of capture lists allocated in `list` that are not currently in
+  // use. We reuse those existing-but-unused capture lists before trying to
+  // allocate any new ones. We use an invalid value (UINT32_MAX) for a capture
+  // list's length to indicate that it's not in use.
+  uint32_t free_capture_list_count;
+} CaptureListPool;
+
+/*
+ * AnalysisState - The state needed for walking the parse table when analyzing
+ * a query pattern, to determine at which steps the pattern might fail to match.
+ */
+typedef struct {
+  TSStateId parse_state;
+  TSSymbol parent_symbol;
+  uint16_t child_index;
+  TSFieldId field_id: 15;
+  bool done: 1;
+} AnalysisStateEntry;
+
+typedef struct {
+  AnalysisStateEntry stack[MAX_ANALYSIS_STATE_DEPTH];
+  uint16_t depth;
+  uint16_t step_index;
+  TSSymbol root_symbol;
+} AnalysisState;
+
+typedef Array(AnalysisState *) AnalysisStateSet;
+
+typedef struct {
+  AnalysisStateSet states;
+  AnalysisStateSet next_states;
+  AnalysisStateSet deeper_states;
+  AnalysisStateSet state_pool;
+  Array(uint16_t) final_step_indices;
+  Array(TSSymbol) finished_parent_symbols;
+  bool did_abort;
+} QueryAnalysis;
+
+/*
+ * AnalysisSubgraph - A subset of the states in the parse table that are used
+ * in constructing nodes with a certain symbol. Each state is accompanied by
+ * some information about the possible node that could be produced in
+ * downstream states.
+ */
+typedef struct {
+  TSStateId state;
+  uint16_t production_id;
+  uint8_t child_index: 7;
+  bool done: 1;
+} AnalysisSubgraphNode;
+
+typedef struct {
+  TSSymbol symbol;
+  Array(TSStateId) start_states;
+  Array(AnalysisSubgraphNode) nodes;
+} AnalysisSubgraph;
+
+typedef Array(AnalysisSubgraph) AnalysisSubgraphArray;
+
+/*
+ * StatePredecessorMap - A map that stores the predecessors of each parse state.
+ * This is used during query analysis to determine which parse states can lead
+ * to which reduce actions.
+ */
+typedef struct {
+  TSStateId *contents;
+} StatePredecessorMap;
+
+/*
+ * TSQuery - A tree query, compiled from a string of S-expressions. The query
+ * itself is immutable. The mutable state used in the process of executing the
+ * query is stored in a `TSQueryCursor`.
+ */
+struct TSQuery {
+  SymbolTable captures;
+  SymbolTable predicate_values;
+  Array(CaptureQuantifiers) capture_quantifiers;
+  Array(QueryStep) steps;
+  Array(PatternEntry) pattern_map;
+  Array(TSQueryPredicateStep) predicate_steps;
+  Array(QueryPattern) patterns;
+  Array(StepOffset) step_offsets;
+  Array(TSFieldId) negated_fields;
+  Array(char) string_buffer;
+  Array(TSSymbol) repeat_symbols_with_rootless_patterns;
+  const TSLanguage *language;
+  uint16_t wildcard_root_pattern_count;
+};
+
+/*
+ * TSQueryCursor - A stateful struct used to execute a query on a tree.
+ */
+struct TSQueryCursor {
+  const TSQuery *query;
+  TSTreeCursor cursor;
+  Array(QueryState) states;
+  Array(QueryState) finished_states;
+  CaptureListPool capture_list_pool;
+  uint32_t depth;
+  uint32_t max_start_depth;
+  uint32_t start_byte;
+  uint32_t end_byte;
+  TSPoint start_point;
+  TSPoint end_point;
+  uint32_t next_state_id;
+  const TSQueryCursorOptions *query_options;
+  TSQueryCursorState query_state;
+  unsigned operation_count;
+  bool on_visible_node;
+  bool ascending;
+  bool halted;
+  bool did_exceed_match_limit;
+};
+
+static const TSQueryError PARENT_DONE = -1;
+static const uint16_t PATTERN_DONE_MARKER = UINT16_MAX;
+static const uint16_t NONE = UINT16_MAX;
+static const TSSymbol WILDCARD_SYMBOL = 0;
+static const unsigned OP_COUNT_PER_QUERY_CALLBACK_CHECK = 100;
+
+/**********
+ * Stream
+ **********/
+
+// Advance to the next unicode code point in the stream.
+static bool stream_advance(Stream *self) {
+  self->input += self->next_size;
+  if (self->input < self->end) {
+    uint32_t size = ts_decode_utf8(
+      (const uint8_t *)self->input,
+      (uint32_t)(self->end - self->input),
+      &self->next
+    );
+    if (size > 0) {
+      self->next_size = size;
+      return true;
+    }
+  } else {
+    self->next_size = 0;
+    self->next = '\0';
+  }
+  return false;
+}
+
+// Reset the stream to the given input position, represented as a pointer
+// into the input string.
+static void stream_reset(Stream *self, const char *input) {
+  self->input = input;
+  self->next_size = 0;
+  stream_advance(self);
+}
+
+static Stream stream_new(const char *string, uint32_t length) {
+  Stream self = {
+    .next = 0,
+    .input = string,
+    .start = string,
+    .end = string + length,
+  };
+  stream_advance(&self);
+  return self;
+}
+
+static void stream_skip_whitespace(Stream *self) {
+  for (;;) {
+    if (iswspace(self->next)) {
+      stream_advance(self);
+    } else if (self->next == ';') {
+      // skip over comments
+      stream_advance(self);
+      while (self->next && self->next != '\n') {
+        if (!stream_advance(self)) break;
+      }
+    } else {
+      break;
+    }
+  }
+}
+
+static bool stream_is_ident_start(Stream *self) {
+  return iswalnum(self->next) || self->next == '_' || self->next == '-';
+}
+
+static void stream_scan_identifier(Stream *stream) {
+  do {
+    stream_advance(stream);
+  } while (
+    iswalnum(stream->next) ||
+    stream->next == '_' ||
+    stream->next == '-' ||
+    stream->next == '.'
+  );
+}
+
+static uint32_t stream_offset(Stream *self) {
+  return (uint32_t)(self->input - self->start);
+}
+
+/******************
+ * CaptureListPool
+ ******************/
+
+static CaptureListPool capture_list_pool_new(void) {
+  return (CaptureListPool) {
+    .list = array_new(),
+    .empty_list = array_new(),
+    .max_capture_list_count = UINT32_MAX,
+    .free_capture_list_count = 0,
+  };
+}
+
+static void capture_list_pool_reset(CaptureListPool *self) {
+  for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
+    // This invalid size means that the list is not in use.
+    array_get(&self->list, i)->size = UINT32_MAX;
+  }
+  self->free_capture_list_count = self->list.size;
+}
+
+static void capture_list_pool_delete(CaptureListPool *self) {
+  for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
+    array_delete(array_get(&self->list, i));
+  }
+  array_delete(&self->list);
+}
+
+static const CaptureList *capture_list_pool_get(const CaptureListPool *self, uint16_t id) {
+  if (id >= self->list.size) return &self->empty_list;
+  return array_get(&self->list, id);
+}
+
+static CaptureList *capture_list_pool_get_mut(CaptureListPool *self, uint16_t id) {
+  ts_assert(id < self->list.size);
+  return array_get(&self->list, id);
+}
+
+static bool capture_list_pool_is_empty(const CaptureListPool *self) {
+  // The capture list pool is empty if all allocated lists are in use, and we
+  // have reached the maximum allowed number of allocated lists.
+  return self->free_capture_list_count == 0 && self->list.size >= self->max_capture_list_count;
+}
+
+static uint16_t capture_list_pool_acquire(CaptureListPool *self) {
+  // First see if any already allocated capture list is currently unused.
+  if (self->free_capture_list_count > 0) {
+    for (uint16_t i = 0; i < (uint16_t)self->list.size; i++) {
+      if (array_get(&self->list, i)->size == UINT32_MAX) {
+        array_clear(array_get(&self->list, i));
+        self->free_capture_list_count--;
+        return i;
+      }
+    }
+  }
+
+  // Otherwise allocate and initialize a new capture list, as long as that
+  // doesn't put us over the requested maximum.
+  uint32_t i = self->list.size;
+  if (i >= self->max_capture_list_count) {
+    return NONE;
+  }
+  CaptureList list;
+  array_init(&list);
+  array_push(&self->list, list);
+  return i;
+}
+
+static void capture_list_pool_release(CaptureListPool *self, uint16_t id) {
+  if (id >= self->list.size) return;
+  array_get(&self->list, id)->size = UINT32_MAX;
+  self->free_capture_list_count++;
+}
+
+/**************
+ * Quantifiers
+ **************/
+
+static TSQuantifier quantifier_mul(
+  TSQuantifier left,
+  TSQuantifier right
+) {
+  switch (left)
+  {
+    case TSQuantifierZero:
+      return TSQuantifierZero;
+    case TSQuantifierZeroOrOne:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZero;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierOne:
+          return TSQuantifierZeroOrOne;
+        case TSQuantifierZeroOrMore:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierZeroOrMore;
+      };
+      break;
+    case TSQuantifierZeroOrMore:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZero;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierZeroOrMore;
+      };
+      break;
+    case TSQuantifierOne:
+      return right;
+    case TSQuantifierOneOrMore:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZero;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+  }
+  return TSQuantifierZero; // to make compiler happy, but all cases should be covered above!
+}
+
+static TSQuantifier quantifier_join(
+  TSQuantifier left,
+  TSQuantifier right
+) {
+  switch (left)
+  {
+    case TSQuantifierZero:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZero;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierOne:
+          return TSQuantifierZeroOrOne;
+        case TSQuantifierZeroOrMore:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierZeroOrMore;
+      };
+      break;
+    case TSQuantifierZeroOrOne:
+      switch (right) {
+        case TSQuantifierZero:
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierOne:
+          return TSQuantifierZeroOrOne;
+          break;
+        case TSQuantifierZeroOrMore:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierZeroOrMore;
+          break;
+      };
+      break;
+    case TSQuantifierZeroOrMore:
+      return TSQuantifierZeroOrMore;
+    case TSQuantifierOne:
+      switch (right) {
+        case TSQuantifierZero:
+        case TSQuantifierZeroOrOne:
+          return TSQuantifierZeroOrOne;
+        case TSQuantifierZeroOrMore:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierOne:
+          return TSQuantifierOne;
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+    case TSQuantifierOneOrMore:
+      switch (right) {
+        case TSQuantifierZero:
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+  }
+  return TSQuantifierZero; // to make compiler happy, but all cases should be covered above!
+}
+
+static TSQuantifier quantifier_add(
+  TSQuantifier left,
+  TSQuantifier right
+) {
+  switch (left)
+  {
+    case TSQuantifierZero:
+      return right;
+    case TSQuantifierZeroOrOne:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZeroOrOne;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+    case TSQuantifierZeroOrMore:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+          return TSQuantifierZeroOrMore;
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+    case TSQuantifierOne:
+      switch (right) {
+        case TSQuantifierZero:
+          return TSQuantifierOne;
+        case TSQuantifierZeroOrOne:
+        case TSQuantifierZeroOrMore:
+        case TSQuantifierOne:
+        case TSQuantifierOneOrMore:
+          return TSQuantifierOneOrMore;
+      };
+      break;
+    case TSQuantifierOneOrMore:
+      return TSQuantifierOneOrMore;
+  }
+  return TSQuantifierZero; // to make compiler happy, but all cases should be covered above!
+}
+
+// Create new capture quantifiers structure
+static CaptureQuantifiers capture_quantifiers_new(void) {
+  return (CaptureQuantifiers) array_new();
+}
+
+// Delete capture quantifiers structure
+static void capture_quantifiers_delete(
+  CaptureQuantifiers *self
+) {
+  array_delete(self);
+}
+
+// Clear capture quantifiers structure
+static void capture_quantifiers_clear(
+  CaptureQuantifiers *self
+) {
+  array_clear(self);
+}
+
+// Replace capture quantifiers with the given quantifiers
+static void capture_quantifiers_replace(
+  CaptureQuantifiers *self,
+  CaptureQuantifiers *quantifiers
+) {
+  array_clear(self);
+  array_push_all(self, quantifiers);
+}
+
+// Return capture quantifier for the given capture id
+static TSQuantifier capture_quantifier_for_id(
+  const CaptureQuantifiers *self,
+  uint16_t id
+) {
+  return (self->size <= id) ? TSQuantifierZero : (TSQuantifier) *array_get(self, id);
+}
+
+// Add the given quantifier to the current value for id
+static void capture_quantifiers_add_for_id(
+  CaptureQuantifiers *self,
+  uint16_t id,
+  TSQuantifier quantifier
+) {
+  if (self->size <= id) {
+    array_grow_by(self, id + 1 - self->size);
+  }
+  uint8_t *own_quantifier = array_get(self, id);
+  *own_quantifier = (uint8_t) quantifier_add((TSQuantifier) *own_quantifier, quantifier);
+}
+
+// Point-wise add the given quantifiers to the current values
+static void capture_quantifiers_add_all(
+  CaptureQuantifiers *self,
+  CaptureQuantifiers *quantifiers
+) {
+  if (self->size < quantifiers->size) {
+    array_grow_by(self, quantifiers->size - self->size);
+  }
+  for (uint16_t id = 0; id < (uint16_t)quantifiers->size; id++) {
+    uint8_t *quantifier = array_get(quantifiers, id);
+    uint8_t *own_quantifier = array_get(self, id);
+    *own_quantifier = (uint8_t) quantifier_add((TSQuantifier) *own_quantifier, (TSQuantifier) *quantifier);
+  }
+}
+
+// Join the given quantifier with the current values
+static void capture_quantifiers_mul(
+  CaptureQuantifiers *self,
+  TSQuantifier quantifier
+) {
+  for (uint16_t id = 0; id < (uint16_t)self->size; id++) {
+    uint8_t *own_quantifier = array_get(self, id);
+    *own_quantifier = (uint8_t) quantifier_mul((TSQuantifier) *own_quantifier, quantifier);
+  }
+}
+
+// Point-wise join the quantifiers from a list of alternatives with the current values
+static void capture_quantifiers_join_all(
+  CaptureQuantifiers *self,
+  CaptureQuantifiers *quantifiers
+) {
+  if (self->size < quantifiers->size) {
+    array_grow_by(self, quantifiers->size - self->size);
+  }
+  for (uint32_t id = 0; id < quantifiers->size; id++) {
+    uint8_t *quantifier = array_get(quantifiers, id);
+    uint8_t *own_quantifier = array_get(self, id);
+    *own_quantifier = (uint8_t) quantifier_join((TSQuantifier) *own_quantifier, (TSQuantifier) *quantifier);
+  }
+  for (uint32_t id = quantifiers->size; id < self->size; id++) {
+    uint8_t *own_quantifier = array_get(self, id);
+    *own_quantifier = (uint8_t) quantifier_join((TSQuantifier) *own_quantifier, TSQuantifierZero);
+  }
+}
+
+/**************
+ * SymbolTable
+ **************/
+
+static SymbolTable symbol_table_new(void) {
+  return (SymbolTable) {
+    .characters = array_new(),
+    .slices = array_new(),
+  };
+}
+
+static void symbol_table_delete(SymbolTable *self) {
+  array_delete(&self->characters);
+  array_delete(&self->slices);
+}
+
+static int symbol_table_id_for_name(
+  const SymbolTable *self,
+  const char *name,
+  uint32_t length
+) {
+  for (unsigned i = 0; i < self->slices.size; i++) {
+    Slice slice = *array_get(&self->slices, i);
+    if (
+      slice.length == length &&
+      !strncmp(array_get(&self->characters, slice.offset), name, length)
+    ) return i;
+  }
+  return -1;
+}
+
+static const char *symbol_table_name_for_id(
+  const SymbolTable *self,
+  uint16_t id,
+  uint32_t *length
+) {
+  Slice slice = *(array_get(&self->slices,id));
+  *length = slice.length;
+  return array_get(&self->characters, slice.offset);
+}
+
+static uint16_t symbol_table_insert_name(
+  SymbolTable *self,
+  const char *name,
+  uint32_t length
+) {
+  int id = symbol_table_id_for_name(self, name, length);
+  if (id >= 0) return (uint16_t)id;
+  Slice slice = {
+    .offset = self->characters.size,
+    .length = length,
+  };
+  array_grow_by(&self->characters, length + 1);
+  memcpy(array_get(&self->characters, slice.offset), name, length);
+  *array_get(&self->characters, self->characters.size - 1) = 0;
+  array_push(&self->slices, slice);
+  return self->slices.size - 1;
+}
+
+/************
+ * QueryStep
+ ************/
+
+static QueryStep query_step__new(
+  TSSymbol symbol,
+  uint16_t depth,
+  bool is_immediate
+) {
+  QueryStep step = {
+    .symbol = symbol,
+    .depth = depth,
+    .field = 0,
+    .alternative_index = NONE,
+    .negated_field_list_id = 0,
+    .contains_captures = false,
+    .is_last_child = false,
+    .is_named = false,
+    .is_pass_through = false,
+    .is_dead_end = false,
+    .root_pattern_guaranteed = false,
+    .is_immediate = is_immediate,
+    .alternative_is_immediate = false,
+  };
+  for (unsigned i = 0; i < MAX_STEP_CAPTURE_COUNT; i++) {
+    step.capture_ids[i] = NONE;
+  }
+  return step;
+}
+
+static void query_step__add_capture(QueryStep *self, uint16_t capture_id) {
+  for (unsigned i = 0; i < MAX_STEP_CAPTURE_COUNT; i++) {
+    if (self->capture_ids[i] == NONE) {
+      self->capture_ids[i] = capture_id;
+      break;
+    }
+  }
+}
+
+static void query_step__remove_capture(QueryStep *self, uint16_t capture_id) {
+  for (unsigned i = 0; i < MAX_STEP_CAPTURE_COUNT; i++) {
+    if (self->capture_ids[i] == capture_id) {
+      self->capture_ids[i] = NONE;
+      while (i + 1 < MAX_STEP_CAPTURE_COUNT) {
+        if (self->capture_ids[i + 1] == NONE) break;
+        self->capture_ids[i] = self->capture_ids[i + 1];
+        self->capture_ids[i + 1] = NONE;
+        i++;
+      }
+      break;
+    }
+  }
+}
+
+/**********************
+ * StatePredecessorMap
+ **********************/
+
+static inline StatePredecessorMap state_predecessor_map_new(
+  const TSLanguage *language
+) {
+  return (StatePredecessorMap) {
+    .contents = ts_calloc(
+      (size_t)language->state_count * (MAX_STATE_PREDECESSOR_COUNT + 1),
+      sizeof(TSStateId)
+    ),
+  };
+}
+
+static inline void state_predecessor_map_delete(StatePredecessorMap *self) {
+  ts_free(self->contents);
+}
+
+static inline void state_predecessor_map_add(
+  StatePredecessorMap *self,
+  TSStateId state,
+  TSStateId predecessor
+) {
+  size_t index = (size_t)state * (MAX_STATE_PREDECESSOR_COUNT + 1);
+  TSStateId *count = &self->contents[index];
+  if (
+    *count == 0 ||
+    (*count < MAX_STATE_PREDECESSOR_COUNT && self->contents[index + *count] != predecessor)
+  ) {
+    (*count)++;
+    self->contents[index + *count] = predecessor;
+  }
+}
+
+static inline const TSStateId *state_predecessor_map_get(
+  const StatePredecessorMap *self,
+  TSStateId state,
+  unsigned *count
+) {
+  size_t index = (size_t)state * (MAX_STATE_PREDECESSOR_COUNT + 1);
+  *count = self->contents[index];
+  return &self->contents[index + 1];
+}
+
+/****************
+ * AnalysisState
+ ****************/
+
+static unsigned analysis_state__recursion_depth(const AnalysisState *self) {
+  unsigned result = 0;
+  for (unsigned i = 0; i < self->depth; i++) {
+    TSSymbol symbol = self->stack[i].parent_symbol;
+    for (unsigned j = 0; j < i; j++) {
+      if (self->stack[j].parent_symbol == symbol) {
+        result++;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+static inline int analysis_state__compare(
+  AnalysisState *const *self,
+  AnalysisState *const *other
+) {
+  if ((*self)->depth < (*other)->depth) return 1;
+  for (unsigned i = 0; i < (*self)->depth; i++) {
+    if (i >= (*other)->depth) return -1;
+    AnalysisStateEntry s1 = (*self)->stack[i];
+    AnalysisStateEntry s2 = (*other)->stack[i];
+    if (s1.child_index < s2.child_index) return -1;
+    if (s1.child_index > s2.child_index) return 1;
+    if (s1.parent_symbol < s2.parent_symbol) return -1;
+    if (s1.parent_symbol > s2.parent_symbol) return 1;
+    if (s1.parse_state < s2.parse_state) return -1;
+    if (s1.parse_state > s2.parse_state) return 1;
+    if (s1.field_id < s2.field_id) return -1;
+    if (s1.field_id > s2.field_id) return 1;
+  }
+  if ((*self)->step_index < (*other)->step_index) return -1;
+  if ((*self)->step_index > (*other)->step_index) return 1;
+  return 0;
+}
+
+static inline AnalysisStateEntry *analysis_state__top(AnalysisState *self) {
+  if (self->depth == 0) {
+    return &self->stack[0];
+  }
+  return &self->stack[self->depth - 1];
+}
+
+static inline bool analysis_state__has_supertype(AnalysisState *self, TSSymbol symbol) {
+  for (unsigned i = 0; i < self->depth; i++) {
+    if (self->stack[i].parent_symbol == symbol) return true;
+  }
+  return false;
+}
+
+/******************
+ * AnalysisStateSet
+ ******************/
+
+// Obtains an `AnalysisState` instance, either by consuming one from this set's object pool, or by
+// cloning one from scratch.
+static inline AnalysisState *analysis_state_pool__clone_or_reuse(
+  AnalysisStateSet *self,
+  AnalysisState *borrowed_item
+) {
+  AnalysisState *new_item;
+  if (self->size) {
+    new_item = array_pop(self);
+  } else {
+    new_item = ts_malloc(sizeof(AnalysisState));
+  }
+  *new_item = *borrowed_item;
+  return new_item;
+}
+
+// Inserts a clone of the passed-in item at the appropriate position to maintain ordering in this
+// set. The set does not contain duplicates, so if the item is already present, it will not be
+// inserted, and no clone will be made.
+//
+// The caller retains ownership of the passed-in memory. However, the clone that is created by this
+// function will be managed by the state set.
+static inline void analysis_state_set__insert_sorted(
+  AnalysisStateSet *self,
+  AnalysisStateSet *pool,
+  AnalysisState *borrowed_item
+) {
+  unsigned index, exists;
+  array_search_sorted_with(self, analysis_state__compare, &borrowed_item, &index, &exists);
+  if (!exists) {
+    AnalysisState *new_item = analysis_state_pool__clone_or_reuse(pool, borrowed_item);
+    array_insert(self, index, new_item);
+  }
+}
+
+// Inserts a clone of the passed-in item at the end position of this list.
+//
+// IMPORTANT: The caller MUST ENSURE that this item is larger (by the comparison function
+// `analysis_state__compare`) than largest item already in this set. If items are inserted in the
+// wrong order, the set will not function properly for future use.
+//
+// The caller retains ownership of the passed-in memory. However, the clone that is created by this
+// function will be managed by the state set.
+static inline void analysis_state_set__push(
+  AnalysisStateSet *self,
+  AnalysisStateSet *pool,
+  AnalysisState *borrowed_item
+) {
+  AnalysisState *new_item = analysis_state_pool__clone_or_reuse(pool, borrowed_item);
+  array_push(self, new_item);
+}
+
+// Removes all items from this set, returning it to an empty state.
+static inline void analysis_state_set__clear(AnalysisStateSet *self, AnalysisStateSet *pool) {
+  array_push_all(pool, self);
+  array_clear(self);
+}
+
+// Releases all memory that is managed with this state set, including any items currently present.
+// After calling this function, the set is no longer suitable for use.
+static inline void analysis_state_set__delete(AnalysisStateSet *self) {
+  for (unsigned i = 0; i < self->size; i++) {
+    ts_free(self->contents[i]);
+  }
+  array_delete(self);
+}
+
+/****************
+ * QueryAnalyzer
+ ****************/
+
+static inline QueryAnalysis query_analysis__new(void) {
+  return (QueryAnalysis) {
+    .states = array_new(),
+    .next_states = array_new(),
+    .deeper_states = array_new(),
+    .state_pool = array_new(),
+    .final_step_indices = array_new(),
+    .finished_parent_symbols = array_new(),
+    .did_abort = false,
+  };
+}
+
+static inline void query_analysis__delete(QueryAnalysis *self) {
+  analysis_state_set__delete(&self->states);
+  analysis_state_set__delete(&self->next_states);
+  analysis_state_set__delete(&self->deeper_states);
+  analysis_state_set__delete(&self->state_pool);
+  array_delete(&self->final_step_indices);
+  array_delete(&self->finished_parent_symbols);
+}
+
+/***********************
+ * AnalysisSubgraphNode
+ ***********************/
+
+static inline int analysis_subgraph_node__compare(const AnalysisSubgraphNode *self, const AnalysisSubgraphNode *other) {
+  if (self->state < other->state) return -1;
+  if (self->state > other->state) return 1;
+  if (self->child_index < other->child_index) return -1;
+  if (self->child_index > other->child_index) return 1;
+  if (self->done < other->done) return -1;
+  if (self->done > other->done) return 1;
+  if (self->production_id < other->production_id) return -1;
+  if (self->production_id > other->production_id) return 1;
+  return 0;
+}
+
+/*********
+ * Query
+ *********/
+
+// The `pattern_map` contains a mapping from TSSymbol values to indices in the
+// `steps` array. For a given syntax node, the `pattern_map` makes it possible
+// to quickly find the starting steps of all of the patterns whose root matches
+// that node. Each entry has two fields: a `pattern_index`, which identifies one
+// of the patterns in the query, and a `step_index`, which indicates the start
+// offset of that pattern's steps within the `steps` array.
+//
+// The entries are sorted by the patterns' root symbols, and lookups use a
+// binary search. This ensures that the cost of this initial lookup step
+// scales logarithmically with the number of patterns in the query.
+//
+// This returns `true` if the symbol is present and `false` otherwise.
+// If the symbol is not present `*result` is set to the index where the
+// symbol should be inserted.
+static inline bool ts_query__pattern_map_search(
+  const TSQuery *self,
+  TSSymbol needle,
+  uint32_t *result
+) {
+  uint32_t base_index = self->wildcard_root_pattern_count;
+  uint32_t size = self->pattern_map.size - base_index;
+  if (size == 0) {
+    *result = base_index;
+    return false;
+  }
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = base_index + half_size;
+    TSSymbol mid_symbol = array_get(&self->steps,
+      array_get(&self->pattern_map, mid_index)->step_index
+    )->symbol;
+    if (needle > mid_symbol) base_index = mid_index;
+    size -= half_size;
+  }
+
+  TSSymbol symbol = array_get(&self->steps,
+    array_get(&self->pattern_map, base_index)->step_index
+  )->symbol;
+
+  if (needle > symbol) {
+    base_index++;
+    if (base_index < self->pattern_map.size) {
+      symbol = array_get(&self->steps,
+        array_get(&self->pattern_map, base_index)->step_index
+      )->symbol;
+    }
+  }
+
+  *result = base_index;
+  return needle == symbol;
+}
+
+// Insert a new pattern's start index into the pattern map, maintaining
+// the pattern map's ordering invariant.
+static inline void ts_query__pattern_map_insert(
+  TSQuery *self,
+  TSSymbol symbol,
+  PatternEntry new_entry
+) {
+  uint32_t index;
+  ts_query__pattern_map_search(self, symbol, &index);
+
+  // Ensure that the entries are sorted not only by symbol, but also
+  // by pattern_index. This way, states for earlier patterns will be
+  // initiated first, which allows the ordering of the states array
+  // to be maintained more efficiently.
+  while (index < self->pattern_map.size) {
+    PatternEntry *entry = array_get(&self->pattern_map, index);
+    if (
+      array_get(&self->steps, entry->step_index)->symbol == symbol &&
+      entry->pattern_index < new_entry.pattern_index
+    ) {
+      index++;
+    } else {
+      break;
+    }
+  }
+
+  array_insert(&self->pattern_map, index, new_entry);
+}
+
+// Walk the subgraph for this non-terminal, tracking all of the possible
+// sequences of progress within the pattern.
+static void ts_query__perform_analysis(
+  TSQuery *self,
+  const AnalysisSubgraphArray *subgraphs,
+  QueryAnalysis *analysis
+) {
+  unsigned recursion_depth_limit = 0;
+  unsigned prev_final_step_count = 0;
+  array_clear(&analysis->final_step_indices);
+  array_clear(&analysis->finished_parent_symbols);
+
+  for (unsigned iteration = 0;; iteration++) {
+    if (iteration == MAX_ANALYSIS_ITERATION_COUNT) {
+      analysis->did_abort = true;
+      break;
+    }
+
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf("Iteration: %u. Final step indices:", iteration);
+      for (unsigned j = 0; j < analysis->final_step_indices.size; j++) {
+        printf(" %4u", *array_get(&analysis->final_step_indices, j));
+      }
+      printf("\n");
+      for (unsigned j = 0; j < analysis->states.size; j++) {
+        AnalysisState *state = *array_get(&analysis->states, j);
+        printf("  %3u: step: %u, stack: [", j, state->step_index);
+        for (unsigned k = 0; k < state->depth; k++) {
+          printf(
+            " {%s, child: %u, state: %4u",
+            self->language->symbol_names[state->stack[k].parent_symbol],
+            state->stack[k].child_index,
+            state->stack[k].parse_state
+          );
+          if (state->stack[k].field_id) printf(", field: %s", self->language->field_names[state->stack[k].field_id]);
+          if (state->stack[k].done) printf(", DONE");
+          printf("}");
+        }
+        printf(" ]\n");
+      }
+    #endif
+
+    // If no further progress can be made within the current recursion depth limit, then
+    // bump the depth limit by one, and continue to process the states the exceeded the
+    // limit. But only allow this if progress has been made since the last time the depth
+    // limit was increased.
+    if (analysis->states.size == 0) {
+      if (
+        analysis->deeper_states.size > 0 &&
+        analysis->final_step_indices.size > prev_final_step_count
+      ) {
+        #ifdef DEBUG_ANALYZE_QUERY
+          printf("Increase recursion depth limit to %u\n", recursion_depth_limit + 1);
+        #endif
+
+        prev_final_step_count = analysis->final_step_indices.size;
+        recursion_depth_limit++;
+        AnalysisStateSet _states = analysis->states;
+        analysis->states = analysis->deeper_states;
+        analysis->deeper_states = _states;
+        continue;
+      }
+
+      break;
+    }
+
+    analysis_state_set__clear(&analysis->next_states, &analysis->state_pool);
+    for (unsigned j = 0; j < analysis->states.size; j++) {
+      AnalysisState * const state = *array_get(&analysis->states, j);
+
+      // For efficiency, it's important to avoid processing the same analysis state more
+      // than once. To achieve this, keep the states in order of ascending position within
+      // their hypothetical syntax trees. In each iteration of this loop, start by advancing
+      // the states that have made the least progress. Avoid advancing states that have already
+      // made more progress.
+      if (analysis->next_states.size > 0) {
+        int comparison = analysis_state__compare(
+          &state,
+          array_back(&analysis->next_states)
+        );
+        if (comparison == 0) {
+          analysis_state_set__insert_sorted(&analysis->next_states, &analysis->state_pool, state);
+          continue;
+        } else if (comparison > 0) {
+          #ifdef DEBUG_ANALYZE_QUERY
+            printf("Terminate iteration at state %u\n", j);
+          #endif
+          while (j < analysis->states.size) {
+            analysis_state_set__push(
+              &analysis->next_states,
+              &analysis->state_pool,
+              *array_get(&analysis->states, j)
+            );
+            j++;
+          }
+          break;
+        }
+      }
+
+      const TSStateId parse_state = analysis_state__top(state)->parse_state;
+      const TSSymbol parent_symbol = analysis_state__top(state)->parent_symbol;
+      const TSFieldId parent_field_id = analysis_state__top(state)->field_id;
+      const unsigned child_index = analysis_state__top(state)->child_index;
+      const QueryStep * const step = array_get(&self->steps, state->step_index);
+
+      unsigned subgraph_index, exists;
+      array_search_sorted_by(subgraphs, .symbol, parent_symbol, &subgraph_index, &exists);
+      if (!exists) continue;
+      const AnalysisSubgraph *subgraph = array_get(subgraphs, subgraph_index);
+
+      // Follow every possible path in the parse table, but only visit states that
+      // are part of the subgraph for the current symbol.
+      LookaheadIterator lookahead_iterator = ts_language_lookaheads(self->language, parse_state);
+      while (ts_lookahead_iterator__next(&lookahead_iterator)) {
+        TSSymbol sym = lookahead_iterator.symbol;
+
+        AnalysisSubgraphNode successor = {
+          .state = parse_state,
+          .child_index = child_index,
+        };
+        if (lookahead_iterator.action_count) {
+          const TSParseAction *action = &lookahead_iterator.actions[lookahead_iterator.action_count - 1];
+          if (action->type == TSParseActionTypeShift) {
+            if (!action->shift.extra) {
+              successor.state = action->shift.state;
+              successor.child_index++;
+            }
+          } else {
+            continue;
+          }
+        } else if (lookahead_iterator.next_state != 0) {
+          successor.state = lookahead_iterator.next_state;
+          successor.child_index++;
+        } else {
+          continue;
+        }
+
+        unsigned node_index;
+        array_search_sorted_with(
+          &subgraph->nodes,
+          analysis_subgraph_node__compare, &successor,
+          &node_index, &exists
+        );
+        while (node_index < subgraph->nodes.size) {
+          AnalysisSubgraphNode *node = array_get(&subgraph->nodes, node_index);
+          node_index++;
+          if (node->state != successor.state || node->child_index != successor.child_index) break;
+
+          // Use the subgraph to determine what alias and field will eventually be applied
+          // to this child node.
+          TSSymbol alias = ts_language_alias_at(self->language, node->production_id, child_index);
+          TSSymbol visible_symbol = alias
+            ? alias
+            : self->language->symbol_metadata[sym].visible
+              ? self->language->public_symbol_map[sym]
+              : 0;
+          TSFieldId field_id = parent_field_id;
+          if (!field_id) {
+            const TSFieldMapEntry *field_map, *field_map_end;
+            ts_language_field_map(self->language, node->production_id, &field_map, &field_map_end);
+            for (; field_map != field_map_end; field_map++) {
+              if (!field_map->inherited && field_map->child_index == child_index) {
+                field_id = field_map->field_id;
+                break;
+              }
+            }
+          }
+
+          // Create a new state that has advanced past this hypothetical subtree.
+          AnalysisState next_state = *state;
+          AnalysisStateEntry *next_state_top = analysis_state__top(&next_state);
+          next_state_top->child_index = successor.child_index;
+          next_state_top->parse_state = successor.state;
+          if (node->done) next_state_top->done = true;
+
+          // Determine if this hypothetical child node would match the current step
+          // of the query pattern.
+          bool does_match = false;
+
+          // ERROR nodes can appear anywhere, so if the step is 
+          // looking for an ERROR node, consider it potentially matchable.
+          if (step->symbol == ts_builtin_sym_error) {
+            does_match = true;
+          } else if (visible_symbol) {
+            does_match = true;
+            if (step->symbol == WILDCARD_SYMBOL) {
+              if (
+                step->is_named &&
+                !self->language->symbol_metadata[visible_symbol].named
+              ) does_match = false;
+            } else if (step->symbol != visible_symbol) {
+              does_match = false;
+            }
+            if (step->field && step->field != field_id) {
+              does_match = false;
+            }
+            if (
+              step->supertype_symbol &&
+              !analysis_state__has_supertype(state, step->supertype_symbol)
+            ) does_match = false;
+          }
+
+          // If this child is hidden, then descend into it and walk through its children.
+          // If the top entry of the stack is at the end of its rule, then that entry can
+          // be replaced. Otherwise, push a new entry onto the stack.
+          else if (sym >= self->language->token_count) {
+            if (!next_state_top->done) {
+              if (next_state.depth + 1 >= MAX_ANALYSIS_STATE_DEPTH) {
+                #ifdef DEBUG_ANALYZE_QUERY
+                  printf("Exceeded depth limit for state %u\n", j);
+                #endif
+
+                analysis->did_abort = true;
+                continue;
+              }
+
+              next_state.depth++;
+              next_state_top = analysis_state__top(&next_state);
+            }
+
+            *next_state_top = (AnalysisStateEntry) {
+              .parse_state = parse_state,
+              .parent_symbol = sym,
+              .child_index = 0,
+              .field_id = field_id,
+              .done = false,
+            };
+
+            if (analysis_state__recursion_depth(&next_state) > recursion_depth_limit) {
+              analysis_state_set__insert_sorted(
+                &analysis->deeper_states,
+                &analysis->state_pool,
+                &next_state
+              );
+              continue;
+            }
+          }
+
+          // Pop from the stack when this state reached the end of its current syntax node.
+          while (next_state.depth > 0 && next_state_top->done) {
+            next_state.depth--;
+            next_state_top = analysis_state__top(&next_state);
+          }
+
+          // If this hypothetical child did match the current step of the query pattern,
+          // then advance to the next step at the current depth. This involves skipping
+          // over any descendant steps of the current child.
+          const QueryStep *next_step = step;
+          if (does_match) {
+            for (;;) {
+              next_state.step_index++;
+              next_step = array_get(&self->steps, next_state.step_index);
+              if (
+                next_step->depth == PATTERN_DONE_MARKER ||
+                next_step->depth <= step->depth
+              ) break;
+            }
+          } else if (successor.state == parse_state) {
+            continue;
+          }
+
+          for (;;) {
+            // Skip pass-through states. Although these states have alternatives, they are only
+            // used to implement repetitions, and query analysis does not need to process
+            // repetitions in order to determine whether steps are possible and definite.
+            if (next_step->is_pass_through) {
+              next_state.step_index++;
+              next_step++;
+              continue;
+            }
+
+            // If the pattern is finished or hypothetical parent node is complete, then
+            // record that matching can terminate at this step of the pattern. Otherwise,
+            // add this state to the list of states to process on the next iteration.
+            if (!next_step->is_dead_end) {
+              bool did_finish_pattern = array_get(&self->steps, next_state.step_index)->depth != step->depth;
+              if (did_finish_pattern) {
+                array_insert_sorted_by(&analysis->finished_parent_symbols, , state->root_symbol);
+              } else if (next_state.depth == 0) {
+                array_insert_sorted_by(&analysis->final_step_indices, , next_state.step_index);
+              } else {
+                analysis_state_set__insert_sorted(&analysis->next_states, &analysis->state_pool, &next_state);
+              }
+            }
+
+            // If the state has advanced to a step with an alternative step, then add another state
+            // at that alternative step. This process is simpler than the process of actually matching a
+            // pattern during query execution, because for the purposes of query analysis, there is no
+            // need to process repetitions.
+            if (
+              does_match &&
+              next_step->alternative_index != NONE &&
+              next_step->alternative_index > next_state.step_index
+            ) {
+              next_state.step_index = next_step->alternative_index;
+              next_step = array_get(&self->steps, next_state.step_index);
+            } else {
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    AnalysisStateSet _states = analysis->states;
+    analysis->states = analysis->next_states;
+    analysis->next_states = _states;
+  }
+}
+
+static bool ts_query__analyze_patterns(TSQuery *self, unsigned *error_offset) {
+  Array(uint16_t) non_rooted_pattern_start_steps = array_new();
+  for (unsigned i = 0; i < self->pattern_map.size; i++) {
+    PatternEntry *pattern = array_get(&self->pattern_map, i);
+    if (!pattern->is_rooted) {
+      QueryStep *step = array_get(&self->steps, pattern->step_index);
+      if (step->symbol != WILDCARD_SYMBOL) {
+        array_push(&non_rooted_pattern_start_steps, i);
+      }
+    }
+  }
+
+  // Walk forward through all of the steps in the query, computing some
+  // basic information about each step. Mark all of the steps that contain
+  // captures, and record the indices of all of the steps that have child steps.
+  Array(uint32_t) parent_step_indices = array_new();
+  bool all_patterns_are_valid = true;
+  for (unsigned i = 0; i < self->steps.size; i++) {
+    QueryStep *step = array_get(&self->steps, i);
+    if (step->depth == PATTERN_DONE_MARKER) {
+      step->parent_pattern_guaranteed = true;
+      step->root_pattern_guaranteed = true;
+      continue;
+    }
+
+    bool has_children = false;
+    bool is_wildcard = step->symbol == WILDCARD_SYMBOL;
+    step->contains_captures = step->capture_ids[0] != NONE;
+    for (unsigned j = i + 1; j < self->steps.size; j++) {
+      QueryStep *next_step = array_get(&self->steps, j);
+      if (
+        next_step->depth == PATTERN_DONE_MARKER ||
+        next_step->depth <= step->depth
+      ) break;
+      if (next_step->capture_ids[0] != NONE) {
+        step->contains_captures = true;
+      }
+      if (!is_wildcard) {
+        next_step->root_pattern_guaranteed = true;
+        next_step->parent_pattern_guaranteed = true;
+      }
+      has_children = true;
+    }
+
+    if (has_children) {
+      if (!is_wildcard) {
+        array_push(&parent_step_indices, i);
+      } else if (step->supertype_symbol && self->language->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS) {
+        // Look at the child steps to see if any aren't valid subtypes for this supertype.
+        uint32_t subtype_length;
+        const TSSymbol *subtypes = ts_language_subtypes(
+          self->language,
+          step->supertype_symbol,
+          &subtype_length
+        );
+
+        for (unsigned j = i + 1; j < self->steps.size; j++) {
+          QueryStep *child_step = array_get(&self->steps, j);
+          if (child_step->depth == PATTERN_DONE_MARKER || child_step->depth <= step->depth) {
+            break;
+          }
+          if (child_step->depth == step->depth + 1 && child_step->symbol != WILDCARD_SYMBOL) {
+            bool is_valid_subtype = false;
+            for (uint32_t k = 0; k < subtype_length; k++) {
+              if (child_step->symbol == subtypes[k]) {
+                is_valid_subtype = true;
+                break;
+              }
+            }
+
+            if (!is_valid_subtype) {
+              for (unsigned offset_idx = 0; offset_idx < self->step_offsets.size; offset_idx++) {
+                StepOffset *step_offset = array_get(&self->step_offsets, offset_idx);
+                if (step_offset->step_index >= j) {
+                  *error_offset = step_offset->byte_offset;
+                  all_patterns_are_valid = false;
+                  goto supertype_cleanup;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // For every parent symbol in the query, initialize an 'analysis subgraph'.
+  // This subgraph lists all of the states in the parse table that are directly
+  // involved in building subtrees for this symbol.
+  //
+  // In addition to the parent symbols in the query, construct subgraphs for all
+  // of the hidden symbols in the grammar, because these might occur within
+  // one of the parent nodes, such that their children appear to belong to the
+  // parent.
+  AnalysisSubgraphArray subgraphs = array_new();
+  for (unsigned i = 0; i < parent_step_indices.size; i++) {
+    uint32_t parent_step_index = *array_get(&parent_step_indices, i);
+    TSSymbol parent_symbol = array_get(&self->steps, parent_step_index)->symbol;
+    AnalysisSubgraph subgraph = { .symbol = parent_symbol };
+    array_insert_sorted_by(&subgraphs, .symbol, subgraph);
+  }
+  for (TSSymbol sym = (uint16_t)self->language->token_count; sym < (uint16_t)self->language->symbol_count; sym++) {
+    if (!ts_language_symbol_metadata(self->language, sym).visible) {
+      AnalysisSubgraph subgraph = { .symbol = sym };
+      array_insert_sorted_by(&subgraphs, .symbol, subgraph);
+    }
+  }
+
+  // Scan the parse table to find the data needed to populate these subgraphs.
+  // Collect three things during this scan:
+  //   1) All of the parse states where one of these symbols can start.
+  //   2) All of the parse states where one of these symbols can end, along
+  //      with information about the node that would be created.
+  //   3) A list of predecessor states for each state.
+  StatePredecessorMap predecessor_map = state_predecessor_map_new(self->language);
+  for (TSStateId state = 1; state < (uint16_t)self->language->state_count; state++) {
+    unsigned subgraph_index, exists;
+    LookaheadIterator lookahead_iterator = ts_language_lookaheads(self->language, state);
+    while (ts_lookahead_iterator__next(&lookahead_iterator)) {
+      if (lookahead_iterator.action_count) {
+        for (unsigned i = 0; i < lookahead_iterator.action_count; i++) {
+          const TSParseAction *action = &lookahead_iterator.actions[i];
+          if (action->type == TSParseActionTypeReduce) {
+            const TSSymbol *aliases, *aliases_end;
+            ts_language_aliases_for_symbol(
+              self->language,
+              action->reduce.symbol,
+              &aliases,
+              &aliases_end
+            );
+            for (const TSSymbol *symbol = aliases; symbol < aliases_end; symbol++) {
+              array_search_sorted_by(
+                &subgraphs,
+                .symbol,
+                *symbol,
+                &subgraph_index,
+                &exists
+              );
+              if (exists) {
+                AnalysisSubgraph *subgraph = array_get(&subgraphs, subgraph_index);
+                if (subgraph->nodes.size == 0 || array_back(&subgraph->nodes)->state != state) {
+                  array_push(&subgraph->nodes, ((AnalysisSubgraphNode) {
+                    .state = state,
+                    .production_id = action->reduce.production_id,
+                    .child_index = action->reduce.child_count,
+                    .done = true,
+                  }));
+                }
+              }
+            }
+          } else if (action->type == TSParseActionTypeShift && !action->shift.extra) {
+            TSStateId next_state = action->shift.state;
+            state_predecessor_map_add(&predecessor_map, next_state, state);
+          }
+        }
+      } else if (lookahead_iterator.next_state != 0) {
+        if (lookahead_iterator.next_state != state) {
+          state_predecessor_map_add(&predecessor_map, lookahead_iterator.next_state, state);
+        }
+        if (ts_language_state_is_primary(self->language, state)) {
+          const TSSymbol *aliases, *aliases_end;
+          ts_language_aliases_for_symbol(
+            self->language,
+            lookahead_iterator.symbol,
+            &aliases,
+            &aliases_end
+          );
+          for (const TSSymbol *symbol = aliases; symbol < aliases_end; symbol++) {
+            array_search_sorted_by(
+              &subgraphs,
+              .symbol,
+              *symbol,
+              &subgraph_index,
+              &exists
+            );
+            if (exists) {
+              AnalysisSubgraph *subgraph = array_get(&subgraphs, subgraph_index);
+              if (
+                subgraph->start_states.size == 0 ||
+                *array_back(&subgraph->start_states) != state
+              )
+              array_push(&subgraph->start_states, state);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // For each subgraph, compute the preceding states by walking backward
+  // from the end states using the predecessor map.
+  Array(AnalysisSubgraphNode) next_nodes = array_new();
+  for (unsigned i = 0; i < subgraphs.size; i++) {
+    AnalysisSubgraph *subgraph = array_get(&subgraphs, i);
+    if (subgraph->nodes.size == 0) {
+      array_delete(&subgraph->start_states);
+      array_erase(&subgraphs, i);
+      i--;
+      continue;
+    }
+    array_assign(&next_nodes, &subgraph->nodes);
+    while (next_nodes.size > 0) {
+      AnalysisSubgraphNode node = array_pop(&next_nodes);
+      if (node.child_index > 1) {
+        unsigned predecessor_count;
+        const TSStateId *predecessors = state_predecessor_map_get(
+          &predecessor_map,
+          node.state,
+          &predecessor_count
+        );
+        for (unsigned j = 0; j < predecessor_count; j++) {
+          AnalysisSubgraphNode predecessor_node = {
+            .state = predecessors[j],
+            .child_index = node.child_index - 1,
+            .production_id = node.production_id,
+            .done = false,
+          };
+          unsigned index, exists;
+          array_search_sorted_with(
+            &subgraph->nodes, analysis_subgraph_node__compare, &predecessor_node,
+            &index, &exists
+          );
+          if (!exists) {
+            array_insert(&subgraph->nodes, index, predecessor_node);
+            array_push(&next_nodes, predecessor_node);
+          }
+        }
+      }
+    }
+  }
+
+  #ifdef DEBUG_ANALYZE_QUERY
+    printf("\nSubgraphs:\n");
+    for (unsigned i = 0; i < subgraphs.size; i++) {
+      AnalysisSubgraph *subgraph = array_get(&subgraphs, i);
+      printf("  %u, %s:\n", subgraph->symbol, ts_language_symbol_name(self->language, subgraph->symbol));
+      for (unsigned j = 0; j < subgraph->start_states.size; j++) {
+        printf(
+          "    {state: %u}\n",
+          *array_get(&subgraph->start_states, j)
+        );
+      }
+      for (unsigned j = 0; j < subgraph->nodes.size; j++) {
+        AnalysisSubgraphNode *node = array_get(&subgraph->nodes, j);
+        printf(
+          "    {state: %u, child_index: %u, production_id: %u, done: %d}\n",
+          node->state, node->child_index, node->production_id, node->done
+        );
+      }
+      printf("\n");
+    }
+  #endif
+
+  // For each non-terminal pattern, determine if the pattern can successfully match,
+  // and identify all of the possible children within the pattern where matching could fail.
+  QueryAnalysis analysis = query_analysis__new();
+  for (unsigned i = 0; i < parent_step_indices.size; i++) {
+    uint16_t parent_step_index = *array_get(&parent_step_indices, i);
+    uint16_t parent_depth = array_get(&self->steps, parent_step_index)->depth;
+    TSSymbol parent_symbol = array_get(&self->steps, parent_step_index)->symbol;
+    if (parent_symbol == ts_builtin_sym_error) continue;
+
+    // Find the subgraph that corresponds to this pattern's root symbol. If the pattern's
+    // root symbol is a terminal, then return an error.
+    unsigned subgraph_index, exists;
+    array_search_sorted_by(&subgraphs, .symbol, parent_symbol, &subgraph_index, &exists);
+    if (!exists) {
+      unsigned first_child_step_index = parent_step_index + 1;
+      uint32_t j, child_exists;
+      array_search_sorted_by(&self->step_offsets, .step_index, first_child_step_index, &j, &child_exists);
+      ts_assert(child_exists);
+      *error_offset = array_get(&self->step_offsets, j)->byte_offset;
+      all_patterns_are_valid = false;
+      break;
+    }
+
+    // Initialize an analysis state at every parse state in the table where
+    // this parent symbol can occur.
+    AnalysisSubgraph *subgraph = array_get(&subgraphs, subgraph_index);
+    analysis_state_set__clear(&analysis.states, &analysis.state_pool);
+    analysis_state_set__clear(&analysis.deeper_states, &analysis.state_pool);
+    for (unsigned j = 0; j < subgraph->start_states.size; j++) {
+      TSStateId parse_state = *array_get(&subgraph->start_states, j);
+      analysis_state_set__push(&analysis.states, &analysis.state_pool, &((AnalysisState) {
+        .step_index = parent_step_index + 1,
+        .stack = {
+          [0] = {
+            .parse_state = parse_state,
+            .parent_symbol = parent_symbol,
+            .child_index = 0,
+            .field_id = 0,
+            .done = false,
+          },
+        },
+        .depth = 1,
+        .root_symbol = parent_symbol,
+      }));
+    }
+
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf(
+        "\nWalk states for %s:\n",
+        ts_language_symbol_name(self->language, (*array_get(&analysis.states, 0))->stack[0].parent_symbol)
+      );
+    #endif
+
+    analysis.did_abort = false;
+    ts_query__perform_analysis(self, &subgraphs, &analysis);
+
+    // If this pattern could not be fully analyzed, then every step should
+    // be considered fallible.
+    if (analysis.did_abort) {
+      for (unsigned j = parent_step_index + 1; j < self->steps.size; j++) {
+        QueryStep *step = array_get(&self->steps, j);
+        if (
+          step->depth <= parent_depth ||
+          step->depth == PATTERN_DONE_MARKER
+        ) break;
+        if (!step->is_dead_end) {
+          step->parent_pattern_guaranteed = false;
+          step->root_pattern_guaranteed = false;
+        }
+      }
+      continue;
+    }
+
+    // If this pattern cannot match, store the pattern index so that it can be
+    // returned to the caller.
+    if (analysis.finished_parent_symbols.size == 0) {
+      uint16_t impossible_step_index;
+      if (analysis.final_step_indices.size > 0) {
+        impossible_step_index = *array_back(&analysis.final_step_indices);
+      } else {
+        // If there isn't a final step, then that means the parent step itself is unreachable.
+        impossible_step_index = parent_step_index;
+      }
+      uint32_t j, impossible_exists;
+      array_search_sorted_by(&self->step_offsets, .step_index, impossible_step_index, &j, &impossible_exists);
+      if (j >= self->step_offsets.size) j = self->step_offsets.size - 1;
+      *error_offset = array_get(&self->step_offsets, j)->byte_offset;
+      all_patterns_are_valid = false;
+      break;
+    }
+
+    // Mark as fallible any step where a match terminated.
+    // Later, this property will be propagated to all of the step's predecessors.
+    for (unsigned j = 0; j < analysis.final_step_indices.size; j++) {
+      uint32_t final_step_index = *array_get(&analysis.final_step_indices, j);
+      QueryStep *step = array_get(&self->steps, final_step_index);
+      if (
+        step->depth != PATTERN_DONE_MARKER &&
+        step->depth > parent_depth &&
+        !step->is_dead_end
+      ) {
+        step->parent_pattern_guaranteed = false;
+        step->root_pattern_guaranteed = false;
+      }
+    }
+  }
+
+  // Mark as indefinite any step with captures that are used in predicates.
+  Array(uint16_t) predicate_capture_ids = array_new();
+  for (unsigned i = 0; i < self->patterns.size; i++) {
+    QueryPattern *pattern = array_get(&self->patterns, i);
+
+    // Gather all of the captures that are used in predicates for this pattern.
+    array_clear(&predicate_capture_ids);
+    for (
+      unsigned start = pattern->predicate_steps.offset,
+      end = start + pattern->predicate_steps.length,
+      j = start; j < end; j++
+    ) {
+      TSQueryPredicateStep *step = array_get(&self->predicate_steps, j);
+      if (step->type == TSQueryPredicateStepTypeCapture) {
+        uint16_t value_id = step->value_id;
+        array_insert_sorted_by(&predicate_capture_ids, , value_id);
+      }
+    }
+
+    // Find all of the steps that have these captures.
+    for (
+      unsigned start = pattern->steps.offset,
+      end = start + pattern->steps.length,
+      j = start; j < end; j++
+    ) {
+      QueryStep *step = array_get(&self->steps, j);
+      for (unsigned k = 0; k < MAX_STEP_CAPTURE_COUNT; k++) {
+        uint16_t capture_id = step->capture_ids[k];
+        if (capture_id == NONE) break;
+        unsigned index, exists;
+        array_search_sorted_by(&predicate_capture_ids, , capture_id, &index, &exists);
+        if (exists) {
+          step->root_pattern_guaranteed = false;
+          break;
+        }
+      }
+    }
+  }
+
+  // Propagate fallibility. If a pattern is fallible at a given step, then it is
+  // fallible at all of its preceding steps.
+  bool done = self->steps.size == 0;
+  while (!done) {
+    done = true;
+    for (unsigned i = self->steps.size - 1; i > 0; i--) {
+      QueryStep *step = array_get(&self->steps, i);
+      if (step->depth == PATTERN_DONE_MARKER) continue;
+
+      // Determine if this step is definite or has definite alternatives.
+      bool parent_pattern_guaranteed = false;
+      for (;;) {
+        if (step->root_pattern_guaranteed) {
+          parent_pattern_guaranteed = true;
+          break;
+        }
+        if (step->alternative_index == NONE || step->alternative_index < i) {
+          break;
+        }
+        step = array_get(&self->steps, step->alternative_index);
+      }
+
+      // If not, mark its predecessor as indefinite.
+      if (!parent_pattern_guaranteed) {
+        QueryStep *prev_step = array_get(&self->steps, i - 1);
+        if (
+          !prev_step->is_dead_end &&
+          prev_step->depth != PATTERN_DONE_MARKER &&
+          prev_step->root_pattern_guaranteed
+        ) {
+          prev_step->root_pattern_guaranteed = false;
+          done = false;
+        }
+      }
+    }
+  }
+
+  #ifdef DEBUG_ANALYZE_QUERY
+    printf("Steps:\n");
+    for (unsigned i = 0; i < self->steps.size; i++) {
+      QueryStep *step = array_get(&self->steps, i);
+      if (step->depth == PATTERN_DONE_MARKER) {
+        printf("  %u: DONE\n", i);
+      } else {
+        printf(
+          "  %u: {symbol: %s, field: %s, depth: %u, parent_pattern_guaranteed: %d, root_pattern_guaranteed: %d}\n",
+          i,
+          (step->symbol == WILDCARD_SYMBOL)
+            ? "ANY"
+            : ts_language_symbol_name(self->language, step->symbol),
+          (step->field ? ts_language_field_name_for_id(self->language, step->field) : "-"),
+          step->depth,
+          step->parent_pattern_guaranteed,
+          step->root_pattern_guaranteed
+        );
+      }
+    }
+  #endif
+
+  // Determine which repetition symbols in this language have the possibility
+  // of matching non-rooted patterns in this query. These repetition symbols
+  // prevent certain optimizations with range restrictions.
+  analysis.did_abort = false;
+  for (uint32_t i = 0; i < non_rooted_pattern_start_steps.size; i++) {
+    uint16_t pattern_entry_index = *array_get(&non_rooted_pattern_start_steps, i);
+    PatternEntry *pattern_entry = array_get(&self->pattern_map, pattern_entry_index);
+
+    analysis_state_set__clear(&analysis.states, &analysis.state_pool);
+    analysis_state_set__clear(&analysis.deeper_states, &analysis.state_pool);
+    for (unsigned j = 0; j < subgraphs.size; j++) {
+      AnalysisSubgraph *subgraph = array_get(&subgraphs, j);
+      TSSymbolMetadata metadata = ts_language_symbol_metadata(self->language, subgraph->symbol);
+      if (metadata.visible || metadata.named) continue;
+
+      for (uint32_t k = 0; k < subgraph->start_states.size; k++) {
+        TSStateId parse_state = *array_get(&subgraph->start_states, k);
+        analysis_state_set__push(&analysis.states, &analysis.state_pool, &((AnalysisState) {
+          .step_index = pattern_entry->step_index,
+          .stack = {
+            [0] = {
+              .parse_state = parse_state,
+              .parent_symbol = subgraph->symbol,
+              .child_index = 0,
+              .field_id = 0,
+              .done = false,
+            },
+          },
+          .root_symbol = subgraph->symbol,
+          .depth = 1,
+        }));
+      }
+    }
+
+    #ifdef DEBUG_ANALYZE_QUERY
+      printf("\nWalk states for rootless pattern step %u:\n", pattern_entry->step_index);
+    #endif
+
+    ts_query__perform_analysis(
+      self,
+      &subgraphs,
+      &analysis
+    );
+
+    if (analysis.finished_parent_symbols.size > 0) {
+      array_get(&self->patterns, pattern_entry->pattern_index)->is_non_local = true;
+    }
+
+    for (unsigned k = 0; k < analysis.finished_parent_symbols.size; k++) {
+      TSSymbol symbol = *array_get(&analysis.finished_parent_symbols, k);
+      array_insert_sorted_by(&self->repeat_symbols_with_rootless_patterns, , symbol);
+    }
+  }
+
+  #ifdef DEBUG_ANALYZE_QUERY
+    if (self->repeat_symbols_with_rootless_patterns.size > 0) {
+      printf("\nRepetition symbols with rootless patterns:\n");
+      printf("aborted analysis: %d\n", analysis.did_abort);
+      for (unsigned i = 0; i < self->repeat_symbols_with_rootless_patterns.size; i++) {
+        TSSymbol symbol = *array_get(&self->repeat_symbols_with_rootless_patterns, i);
+        printf("  %u, %s\n", symbol, ts_language_symbol_name(self->language, symbol));
+      }
+      printf("\n");
+    }
+  #endif
+
+  // Cleanup
+  for (unsigned i = 0; i < subgraphs.size; i++) {
+    array_delete(&array_get(&subgraphs, i)->start_states);
+    array_delete(&array_get(&subgraphs, i)->nodes);
+  }
+  array_delete(&subgraphs);
+  query_analysis__delete(&analysis);
+  array_delete(&next_nodes);
+  array_delete(&predicate_capture_ids);
+  state_predecessor_map_delete(&predecessor_map);
+
+supertype_cleanup:
+  array_delete(&non_rooted_pattern_start_steps);
+  array_delete(&parent_step_indices);
+
+  return all_patterns_are_valid;
+}
+
+static void ts_query__add_negated_fields(
+  TSQuery *self,
+  uint16_t step_index,
+  TSFieldId *field_ids,
+  uint16_t field_count
+) {
+  QueryStep *step = array_get(&self->steps, step_index);
+
+  // The negated field array stores a list of field lists, separated by zeros.
+  // Try to find the start index of an existing list that matches this new list.
+  bool failed_match = false;
+  unsigned match_count = 0;
+  unsigned start_i = 0;
+  for (unsigned i = 0; i < self->negated_fields.size; i++) {
+    TSFieldId existing_field_id = *array_get(&self->negated_fields, i);
+
+    // At each zero value, terminate the match attempt. If we've exactly
+    // matched the new field list, then reuse this index. Otherwise,
+    // start over the matching process.
+    if (existing_field_id == 0) {
+      if (match_count == field_count) {
+        step->negated_field_list_id = start_i;
+        return;
+      } else {
+        start_i = i + 1;
+        match_count = 0;
+        failed_match = false;
+      }
+    }
+
+    // If the existing list matches our new list so far, then advance
+    // to the next element of the new list.
+    else if (
+      match_count < field_count &&
+      existing_field_id == field_ids[match_count] &&
+      !failed_match
+    ) {
+      match_count++;
+    }
+
+    // Otherwise, this existing list has failed to match.
+    else {
+      match_count = 0;
+      failed_match = true;
+    }
+  }
+
+  step->negated_field_list_id = self->negated_fields.size;
+  array_extend(&self->negated_fields, field_count, field_ids);
+  array_push(&self->negated_fields, 0);
+}
+
+static TSQueryError ts_query__parse_string_literal(
+  TSQuery *self,
+  Stream *stream
+) {
+  const char *string_start = stream->input;
+  if (stream->next != '"') return TSQueryErrorSyntax;
+  stream_advance(stream);
+  const char *prev_position = stream->input;
+
+  bool is_escaped = false;
+  array_clear(&self->string_buffer);
+  for (;;) {
+    if (is_escaped) {
+      is_escaped = false;
+      switch (stream->next) {
+        case 'n':
+          array_push(&self->string_buffer, '\n');
+          break;
+        case 'r':
+          array_push(&self->string_buffer, '\r');
+          break;
+        case 't':
+          array_push(&self->string_buffer, '\t');
+          break;
+        case '0':
+          array_push(&self->string_buffer, '\0');
+          break;
+        default:
+          array_extend(&self->string_buffer, stream->next_size, stream->input);
+          break;
+      }
+      prev_position = stream->input + stream->next_size;
+    } else {
+      if (stream->next == '\\') {
+        array_extend(&self->string_buffer, (uint32_t)(stream->input - prev_position), prev_position);
+        prev_position = stream->input + 1;
+        is_escaped = true;
+      } else if (stream->next == '"') {
+        array_extend(&self->string_buffer, (uint32_t)(stream->input - prev_position), prev_position);
+        stream_advance(stream);
+        return TSQueryErrorNone;
+      } else if (stream->next == '\n') {
+        stream_reset(stream, string_start);
+        return TSQueryErrorSyntax;
+      }
+    }
+    if (!stream_advance(stream)) {
+      stream_reset(stream, string_start);
+      return TSQueryErrorSyntax;
+    }
+  }
+}
+
+// Parse a single predicate associated with a pattern, adding it to the
+// query's internal `predicate_steps` array. Predicates are arbitrary
+// S-expressions associated with a pattern which are meant to be handled at
+// a higher level of abstraction, such as the Rust/JavaScript bindings. They
+// can contain '@'-prefixed capture names, double-quoted strings, and bare
+// symbols, which also represent strings.
+static TSQueryError ts_query__parse_predicate(
+  TSQuery *self,
+  Stream *stream
+) {
+  if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
+  const char *predicate_name = stream->input;
+  stream_scan_identifier(stream);
+  if (stream->next != '?' && stream->next != '!') {
+    return TSQueryErrorSyntax;
+  }
+  stream_advance(stream);
+  uint32_t length = (uint32_t)(stream->input - predicate_name);
+  uint16_t id = symbol_table_insert_name(
+    &self->predicate_values,
+    predicate_name,
+    length
+  );
+  array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
+    .type = TSQueryPredicateStepTypeString,
+    .value_id = id,
+  }));
+  stream_skip_whitespace(stream);
+
+  for (;;) {
+    if (stream->next == ')') {
+      stream_advance(stream);
+      stream_skip_whitespace(stream);
+      array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
+        .type = TSQueryPredicateStepTypeDone,
+        .value_id = 0,
+      }));
+      break;
+    }
+
+    // Parse an '@'-prefixed capture name
+    else if (stream->next == '@') {
+      stream_advance(stream);
+
+      // Parse the capture name
+      if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
+      const char *capture_name = stream->input;
+      stream_scan_identifier(stream);
+      uint32_t capture_length = (uint32_t)(stream->input - capture_name);
+
+      // Add the capture id to the first step of the pattern
+      int capture_id = symbol_table_id_for_name(
+        &self->captures,
+        capture_name,
+        capture_length
+      );
+      if (capture_id == -1) {
+        stream_reset(stream, capture_name);
+        return TSQueryErrorCapture;
+      }
+
+      array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
+        .type = TSQueryPredicateStepTypeCapture,
+        .value_id = capture_id,
+      }));
+    }
+
+    // Parse a string literal
+    else if (stream->next == '"') {
+      TSQueryError e = ts_query__parse_string_literal(self, stream);
+      if (e) return e;
+      uint16_t query_id = symbol_table_insert_name(
+        &self->predicate_values,
+        self->string_buffer.contents,
+        self->string_buffer.size
+      );
+      array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
+        .type = TSQueryPredicateStepTypeString,
+        .value_id = query_id,
+      }));
+    }
+
+    // Parse a bare symbol
+    else if (stream_is_ident_start(stream)) {
+      const char *symbol_start = stream->input;
+      stream_scan_identifier(stream);
+      uint32_t symbol_length = (uint32_t)(stream->input - symbol_start);
+      uint16_t query_id = symbol_table_insert_name(
+        &self->predicate_values,
+        symbol_start,
+        symbol_length
+      );
+      array_push(&self->predicate_steps, ((TSQueryPredicateStep) {
+        .type = TSQueryPredicateStepTypeString,
+        .value_id = query_id,
+      }));
+    }
+
+    else {
+      return TSQueryErrorSyntax;
+    }
+
+    stream_skip_whitespace(stream);
+  }
+
+  return 0;
+}
+
+// Read one S-expression pattern from the stream, and incorporate it into
+// the query's internal state machine representation. For nested patterns,
+// this function calls itself recursively.
+//
+// The caller is responsible for passing in a dedicated CaptureQuantifiers.
+// These should not be shared between different calls to ts_query__parse_pattern!
+static TSQueryError ts_query__parse_pattern(
+  TSQuery *self,
+  Stream *stream,
+  uint32_t depth,
+  bool is_immediate,
+  CaptureQuantifiers *capture_quantifiers
+) {
+  if (stream->next == 0) return TSQueryErrorSyntax;
+  if (stream->next == ')' || stream->next == ']') return PARENT_DONE;
+
+  const uint32_t starting_step_index = self->steps.size;
+
+  // Store the byte offset of each step in the query.
+  if (
+    self->step_offsets.size == 0 ||
+    array_back(&self->step_offsets)->step_index != starting_step_index
+  ) {
+    array_push(&self->step_offsets, ((StepOffset) {
+      .step_index = starting_step_index,
+      .byte_offset = stream_offset(stream),
+    }));
+  }
+
+  // An open bracket is the start of an alternation.
+  if (stream->next == '[') {
+    stream_advance(stream);
+    stream_skip_whitespace(stream);
+
+    // Parse each branch, and add a placeholder step in between the branches.
+    Array(uint32_t) branch_step_indices = array_new();
+    CaptureQuantifiers branch_capture_quantifiers = capture_quantifiers_new();
+    for (;;) {
+      uint32_t start_index = self->steps.size;
+      TSQueryError e = ts_query__parse_pattern(
+        self,
+        stream,
+        depth,
+        is_immediate,
+        &branch_capture_quantifiers
+      );
+
+      if (e == PARENT_DONE) {
+        if (stream->next == ']' && branch_step_indices.size > 0) {
+          stream_advance(stream);
+          break;
+        }
+        e = TSQueryErrorSyntax;
+      }
+      if (e) {
+        capture_quantifiers_delete(&branch_capture_quantifiers);
+        array_delete(&branch_step_indices);
+        return e;
+      }
+
+      if (start_index == starting_step_index) {
+        capture_quantifiers_replace(capture_quantifiers, &branch_capture_quantifiers);
+      } else {
+        capture_quantifiers_join_all(capture_quantifiers, &branch_capture_quantifiers);
+      }
+
+      array_push(&branch_step_indices, start_index);
+      array_push(&self->steps, query_step__new(0, depth, false));
+      capture_quantifiers_clear(&branch_capture_quantifiers);
+    }
+    (void)array_pop(&self->steps);
+
+    // For all of the branches except for the last one, add the subsequent branch as an
+    // alternative, and link the end of the branch to the current end of the steps.
+    for (unsigned i = 0; i < branch_step_indices.size - 1; i++) {
+      uint32_t step_index = *array_get(&branch_step_indices, i);
+      uint32_t next_step_index = *array_get(&branch_step_indices, i + 1);
+      QueryStep *start_step = array_get(&self->steps, step_index);
+      QueryStep *end_step = array_get(&self->steps, next_step_index - 1);
+      start_step->alternative_index = next_step_index;
+      end_step->alternative_index = self->steps.size;
+      end_step->is_dead_end = true;
+    }
+
+    capture_quantifiers_delete(&branch_capture_quantifiers);
+    array_delete(&branch_step_indices);
+  }
+
+  // An open parenthesis can be the start of three possible constructs:
+  // * A grouped sequence
+  // * A predicate
+  // * A named node
+  else if (stream->next == '(') {
+    stream_advance(stream);
+    stream_skip_whitespace(stream);
+
+    // If this parenthesis is followed by a node, then it represents a grouped sequence.
+    if (stream->next == '(' || stream->next == '"' || stream->next == '[') {
+      bool child_is_immediate = is_immediate;
+      CaptureQuantifiers child_capture_quantifiers = capture_quantifiers_new();
+      for (;;) {
+        if (stream->next == '.') {
+          child_is_immediate = true;
+          stream_advance(stream);
+          stream_skip_whitespace(stream);
+        }
+        TSQueryError e = ts_query__parse_pattern(
+          self,
+          stream,
+          depth,
+          child_is_immediate,
+          &child_capture_quantifiers
+        );
+        if (e == PARENT_DONE) {
+          if (stream->next == ')') {
+            stream_advance(stream);
+            break;
+          }
+          e = TSQueryErrorSyntax;
+        }
+        if (e) {
+          capture_quantifiers_delete(&child_capture_quantifiers);
+          return e;
+        }
+
+        capture_quantifiers_add_all(capture_quantifiers, &child_capture_quantifiers);
+        capture_quantifiers_clear(&child_capture_quantifiers);
+        child_is_immediate = false;
+      }
+
+      capture_quantifiers_delete(&child_capture_quantifiers);
+    }
+
+    // A dot/pound character indicates the start of a predicate.
+    else if (stream->next == '.' || stream->next == '#') {
+      stream_advance(stream);
+      return ts_query__parse_predicate(self, stream);
+    }
+
+    // Otherwise, this parenthesis is the start of a named node.
+    else {
+      TSSymbol symbol;
+      bool is_missing = false;
+      const char *node_name = stream->input;
+
+      // Parse a normal node name
+      if (stream_is_ident_start(stream)) {
+        stream_scan_identifier(stream);
+        uint32_t length = (uint32_t)(stream->input - node_name);
+
+        // Parse the wildcard symbol
+        if (length == 1 && node_name[0] == '_') {
+          symbol = WILDCARD_SYMBOL;
+        } else if (!strncmp(node_name, "MISSING", length)) {
+          is_missing = true;
+          stream_skip_whitespace(stream);
+
+          if (stream_is_ident_start(stream)) {
+            const char *missing_node_name = stream->input;
+            stream_scan_identifier(stream);
+            uint32_t missing_node_length = (uint32_t)(stream->input - missing_node_name);
+            symbol = ts_language_symbol_for_name(
+              self->language,
+              missing_node_name,
+              missing_node_length,
+              true
+            );
+            if (!symbol) {
+              stream_reset(stream, missing_node_name);
+              return TSQueryErrorNodeType;
+            }
+          }
+
+          else if (stream->next == '"') {
+            const char *string_start = stream->input;
+            TSQueryError e = ts_query__parse_string_literal(self, stream);
+            if (e) return e;
+
+            symbol = ts_language_symbol_for_name(
+              self->language,
+              self->string_buffer.contents,
+              self->string_buffer.size,
+              false
+            );
+            if (!symbol) {
+              stream_reset(stream, string_start + 1);
+              return TSQueryErrorNodeType;
+            }
+          }
+
+          else if (stream->next == ')') {
+            symbol = WILDCARD_SYMBOL;
+          }
+
+          else {
+            stream_reset(stream, stream->input);
+            return TSQueryErrorSyntax;
+          }
+        }
+
+        else {
+          symbol = ts_language_symbol_for_name(
+            self->language,
+            node_name,
+            length,
+            true
+          );
+          if (!symbol) {
+            stream_reset(stream, node_name);
+            return TSQueryErrorNodeType;
+          }
+        }
+      } else {
+        return TSQueryErrorSyntax;
+      }
+
+      // Add a step for the node.
+      array_push(&self->steps, query_step__new(symbol, depth, is_immediate));
+      QueryStep *step = array_back(&self->steps);
+      if (ts_language_symbol_metadata(self->language, symbol).supertype) {
+        step->supertype_symbol = step->symbol;
+        step->symbol = WILDCARD_SYMBOL;
+      }
+      if (is_missing) {
+        step->is_missing = true;
+      }
+      if (symbol == WILDCARD_SYMBOL) {
+        step->is_named = true;
+      }
+
+      // Parse a supertype symbol
+      if (stream->next == '/') {
+        if (!step->supertype_symbol) {
+          stream_reset(stream, node_name - 1); // reset to the start of the node
+          return TSQueryErrorStructure;
+        }
+
+        stream_advance(stream);
+
+        const char *subtype_node_name = stream->input;
+
+        if (stream_is_ident_start(stream)) { // Named node
+          stream_scan_identifier(stream);
+          uint32_t length = (uint32_t)(stream->input - subtype_node_name);
+          step->symbol = ts_language_symbol_for_name(
+            self->language,
+            subtype_node_name,
+            length,
+            true
+          );
+        } else if (stream->next == '"') { // Anonymous leaf node
+          TSQueryError e = ts_query__parse_string_literal(self, stream);
+          if (e) return e;
+          step->symbol = ts_language_symbol_for_name(
+            self->language,
+            self->string_buffer.contents,
+            self->string_buffer.size,
+            false
+          );
+        } else {
+          return TSQueryErrorSyntax;
+        }
+
+        if (!step->symbol) {
+          stream_reset(stream, subtype_node_name);
+          return TSQueryErrorNodeType;
+        }
+
+        // Get all the possible subtypes for the given supertype,
+        // and check if the given subtype is valid.
+        if (self->language->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS) {
+          uint32_t subtype_length;
+          const TSSymbol *subtypes = ts_language_subtypes(
+            self->language,
+            step->supertype_symbol,
+            &subtype_length
+          );
+
+          bool subtype_is_valid = false;
+          for (uint32_t i = 0; i < subtype_length; i++) {
+            if (subtypes[i] == step->symbol) {
+              subtype_is_valid = true;
+              break;
+            }
+          }
+
+          // This subtype is not valid for the given supertype.
+          if (!subtype_is_valid) {
+            stream_reset(stream, node_name - 1); // reset to the start of the node
+            return TSQueryErrorStructure;
+          }
+        }
+      }
+
+      stream_skip_whitespace(stream);
+
+      // Parse the child patterns
+      bool child_is_immediate = false;
+      uint16_t last_child_step_index = 0;
+      uint16_t negated_field_count = 0;
+      TSFieldId negated_field_ids[MAX_NEGATED_FIELD_COUNT];
+      CaptureQuantifiers child_capture_quantifiers = capture_quantifiers_new();
+      for (;;) {
+        // Parse a negated field assertion
+        if (stream->next == '!') {
+          stream_advance(stream);
+          stream_skip_whitespace(stream);
+          if (!stream_is_ident_start(stream)) {
+            capture_quantifiers_delete(&child_capture_quantifiers);
+            return TSQueryErrorSyntax;
+          }
+          const char *field_name = stream->input;
+          stream_scan_identifier(stream);
+          uint32_t length = (uint32_t)(stream->input - field_name);
+          stream_skip_whitespace(stream);
+
+          TSFieldId field_id = ts_language_field_id_for_name(
+            self->language,
+            field_name,
+            length
+          );
+          if (!field_id) {
+            stream->input = field_name;
+            capture_quantifiers_delete(&child_capture_quantifiers);
+            return TSQueryErrorField;
+          }
+
+          // Keep the field ids sorted.
+          if (negated_field_count < MAX_NEGATED_FIELD_COUNT) {
+            negated_field_ids[negated_field_count] = field_id;
+            negated_field_count++;
+          }
+
+          continue;
+        }
+
+        // Parse a sibling anchor
+        if (stream->next == '.') {
+          child_is_immediate = true;
+          stream_advance(stream);
+          stream_skip_whitespace(stream);
+        }
+
+        uint16_t step_index = self->steps.size;
+        TSQueryError e = ts_query__parse_pattern(
+          self,
+          stream,
+          depth + 1,
+          child_is_immediate,
+          &child_capture_quantifiers
+        );
+        // In the event we only parsed a predicate, meaning no new steps were added,
+        // then subtract one so we're not indexing past the end of the array
+        if (step_index == self->steps.size) step_index--;
+        if (e == PARENT_DONE) {
+          if (stream->next == ')') {
+            if (child_is_immediate) {
+              if (last_child_step_index == 0) {
+                capture_quantifiers_delete(&child_capture_quantifiers);
+                return TSQueryErrorSyntax;
+              }
+              // Mark this step *and* its alternatives as the last child of the parent.
+              QueryStep *last_child_step = array_get(&self->steps, last_child_step_index);
+              last_child_step->is_last_child = true;
+              if (
+                last_child_step->alternative_index != NONE &&
+                last_child_step->alternative_index < self->steps.size
+              ) {
+                QueryStep *alternative_step = array_get(&self->steps, last_child_step->alternative_index);
+                alternative_step->is_last_child = true;
+                while (
+                  alternative_step->alternative_index != NONE &&
+                  alternative_step->alternative_index < self->steps.size
+                ) {
+                  alternative_step = array_get(&self->steps, alternative_step->alternative_index);
+                  alternative_step->is_last_child = true;
+                }
+              }
+            }
+
+            if (negated_field_count) {
+              ts_query__add_negated_fields(
+                self,
+                starting_step_index,
+                negated_field_ids,
+                negated_field_count
+              );
+            }
+
+            stream_advance(stream);
+            break;
+          }
+          e = TSQueryErrorSyntax;
+        }
+        if (e) {
+          capture_quantifiers_delete(&child_capture_quantifiers);
+          return e;
+        }
+
+        capture_quantifiers_add_all(capture_quantifiers, &child_capture_quantifiers);
+
+        last_child_step_index = step_index;
+        child_is_immediate = false;
+        capture_quantifiers_clear(&child_capture_quantifiers);
+      }
+      capture_quantifiers_delete(&child_capture_quantifiers);
+    }
+  }
+
+  // Parse a wildcard pattern
+  else if (stream->next == '_') {
+    stream_advance(stream);
+    stream_skip_whitespace(stream);
+
+    // Add a step that matches any kind of node
+    array_push(&self->steps, query_step__new(WILDCARD_SYMBOL, depth, is_immediate));
+  }
+
+  // Parse a double-quoted anonymous leaf node expression
+  else if (stream->next == '"') {
+    const char *string_start = stream->input;
+    TSQueryError e = ts_query__parse_string_literal(self, stream);
+    if (e) return e;
+
+    // Add a step for the node
+    TSSymbol symbol = ts_language_symbol_for_name(
+      self->language,
+      self->string_buffer.contents,
+      self->string_buffer.size,
+      false
+    );
+    if (!symbol) {
+      stream_reset(stream, string_start + 1);
+      return TSQueryErrorNodeType;
+    }
+    array_push(&self->steps, query_step__new(symbol, depth, is_immediate));
+  }
+
+  // Parse a field-prefixed pattern
+  else if (stream_is_ident_start(stream)) {
+    // Parse the field name
+    const char *field_name = stream->input;
+    stream_scan_identifier(stream);
+    uint32_t length = (uint32_t)(stream->input - field_name);
+    stream_skip_whitespace(stream);
+
+    if (stream->next != ':') {
+      stream_reset(stream, field_name);
+      return TSQueryErrorSyntax;
+    }
+    stream_advance(stream);
+    stream_skip_whitespace(stream);
+
+    // Parse the pattern
+    CaptureQuantifiers field_capture_quantifiers = capture_quantifiers_new();
+    TSQueryError e = ts_query__parse_pattern(
+      self,
+      stream,
+      depth,
+      is_immediate,
+      &field_capture_quantifiers
+    );
+    if (e) {
+      capture_quantifiers_delete(&field_capture_quantifiers);
+      if (e == PARENT_DONE) e = TSQueryErrorSyntax;
+      return e;
+    }
+
+    // Add the field name to the first step of the pattern
+    TSFieldId field_id = ts_language_field_id_for_name(
+      self->language,
+      field_name,
+      length
+    );
+    if (!field_id) {
+      stream->input = field_name;
+      return TSQueryErrorField;
+    }
+
+    uint32_t step_index = starting_step_index;
+    QueryStep *step = array_get(&self->steps, step_index);
+    for (;;) {
+      step->field = field_id;
+      if (
+        step->alternative_index != NONE &&
+        step->alternative_index > step_index &&
+        step->alternative_index < self->steps.size
+      ) {
+        step_index = step->alternative_index;
+        step = array_get(&self->steps, step_index);
+      } else {
+        break;
+      }
+    }
+
+    capture_quantifiers_add_all(capture_quantifiers, &field_capture_quantifiers);
+    capture_quantifiers_delete(&field_capture_quantifiers);
+  }
+
+  else {
+    return TSQueryErrorSyntax;
+  }
+
+  stream_skip_whitespace(stream);
+
+  // Parse suffixes modifiers for this pattern
+  TSQuantifier quantifier = TSQuantifierOne;
+  for (;;) {
+    // Parse the one-or-more operator.
+    if (stream->next == '+') {
+      quantifier = quantifier_join(TSQuantifierOneOrMore, quantifier);
+
+      stream_advance(stream);
+      stream_skip_whitespace(stream);
+
+      QueryStep repeat_step = query_step__new(WILDCARD_SYMBOL, depth, false);
+      repeat_step.alternative_index = starting_step_index;
+      repeat_step.is_pass_through = true;
+      repeat_step.alternative_is_immediate = true;
+      array_push(&self->steps, repeat_step);
+    }
+
+    // Parse the zero-or-more repetition operator.
+    else if (stream->next == '*') {
+      quantifier = quantifier_join(TSQuantifierZeroOrMore, quantifier);
+
+      stream_advance(stream);
+      stream_skip_whitespace(stream);
+
+      QueryStep repeat_step = query_step__new(WILDCARD_SYMBOL, depth, false);
+      repeat_step.alternative_index = starting_step_index;
+      repeat_step.is_pass_through = true;
+      repeat_step.alternative_is_immediate = true;
+      array_push(&self->steps, repeat_step);
+
+      // Stop when `step->alternative_index` is `NONE` or it points to
+      // `repeat_step` or beyond. Note that having just been pushed,
+      // `repeat_step` occupies slot `self->steps.size - 1`.
+      QueryStep *step = array_get(&self->steps, starting_step_index);
+      while (step->alternative_index != NONE && step->alternative_index < self->steps.size - 1) {
+        step = array_get(&self->steps, step->alternative_index);
+      }
+      step->alternative_index = self->steps.size;
+    }
+
+    // Parse the optional operator.
+    else if (stream->next == '?') {
+      quantifier = quantifier_join(TSQuantifierZeroOrOne, quantifier);
+
+      stream_advance(stream);
+      stream_skip_whitespace(stream);
+
+      QueryStep *step = array_get(&self->steps, starting_step_index);
+      while (step->alternative_index != NONE && step->alternative_index < self->steps.size) {
+        step = array_get(&self->steps, step->alternative_index);
+      }
+      step->alternative_index = self->steps.size;
+    }
+
+    // Parse an '@'-prefixed capture pattern
+    else if (stream->next == '@') {
+      stream_advance(stream);
+      if (!stream_is_ident_start(stream)) return TSQueryErrorSyntax;
+      const char *capture_name = stream->input;
+      stream_scan_identifier(stream);
+      uint32_t length = (uint32_t)(stream->input - capture_name);
+      stream_skip_whitespace(stream);
+
+      // Add the capture id to the first step of the pattern
+      uint16_t capture_id = symbol_table_insert_name(
+        &self->captures,
+        capture_name,
+        length
+      );
+
+      // Add the capture quantifier
+      capture_quantifiers_add_for_id(capture_quantifiers, capture_id, TSQuantifierOne);
+
+      uint32_t step_index = starting_step_index;
+      for (;;) {
+        QueryStep *step = array_get(&self->steps, step_index);
+        query_step__add_capture(step, capture_id);
+        if (
+          step->alternative_index != NONE &&
+          step->alternative_index > step_index &&
+          step->alternative_index < self->steps.size
+        ) {
+          step_index = step->alternative_index;
+        } else {
+          break;
+        }
+      }
+    }
+
+    // No more suffix modifiers
+    else {
+      break;
+    }
+  }
+
+  capture_quantifiers_mul(capture_quantifiers, quantifier);
+
+  return 0;
+}
+
+TSQuery *ts_query_new(
+  const TSLanguage *language,
+  const char *source,
+  uint32_t source_len,
+  uint32_t *error_offset,
+  TSQueryError *error_type
+) {
+  if (
+    !language ||
+    language->abi_version > TREE_SITTER_LANGUAGE_VERSION ||
+    language->abi_version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION
+  ) {
+    *error_type = TSQueryErrorLanguage;
+    return NULL;
+  }
+
+  TSQuery *self = ts_malloc(sizeof(TSQuery));
+  *self = (TSQuery) {
+    .steps = array_new(),
+    .pattern_map = array_new(),
+    .captures = symbol_table_new(),
+    .capture_quantifiers = array_new(),
+    .predicate_values = symbol_table_new(),
+    .predicate_steps = array_new(),
+    .patterns = array_new(),
+    .step_offsets = array_new(),
+    .string_buffer = array_new(),
+    .negated_fields = array_new(),
+    .repeat_symbols_with_rootless_patterns = array_new(),
+    .wildcard_root_pattern_count = 0,
+    .language = ts_language_copy(language),
+  };
+
+  array_push(&self->negated_fields, 0);
+
+  // Parse all of the S-expressions in the given string.
+  Stream stream = stream_new(source, source_len);
+  stream_skip_whitespace(&stream);
+  while (stream.input < stream.end) {
+    uint32_t pattern_index = self->patterns.size;
+    uint32_t start_step_index = self->steps.size;
+    uint32_t start_predicate_step_index = self->predicate_steps.size;
+    array_push(&self->patterns, ((QueryPattern) {
+      .steps = (Slice) {.offset = start_step_index},
+      .predicate_steps = (Slice) {.offset = start_predicate_step_index},
+      .start_byte = stream_offset(&stream),
+      .is_non_local = false,
+    }));
+    CaptureQuantifiers capture_quantifiers = capture_quantifiers_new();
+    *error_type = ts_query__parse_pattern(self, &stream, 0, false, &capture_quantifiers);
+    array_push(&self->steps, query_step__new(0, PATTERN_DONE_MARKER, false));
+
+    QueryPattern *pattern = array_back(&self->patterns);
+    pattern->steps.length = self->steps.size - start_step_index;
+    pattern->predicate_steps.length = self->predicate_steps.size - start_predicate_step_index;
+    pattern->end_byte = stream_offset(&stream);
+
+    // If any pattern could not be parsed, then report the error information
+    // and terminate.
+    if (*error_type) {
+      if (*error_type == PARENT_DONE) *error_type = TSQueryErrorSyntax;
+      *error_offset = stream_offset(&stream);
+      capture_quantifiers_delete(&capture_quantifiers);
+      ts_query_delete(self);
+      return NULL;
+    }
+
+    // Maintain a list of capture quantifiers for each pattern
+    array_push(&self->capture_quantifiers, capture_quantifiers);
+
+    // Maintain a map that can look up patterns for a given root symbol.
+    uint16_t wildcard_root_alternative_index = NONE;
+    for (;;) {
+      QueryStep *step = array_get(&self->steps, start_step_index);
+
+      // If a pattern has a wildcard at its root, but it has a non-wildcard child,
+      // then optimize the matching process by skipping matching the wildcard.
+      // Later, during the matching process, the query cursor will check that
+      // there is a parent node, and capture it if necessary.
+      if (step->symbol == WILDCARD_SYMBOL && step->depth == 0 && !step->field) {
+        QueryStep *second_step = array_get(&self->steps, start_step_index + 1);
+        if (second_step->symbol != WILDCARD_SYMBOL && second_step->depth == 1 && !second_step->is_immediate) {
+          wildcard_root_alternative_index = step->alternative_index;
+          start_step_index += 1;
+          step = second_step;
+        }
+      }
+
+      // Determine whether the pattern has a single root node. This affects
+      // decisions about whether or not to start matching the pattern when
+      // a query cursor has a range restriction or when immediately within an
+      // error node.
+      uint32_t start_depth = step->depth;
+      bool is_rooted = start_depth == 0;
+      for (uint32_t step_index = start_step_index + 1; step_index < self->steps.size; step_index++) {
+        QueryStep *child_step = array_get(&self->steps, step_index);
+        if (child_step->is_dead_end) break;
+        if (child_step->depth == start_depth) {
+          is_rooted = false;
+          break;
+        }
+      }
+
+      ts_query__pattern_map_insert(self, step->symbol, (PatternEntry) {
+        .step_index = start_step_index,
+        .pattern_index = pattern_index,
+        .is_rooted = is_rooted
+      });
+      if (step->symbol == WILDCARD_SYMBOL) {
+        self->wildcard_root_pattern_count++;
+      }
+
+      // If there are alternatives or options at the root of the pattern,
+      // then add multiple entries to the pattern map.
+      if (step->alternative_index != NONE) {
+        start_step_index = step->alternative_index;
+      } else if (wildcard_root_alternative_index != NONE) {
+        start_step_index = wildcard_root_alternative_index;
+        wildcard_root_alternative_index = NONE;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (!ts_query__analyze_patterns(self, error_offset)) {
+    *error_type = TSQueryErrorStructure;
+    ts_query_delete(self);
+    return NULL;
+  }
+
+  array_delete(&self->string_buffer);
+  return self;
+}
+
+void ts_query_delete(TSQuery *self) {
+  if (self) {
+    array_delete(&self->steps);
+    array_delete(&self->pattern_map);
+    array_delete(&self->predicate_steps);
+    array_delete(&self->patterns);
+    array_delete(&self->step_offsets);
+    array_delete(&self->string_buffer);
+    array_delete(&self->negated_fields);
+    array_delete(&self->repeat_symbols_with_rootless_patterns);
+    ts_language_delete(self->language);
+    symbol_table_delete(&self->captures);
+    symbol_table_delete(&self->predicate_values);
+    for (uint32_t index = 0; index < self->capture_quantifiers.size; index++) {
+      CaptureQuantifiers *capture_quantifiers = array_get(&self->capture_quantifiers, index);
+      capture_quantifiers_delete(capture_quantifiers);
+    }
+    array_delete(&self->capture_quantifiers);
+    ts_free(self);
+  }
+}
+
+uint32_t ts_query_pattern_count(const TSQuery *self) {
+  return self->patterns.size;
+}
+
+uint32_t ts_query_capture_count(const TSQuery *self) {
+  return self->captures.slices.size;
+}
+
+uint32_t ts_query_string_count(const TSQuery *self) {
+  return self->predicate_values.slices.size;
+}
+
+const char *ts_query_capture_name_for_id(
+  const TSQuery *self,
+  uint32_t index,
+  uint32_t *length
+) {
+  return symbol_table_name_for_id(&self->captures, index, length);
+}
+
+TSQuantifier ts_query_capture_quantifier_for_id(
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t capture_index
+) {
+  CaptureQuantifiers *capture_quantifiers = array_get(&self->capture_quantifiers, pattern_index);
+  return capture_quantifier_for_id(capture_quantifiers, capture_index);
+}
+
+const char *ts_query_string_value_for_id(
+  const TSQuery *self,
+  uint32_t index,
+  uint32_t *length
+) {
+  return symbol_table_name_for_id(&self->predicate_values, index, length);
+}
+
+const TSQueryPredicateStep *ts_query_predicates_for_pattern(
+  const TSQuery *self,
+  uint32_t pattern_index,
+  uint32_t *step_count
+) {
+  Slice slice = array_get(&self->patterns, pattern_index)->predicate_steps;
+  *step_count = slice.length;
+  if (slice.length == 0) return NULL;
+  return array_get(&self->predicate_steps, slice.offset);
+}
+
+uint32_t ts_query_start_byte_for_pattern(
+  const TSQuery *self,
+  uint32_t pattern_index
+) {
+  return array_get(&self->patterns, pattern_index)->start_byte;
+}
+
+uint32_t ts_query_end_byte_for_pattern(
+  const TSQuery *self,
+  uint32_t pattern_index
+) {
+  return array_get(&self->patterns, pattern_index)->end_byte;
+}
+
+bool ts_query_is_pattern_rooted(
+  const TSQuery *self,
+  uint32_t pattern_index
+) {
+  for (unsigned i = 0; i < self->pattern_map.size; i++) {
+    PatternEntry *entry = array_get(&self->pattern_map, i);
+    if (entry->pattern_index == pattern_index) {
+      if (!entry->is_rooted) return false;
+    }
+  }
+  return true;
+}
+
+bool ts_query_is_pattern_non_local(
+  const TSQuery *self,
+  uint32_t pattern_index
+) {
+  if (pattern_index < self->patterns.size) {
+    return array_get(&self->patterns, pattern_index)->is_non_local;
+  } else {
+    return false;
+  }
+}
+
+bool ts_query_is_pattern_guaranteed_at_step(
+  const TSQuery *self,
+  uint32_t byte_offset
+) {
+  uint32_t step_index = UINT32_MAX;
+  for (unsigned i = 0; i < self->step_offsets.size; i++) {
+    StepOffset *step_offset = array_get(&self->step_offsets, i);
+    if (step_offset->byte_offset > byte_offset) break;
+    step_index = step_offset->step_index;
+  }
+  if (step_index < self->steps.size) {
+    return array_get(&self->steps, step_index)->root_pattern_guaranteed;
+  } else {
+    return false;
+  }
+}
+
+bool ts_query__step_is_fallible(
+  const TSQuery *self,
+  uint16_t step_index
+) {
+  ts_assert((uint32_t)step_index + 1 < self->steps.size);
+  QueryStep *step = array_get(&self->steps, step_index);
+  QueryStep *next_step = array_get(&self->steps, step_index + 1);
+  return (
+    next_step->depth != PATTERN_DONE_MARKER &&
+    next_step->depth > step->depth &&
+    (!next_step->parent_pattern_guaranteed || step->symbol == WILDCARD_SYMBOL)
+  );
+}
+
+void ts_query_disable_capture(
+  TSQuery *self,
+  const char *name,
+  uint32_t length
+) {
+  // Remove capture information for any pattern step that previously
+  // captured with the given name.
+  int id = symbol_table_id_for_name(&self->captures, name, length);
+  if (id != -1) {
+    for (unsigned i = 0; i < self->steps.size; i++) {
+      QueryStep *step = array_get(&self->steps, i);
+      query_step__remove_capture(step, id);
+    }
+  }
+}
+
+void ts_query_disable_pattern(
+  TSQuery *self,
+  uint32_t pattern_index
+) {
+  // Remove the given pattern from the pattern map. Its steps will still
+  // be in the `steps` array, but they will never be read.
+  for (unsigned i = 0; i < self->pattern_map.size; i++) {
+    PatternEntry *pattern = array_get(&self->pattern_map, i);
+    if (pattern->pattern_index == pattern_index) {
+      array_erase(&self->pattern_map, i);
+      i--;
+    }
+  }
+}
+
+/***************
+ * QueryCursor
+ ***************/
+
+TSQueryCursor *ts_query_cursor_new(void) {
+  TSQueryCursor *self = ts_malloc(sizeof(TSQueryCursor));
+  *self = (TSQueryCursor) {
+    .did_exceed_match_limit = false,
+    .ascending = false,
+    .halted = false,
+    .states = array_new(),
+    .finished_states = array_new(),
+    .capture_list_pool = capture_list_pool_new(),
+    .start_byte = 0,
+    .end_byte = UINT32_MAX,
+    .start_point = {0, 0},
+    .end_point = POINT_MAX,
+    .max_start_depth = UINT32_MAX,
+    .operation_count = 0,
+  };
+  array_reserve(&self->states, 8);
+  array_reserve(&self->finished_states, 8);
+  return self;
+}
+
+void ts_query_cursor_delete(TSQueryCursor *self) {
+  array_delete(&self->states);
+  array_delete(&self->finished_states);
+  ts_tree_cursor_delete(&self->cursor);
+  capture_list_pool_delete(&self->capture_list_pool);
+  ts_free(self);
+}
+
+bool ts_query_cursor_did_exceed_match_limit(const TSQueryCursor *self) {
+  return self->did_exceed_match_limit;
+}
+
+uint32_t ts_query_cursor_match_limit(const TSQueryCursor *self) {
+  return self->capture_list_pool.max_capture_list_count;
+}
+
+void ts_query_cursor_set_match_limit(TSQueryCursor *self, uint32_t limit) {
+  self->capture_list_pool.max_capture_list_count = limit;
+}
+
+#ifdef DEBUG_EXECUTE_QUERY
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...)
+#endif
+
+void ts_query_cursor_exec(
+  TSQueryCursor *self,
+  const TSQuery *query,
+  TSNode node
+) {
+  if (query) {
+    LOG("query steps:\n");
+    for (unsigned i = 0; i < query->steps.size; i++) {
+      QueryStep *step = array_get(&query->steps, i);
+      LOG("  %u: {", i);
+      if (step->depth == PATTERN_DONE_MARKER) {
+        LOG("DONE");
+      } else if (step->is_dead_end) {
+        LOG("dead_end");
+      } else if (step->is_pass_through) {
+        LOG("pass_through");
+      } else if (step->symbol != WILDCARD_SYMBOL) {
+        LOG("symbol: %s", query->language->symbol_names[step->symbol]);
+      } else {
+        LOG("symbol: *");
+      }
+      if (step->field) {
+        LOG(", field: %s", query->language->field_names[step->field]);
+      }
+      if (step->alternative_index != NONE) {
+        LOG(", alternative: %u", step->alternative_index);
+      }
+      LOG("},\n");
+    }
+  }
+
+  array_clear(&self->states);
+  array_clear(&self->finished_states);
+  ts_tree_cursor_reset(&self->cursor, node);
+  capture_list_pool_reset(&self->capture_list_pool);
+  self->on_visible_node = true;
+  self->next_state_id = 0;
+  self->depth = 0;
+  self->ascending = false;
+  self->halted = false;
+  self->query = query;
+  self->did_exceed_match_limit = false;
+  self->operation_count = 0;
+  self->query_options = NULL;
+  self->query_state = (TSQueryCursorState) {0};
+}
+
+void ts_query_cursor_exec_with_options(
+  TSQueryCursor *self,
+  const TSQuery *query,
+  TSNode node,
+  const TSQueryCursorOptions *query_options
+) {
+  ts_query_cursor_exec(self, query, node);
+  if (query_options) {
+    self->query_options = query_options;
+    self->query_state = (TSQueryCursorState) {
+      .payload = query_options->payload
+    };
+  }
+}
+
+bool ts_query_cursor_set_byte_range(
+  TSQueryCursor *self,
+  uint32_t start_byte,
+  uint32_t end_byte
+) {
+  if (end_byte == 0) {
+    end_byte = UINT32_MAX;
+  }
+  if (start_byte > end_byte) {
+    return false;
+  }
+  self->start_byte = start_byte;
+  self->end_byte = end_byte;
+  return true;
+}
+
+bool ts_query_cursor_set_point_range(
+  TSQueryCursor *self,
+  TSPoint start_point,
+  TSPoint end_point
+) {
+  if (end_point.row == 0 && end_point.column == 0) {
+    end_point = POINT_MAX;
+  }
+  if (point_gt(start_point, end_point)) {
+    return false;
+  }
+  self->start_point = start_point;
+  self->end_point = end_point;
+  return true;
+}
+
+// Search through all of the in-progress states, and find the captured
+// node that occurs earliest in the document.
+static bool ts_query_cursor__first_in_progress_capture(
+  TSQueryCursor *self,
+  uint32_t *state_index,
+  uint32_t *byte_offset,
+  uint32_t *pattern_index,
+  bool *is_definite
+) {
+  bool result = false;
+  *state_index = UINT32_MAX;
+  *byte_offset = UINT32_MAX;
+  *pattern_index = UINT32_MAX;
+  for (unsigned i = 0; i < self->states.size; i++) {
+    QueryState *state = array_get(&self->states, i);
+    if (state->dead) continue;
+
+    const CaptureList *captures = capture_list_pool_get(
+      &self->capture_list_pool,
+      state->capture_list_id
+    );
+    if (state->consumed_capture_count >= captures->size) {
+      continue;
+    }
+
+    TSNode node = array_get(captures, state->consumed_capture_count)->node;
+    if (
+      ts_node_end_byte(node) <= self->start_byte ||
+      point_lte(ts_node_end_point(node), self->start_point)
+    ) {
+      state->consumed_capture_count++;
+      i--;
+      continue;
+    }
+
+    uint32_t node_start_byte = ts_node_start_byte(node);
+    if (
+      !result ||
+      node_start_byte < *byte_offset ||
+      (node_start_byte == *byte_offset && state->pattern_index < *pattern_index)
+    ) {
+      QueryStep *step = array_get(&self->query->steps, state->step_index);
+      if (is_definite) {
+        // We're being a bit conservative here by asserting that the following step
+        // is not immediate, because this capture might end up being discarded if the
+        // following symbol in the tree isn't the required symbol for this step.
+        *is_definite = step->root_pattern_guaranteed && !step->is_immediate;
+      } else if (step->root_pattern_guaranteed) {
+        continue;
+      }
+
+      result = true;
+      *state_index = i;
+      *byte_offset = node_start_byte;
+      *pattern_index = state->pattern_index;
+    }
+  }
+  return result;
+}
+
+// Determine which node is first in a depth-first traversal
+int ts_query_cursor__compare_nodes(TSNode left, TSNode right) {
+  if (left.id != right.id) {
+    uint32_t left_start = ts_node_start_byte(left);
+    uint32_t right_start = ts_node_start_byte(right);
+    if (left_start < right_start) return -1;
+    if (left_start > right_start) return 1;
+    uint32_t left_node_count = ts_node_end_byte(left);
+    uint32_t right_node_count = ts_node_end_byte(right);
+    if (left_node_count > right_node_count) return -1;
+    if (left_node_count < right_node_count) return 1;
+  }
+  return 0;
+}
+
+// Determine if either state contains a superset of the other state's captures.
+void ts_query_cursor__compare_captures(
+  TSQueryCursor *self,
+  QueryState *left_state,
+  QueryState *right_state,
+  bool *left_contains_right,
+  bool *right_contains_left
+) {
+  const CaptureList *left_captures = capture_list_pool_get(
+    &self->capture_list_pool,
+    left_state->capture_list_id
+  );
+  const CaptureList *right_captures = capture_list_pool_get(
+    &self->capture_list_pool,
+    right_state->capture_list_id
+  );
+  *left_contains_right = true;
+  *right_contains_left = true;
+  unsigned i = 0, j = 0;
+  for (;;) {
+    if (i < left_captures->size) {
+      if (j < right_captures->size) {
+        TSQueryCapture *left = array_get(left_captures, i);
+        TSQueryCapture *right = array_get(right_captures, j);
+        if (left->node.id == right->node.id && left->index == right->index) {
+          i++;
+          j++;
+        } else {
+          switch (ts_query_cursor__compare_nodes(left->node, right->node)) {
+            case -1:
+              *right_contains_left = false;
+              i++;
+              break;
+            case 1:
+              *left_contains_right = false;
+              j++;
+              break;
+            default:
+              *right_contains_left = false;
+              *left_contains_right = false;
+              i++;
+              j++;
+              break;
+          }
+        }
+      } else {
+        *right_contains_left = false;
+        break;
+      }
+    } else {
+      if (j < right_captures->size) {
+        *left_contains_right = false;
+      }
+      break;
+    }
+  }
+}
+
+static void ts_query_cursor__add_state(
+  TSQueryCursor *self,
+  const PatternEntry *pattern
+) {
+  QueryStep *step = array_get(&self->query->steps, pattern->step_index);
+  uint32_t start_depth = self->depth - step->depth;
+
+  // Keep the states array in ascending order of start_depth and pattern_index,
+  // so that it can be processed more efficiently elsewhere. Usually, there is
+  // no work to do here because of two facts:
+  // * States with lower start_depth are naturally added first due to the
+  //   order in which nodes are visited.
+  // * Earlier patterns are naturally added first because of the ordering of the
+  //   pattern_map data structure that's used to initiate matches.
+  //
+  // This loop is only needed in cases where two conditions hold:
+  // * A pattern consists of more than one sibling node, so that its states
+  //   remain in progress after exiting the node that started the match.
+  // * The first node in the pattern matches against multiple nodes at the
+  //   same depth.
+  //
+  // An example of this is the pattern '((comment)* (function))'. If multiple
+  // `comment` nodes appear in a row, then we may initiate a new state for this
+  // pattern while another state for the same pattern is already in progress.
+  // If there are multiple patterns like this in a query, then this loop will
+  // need to execute in order to keep the states ordered by pattern_index.
+  uint32_t index = self->states.size;
+  while (index > 0) {
+    QueryState *prev_state = array_get(&self->states, index - 1);
+    if (prev_state->start_depth < start_depth) break;
+    if (prev_state->start_depth == start_depth) {
+      // Avoid inserting an unnecessary duplicate state, which would be
+      // immediately pruned by the longest-match criteria.
+      if (
+        prev_state->pattern_index == pattern->pattern_index &&
+        prev_state->step_index == pattern->step_index
+      ) return;
+      if (prev_state->pattern_index <= pattern->pattern_index) break;
+    }
+    index--;
+  }
+
+  LOG(
+    "  start state. pattern:%u, step:%u\n",
+    pattern->pattern_index,
+    pattern->step_index
+  );
+  array_insert(&self->states, index, ((QueryState) {
+    .id = UINT32_MAX,
+    .capture_list_id = NONE,
+    .step_index = pattern->step_index,
+    .pattern_index = pattern->pattern_index,
+    .start_depth = start_depth,
+    .consumed_capture_count = 0,
+    .seeking_immediate_match = true,
+    .has_in_progress_alternatives = false,
+    .needs_parent = step->depth == 1,
+    .dead = false,
+  }));
+}
+
+// Acquire a capture list for this state. If there are no capture lists left in the
+// pool, this will steal the capture list from another existing state, and mark that
+// other state as 'dead'.
+static CaptureList *ts_query_cursor__prepare_to_capture(
+  TSQueryCursor *self,
+  QueryState *state,
+  unsigned state_index_to_preserve
+) {
+  if (state->capture_list_id == NONE) {
+    state->capture_list_id = capture_list_pool_acquire(&self->capture_list_pool);
+
+    // If there are no capture lists left in the pool, then terminate whichever
+    // state has captured the earliest node in the document, and steal its
+    // capture list.
+    if (state->capture_list_id == NONE) {
+      self->did_exceed_match_limit = true;
+      uint32_t state_index, byte_offset, pattern_index;
+      if (
+        ts_query_cursor__first_in_progress_capture(
+          self,
+          &state_index,
+          &byte_offset,
+          &pattern_index,
+          NULL
+        ) &&
+        state_index != state_index_to_preserve
+      ) {
+        LOG(
+          "  abandon state. index:%u, pattern:%u, offset:%u.\n",
+          state_index, pattern_index, byte_offset
+        );
+        QueryState *other_state = array_get(&self->states, state_index);
+        state->capture_list_id = other_state->capture_list_id;
+        other_state->capture_list_id = NONE;
+        other_state->dead = true;
+        CaptureList *list = capture_list_pool_get_mut(
+          &self->capture_list_pool,
+          state->capture_list_id
+        );
+        array_clear(list);
+        return list;
+      } else {
+        LOG("  ran out of capture lists");
+        return NULL;
+      }
+    }
+  }
+  return capture_list_pool_get_mut(&self->capture_list_pool, state->capture_list_id);
+}
+
+static void ts_query_cursor__capture(
+  TSQueryCursor *self,
+  QueryState *state,
+  QueryStep *step,
+  TSNode node
+) {
+  if (state->dead) return;
+  CaptureList *capture_list = ts_query_cursor__prepare_to_capture(self, state, UINT32_MAX);
+  if (!capture_list) {
+    state->dead = true;
+    return;
+  }
+
+  for (unsigned j = 0; j < MAX_STEP_CAPTURE_COUNT; j++) {
+    uint16_t capture_id = step->capture_ids[j];
+    if (step->capture_ids[j] == NONE) break;
+    array_push(capture_list, ((TSQueryCapture) { node, capture_id }));
+    LOG(
+      "  capture node. type:%s, pattern:%u, capture_id:%u, capture_count:%u\n",
+      ts_node_type(node),
+      state->pattern_index,
+      capture_id,
+      capture_list->size
+    );
+  }
+}
+
+// Duplicate the given state and insert the newly-created state immediately after
+// the given state in the `states` array. Ensures that the given state reference is
+// still valid, even if the states array is reallocated.
+static QueryState *ts_query_cursor__copy_state(
+  TSQueryCursor *self,
+  QueryState **state_ref
+) {
+  const QueryState *state = *state_ref;
+  uint32_t state_index = (uint32_t)(state - self->states.contents);
+  QueryState copy = *state;
+  copy.capture_list_id = NONE;
+
+  // If the state has captures, copy its capture list.
+  if (state->capture_list_id != NONE) {
+    CaptureList *new_captures = ts_query_cursor__prepare_to_capture(self, &copy, state_index);
+    if (!new_captures) return NULL;
+    const CaptureList *old_captures = capture_list_pool_get(
+      &self->capture_list_pool,
+      state->capture_list_id
+    );
+    array_push_all(new_captures, old_captures);
+  }
+
+  array_insert(&self->states, state_index + 1, copy);
+  *state_ref = array_get(&self->states, state_index);
+  return array_get(&self->states, state_index + 1);
+}
+
+static inline bool ts_query_cursor__should_descend(
+  TSQueryCursor *self,
+  bool node_intersects_range
+) {
+
+  if (node_intersects_range && self->depth < self->max_start_depth) {
+    return true;
+  }
+
+  // If there are in-progress matches whose remaining steps occur
+  // deeper in the tree, then descend.
+  for (unsigned i = 0; i < self->states.size; i++) {
+    QueryState *state = array_get(&self->states, i);
+    QueryStep *next_step = array_get(&self->query->steps, state->step_index);
+    if (
+      next_step->depth != PATTERN_DONE_MARKER &&
+      state->start_depth + next_step->depth > self->depth
+    ) {
+      return true;
+    }
+  }
+
+  if (self->depth >= self->max_start_depth) {
+    return false;
+  }
+
+  // If the current node is hidden, then a non-rooted pattern might match
+  // one if its roots inside of this node, and match another of its roots
+  // as part of a sibling node, so we may need to descend.
+  if (!self->on_visible_node) {
+    // Descending into a repetition node outside of the range can be
+    // expensive, because these nodes can have many visible children.
+    // Avoid descending into repetition nodes unless we have already
+    // determined that this query can match rootless patterns inside
+    // of this type of repetition node.
+    Subtree subtree = ts_tree_cursor_current_subtree(&self->cursor);
+    if (ts_subtree_is_repetition(subtree)) {
+      bool exists;
+      uint32_t index;
+      array_search_sorted_by(
+        &self->query->repeat_symbols_with_rootless_patterns,,
+        ts_subtree_symbol(subtree),
+        &index,
+        &exists
+      );
+      return exists;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+// Walk the tree, processing patterns until at least one pattern finishes,
+// If one or more patterns finish, return `true` and store their states in the
+// `finished_states` array. Multiple patterns can finish on the same node. If
+// there are no more matches, return `false`.
+static inline bool ts_query_cursor__advance(
+  TSQueryCursor *self,
+  bool stop_on_definite_step
+) {
+  bool did_match = false;
+  for (;;) {
+    if (self->halted) {
+      while (self->states.size > 0) {
+        QueryState state = array_pop(&self->states);
+        capture_list_pool_release(
+          &self->capture_list_pool,
+          state.capture_list_id
+        );
+      }
+    }
+
+    if (++self->operation_count == OP_COUNT_PER_QUERY_CALLBACK_CHECK) {
+      self->operation_count = 0;
+    }
+
+    if (self->query_options && self->query_options->progress_callback) {
+      self->query_state.current_byte_offset = ts_node_start_byte(ts_tree_cursor_current_node(&self->cursor));
+    }
+    if (
+      did_match ||
+      self->halted ||
+      (
+        self->operation_count == 0 &&
+        (
+          (self->query_options && self->query_options->progress_callback && self->query_options->progress_callback(&self->query_state))
+        )
+      )
+    ) {
+      return did_match;
+    }
+
+    // Exit the current node.
+    if (self->ascending) {
+      if (self->on_visible_node) {
+        LOG(
+          "leave node. depth:%u, type:%s\n",
+          self->depth,
+          ts_node_type(ts_tree_cursor_current_node(&self->cursor))
+        );
+
+        // After leaving a node, remove any states that cannot make further progress.
+        uint32_t deleted_count = 0;
+        for (unsigned i = 0, n = self->states.size; i < n; i++) {
+          QueryState *state = array_get(&self->states, i);
+          QueryStep *step = array_get(&self->query->steps, state->step_index);
+
+          // If a state completed its pattern inside of this node, but was deferred from finishing
+          // in order to search for longer matches, mark it as finished.
+          if (
+            step->depth == PATTERN_DONE_MARKER &&
+            (state->start_depth > self->depth || self->depth == 0)
+          ) {
+            LOG("  finish pattern %u\n", state->pattern_index);
+            array_push(&self->finished_states, *state);
+            did_match = true;
+            deleted_count++;
+          }
+
+          // If a state needed to match something within this node, then remove that state
+          // as it has failed to match.
+          else if (
+            step->depth != PATTERN_DONE_MARKER &&
+            (uint32_t)state->start_depth + (uint32_t)step->depth > self->depth
+          ) {
+            LOG(
+              "  failed to match. pattern:%u, step:%u\n",
+              state->pattern_index,
+              state->step_index
+            );
+            capture_list_pool_release(
+              &self->capture_list_pool,
+              state->capture_list_id
+            );
+            deleted_count++;
+          }
+
+          else if (deleted_count > 0) {
+            *array_get(&self->states, i - deleted_count) = *state;
+          }
+        }
+        self->states.size -= deleted_count;
+      }
+
+      // Leave this node by stepping to its next sibling or to its parent.
+      switch (ts_tree_cursor_goto_next_sibling_internal(&self->cursor)) {
+        case TreeCursorStepVisible:
+          if (!self->on_visible_node) {
+            self->depth++;
+            self->on_visible_node = true;
+          }
+          self->ascending = false;
+          break;
+        case TreeCursorStepHidden:
+          if (self->on_visible_node) {
+            self->depth--;
+            self->on_visible_node = false;
+          }
+          self->ascending = false;
+          break;
+        default:
+          if (ts_tree_cursor_goto_parent(&self->cursor)) {
+            self->depth--;
+          } else {
+            LOG("halt at root\n");
+            self->halted = true;
+          }
+      }
+    }
+
+    // Enter a new node.
+    else {
+      // Get the properties of the current node.
+      TSNode node = ts_tree_cursor_current_node(&self->cursor);
+      TSNode parent_node = ts_tree_cursor_parent_node(&self->cursor);
+
+      uint32_t start_byte = ts_node_start_byte(node);
+      uint32_t end_byte = ts_node_end_byte(node);
+      TSPoint start_point = ts_node_start_point(node);
+      TSPoint end_point = ts_node_end_point(node);
+      bool is_empty = start_byte == end_byte;
+
+      bool parent_precedes_range = !ts_node_is_null(parent_node) && (
+        ts_node_end_byte(parent_node) <= self->start_byte ||
+        point_lte(ts_node_end_point(parent_node), self->start_point)
+      );
+      bool parent_follows_range = !ts_node_is_null(parent_node) && (
+        ts_node_start_byte(parent_node) >= self->end_byte ||
+        point_gte(ts_node_start_point(parent_node), self->end_point)
+      );
+      bool node_precedes_range =
+        parent_precedes_range ||
+        end_byte < self->start_byte ||
+        point_lt(end_point, self->start_point) ||
+        (!is_empty && end_byte == self->start_byte) ||
+        (!is_empty && point_eq(end_point, self->start_point));
+
+      bool node_follows_range = parent_follows_range || (
+        start_byte >= self->end_byte ||
+        point_gte(start_point, self->end_point)
+      );
+      bool parent_intersects_range = !parent_precedes_range && !parent_follows_range;
+      bool node_intersects_range = !node_precedes_range && !node_follows_range;
+
+      if (self->on_visible_node) {
+        TSSymbol symbol = ts_node_symbol(node);
+        bool is_named = ts_node_is_named(node);
+        bool is_missing = ts_node_is_missing(node);
+        bool has_later_siblings;
+        bool has_later_named_siblings;
+        bool can_have_later_siblings_with_this_field;
+        TSFieldId field_id = 0;
+        TSSymbol supertypes[8] = {0};
+        unsigned supertype_count = 8;
+        ts_tree_cursor_current_status(
+          &self->cursor,
+          &field_id,
+          &has_later_siblings,
+          &has_later_named_siblings,
+          &can_have_later_siblings_with_this_field,
+          supertypes,
+          &supertype_count
+        );
+        LOG(
+          "enter node. depth:%u, type:%s, field:%s, row:%u state_count:%u, finished_state_count:%u\n",
+          self->depth,
+          ts_node_type(node),
+          ts_language_field_name_for_id(self->query->language, field_id),
+          ts_node_start_point(node).row,
+          self->states.size,
+          self->finished_states.size
+        );
+
+        bool node_is_error = symbol == ts_builtin_sym_error;
+        bool parent_is_error =
+          !ts_node_is_null(parent_node) &&
+          ts_node_symbol(parent_node) == ts_builtin_sym_error;
+
+        // Add new states for any patterns whose root node is a wildcard.
+        if (!node_is_error) {
+          for (unsigned i = 0; i < self->query->wildcard_root_pattern_count; i++) {
+            PatternEntry *pattern = array_get(&self->query->pattern_map, i);
+
+            // If this node matches the first step of the pattern, then add a new
+            // state at the start of this pattern.
+            QueryStep *step = array_get(&self->query->steps, pattern->step_index);
+            uint32_t start_depth = self->depth - step->depth;
+            if (
+              (pattern->is_rooted ?
+                node_intersects_range :
+                (parent_intersects_range && !parent_is_error)) &&
+              (!step->field || field_id == step->field) &&
+              (!step->supertype_symbol || supertype_count > 0) &&
+              (start_depth <= self->max_start_depth)
+            ) {
+              ts_query_cursor__add_state(self, pattern);
+            }
+          }
+        }
+
+        // Add new states for any patterns whose root node matches this node.
+        unsigned i;
+        if (ts_query__pattern_map_search(self->query, symbol, &i)) {
+          PatternEntry *pattern = array_get(&self->query->pattern_map, i);
+
+          QueryStep *step = array_get(&self->query->steps, pattern->step_index);
+          uint32_t start_depth = self->depth - step->depth;
+          do {
+            // If this node matches the first step of the pattern, then add a new
+            // state at the start of this pattern.
+            if (
+              (pattern->is_rooted ?
+                node_intersects_range :
+                (parent_intersects_range && !parent_is_error)) &&
+              (!step->field || field_id == step->field) &&
+              (start_depth <= self->max_start_depth)
+            ) {
+              ts_query_cursor__add_state(self, pattern);
+            }
+
+            // Advance to the next pattern whose root node matches this node.
+            i++;
+            if (i == self->query->pattern_map.size) break;
+            pattern = array_get(&self->query->pattern_map, i);
+            step = array_get(&self->query->steps, pattern->step_index);
+          } while (step->symbol == symbol);
+        }
+
+        // Update all of the in-progress states with current node.
+        for (unsigned j = 0, copy_count = 0; j < self->states.size; j += 1 + copy_count) {
+          QueryState *state = array_get(&self->states, j);
+          QueryStep *step = array_get(&self->query->steps, state->step_index);
+          state->has_in_progress_alternatives = false;
+          copy_count = 0;
+
+          // Check that the node matches all of the criteria for the next
+          // step of the pattern.
+          if ((uint32_t)state->start_depth + (uint32_t)step->depth != self->depth) continue;
+
+          // Determine if this node matches this step of the pattern, and also
+          // if this node can have later siblings that match this step of the
+          // pattern.
+          bool node_does_match = false;
+          if (step->symbol == WILDCARD_SYMBOL) {
+            if (step->is_missing) {
+              node_does_match = is_missing;
+            } else {
+              node_does_match = !node_is_error && (is_named || !step->is_named);
+            }
+          } else {
+            node_does_match = symbol == step->symbol && (!step->is_missing || is_missing);
+          }
+          bool later_sibling_can_match = has_later_siblings;
+          if ((step->is_immediate && is_named) || state->seeking_immediate_match) {
+            later_sibling_can_match = false;
+          }
+          if (step->is_last_child && has_later_named_siblings) {
+            node_does_match = false;
+          }
+          if (step->supertype_symbol) {
+            bool has_supertype = false;
+            for (unsigned k = 0; k < supertype_count; k++) {
+              if (supertypes[k] == step->supertype_symbol) {
+                has_supertype = true;
+                break;
+              }
+            }
+            if (!has_supertype) node_does_match = false;
+          }
+          if (step->field) {
+            if (step->field == field_id) {
+              if (!can_have_later_siblings_with_this_field) {
+                later_sibling_can_match = false;
+              }
+            } else {
+              node_does_match = false;
+            }
+          }
+
+          if (step->negated_field_list_id) {
+            TSFieldId *negated_field_ids = array_get(&self->query->negated_fields, step->negated_field_list_id);
+            for (;;) {
+              TSFieldId negated_field_id = *negated_field_ids;
+              if (negated_field_id) {
+                negated_field_ids++;
+                if (ts_node_child_by_field_id(node, negated_field_id).id) {
+                  node_does_match = false;
+                  break;
+                }
+              } else {
+                break;
+              }
+            }
+          }
+
+          // Remove states immediately if it is ever clear that they cannot match.
+          if (!node_does_match) {
+            if (!later_sibling_can_match) {
+              LOG(
+                "  discard state. pattern:%u, step:%u\n",
+                state->pattern_index,
+                state->step_index
+              );
+              capture_list_pool_release(
+                &self->capture_list_pool,
+                state->capture_list_id
+              );
+              array_erase(&self->states, j);
+              j--;
+            }
+            continue;
+          }
+
+          // Some patterns can match their root node in multiple ways, capturing different
+          // children. If this pattern step could match later children within the same
+          // parent, then this query state cannot simply be updated in place. It must be
+          // split into two states: one that matches this node, and one which skips over
+          // this node, to preserve the possibility of matching later siblings.
+          if (later_sibling_can_match && (
+            step->contains_captures ||
+            ts_query__step_is_fallible(self->query, state->step_index)
+          )) {
+            if (ts_query_cursor__copy_state(self, &state)) {
+              LOG(
+                "  split state for capture. pattern:%u, step:%u\n",
+                state->pattern_index,
+                state->step_index
+              );
+              copy_count++;
+            }
+          }
+
+          // If this pattern started with a wildcard, such that the pattern map
+          // actually points to the *second* step of the pattern, then check
+          // that the node has a parent, and capture the parent node if necessary.
+          if (state->needs_parent) {
+            TSNode parent = ts_tree_cursor_parent_node(&self->cursor);
+            if (ts_node_is_null(parent)) {
+              LOG("  missing parent node\n");
+              state->dead = true;
+            } else {
+              state->needs_parent = false;
+              QueryStep *skipped_wildcard_step = step;
+              do {
+                skipped_wildcard_step--;
+              } while (
+                skipped_wildcard_step->is_dead_end ||
+                skipped_wildcard_step->is_pass_through ||
+                skipped_wildcard_step->depth > 0
+              );
+              if (skipped_wildcard_step->capture_ids[0] != NONE) {
+                LOG("  capture wildcard parent\n");
+                ts_query_cursor__capture(
+                  self,
+                  state,
+                  skipped_wildcard_step,
+                  parent
+                );
+              }
+            }
+          }
+
+          // If the current node is captured in this pattern, add it to the capture list.
+          if (step->capture_ids[0] != NONE) {
+            ts_query_cursor__capture(self, state, step, node);
+          }
+
+          if (state->dead) {
+            array_erase(&self->states, j);
+            j--;
+            continue;
+          }
+
+          // Advance this state to the next step of its pattern.
+          state->step_index++;
+          LOG(
+            "  advance state. pattern:%u, step:%u\n",
+            state->pattern_index,
+            state->step_index
+          );
+
+          QueryStep *next_step = array_get(&self->query->steps, state->step_index);
+
+          // For a given step, if the current symbol is the wildcard symbol, `_`, and it is **not**
+          // named, meaning it should capture anonymous nodes, **and** the next step is immediate,
+          // we reuse the `seeking_immediate_match` flag to indicate that we are looking for an
+          // immediate match due to an unnamed wildcard symbol.
+          //
+          // The reason for this is that typically, anchors will not consider anonymous nodes,
+          // but we're special casing the wildcard symbol to allow for any immediate matches,
+          // regardless of whether they are named or not.
+          if (step->symbol == WILDCARD_SYMBOL && !step->is_named && next_step->is_immediate) {
+              state->seeking_immediate_match = true;
+          } else {
+              state->seeking_immediate_match = false;
+          }
+
+          if (stop_on_definite_step && next_step->root_pattern_guaranteed) did_match = true;
+
+          // If this state's next step has an alternative step, then copy the state in order
+          // to pursue both alternatives. The alternative step itself may have an alternative,
+          // so this is an interactive process.
+          unsigned end_index = j + 1;
+          for (unsigned k = j; k < end_index; k++) {
+            QueryState *child_state = array_get(&self->states, k);
+            QueryStep *child_step = array_get(&self->query->steps, child_state->step_index);
+            if (child_step->alternative_index != NONE) {
+              // A "dead-end" step exists only to add a non-sequential jump into the step sequence,
+              // via its alternative index. When a state reaches a dead-end step, it jumps straight
+              // to the step's alternative.
+              if (child_step->is_dead_end) {
+                child_state->step_index = child_step->alternative_index;
+                k--;
+                continue;
+              }
+
+              // A "pass-through" step exists only to add a branch into the step sequence,
+              // via its alternative_index. When a state reaches a pass-through step, it splits
+              // in order to process the alternative step, and then it advances to the next step.
+              if (child_step->is_pass_through) {
+                child_state->step_index++;
+                k--;
+              }
+
+              QueryState *copy = ts_query_cursor__copy_state(self, &child_state);
+              if (copy) {
+                LOG(
+                  "  split state for branch. pattern:%u, from_step:%u, to_step:%u, immediate:%d, capture_count: %u\n",
+                  copy->pattern_index,
+                  copy->step_index,
+                  next_step->alternative_index,
+                  next_step->alternative_is_immediate,
+                  capture_list_pool_get(&self->capture_list_pool, copy->capture_list_id)->size
+                );
+                end_index++;
+                copy_count++;
+                copy->step_index = child_step->alternative_index;
+                if (child_step->alternative_is_immediate) {
+                  copy->seeking_immediate_match = true;
+                }
+              }
+            }
+          }
+        }
+
+        for (unsigned j = 0; j < self->states.size; j++) {
+          QueryState *state = array_get(&self->states, j);
+          if (state->dead) {
+            array_erase(&self->states, j);
+            j--;
+            continue;
+          }
+
+          // Enforce the longest-match criteria. When a query pattern contains optional or
+          // repeated nodes, this is necessary to avoid multiple redundant states, where
+          // one state has a strict subset of another state's captures.
+          bool did_remove = false;
+          for (unsigned k = j + 1; k < self->states.size; k++) {
+            QueryState *other_state = array_get(&self->states, k);
+
+            // Query states are kept in ascending order of start_depth and pattern_index.
+            // Since the longest-match criteria is only used for deduping matches of the same
+            // pattern and root node, we only need to perform pairwise comparisons within a
+            // small slice of the states array.
+            if (
+              other_state->start_depth != state->start_depth ||
+              other_state->pattern_index != state->pattern_index
+            ) break;
+
+            bool left_contains_right, right_contains_left;
+            ts_query_cursor__compare_captures(
+              self,
+              state,
+              other_state,
+              &left_contains_right,
+              &right_contains_left
+            );
+            if (left_contains_right) {
+              if (state->step_index == other_state->step_index) {
+                LOG(
+                  "  drop shorter state. pattern: %u, step_index: %u\n",
+                  state->pattern_index,
+                  state->step_index
+                );
+                capture_list_pool_release(&self->capture_list_pool, other_state->capture_list_id);
+                array_erase(&self->states, k);
+                k--;
+                continue;
+              }
+              other_state->has_in_progress_alternatives = true;
+            }
+            if (right_contains_left) {
+              if (state->step_index == other_state->step_index) {
+                LOG(
+                  "  drop shorter state. pattern: %u, step_index: %u\n",
+                  state->pattern_index,
+                  state->step_index
+                );
+                capture_list_pool_release(&self->capture_list_pool, state->capture_list_id);
+                array_erase(&self->states, j);
+                j--;
+                did_remove = true;
+                break;
+              }
+              state->has_in_progress_alternatives = true;
+            }
+          }
+
+          // If the state is at the end of its pattern, remove it from the list
+          // of in-progress states and add it to the list of finished states.
+          if (!did_remove) {
+            LOG(
+              "  keep state. pattern: %u, start_depth: %u, step_index: %u, capture_count: %u\n",
+              state->pattern_index,
+              state->start_depth,
+              state->step_index,
+              capture_list_pool_get(&self->capture_list_pool, state->capture_list_id)->size
+            );
+            QueryStep *next_step = array_get(&self->query->steps, state->step_index);
+            if (next_step->depth == PATTERN_DONE_MARKER) {
+              if (state->has_in_progress_alternatives) {
+                LOG("  defer finishing pattern %u\n", state->pattern_index);
+              } else {
+                LOG("  finish pattern %u\n", state->pattern_index);
+                array_push(&self->finished_states, *state);
+                array_erase(&self->states, (uint32_t)(state - self->states.contents));
+                did_match = true;
+                j--;
+              }
+            }
+          }
+        }
+      }
+
+      if (ts_query_cursor__should_descend(self, node_intersects_range)) {
+        switch (ts_tree_cursor_goto_first_child_internal(&self->cursor)) {
+          case TreeCursorStepVisible:
+            self->depth++;
+            self->on_visible_node = true;
+            continue;
+          case TreeCursorStepHidden:
+            self->on_visible_node = false;
+            continue;
+          default:
+            break;
+        }
+      }
+
+      self->ascending = true;
+    }
+  }
+}
+
+bool ts_query_cursor_next_match(
+  TSQueryCursor *self,
+  TSQueryMatch *match
+) {
+  if (self->finished_states.size == 0) {
+    if (!ts_query_cursor__advance(self, false)) {
+      return false;
+    }
+  }
+
+  QueryState *state = array_get(&self->finished_states, 0);
+  if (state->id == UINT32_MAX) state->id = self->next_state_id++;
+  match->id = state->id;
+  match->pattern_index = state->pattern_index;
+  const CaptureList *captures = capture_list_pool_get(
+    &self->capture_list_pool,
+    state->capture_list_id
+  );
+  match->captures = captures->contents;
+  match->capture_count = captures->size;
+  capture_list_pool_release(&self->capture_list_pool, state->capture_list_id);
+  array_erase(&self->finished_states, 0);
+  return true;
+}
+
+void ts_query_cursor_remove_match(
+  TSQueryCursor *self,
+  uint32_t match_id
+) {
+  for (unsigned i = 0; i < self->finished_states.size; i++) {
+    const QueryState *state = array_get(&self->finished_states, i);
+    if (state->id == match_id) {
+      capture_list_pool_release(
+        &self->capture_list_pool,
+        state->capture_list_id
+      );
+      array_erase(&self->finished_states, i);
+      return;
+    }
+  }
+
+  // Remove unfinished query states as well to prevent future
+  // captures for a match being removed.
+  for (unsigned i = 0; i < self->states.size; i++) {
+    const QueryState *state = array_get(&self->states, i);
+    if (state->id == match_id) {
+      capture_list_pool_release(
+        &self->capture_list_pool,
+        state->capture_list_id
+      );
+      array_erase(&self->states, i);
+      return;
+    }
+  }
+}
+
+bool ts_query_cursor_next_capture(
+  TSQueryCursor *self,
+  TSQueryMatch *match,
+  uint32_t *capture_index
+) {
+  // The goal here is to return captures in order, even though they may not
+  // be discovered in order, because patterns can overlap. Search for matches
+  // until there is a finished capture that is before any unfinished capture.
+  for (;;) {
+    // First, find the earliest capture in an unfinished match.
+    uint32_t first_unfinished_capture_byte;
+    uint32_t first_unfinished_pattern_index;
+    uint32_t first_unfinished_state_index;
+    bool first_unfinished_state_is_definite = false;
+    bool found_unfinished_state = ts_query_cursor__first_in_progress_capture(
+      self,
+      &first_unfinished_state_index,
+      &first_unfinished_capture_byte,
+      &first_unfinished_pattern_index,
+      &first_unfinished_state_is_definite
+    );
+
+    // Then find the earliest capture in a finished match. It must occur
+    // before the first capture in an *unfinished* match.
+    QueryState *first_finished_state = NULL;
+    uint32_t first_finished_capture_byte = first_unfinished_capture_byte;
+    uint32_t first_finished_pattern_index = first_unfinished_pattern_index;
+    for (unsigned i = 0; i < self->finished_states.size;) {
+      QueryState *state = array_get(&self->finished_states, i);
+      const CaptureList *captures = capture_list_pool_get(
+        &self->capture_list_pool,
+        state->capture_list_id
+      );
+
+      // Remove states whose captures are all consumed.
+      if (state->consumed_capture_count >= captures->size) {
+        capture_list_pool_release(
+          &self->capture_list_pool,
+          state->capture_list_id
+        );
+        array_erase(&self->finished_states, i);
+        continue;
+      }
+
+      TSNode node = array_get(captures, state->consumed_capture_count)->node;
+
+      bool node_precedes_range = (
+        ts_node_end_byte(node) <= self->start_byte ||
+        point_lte(ts_node_end_point(node), self->start_point)
+      );
+      bool node_follows_range = (
+        ts_node_start_byte(node) >= self->end_byte ||
+        point_gte(ts_node_start_point(node), self->end_point)
+      );
+      bool node_outside_of_range = node_precedes_range || node_follows_range;
+
+      // Skip captures that are outside of the cursor's range.
+      if (node_outside_of_range) {
+        state->consumed_capture_count++;
+        continue;
+      }
+
+      uint32_t node_start_byte = ts_node_start_byte(node);
+      if (
+        node_start_byte < first_finished_capture_byte ||
+        (
+          node_start_byte == first_finished_capture_byte &&
+          state->pattern_index < first_finished_pattern_index
+        )
+      ) {
+        first_finished_state = state;
+        first_finished_capture_byte = node_start_byte;
+        first_finished_pattern_index = state->pattern_index;
+      }
+      i++;
+    }
+
+    // If there is finished capture that is clearly before any unfinished
+    // capture, then return its match, and its capture index. Internally
+    // record the fact that the capture has been 'consumed'.
+    QueryState *state;
+    if (first_finished_state) {
+      state = first_finished_state;
+    } else if (first_unfinished_state_is_definite) {
+      state = array_get(&self->states, first_unfinished_state_index);
+    } else {
+      state = NULL;
+    }
+
+    if (state) {
+      if (state->id == UINT32_MAX) state->id = self->next_state_id++;
+      match->id = state->id;
+      match->pattern_index = state->pattern_index;
+      const CaptureList *captures = capture_list_pool_get(
+        &self->capture_list_pool,
+        state->capture_list_id
+      );
+      match->captures = captures->contents;
+      match->capture_count = captures->size;
+      *capture_index = state->consumed_capture_count;
+      state->consumed_capture_count++;
+      return true;
+    }
+
+    if (capture_list_pool_is_empty(&self->capture_list_pool) && found_unfinished_state) {
+      LOG(
+        "  abandon state. index:%u, pattern:%u, offset:%u.\n",
+        first_unfinished_state_index,
+        first_unfinished_pattern_index,
+        first_unfinished_capture_byte
+      );
+      capture_list_pool_release(
+        &self->capture_list_pool,
+        array_get(&self->states, first_unfinished_state_index)->capture_list_id
+      );
+      array_erase(&self->states, first_unfinished_state_index);
+    }
+
+    // If there are no finished matches that are ready to be returned, then
+    // continue finding more matches.
+    if (
+      !ts_query_cursor__advance(self, true) &&
+      self->finished_states.size == 0
+    ) return false;
+  }
+}
+
+void ts_query_cursor_set_max_start_depth(
+  TSQueryCursor *self,
+  uint32_t max_start_depth
+) {
+  self->max_start_depth = max_start_depth;
+}
+
+#undef LOG
diff --git a/src/library/ts/src/tree-sitter/lib/src/reduce_action.h b/src/library/ts/src/tree-sitter/lib/src/reduce_action.h
new file mode 100644
index 0000000000..72aff08d73
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/reduce_action.h
@@ -0,0 +1,34 @@
+#ifndef TREE_SITTER_REDUCE_ACTION_H_
+#define TREE_SITTER_REDUCE_ACTION_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./array.h"
+#include "tree_sitter/api.h"
+
+typedef struct {
+  uint32_t count;
+  TSSymbol symbol;
+  int dynamic_precedence;
+  unsigned short production_id;
+} ReduceAction;
+
+typedef Array(ReduceAction) ReduceActionSet;
+
+static inline void ts_reduce_action_set_add(ReduceActionSet *self,
+                                            ReduceAction new_action) {
+  for (uint32_t i = 0; i < self->size; i++) {
+    ReduceAction action = self->contents[i];
+    if (action.symbol == new_action.symbol && action.count == new_action.count)
+      return;
+  }
+  array_push(self, new_action);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_REDUCE_ACTION_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/reusable_node.h b/src/library/ts/src/tree-sitter/lib/src/reusable_node.h
new file mode 100644
index 0000000000..63fe3c1a36
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/reusable_node.h
@@ -0,0 +1,95 @@
+#include "./subtree.h"
+
+typedef struct {
+  Subtree tree;
+  uint32_t child_index;
+  uint32_t byte_offset;
+} StackEntry;
+
+typedef struct {
+  Array(StackEntry) stack;
+  Subtree last_external_token;
+} ReusableNode;
+
+static inline ReusableNode reusable_node_new(void) {
+  return (ReusableNode) {array_new(), NULL_SUBTREE};
+}
+
+static inline void reusable_node_clear(ReusableNode *self) {
+  array_clear(&self->stack);
+  self->last_external_token = NULL_SUBTREE;
+}
+
+static inline Subtree reusable_node_tree(ReusableNode *self) {
+  return self->stack.size > 0
+    ? self->stack.contents[self->stack.size - 1].tree
+    : NULL_SUBTREE;
+}
+
+static inline uint32_t reusable_node_byte_offset(ReusableNode *self) {
+  return self->stack.size > 0
+    ? self->stack.contents[self->stack.size - 1].byte_offset
+    : UINT32_MAX;
+}
+
+static inline void reusable_node_delete(ReusableNode *self) {
+  array_delete(&self->stack);
+}
+
+static inline void reusable_node_advance(ReusableNode *self) {
+  StackEntry last_entry = *array_back(&self->stack);
+  uint32_t byte_offset = last_entry.byte_offset + ts_subtree_total_bytes(last_entry.tree);
+  if (ts_subtree_has_external_tokens(last_entry.tree)) {
+    self->last_external_token = ts_subtree_last_external_token(last_entry.tree);
+  }
+
+  Subtree tree;
+  uint32_t next_index;
+  do {
+    StackEntry popped_entry = array_pop(&self->stack);
+    next_index = popped_entry.child_index + 1;
+    if (self->stack.size == 0) return;
+    tree = array_back(&self->stack)->tree;
+  } while (ts_subtree_child_count(tree) <= next_index);
+
+  array_push(&self->stack, ((StackEntry) {
+    .tree = ts_subtree_children(tree)[next_index],
+    .child_index = next_index,
+    .byte_offset = byte_offset,
+  }));
+}
+
+static inline bool reusable_node_descend(ReusableNode *self) {
+  StackEntry last_entry = *array_back(&self->stack);
+  if (ts_subtree_child_count(last_entry.tree) > 0) {
+    array_push(&self->stack, ((StackEntry) {
+      .tree = ts_subtree_children(last_entry.tree)[0],
+      .child_index = 0,
+      .byte_offset = last_entry.byte_offset,
+    }));
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static inline void reusable_node_advance_past_leaf(ReusableNode *self) {
+  while (reusable_node_descend(self)) {}
+  reusable_node_advance(self);
+}
+
+static inline void reusable_node_reset(ReusableNode *self, Subtree tree) {
+  reusable_node_clear(self);
+  array_push(&self->stack, ((StackEntry) {
+    .tree = tree,
+    .child_index = 0,
+    .byte_offset = 0,
+  }));
+
+  // Never reuse the root node, because it has a non-standard internal structure
+  // due to transformations that are applied when it is accepted: adding the EOF
+  // child and any extra children.
+  if (!reusable_node_descend(self)) {
+    reusable_node_clear(self);
+  }
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/stack.c b/src/library/ts/src/tree-sitter/lib/src/stack.c
new file mode 100644
index 0000000000..9142007476
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/stack.c
@@ -0,0 +1,912 @@
+#include "./alloc.h"
+#include "./language.h"
+#include "./subtree.h"
+#include "./array.h"
+#include "./stack.h"
+#include "./length.h"
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+
+#define MAX_LINK_COUNT 8
+#define MAX_NODE_POOL_SIZE 50
+#define MAX_ITERATOR_COUNT 64
+
+#if defined _WIN32 && !defined __GNUC__
+#define forceinline __forceinline
+#else
+#define forceinline static inline __attribute__((always_inline))
+#endif
+
+typedef struct StackNode StackNode;
+
+typedef struct {
+  StackNode *node;
+  Subtree subtree;
+  bool is_pending;
+} StackLink;
+
+struct StackNode {
+  TSStateId state;
+  Length position;
+  StackLink links[MAX_LINK_COUNT];
+  short unsigned int link_count;
+  uint32_t ref_count;
+  unsigned error_cost;
+  unsigned node_count;
+  int dynamic_precedence;
+};
+
+typedef struct {
+  StackNode *node;
+  SubtreeArray subtrees;
+  uint32_t subtree_count;
+  bool is_pending;
+} StackIterator;
+
+typedef Array(StackNode *) StackNodeArray;
+
+typedef enum {
+  StackStatusActive,
+  StackStatusPaused,
+  StackStatusHalted,
+} StackStatus;
+
+typedef struct {
+  StackNode *node;
+  StackSummary *summary;
+  unsigned node_count_at_last_error;
+  Subtree last_external_token;
+  Subtree lookahead_when_paused;
+  StackStatus status;
+} StackHead;
+
+struct Stack {
+  Array(StackHead) heads;
+  StackSliceArray slices;
+  Array(StackIterator) iterators;
+  StackNodeArray node_pool;
+  StackNode *base_node;
+  SubtreePool *subtree_pool;
+};
+
+typedef unsigned StackAction;
+enum {
+  StackActionNone,
+  StackActionStop = 1,
+  StackActionPop = 2,
+};
+
+typedef StackAction (*StackCallback)(void *, const StackIterator *);
+
+static void stack_node_retain(StackNode *self) {
+  if (!self)
+    return;
+  ts_assert(self->ref_count > 0);
+  self->ref_count++;
+  ts_assert(self->ref_count != 0);
+}
+
+static void stack_node_release(
+  StackNode *self,
+  StackNodeArray *pool,
+  SubtreePool *subtree_pool
+) {
+recur:
+  ts_assert(self->ref_count != 0);
+  self->ref_count--;
+  if (self->ref_count > 0) return;
+
+  StackNode *first_predecessor = NULL;
+  if (self->link_count > 0) {
+    for (unsigned i = self->link_count - 1; i > 0; i--) {
+      StackLink link = self->links[i];
+      if (link.subtree.ptr) ts_subtree_release(subtree_pool, link.subtree);
+      stack_node_release(link.node, pool, subtree_pool);
+    }
+    StackLink link = self->links[0];
+    if (link.subtree.ptr) ts_subtree_release(subtree_pool, link.subtree);
+    first_predecessor = self->links[0].node;
+  }
+
+  if (pool->size < MAX_NODE_POOL_SIZE) {
+    array_push(pool, self);
+  } else {
+    ts_free(self);
+  }
+
+  if (first_predecessor) {
+    self = first_predecessor;
+    goto recur;
+  }
+}
+
+/// Get the number of nodes in the subtree, for the purpose of measuring
+/// how much progress has been made by a given version of the stack.
+static uint32_t stack__subtree_node_count(Subtree subtree) {
+  uint32_t count = ts_subtree_visible_descendant_count(subtree);
+  if (ts_subtree_visible(subtree)) count++;
+
+  // Count intermediate error nodes even though they are not visible,
+  // because a stack version's node count is used to check whether it
+  // has made any progress since the last time it encountered an error.
+  if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat) count++;
+
+  return count;
+}
+
+static StackNode *stack_node_new(
+  StackNode *previous_node,
+  Subtree subtree,
+  bool is_pending,
+  TSStateId state,
+  StackNodeArray *pool
+) {
+  StackNode *node = pool->size > 0
+    ? array_pop(pool)
+    : ts_malloc(sizeof(StackNode));
+  *node = (StackNode) {
+    .ref_count = 1,
+    .link_count = 0,
+    .state = state
+  };
+
+  if (previous_node) {
+    node->link_count = 1;
+    node->links[0] = (StackLink) {
+      .node = previous_node,
+      .subtree = subtree,
+      .is_pending = is_pending,
+    };
+
+    node->position = previous_node->position;
+    node->error_cost = previous_node->error_cost;
+    node->dynamic_precedence = previous_node->dynamic_precedence;
+    node->node_count = previous_node->node_count;
+
+    if (subtree.ptr) {
+      node->error_cost += ts_subtree_error_cost(subtree);
+      node->position = length_add(node->position, ts_subtree_total_size(subtree));
+      node->node_count += stack__subtree_node_count(subtree);
+      node->dynamic_precedence += ts_subtree_dynamic_precedence(subtree);
+    }
+  } else {
+    node->position = length_zero();
+    node->error_cost = 0;
+  }
+
+  return node;
+}
+
+static bool stack__subtree_is_equivalent(Subtree left, Subtree right) {
+  if (left.ptr == right.ptr) return true;
+  if (!left.ptr || !right.ptr) return false;
+
+  // Symbols must match
+  if (ts_subtree_symbol(left) != ts_subtree_symbol(right)) return false;
+
+  // If both have errors, don't bother keeping both.
+  if (ts_subtree_error_cost(left) > 0 && ts_subtree_error_cost(right) > 0) return true;
+
+  return (
+    ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes &&
+    ts_subtree_size(left).bytes == ts_subtree_size(right).bytes &&
+    ts_subtree_child_count(left) == ts_subtree_child_count(right) &&
+    ts_subtree_extra(left) == ts_subtree_extra(right) &&
+    ts_subtree_external_scanner_state_eq(left, right)
+  );
+}
+
+static void stack_node_add_link(
+  StackNode *self,
+  StackLink link,
+  SubtreePool *subtree_pool
+) {
+  if (link.node == self) return;
+
+  for (int i = 0; i < self->link_count; i++) {
+    StackLink *existing_link = &self->links[i];
+    if (stack__subtree_is_equivalent(existing_link->subtree, link.subtree)) {
+      // In general, we preserve ambiguities until they are removed from the stack
+      // during a pop operation where multiple paths lead to the same node. But in
+      // the special case where two links directly connect the same pair of nodes,
+      // we can safely remove the ambiguity ahead of time without changing behavior.
+      if (existing_link->node == link.node) {
+        if (
+          ts_subtree_dynamic_precedence(link.subtree) >
+          ts_subtree_dynamic_precedence(existing_link->subtree)
+        ) {
+          ts_subtree_retain(link.subtree);
+          ts_subtree_release(subtree_pool, existing_link->subtree);
+          existing_link->subtree = link.subtree;
+          self->dynamic_precedence =
+            link.node->dynamic_precedence + ts_subtree_dynamic_precedence(link.subtree);
+        }
+        return;
+      }
+
+      // If the previous nodes are mergeable, merge them recursively.
+      if (
+        existing_link->node->state == link.node->state &&
+        existing_link->node->position.bytes == link.node->position.bytes &&
+        existing_link->node->error_cost == link.node->error_cost
+      ) {
+        for (int j = 0; j < link.node->link_count; j++) {
+          stack_node_add_link(existing_link->node, link.node->links[j], subtree_pool);
+        }
+        int32_t dynamic_precedence = link.node->dynamic_precedence;
+        if (link.subtree.ptr) {
+          dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree);
+        }
+        if (dynamic_precedence > self->dynamic_precedence) {
+          self->dynamic_precedence = dynamic_precedence;
+        }
+        return;
+      }
+    }
+  }
+
+  if (self->link_count == MAX_LINK_COUNT) return;
+
+  stack_node_retain(link.node);
+  unsigned node_count = link.node->node_count;
+  int dynamic_precedence = link.node->dynamic_precedence;
+  self->links[self->link_count++] = link;
+
+  if (link.subtree.ptr) {
+    ts_subtree_retain(link.subtree);
+    node_count += stack__subtree_node_count(link.subtree);
+    dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree);
+  }
+
+  if (node_count > self->node_count) self->node_count = node_count;
+  if (dynamic_precedence > self->dynamic_precedence) self->dynamic_precedence = dynamic_precedence;
+}
+
+static void stack_head_delete(
+  StackHead *self,
+  StackNodeArray *pool,
+  SubtreePool *subtree_pool
+) {
+  if (self->node) {
+    if (self->last_external_token.ptr) {
+      ts_subtree_release(subtree_pool, self->last_external_token);
+    }
+    if (self->lookahead_when_paused.ptr) {
+      ts_subtree_release(subtree_pool, self->lookahead_when_paused);
+    }
+    if (self->summary) {
+      array_delete(self->summary);
+      ts_free(self->summary);
+    }
+    stack_node_release(self->node, pool, subtree_pool);
+  }
+}
+
+static StackVersion ts_stack__add_version(
+  Stack *self,
+  StackVersion original_version,
+  StackNode *node
+) {
+  StackHead head = {
+    .node = node,
+    .node_count_at_last_error = array_get(&self->heads, original_version)->node_count_at_last_error,
+    .last_external_token = array_get(&self->heads, original_version)->last_external_token,
+    .status = StackStatusActive,
+    .lookahead_when_paused = NULL_SUBTREE,
+  };
+  array_push(&self->heads, head);
+  stack_node_retain(node);
+  if (head.last_external_token.ptr) ts_subtree_retain(head.last_external_token);
+  return (StackVersion)(self->heads.size - 1);
+}
+
+static void ts_stack__add_slice(
+  Stack *self,
+  StackVersion original_version,
+  StackNode *node,
+  SubtreeArray *subtrees
+) {
+  for (uint32_t i = self->slices.size - 1; i + 1 > 0; i--) {
+    StackVersion version = array_get(&self->slices, i)->version;
+    if (array_get(&self->heads, version)->node == node) {
+      StackSlice slice = {*subtrees, version};
+      array_insert(&self->slices, i + 1, slice);
+      return;
+    }
+  }
+
+  StackVersion version = ts_stack__add_version(self, original_version, node);
+  StackSlice slice = { *subtrees, version };
+  array_push(&self->slices, slice);
+}
+
+static StackSliceArray stack__iter(
+  Stack *self,
+  StackVersion version,
+  StackCallback callback,
+  void *payload,
+  int goal_subtree_count
+) {
+  array_clear(&self->slices);
+  array_clear(&self->iterators);
+
+  StackHead *head = array_get(&self->heads, version);
+  StackIterator new_iterator = {
+    .node = head->node,
+    .subtrees = array_new(),
+    .subtree_count = 0,
+    .is_pending = true,
+  };
+
+  bool include_subtrees = false;
+  if (goal_subtree_count >= 0) {
+    include_subtrees = true;
+    array_reserve(&new_iterator.subtrees, (uint32_t)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree));
+  }
+
+  array_push(&self->iterators, new_iterator);
+
+  while (self->iterators.size > 0) {
+    for (uint32_t i = 0, size = self->iterators.size; i < size; i++) {
+      StackIterator *iterator = array_get(&self->iterators, i);
+      StackNode *node = iterator->node;
+
+      StackAction action = callback(payload, iterator);
+      bool should_pop = action & StackActionPop;
+      bool should_stop = action & StackActionStop || node->link_count == 0;
+
+      if (should_pop) {
+        SubtreeArray subtrees = iterator->subtrees;
+        if (!should_stop) {
+          ts_subtree_array_copy(subtrees, &subtrees);
+        }
+        ts_subtree_array_reverse(&subtrees);
+        ts_stack__add_slice(
+          self,
+          version,
+          node,
+          &subtrees
+        );
+      }
+
+      if (should_stop) {
+        if (!should_pop) {
+          ts_subtree_array_delete(self->subtree_pool, &iterator->subtrees);
+        }
+        array_erase(&self->iterators, i);
+        i--, size--;
+        continue;
+      }
+
+      for (uint32_t j = 1; j <= node->link_count; j++) {
+        StackIterator *next_iterator;
+        StackLink link;
+        if (j == node->link_count) {
+          link = node->links[0];
+          next_iterator = array_get(&self->iterators, i);
+        } else {
+          if (self->iterators.size >= MAX_ITERATOR_COUNT) continue;
+          link = node->links[j];
+          StackIterator current_iterator = *array_get(&self->iterators, i);
+          array_push(&self->iterators, current_iterator);
+          next_iterator = array_back(&self->iterators);
+          ts_subtree_array_copy(next_iterator->subtrees, &next_iterator->subtrees);
+        }
+
+        next_iterator->node = link.node;
+        if (link.subtree.ptr) {
+          if (include_subtrees) {
+            array_push(&next_iterator->subtrees, link.subtree);
+            ts_subtree_retain(link.subtree);
+          }
+
+          if (!ts_subtree_extra(link.subtree)) {
+            next_iterator->subtree_count++;
+            if (!link.is_pending) {
+              next_iterator->is_pending = false;
+            }
+          }
+        } else {
+          next_iterator->subtree_count++;
+          next_iterator->is_pending = false;
+        }
+      }
+    }
+  }
+
+  return self->slices;
+}
+
+Stack *ts_stack_new(SubtreePool *subtree_pool) {
+  Stack *self = ts_calloc(1, sizeof(Stack));
+
+  array_init(&self->heads);
+  array_init(&self->slices);
+  array_init(&self->iterators);
+  array_init(&self->node_pool);
+  array_reserve(&self->heads, 4);
+  array_reserve(&self->slices, 4);
+  array_reserve(&self->iterators, 4);
+  array_reserve(&self->node_pool, MAX_NODE_POOL_SIZE);
+
+  self->subtree_pool = subtree_pool;
+  self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool);
+  ts_stack_clear(self);
+
+  return self;
+}
+
+void ts_stack_delete(Stack *self) {
+  if (self->slices.contents)
+    array_delete(&self->slices);
+  if (self->iterators.contents)
+    array_delete(&self->iterators);
+  stack_node_release(self->base_node, &self->node_pool, self->subtree_pool);
+  for (uint32_t i = 0; i < self->heads.size; i++) {
+    stack_head_delete(array_get(&self->heads, i), &self->node_pool, self->subtree_pool);
+  }
+  array_clear(&self->heads);
+  if (self->node_pool.contents) {
+    for (uint32_t i = 0; i < self->node_pool.size; i++)
+      ts_free(*array_get(&self->node_pool, i));
+    array_delete(&self->node_pool);
+  }
+  array_delete(&self->heads);
+  ts_free(self);
+}
+
+uint32_t ts_stack_version_count(const Stack *self) {
+  return self->heads.size;
+}
+
+uint32_t ts_stack_halted_version_count(Stack *self) {
+  uint32_t count = 0;
+  for (uint32_t i = 0; i < self->heads.size; i++) {
+    StackHead *head = array_get(&self->heads, i);
+    if (head->status == StackStatusHalted) {
+      count++;
+    }
+  }
+  return count;
+}
+
+TSStateId ts_stack_state(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->node->state;
+}
+
+Length ts_stack_position(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->node->position;
+}
+
+Subtree ts_stack_last_external_token(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->last_external_token;
+}
+
+void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree token) {
+  StackHead *head = array_get(&self->heads, version);
+  if (token.ptr) ts_subtree_retain(token);
+  if (head->last_external_token.ptr) ts_subtree_release(self->subtree_pool, head->last_external_token);
+  head->last_external_token = token;
+}
+
+unsigned ts_stack_error_cost(const Stack *self, StackVersion version) {
+  StackHead *head = array_get(&self->heads, version);
+  unsigned result = head->node->error_cost;
+  if (
+    head->status == StackStatusPaused ||
+    (head->node->state == ERROR_STATE && !head->node->links[0].subtree.ptr)) {
+    result += ERROR_COST_PER_RECOVERY;
+  }
+  return result;
+}
+
+unsigned ts_stack_node_count_since_error(const Stack *self, StackVersion version) {
+  StackHead *head = array_get(&self->heads, version);
+  if (head->node->node_count < head->node_count_at_last_error) {
+    head->node_count_at_last_error = head->node->node_count;
+  }
+  return head->node->node_count - head->node_count_at_last_error;
+}
+
+void ts_stack_push(
+  Stack *self,
+  StackVersion version,
+  Subtree subtree,
+  bool pending,
+  TSStateId state
+) {
+  StackHead *head = array_get(&self->heads, version);
+  StackNode *new_node = stack_node_new(head->node, subtree, pending, state, &self->node_pool);
+  if (!subtree.ptr) head->node_count_at_last_error = new_node->node_count;
+  head->node = new_node;
+}
+
+forceinline StackAction pop_count_callback(void *payload, const StackIterator *iterator) {
+  unsigned *goal_subtree_count = payload;
+  if (iterator->subtree_count == *goal_subtree_count) {
+    return StackActionPop | StackActionStop;
+  } else {
+    return StackActionNone;
+  }
+}
+
+StackSliceArray ts_stack_pop_count(Stack *self, StackVersion version, uint32_t count) {
+  return stack__iter(self, version, pop_count_callback, &count, (int)count);
+}
+
+
+forceinline StackAction pop_pending_callback(void *payload, const StackIterator *iterator) {
+  (void)payload;
+  if (iterator->subtree_count >= 1) {
+    if (iterator->is_pending) {
+      return StackActionPop | StackActionStop;
+    } else {
+      return StackActionStop;
+    }
+  } else {
+    return StackActionNone;
+  }
+}
+
+StackSliceArray ts_stack_pop_pending(Stack *self, StackVersion version) {
+  StackSliceArray pop = stack__iter(self, version, pop_pending_callback, NULL, 0);
+  if (pop.size > 0) {
+    ts_stack_renumber_version(self, array_get(&pop, 0)->version, version);
+    array_get(&pop, 0)->version = version;
+  }
+  return pop;
+}
+
+forceinline StackAction pop_error_callback(void *payload, const StackIterator *iterator) {
+  if (iterator->subtrees.size > 0) {
+    bool *found_error = payload;
+    if (!*found_error && ts_subtree_is_error(*array_get(&iterator->subtrees, 0))) {
+      *found_error = true;
+      return StackActionPop | StackActionStop;
+    } else {
+      return StackActionStop;
+    }
+  } else {
+    return StackActionNone;
+  }
+}
+
+SubtreeArray ts_stack_pop_error(Stack *self, StackVersion version) {
+  StackNode *node = array_get(&self->heads, version)->node;
+  for (unsigned i = 0; i < node->link_count; i++) {
+    if (node->links[i].subtree.ptr && ts_subtree_is_error(node->links[i].subtree)) {
+      bool found_error = false;
+      StackSliceArray pop = stack__iter(self, version, pop_error_callback, &found_error, 1);
+      if (pop.size > 0) {
+        ts_assert(pop.size == 1);
+        ts_stack_renumber_version(self, array_get(&pop, 0)->version, version);
+        return array_get(&pop, 0)->subtrees;
+      }
+      break;
+    }
+  }
+  return (SubtreeArray) {.size = 0};
+}
+
+forceinline StackAction pop_all_callback(void *payload, const StackIterator *iterator) {
+  (void)payload;
+  return iterator->node->link_count == 0 ? StackActionPop : StackActionNone;
+}
+
+StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version) {
+  return stack__iter(self, version, pop_all_callback, NULL, 0);
+}
+
+typedef struct {
+  StackSummary *summary;
+  unsigned max_depth;
+} SummarizeStackSession;
+
+forceinline StackAction summarize_stack_callback(void *payload, const StackIterator *iterator) {
+  SummarizeStackSession *session = payload;
+  TSStateId state = iterator->node->state;
+  unsigned depth = iterator->subtree_count;
+  if (depth > session->max_depth) return StackActionStop;
+  for (unsigned i = session->summary->size - 1; i + 1 > 0; i--) {
+    StackSummaryEntry entry = *array_get(session->summary, i);
+    if (entry.depth < depth) break;
+    if (entry.depth == depth && entry.state == state) return StackActionNone;
+  }
+  array_push(session->summary, ((StackSummaryEntry) {
+    .position = iterator->node->position,
+    .depth = depth,
+    .state = state,
+  }));
+  return StackActionNone;
+}
+
+void ts_stack_record_summary(Stack *self, StackVersion version, unsigned max_depth) {
+  SummarizeStackSession session = {
+    .summary = ts_malloc(sizeof(StackSummary)),
+    .max_depth = max_depth
+  };
+  array_init(session.summary);
+  stack__iter(self, version, summarize_stack_callback, &session, -1);
+  StackHead *head = array_get(&self->heads, version);
+  if (head->summary) {
+    array_delete(head->summary);
+    ts_free(head->summary);
+  }
+  head->summary = session.summary;
+}
+
+StackSummary *ts_stack_get_summary(Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->summary;
+}
+
+int ts_stack_dynamic_precedence(Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->node->dynamic_precedence;
+}
+
+bool ts_stack_has_advanced_since_error(const Stack *self, StackVersion version) {
+  const StackHead *head = array_get(&self->heads, version);
+  const StackNode *node = head->node;
+  if (node->error_cost == 0) return true;
+  while (node) {
+    if (node->link_count > 0) {
+      Subtree subtree = node->links[0].subtree;
+      if (subtree.ptr) {
+        if (ts_subtree_total_bytes(subtree) > 0) {
+          return true;
+        } else if (
+          node->node_count > head->node_count_at_last_error &&
+          ts_subtree_error_cost(subtree) == 0
+        ) {
+          node = node->links[0].node;
+          continue;
+        }
+      }
+    }
+    break;
+  }
+  return false;
+}
+
+void ts_stack_remove_version(Stack *self, StackVersion version) {
+  stack_head_delete(array_get(&self->heads, version), &self->node_pool, self->subtree_pool);
+  array_erase(&self->heads, version);
+}
+
+void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2) {
+  if (v1 == v2) return;
+  ts_assert(v2 < v1);
+  ts_assert((uint32_t)v1 < self->heads.size);
+  StackHead *source_head = array_get(&self->heads, v1);
+  StackHead *target_head = array_get(&self->heads, v2);
+  if (target_head->summary && !source_head->summary) {
+    source_head->summary = target_head->summary;
+    target_head->summary = NULL;
+  }
+  stack_head_delete(target_head, &self->node_pool, self->subtree_pool);
+  *target_head = *source_head;
+  array_erase(&self->heads, v1);
+}
+
+void ts_stack_swap_versions(Stack *self, StackVersion v1, StackVersion v2) {
+  StackHead temporary_head = *array_get(&self->heads, v1);
+  *array_get(&self->heads, v1) = *array_get(&self->heads, v2);
+  *array_get(&self->heads, v2) = temporary_head;
+}
+
+StackVersion ts_stack_copy_version(Stack *self, StackVersion version) {
+  ts_assert(version < self->heads.size);
+  StackHead version_head = *array_get(&self->heads, version);
+  array_push(&self->heads, version_head);
+  StackHead *head = array_back(&self->heads);
+  stack_node_retain(head->node);
+  if (head->last_external_token.ptr) ts_subtree_retain(head->last_external_token);
+  head->summary = NULL;
+  return self->heads.size - 1;
+}
+
+bool ts_stack_merge(Stack *self, StackVersion version1, StackVersion version2) {
+  if (!ts_stack_can_merge(self, version1, version2)) return false;
+  StackHead *head1 = array_get(&self->heads, version1);
+  StackHead *head2 = array_get(&self->heads, version2);
+  for (uint32_t i = 0; i < head2->node->link_count; i++) {
+    stack_node_add_link(head1->node, head2->node->links[i], self->subtree_pool);
+  }
+  if (head1->node->state == ERROR_STATE) {
+    head1->node_count_at_last_error = head1->node->node_count;
+  }
+  ts_stack_remove_version(self, version2);
+  return true;
+}
+
+bool ts_stack_can_merge(Stack *self, StackVersion version1, StackVersion version2) {
+  StackHead *head1 = array_get(&self->heads, version1);
+  StackHead *head2 = array_get(&self->heads, version2);
+  return
+    head1->status == StackStatusActive &&
+    head2->status == StackStatusActive &&
+    head1->node->state == head2->node->state &&
+    head1->node->position.bytes == head2->node->position.bytes &&
+    head1->node->error_cost == head2->node->error_cost &&
+    ts_subtree_external_scanner_state_eq(head1->last_external_token, head2->last_external_token);
+}
+
+void ts_stack_halt(Stack *self, StackVersion version) {
+  array_get(&self->heads, version)->status = StackStatusHalted;
+}
+
+void ts_stack_pause(Stack *self, StackVersion version, Subtree lookahead) {
+  StackHead *head = array_get(&self->heads, version);
+  head->status = StackStatusPaused;
+  head->lookahead_when_paused = lookahead;
+  head->node_count_at_last_error = head->node->node_count;
+}
+
+bool ts_stack_is_active(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->status == StackStatusActive;
+}
+
+bool ts_stack_is_halted(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->status == StackStatusHalted;
+}
+
+bool ts_stack_is_paused(const Stack *self, StackVersion version) {
+  return array_get(&self->heads, version)->status == StackStatusPaused;
+}
+
+Subtree ts_stack_resume(Stack *self, StackVersion version) {
+  StackHead *head = array_get(&self->heads, version);
+  ts_assert(head->status == StackStatusPaused);
+  Subtree result = head->lookahead_when_paused;
+  head->status = StackStatusActive;
+  head->lookahead_when_paused = NULL_SUBTREE;
+  return result;
+}
+
+void ts_stack_clear(Stack *self) {
+  stack_node_retain(self->base_node);
+  for (uint32_t i = 0; i < self->heads.size; i++) {
+    stack_head_delete(array_get(&self->heads, i), &self->node_pool, self->subtree_pool);
+  }
+  array_clear(&self->heads);
+  array_push(&self->heads, ((StackHead) {
+    .node = self->base_node,
+    .status = StackStatusActive,
+    .last_external_token = NULL_SUBTREE,
+    .lookahead_when_paused = NULL_SUBTREE,
+  }));
+}
+
+bool ts_stack_print_dot_graph(Stack *self, const TSLanguage *language, FILE *f) {
+  array_reserve(&self->iterators, 32);
+  if (!f) f = stderr;
+
+  fprintf(f, "digraph stack {\n");
+  fprintf(f, "rankdir=\"RL\";\n");
+  fprintf(f, "edge [arrowhead=none]\n");
+
+  Array(StackNode *) visited_nodes = array_new();
+
+  array_clear(&self->iterators);
+  for (uint32_t i = 0; i < self->heads.size; i++) {
+    StackHead *head = array_get(&self->heads, i);
+    if (head->status == StackStatusHalted) continue;
+
+    fprintf(f, "node_head_%u [shape=none, label=\"\"]\n", i);
+    fprintf(f, "node_head_%u -> node_%p [", i, (void *)head->node);
+
+    if (head->status == StackStatusPaused) {
+      fprintf(f, "color=red ");
+    }
+    fprintf(f,
+      "label=%u, fontcolor=blue, weight=10000, labeltooltip=\"node_count: %u\nerror_cost: %u",
+      i,
+      ts_stack_node_count_since_error(self, i),
+      ts_stack_error_cost(self, i)
+    );
+
+    if (head->summary) {
+      fprintf(f, "\nsummary:");
+      for (uint32_t j = 0; j < head->summary->size; j++) fprintf(f, " %u", array_get(head->summary, j)->state);
+    }
+
+    if (head->last_external_token.ptr) {
+      const ExternalScannerState *state = &head->last_external_token.ptr->external_scanner_state;
+      const char *data = ts_external_scanner_state_data(state);
+      fprintf(f, "\nexternal_scanner_state:");
+      for (uint32_t j = 0; j < state->length; j++) fprintf(f, " %2X", data[j]);
+    }
+
+    fprintf(f, "\"]\n");
+    array_push(&self->iterators, ((StackIterator) {
+      .node = head->node
+    }));
+  }
+
+  bool all_iterators_done = false;
+  while (!all_iterators_done) {
+    all_iterators_done = true;
+
+    for (uint32_t i = 0; i < self->iterators.size; i++) {
+      StackIterator iterator = *array_get(&self->iterators, i);
+      StackNode *node = iterator.node;
+
+      for (uint32_t j = 0; j < visited_nodes.size; j++) {
+        if (*array_get(&visited_nodes, j) == node) {
+          node = NULL;
+          break;
+        }
+      }
+
+      if (!node) continue;
+      all_iterators_done = false;
+
+      fprintf(f, "node_%p [", (void *)node);
+      if (node->state == ERROR_STATE) {
+        fprintf(f, "label=\"?\"");
+      } else if (
+        node->link_count == 1 &&
+        node->links[0].subtree.ptr &&
+        ts_subtree_extra(node->links[0].subtree)
+      ) {
+        fprintf(f, "shape=point margin=0 label=\"\"");
+      } else {
+        fprintf(f, "label=\"%d\"", node->state);
+      }
+
+      fprintf(
+        f,
+        " tooltip=\"position: %u,%u\nnode_count:%u\nerror_cost: %u\ndynamic_precedence: %d\"];\n",
+        node->position.extent.row + 1,
+        node->position.extent.column,
+        node->node_count,
+        node->error_cost,
+        node->dynamic_precedence
+      );
+
+      for (int j = 0; j < node->link_count; j++) {
+        StackLink link = node->links[j];
+        fprintf(f, "node_%p -> node_%p [", (void *)node, (void *)link.node);
+        if (link.is_pending) fprintf(f, "style=dashed ");
+        if (link.subtree.ptr && ts_subtree_extra(link.subtree)) fprintf(f, "fontcolor=gray ");
+
+        if (!link.subtree.ptr) {
+          fprintf(f, "color=red");
+        } else {
+          fprintf(f, "label=\"");
+          bool quoted = ts_subtree_visible(link.subtree) && !ts_subtree_named(link.subtree);
+          if (quoted) fprintf(f, "'");
+          ts_language_write_symbol_as_dot_string(language, f, ts_subtree_symbol(link.subtree));
+          if (quoted) fprintf(f, "'");
+          fprintf(f, "\"");
+          fprintf(
+            f,
+            "labeltooltip=\"error_cost: %u\ndynamic_precedence: %" PRId32 "\"",
+            ts_subtree_error_cost(link.subtree),
+            ts_subtree_dynamic_precedence(link.subtree)
+          );
+        }
+
+        fprintf(f, "];\n");
+
+        StackIterator *next_iterator;
+        if (j == 0) {
+          next_iterator = array_get(&self->iterators, i);
+        } else {
+          array_push(&self->iterators, iterator);
+          next_iterator = array_back(&self->iterators);
+        }
+        next_iterator->node = link.node;
+      }
+
+      array_push(&visited_nodes, node);
+    }
+  }
+
+  fprintf(f, "}\n");
+
+  array_delete(&visited_nodes);
+  return true;
+}
+
+#undef forceinline
diff --git a/src/library/ts/src/tree-sitter/lib/src/stack.h b/src/library/ts/src/tree-sitter/lib/src/stack.h
new file mode 100644
index 0000000000..2619f1e8a5
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/stack.h
@@ -0,0 +1,133 @@
+#ifndef TREE_SITTER_PARSE_STACK_H_
+#define TREE_SITTER_PARSE_STACK_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./array.h"
+#include "./subtree.h"
+#include <stdio.h>
+
+typedef struct Stack Stack;
+
+typedef unsigned StackVersion;
+#define STACK_VERSION_NONE ((StackVersion)-1)
+
+typedef struct {
+  SubtreeArray subtrees;
+  StackVersion version;
+} StackSlice;
+typedef Array(StackSlice) StackSliceArray;
+
+typedef struct {
+  Length position;
+  unsigned depth;
+  TSStateId state;
+} StackSummaryEntry;
+typedef Array(StackSummaryEntry) StackSummary;
+
+// Create a stack.
+Stack *ts_stack_new(SubtreePool *subtree_pool);
+
+// Release the memory reserved for a given stack.
+void ts_stack_delete(Stack *self);
+
+// Get the stack's current number of versions.
+uint32_t ts_stack_version_count(const Stack *self);
+
+// Get the stack's current number of halted versions.
+uint32_t ts_stack_halted_version_count(Stack *self);
+
+// Get the state at the top of the given version of the stack. If the stack is
+// empty, this returns the initial state, 0.
+TSStateId ts_stack_state(const Stack *self, StackVersion version);
+
+// Get the last external token associated with a given version of the stack.
+Subtree ts_stack_last_external_token(const Stack *self, StackVersion version);
+
+// Set the last external token associated with a given version of the stack.
+void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree token);
+
+// Get the position of the given version of the stack within the document.
+Length ts_stack_position(const Stack *, StackVersion);
+
+// Push a tree and state onto the given version of the stack.
+//
+// This transfers ownership of the tree to the Stack. Callers that
+// need to retain ownership of the tree for their own purposes should
+// first retain the tree.
+void ts_stack_push(Stack *self, StackVersion version, Subtree subtree, bool pending, TSStateId state);
+
+// Pop the given number of entries from the given version of the stack. This
+// operation can increase the number of stack versions by revealing multiple
+// versions which had previously been merged. It returns an array that
+// specifies the index of each revealed version and the trees that were
+// removed from that version.
+StackSliceArray ts_stack_pop_count(Stack *self, StackVersion version, uint32_t count);
+
+// Remove an error at the top of the given version of the stack.
+SubtreeArray ts_stack_pop_error(Stack *self, StackVersion version);
+
+// Remove any pending trees from the top of the given version of the stack.
+StackSliceArray ts_stack_pop_pending(Stack *self, StackVersion version);
+
+// Remove all trees from the given version of the stack.
+StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version);
+
+// Get the maximum number of tree nodes reachable from this version of the stack
+// since the last error was detected.
+unsigned ts_stack_node_count_since_error(const Stack *self, StackVersion version);
+
+int ts_stack_dynamic_precedence(Stack *self, StackVersion version);
+
+bool ts_stack_has_advanced_since_error(const Stack *self, StackVersion version);
+
+// Compute a summary of all the parse states near the top of the given
+// version of the stack and store the summary for later retrieval.
+void ts_stack_record_summary(Stack *self, StackVersion version, unsigned max_depth);
+
+// Retrieve a summary of all the parse states near the top of the
+// given version of the stack.
+StackSummary *ts_stack_get_summary(Stack *self, StackVersion version);
+
+// Get the total cost of all errors on the given version of the stack.
+unsigned ts_stack_error_cost(const Stack *self, StackVersion version);
+
+// Merge the given two stack versions if possible, returning true
+// if they were successfully merged and false otherwise.
+bool ts_stack_merge(Stack *self, StackVersion version1, StackVersion version2);
+
+// Determine whether the given two stack versions can be merged.
+bool ts_stack_can_merge(Stack *self, StackVersion version1, StackVersion version2);
+
+Subtree ts_stack_resume(Stack *self, StackVersion version);
+
+void ts_stack_pause(Stack *self, StackVersion version, Subtree lookahead);
+
+void ts_stack_halt(Stack *self, StackVersion version);
+
+bool ts_stack_is_active(const Stack *self, StackVersion version);
+
+bool ts_stack_is_paused(const Stack *self, StackVersion version);
+
+bool ts_stack_is_halted(const Stack *self, StackVersion version);
+
+void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2);
+
+void ts_stack_swap_versions(Stack *, StackVersion v1, StackVersion v2);
+
+StackVersion ts_stack_copy_version(Stack *self, StackVersion version);
+
+// Remove the given version from the stack.
+void ts_stack_remove_version(Stack *self, StackVersion version);
+
+void ts_stack_clear(Stack *self);
+
+bool ts_stack_print_dot_graph(Stack *self, const TSLanguage *language, FILE *f);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSE_STACK_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/subtree.c b/src/library/ts/src/tree-sitter/lib/src/subtree.c
new file mode 100644
index 0000000000..bf8e119b94
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/subtree.c
@@ -0,0 +1,1036 @@
+#include <ctype.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include "./alloc.h"
+#include "./array.h"
+#include "./atomic.h"
+#include "./subtree.h"
+#include "./length.h"
+#include "./language.h"
+#include "./error_costs.h"
+#include "./ts_assert.h"
+#include <stddef.h>
+
+typedef struct {
+  Length start;
+  Length old_end;
+  Length new_end;
+} Edit;
+
+#define TS_MAX_INLINE_TREE_LENGTH UINT8_MAX
+#define TS_MAX_TREE_POOL_SIZE 32
+
+// ExternalScannerState
+
+void ts_external_scanner_state_init(ExternalScannerState *self, const char *data, unsigned length) {
+  self->length = length;
+  if (length > sizeof(self->short_data)) {
+    self->long_data = ts_malloc(length);
+    memcpy(self->long_data, data, length);
+  } else {
+    memcpy(self->short_data, data, length);
+  }
+}
+
+ExternalScannerState ts_external_scanner_state_copy(const ExternalScannerState *self) {
+  ExternalScannerState result = *self;
+  if (self->length > sizeof(self->short_data)) {
+    result.long_data = ts_malloc(self->length);
+    memcpy(result.long_data, self->long_data, self->length);
+  }
+  return result;
+}
+
+void ts_external_scanner_state_delete(ExternalScannerState *self) {
+  if (self->length > sizeof(self->short_data)) {
+    ts_free(self->long_data);
+  }
+}
+
+const char *ts_external_scanner_state_data(const ExternalScannerState *self) {
+  if (self->length > sizeof(self->short_data)) {
+    return self->long_data;
+  } else {
+    return self->short_data;
+  }
+}
+
+bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *buffer, unsigned length) {
+  return
+    self->length == length &&
+    memcmp(ts_external_scanner_state_data(self), buffer, length) == 0;
+}
+
+// SubtreeArray
+
+void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest) {
+  dest->size = self.size;
+  dest->capacity = self.capacity;
+  dest->contents = self.contents;
+  if (self.capacity > 0) {
+    dest->contents = ts_calloc(self.capacity, sizeof(Subtree));
+    memcpy(dest->contents, self.contents, self.size * sizeof(Subtree));
+    for (uint32_t i = 0; i < self.size; i++) {
+      ts_subtree_retain(*array_get(dest, i));
+    }
+  }
+}
+
+void ts_subtree_array_clear(SubtreePool *pool, SubtreeArray *self) {
+  for (uint32_t i = 0; i < self->size; i++) {
+    ts_subtree_release(pool, *array_get(self, i));
+  }
+  array_clear(self);
+}
+
+void ts_subtree_array_delete(SubtreePool *pool, SubtreeArray *self) {
+  ts_subtree_array_clear(pool, self);
+  array_delete(self);
+}
+
+void ts_subtree_array_remove_trailing_extras(
+  SubtreeArray *self,
+  SubtreeArray *destination
+) {
+  array_clear(destination);
+  while (self->size > 0) {
+    Subtree last = *array_get(self, self->size - 1);
+    if (ts_subtree_extra(last)) {
+      self->size--;
+      array_push(destination, last);
+    } else {
+      break;
+    }
+  }
+  ts_subtree_array_reverse(destination);
+}
+
+void ts_subtree_array_reverse(SubtreeArray *self) {
+  for (uint32_t i = 0, limit = self->size / 2; i < limit; i++) {
+    size_t reverse_index = self->size - 1 - i;
+    Subtree swap = *array_get(self, i);
+    *array_get(self, i) = *array_get(self, reverse_index);
+    *array_get(self, reverse_index) = swap;
+  }
+}
+
+// SubtreePool
+
+SubtreePool ts_subtree_pool_new(uint32_t capacity) {
+  SubtreePool self = {array_new(), array_new()};
+  array_reserve(&self.free_trees, capacity);
+  return self;
+}
+
+void ts_subtree_pool_delete(SubtreePool *self) {
+  if (self->free_trees.contents) {
+    for (unsigned i = 0; i < self->free_trees.size; i++) {
+      ts_free(array_get(&self->free_trees, i)->ptr);
+    }
+    array_delete(&self->free_trees);
+  }
+  if (self->tree_stack.contents) array_delete(&self->tree_stack);
+}
+
+static SubtreeHeapData *ts_subtree_pool_allocate(SubtreePool *self) {
+  if (self->free_trees.size > 0) {
+    return array_pop(&self->free_trees).ptr;
+  } else {
+    return ts_malloc(sizeof(SubtreeHeapData));
+  }
+}
+
+static void ts_subtree_pool_free(SubtreePool *self, SubtreeHeapData *tree) {
+  if (self->free_trees.capacity > 0 && self->free_trees.size + 1 <= TS_MAX_TREE_POOL_SIZE) {
+    array_push(&self->free_trees, (MutableSubtree) {.ptr = tree});
+  } else {
+    ts_free(tree);
+  }
+}
+
+// Subtree
+
+static inline bool ts_subtree_can_inline(Length padding, Length size, uint32_t lookahead_bytes) {
+  return
+    padding.bytes < TS_MAX_INLINE_TREE_LENGTH &&
+    padding.extent.row < 16 &&
+    padding.extent.column < TS_MAX_INLINE_TREE_LENGTH &&
+    size.bytes < TS_MAX_INLINE_TREE_LENGTH &&
+    size.extent.row == 0 &&
+    size.extent.column < TS_MAX_INLINE_TREE_LENGTH &&
+    lookahead_bytes < 16;
+}
+
+Subtree ts_subtree_new_leaf(
+  SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
+  uint32_t lookahead_bytes, TSStateId parse_state,
+  bool has_external_tokens, bool depends_on_column,
+  bool is_keyword, const TSLanguage *language
+) {
+  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
+  bool extra = symbol == ts_builtin_sym_end;
+
+  bool is_inline = (
+    symbol <= UINT8_MAX &&
+    !has_external_tokens &&
+    ts_subtree_can_inline(padding, size, lookahead_bytes)
+  );
+
+  if (is_inline) {
+    return (Subtree) {{
+      .parse_state = parse_state,
+      .symbol = symbol,
+      .padding_bytes = padding.bytes,
+      .padding_rows = padding.extent.row,
+      .padding_columns = padding.extent.column,
+      .size_bytes = size.bytes,
+      .lookahead_bytes = lookahead_bytes,
+      .visible = metadata.visible,
+      .named = metadata.named,
+      .extra = extra,
+      .has_changes = false,
+      .is_missing = false,
+      .is_keyword = is_keyword,
+      .is_inline = true,
+    }};
+  } else {
+    SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
+    *data = (SubtreeHeapData) {
+      .ref_count = 1,
+      .padding = padding,
+      .size = size,
+      .lookahead_bytes = lookahead_bytes,
+      .error_cost = 0,
+      .child_count = 0,
+      .symbol = symbol,
+      .parse_state = parse_state,
+      .visible = metadata.visible,
+      .named = metadata.named,
+      .extra = extra,
+      .fragile_left = false,
+      .fragile_right = false,
+      .has_changes = false,
+      .has_external_tokens = has_external_tokens,
+      .has_external_scanner_state_change = false,
+      .depends_on_column = depends_on_column,
+      .is_missing = false,
+      .is_keyword = is_keyword,
+      {{.first_leaf = {.symbol = 0, .parse_state = 0}}}
+    };
+    return (Subtree) {.ptr = data};
+  }
+}
+
+void ts_subtree_set_symbol(
+  MutableSubtree *self,
+  TSSymbol symbol,
+  const TSLanguage *language
+) {
+  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
+  if (self->data.is_inline) {
+    ts_assert(symbol < UINT8_MAX);
+    self->data.symbol = symbol;
+    self->data.named = metadata.named;
+    self->data.visible = metadata.visible;
+  } else {
+    self->ptr->symbol = symbol;
+    self->ptr->named = metadata.named;
+    self->ptr->visible = metadata.visible;
+  }
+}
+
+Subtree ts_subtree_new_error(
+  SubtreePool *pool, int32_t lookahead_char, Length padding, Length size,
+  uint32_t bytes_scanned, TSStateId parse_state, const TSLanguage *language
+) {
+  Subtree result = ts_subtree_new_leaf(
+    pool, ts_builtin_sym_error, padding, size, bytes_scanned,
+    parse_state, false, false, false, language
+  );
+  SubtreeHeapData *data = (SubtreeHeapData *)result.ptr;
+  data->fragile_left = true;
+  data->fragile_right = true;
+  data->lookahead_char = lookahead_char;
+  return result;
+}
+
+// Clone a subtree.
+MutableSubtree ts_subtree_clone(Subtree self) {
+  size_t alloc_size = ts_subtree_alloc_size(self.ptr->child_count);
+  Subtree *new_children = ts_malloc(alloc_size);
+  Subtree *old_children = ts_subtree_children(self);
+  memcpy(new_children, old_children, alloc_size);
+  SubtreeHeapData *result = (SubtreeHeapData *)&new_children[self.ptr->child_count];
+  if (self.ptr->child_count > 0) {
+    for (uint32_t i = 0; i < self.ptr->child_count; i++) {
+      ts_subtree_retain(new_children[i]);
+    }
+  } else if (self.ptr->has_external_tokens) {
+    result->external_scanner_state = ts_external_scanner_state_copy(
+      &self.ptr->external_scanner_state
+    );
+  }
+  result->ref_count = 1;
+  return (MutableSubtree) {.ptr = result};
+}
+
+// Get mutable version of a subtree.
+//
+// This takes ownership of the subtree. If the subtree has only one owner,
+// this will directly convert it into a mutable version. Otherwise, it will
+// perform a copy.
+MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self) {
+  if (self.data.is_inline) return (MutableSubtree) {self.data};
+  if (self.ptr->ref_count == 1) return ts_subtree_to_mut_unsafe(self);
+  MutableSubtree result = ts_subtree_clone(self);
+  ts_subtree_release(pool, self);
+  return result;
+}
+
+void ts_subtree_compress(
+  MutableSubtree self,
+  unsigned count,
+  const TSLanguage *language,
+  MutableSubtreeArray *stack
+) {
+  unsigned initial_stack_size = stack->size;
+
+  MutableSubtree tree = self;
+  TSSymbol symbol = tree.ptr->symbol;
+  for (unsigned i = 0; i < count; i++) {
+    if (tree.ptr->ref_count > 1 || tree.ptr->child_count < 2) break;
+
+    MutableSubtree child = ts_subtree_to_mut_unsafe(ts_subtree_children(tree)[0]);
+    if (
+      child.data.is_inline ||
+      child.ptr->child_count < 2 ||
+      child.ptr->ref_count > 1 ||
+      child.ptr->symbol != symbol
+    ) break;
+
+    MutableSubtree grandchild = ts_subtree_to_mut_unsafe(ts_subtree_children(child)[0]);
+    if (
+      grandchild.data.is_inline ||
+      grandchild.ptr->child_count < 2 ||
+      grandchild.ptr->ref_count > 1 ||
+      grandchild.ptr->symbol != symbol
+    ) break;
+
+    ts_subtree_children(tree)[0] = ts_subtree_from_mut(grandchild);
+    ts_subtree_children(child)[0] = ts_subtree_children(grandchild)[grandchild.ptr->child_count - 1];
+    ts_subtree_children(grandchild)[grandchild.ptr->child_count - 1] = ts_subtree_from_mut(child);
+    array_push(stack, tree);
+    tree = grandchild;
+  }
+
+  while (stack->size > initial_stack_size) {
+    tree = array_pop(stack);
+    MutableSubtree child = ts_subtree_to_mut_unsafe(ts_subtree_children(tree)[0]);
+    MutableSubtree grandchild = ts_subtree_to_mut_unsafe(ts_subtree_children(child)[child.ptr->child_count - 1]);
+    ts_subtree_summarize_children(grandchild, language);
+    ts_subtree_summarize_children(child, language);
+    ts_subtree_summarize_children(tree, language);
+  }
+}
+
+// Assign all of the node's properties that depend on its children.
+void ts_subtree_summarize_children(
+  MutableSubtree self,
+  const TSLanguage *language
+) {
+  ts_assert(!self.data.is_inline);
+
+  self.ptr->named_child_count = 0;
+  self.ptr->visible_child_count = 0;
+  self.ptr->error_cost = 0;
+  self.ptr->repeat_depth = 0;
+  self.ptr->visible_descendant_count = 0;
+  self.ptr->has_external_tokens = false;
+  self.ptr->depends_on_column = false;
+  self.ptr->has_external_scanner_state_change = false;
+  self.ptr->dynamic_precedence = 0;
+
+  uint32_t structural_index = 0;
+  const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
+  uint32_t lookahead_end_byte = 0;
+
+  const Subtree *children = ts_subtree_children(self);
+  for (uint32_t i = 0; i < self.ptr->child_count; i++) {
+    Subtree child = children[i];
+
+    if (
+      self.ptr->size.extent.row == 0 &&
+      ts_subtree_depends_on_column(child)
+    ) {
+      self.ptr->depends_on_column = true;
+    }
+
+    if (ts_subtree_has_external_scanner_state_change(child)) {
+      self.ptr->has_external_scanner_state_change = true;
+    }
+
+    if (i == 0) {
+      self.ptr->padding = ts_subtree_padding(child);
+      self.ptr->size = ts_subtree_size(child);
+    } else {
+      self.ptr->size = length_add(self.ptr->size, ts_subtree_total_size(child));
+    }
+
+    uint32_t child_lookahead_end_byte =
+      self.ptr->padding.bytes +
+      self.ptr->size.bytes +
+      ts_subtree_lookahead_bytes(child);
+    if (child_lookahead_end_byte > lookahead_end_byte) {
+      lookahead_end_byte = child_lookahead_end_byte;
+    }
+
+    if (ts_subtree_symbol(child) != ts_builtin_sym_error_repeat) {
+      self.ptr->error_cost += ts_subtree_error_cost(child);
+    }
+
+    uint32_t grandchild_count = ts_subtree_child_count(child);
+    if (
+      self.ptr->symbol == ts_builtin_sym_error ||
+      self.ptr->symbol == ts_builtin_sym_error_repeat
+    ) {
+      if (!ts_subtree_extra(child) && !(ts_subtree_is_error(child) && grandchild_count == 0)) {
+        if (ts_subtree_visible(child)) {
+          self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE;
+        } else if (grandchild_count > 0) {
+          self.ptr->error_cost += ERROR_COST_PER_SKIPPED_TREE * child.ptr->visible_child_count;
+        }
+      }
+    }
+
+    self.ptr->dynamic_precedence += ts_subtree_dynamic_precedence(child);
+    self.ptr->visible_descendant_count += ts_subtree_visible_descendant_count(child);
+
+    if (
+      !ts_subtree_extra(child) &&
+      ts_subtree_symbol(child) != 0 &&
+      alias_sequence &&
+      alias_sequence[structural_index] != 0
+    ) {
+      self.ptr->visible_descendant_count++;
+      self.ptr->visible_child_count++;
+      if (ts_language_symbol_metadata(language, alias_sequence[structural_index]).named) {
+        self.ptr->named_child_count++;
+      }
+    } else if (ts_subtree_visible(child)) {
+      self.ptr->visible_descendant_count++;
+      self.ptr->visible_child_count++;
+      if (ts_subtree_named(child)) self.ptr->named_child_count++;
+    } else if (grandchild_count > 0) {
+      self.ptr->visible_child_count += child.ptr->visible_child_count;
+      self.ptr->named_child_count += child.ptr->named_child_count;
+    }
+
+    if (ts_subtree_has_external_tokens(child)) self.ptr->has_external_tokens = true;
+
+    if (ts_subtree_is_error(child)) {
+      self.ptr->fragile_left = self.ptr->fragile_right = true;
+      self.ptr->parse_state = TS_TREE_STATE_NONE;
+    }
+
+    if (!ts_subtree_extra(child)) structural_index++;
+  }
+
+  self.ptr->lookahead_bytes = lookahead_end_byte - self.ptr->size.bytes - self.ptr->padding.bytes;
+
+  if (
+    self.ptr->symbol == ts_builtin_sym_error ||
+    self.ptr->symbol == ts_builtin_sym_error_repeat
+  ) {
+    self.ptr->error_cost +=
+      ERROR_COST_PER_RECOVERY +
+      ERROR_COST_PER_SKIPPED_CHAR * self.ptr->size.bytes +
+      ERROR_COST_PER_SKIPPED_LINE * self.ptr->size.extent.row;
+  }
+
+  if (self.ptr->child_count > 0) {
+    Subtree first_child = children[0];
+    Subtree last_child = children[self.ptr->child_count - 1];
+
+    self.ptr->first_leaf.symbol = ts_subtree_leaf_symbol(first_child);
+    self.ptr->first_leaf.parse_state = ts_subtree_leaf_parse_state(first_child);
+
+    if (ts_subtree_fragile_left(first_child)) self.ptr->fragile_left = true;
+    if (ts_subtree_fragile_right(last_child)) self.ptr->fragile_right = true;
+
+    if (
+      self.ptr->child_count >= 2 &&
+      !self.ptr->visible &&
+      !self.ptr->named &&
+      ts_subtree_symbol(first_child) == self.ptr->symbol
+    ) {
+      if (ts_subtree_repeat_depth(first_child) > ts_subtree_repeat_depth(last_child)) {
+        self.ptr->repeat_depth = ts_subtree_repeat_depth(first_child) + 1;
+      } else {
+        self.ptr->repeat_depth = ts_subtree_repeat_depth(last_child) + 1;
+      }
+    }
+  }
+}
+
+// Create a new parent node with the given children.
+//
+// This takes ownership of the children array.
+MutableSubtree ts_subtree_new_node(
+  TSSymbol symbol,
+  SubtreeArray *children,
+  unsigned production_id,
+  const TSLanguage *language
+) {
+  TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
+  bool fragile = symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat;
+
+  // Allocate the node's data at the end of the array of children.
+  size_t new_byte_size = ts_subtree_alloc_size(children->size);
+  if (children->capacity * sizeof(Subtree) < new_byte_size) {
+    children->contents = ts_realloc(children->contents, new_byte_size);
+    children->capacity = (uint32_t)(new_byte_size / sizeof(Subtree));
+  }
+  SubtreeHeapData *data = (SubtreeHeapData *)&children->contents[children->size];
+
+  *data = (SubtreeHeapData) {
+    .ref_count = 1,
+    .symbol = symbol,
+    .child_count = children->size,
+    .visible = metadata.visible,
+    .named = metadata.named,
+    .has_changes = false,
+    .has_external_scanner_state_change = false,
+    .fragile_left = fragile,
+    .fragile_right = fragile,
+    .is_keyword = false,
+    {{
+      .visible_descendant_count = 0,
+      .production_id = production_id,
+      .first_leaf = {.symbol = 0, .parse_state = 0},
+    }}
+  };
+  MutableSubtree result = {.ptr = data};
+  ts_subtree_summarize_children(result, language);
+  return result;
+}
+
+// Create a new error node containing the given children.
+//
+// This node is treated as 'extra'. Its children are prevented from having
+// having any effect on the parse state.
+Subtree ts_subtree_new_error_node(
+  SubtreeArray *children,
+  bool extra,
+  const TSLanguage *language
+) {
+  MutableSubtree result = ts_subtree_new_node(
+    ts_builtin_sym_error, children, 0, language
+  );
+  result.ptr->extra = extra;
+  return ts_subtree_from_mut(result);
+}
+
+// Create a new 'missing leaf' node.
+//
+// This node is treated as 'extra'. Its children are prevented from having
+// having any effect on the parse state.
+Subtree ts_subtree_new_missing_leaf(
+  SubtreePool *pool,
+  TSSymbol symbol,
+  Length padding,
+  uint32_t lookahead_bytes,
+  const TSLanguage *language,
+  TSStateId state
+) {
+  Subtree result = ts_subtree_new_leaf(
+    pool, symbol, padding, length_zero(), lookahead_bytes,
+    0, false, false, false, language
+  );
+  if (result.data.is_inline) {
+    result.data.is_missing = true;
+    result.data.parse_state = state;
+  } else {
+    ((SubtreeHeapData *)result.ptr)->is_missing = true;
+  }
+  return result;
+}
+
+void ts_subtree_retain(Subtree self) {
+  if (self.data.is_inline) return;
+  ts_assert(self.ptr->ref_count > 0);
+  atomic_inc((volatile uint32_t *)&self.ptr->ref_count);
+  ts_assert(self.ptr->ref_count != 0);
+}
+
+void ts_subtree_release(SubtreePool *pool, Subtree self) {
+  if (self.data.is_inline) return;
+  array_clear(&pool->tree_stack);
+
+  ts_assert(self.ptr->ref_count > 0);
+  if (atomic_dec((volatile uint32_t *)&self.ptr->ref_count) == 0) {
+    array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self));
+  }
+
+  while (pool->tree_stack.size > 0) {
+    MutableSubtree tree = array_pop(&pool->tree_stack);
+    if (tree.ptr->child_count > 0) {
+      Subtree *children = ts_subtree_children(tree);
+      for (uint32_t i = 0; i < tree.ptr->child_count; i++) {
+        Subtree child = children[i];
+        if (child.data.is_inline) continue;
+        ts_assert(child.ptr->ref_count > 0);
+        if (atomic_dec((volatile uint32_t *)&child.ptr->ref_count) == 0) {
+          array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child));
+        }
+      }
+      ts_free(children);
+    } else {
+      if (tree.ptr->has_external_tokens) {
+        ts_external_scanner_state_delete(&tree.ptr->external_scanner_state);
+      }
+      ts_subtree_pool_free(pool, tree.ptr);
+    }
+  }
+}
+
+int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) {
+  array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left));
+  array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right));
+
+  while (pool->tree_stack.size > 0) {
+    right = ts_subtree_from_mut(array_pop(&pool->tree_stack));
+    left = ts_subtree_from_mut(array_pop(&pool->tree_stack));
+
+    int result = 0;
+    if (ts_subtree_symbol(left) < ts_subtree_symbol(right)) result = -1;
+    else if (ts_subtree_symbol(right) < ts_subtree_symbol(left)) result = 1;
+    else if (ts_subtree_child_count(left) < ts_subtree_child_count(right)) result = -1;
+    else if (ts_subtree_child_count(right) < ts_subtree_child_count(left)) result = 1;
+    if (result != 0) {
+      array_clear(&pool->tree_stack);
+      return result;
+    }
+
+    for (uint32_t i = ts_subtree_child_count(left); i > 0; i--) {
+      Subtree left_child = ts_subtree_children(left)[i - 1];
+      Subtree right_child = ts_subtree_children(right)[i - 1];
+      array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left_child));
+      array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right_child));
+    }
+  }
+
+  return 0;
+}
+
+static inline void ts_subtree_set_has_changes(MutableSubtree *self) {
+  if (self->data.is_inline) {
+    self->data.has_changes = true;
+  } else {
+    self->ptr->has_changes = true;
+  }
+}
+
+Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool *pool) {
+  typedef struct {
+    Subtree *tree;
+    Edit edit;
+  } EditEntry;
+
+  Array(EditEntry) stack = array_new();
+  array_push(&stack, ((EditEntry) {
+    .tree = &self,
+    .edit = (Edit) {
+      .start = {input_edit->start_byte, input_edit->start_point},
+      .old_end = {input_edit->old_end_byte, input_edit->old_end_point},
+      .new_end = {input_edit->new_end_byte, input_edit->new_end_point},
+    },
+  }));
+
+  while (stack.size) {
+    EditEntry entry = array_pop(&stack);
+    Edit edit = entry.edit;
+    bool is_noop = edit.old_end.bytes == edit.start.bytes && edit.new_end.bytes == edit.start.bytes;
+    bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes;
+    bool parent_depends_on_column = ts_subtree_depends_on_column(*entry.tree);
+    bool column_shifted = edit.new_end.extent.column != edit.old_end.extent.column;
+
+    Length size = ts_subtree_size(*entry.tree);
+    Length padding = ts_subtree_padding(*entry.tree);
+    Length total_size = length_add(padding, size);
+    uint32_t lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree);
+    uint32_t end_byte = total_size.bytes + lookahead_bytes;
+    if (edit.start.bytes > end_byte || (is_noop && edit.start.bytes == end_byte)) continue;
+
+    // If the edit is entirely within the space before this subtree, then shift this
+    // subtree over according to the edit without changing its size.
+    if (edit.old_end.bytes <= padding.bytes) {
+      padding = length_add(edit.new_end, length_sub(padding, edit.old_end));
+    }
+
+    // If the edit starts in the space before this subtree and extends into this subtree,
+    // shrink the subtree's content to compensate for the change in the space before it.
+    else if (edit.start.bytes < padding.bytes) {
+      size = length_saturating_sub(size, length_sub(edit.old_end, padding));
+      padding = edit.new_end;
+    }
+
+    // If the edit is within this subtree, resize the subtree to reflect the edit.
+    else if (
+      edit.start.bytes < total_size.bytes ||
+      (edit.start.bytes == total_size.bytes && is_pure_insertion)
+    ) {
+      size = length_add(
+        length_sub(edit.new_end, padding),
+        length_saturating_sub(total_size, edit.old_end)
+      );
+    }
+
+    MutableSubtree result = ts_subtree_make_mut(pool, *entry.tree);
+
+    if (result.data.is_inline) {
+      if (ts_subtree_can_inline(padding, size, lookahead_bytes)) {
+        result.data.padding_bytes = padding.bytes;
+        result.data.padding_rows = padding.extent.row;
+        result.data.padding_columns = padding.extent.column;
+        result.data.size_bytes = size.bytes;
+      } else {
+        SubtreeHeapData *data = ts_subtree_pool_allocate(pool);
+        data->ref_count = 1;
+        data->padding = padding;
+        data->size = size;
+        data->lookahead_bytes = lookahead_bytes;
+        data->error_cost = 0;
+        data->child_count = 0;
+        data->symbol = result.data.symbol;
+        data->parse_state = result.data.parse_state;
+        data->visible = result.data.visible;
+        data->named = result.data.named;
+        data->extra = result.data.extra;
+        data->fragile_left = false;
+        data->fragile_right = false;
+        data->has_changes = false;
+        data->has_external_tokens = false;
+        data->depends_on_column = false;
+        data->is_missing = result.data.is_missing;
+        data->is_keyword = result.data.is_keyword;
+        result.ptr = data;
+      }
+    } else {
+      result.ptr->padding = padding;
+      result.ptr->size = size;
+    }
+
+    ts_subtree_set_has_changes(&result);
+    *entry.tree = ts_subtree_from_mut(result);
+
+    Length child_left, child_right = length_zero();
+    for (uint32_t i = 0, n = ts_subtree_child_count(*entry.tree); i < n; i++) {
+      Subtree *child = &ts_subtree_children(*entry.tree)[i];
+      Length child_size = ts_subtree_total_size(*child);
+      child_left = child_right;
+      child_right = length_add(child_left, child_size);
+
+      // If this child ends before the edit, it is not affected.
+      if (child_right.bytes + ts_subtree_lookahead_bytes(*child) < edit.start.bytes) continue;
+
+      // Keep editing child nodes until a node is reached that starts after the edit.
+      // Also, if this node's validity depends on its column position, then continue
+      // invalidating child nodes until reaching a line break.
+      if ((
+        (child_left.bytes > edit.old_end.bytes) ||
+        (child_left.bytes == edit.old_end.bytes && child_size.bytes > 0 && i > 0)
+      ) && (
+        !parent_depends_on_column ||
+        child_left.extent.row > padding.extent.row
+      ) && (
+        !ts_subtree_depends_on_column(*child) ||
+        !column_shifted ||
+        child_left.extent.row > edit.old_end.extent.row
+      )) {
+        break;
+      }
+
+      // Transform edit into the child's coordinate space.
+      Edit child_edit = {
+        .start = length_saturating_sub(edit.start, child_left),
+        .old_end = length_saturating_sub(edit.old_end, child_left),
+        .new_end = length_saturating_sub(edit.new_end, child_left),
+      };
+
+      // Interpret all inserted text as applying to the *first* child that touches the edit.
+      // Subsequent children are only never have any text inserted into them; they are only
+      // shrunk to compensate for the edit.
+      if (
+        child_right.bytes > edit.start.bytes ||
+        (child_right.bytes == edit.start.bytes && is_pure_insertion)
+      ) {
+        edit.new_end = edit.start;
+      }
+
+      // Children that occur before the edit are not reshaped by the edit.
+      else {
+        child_edit.old_end = child_edit.start;
+        child_edit.new_end = child_edit.start;
+      }
+
+      // Queue processing of this child's subtree.
+      array_push(&stack, ((EditEntry) {
+        .tree = child,
+        .edit = child_edit,
+      }));
+    }
+  }
+
+  array_delete(&stack);
+  return self;
+}
+
+Subtree ts_subtree_last_external_token(Subtree tree) {
+  if (!ts_subtree_has_external_tokens(tree)) return NULL_SUBTREE;
+  while (tree.ptr->child_count > 0) {
+    for (uint32_t i = tree.ptr->child_count - 1; i + 1 > 0; i--) {
+      Subtree child = ts_subtree_children(tree)[i];
+      if (ts_subtree_has_external_tokens(child)) {
+        tree = child;
+        break;
+      }
+    }
+  }
+  return tree;
+}
+
+static size_t ts_subtree__write_char_to_string(char *str, size_t n, int32_t chr) {
+  if (chr == -1)
+    return snprintf(str, n, "INVALID");
+  else if (chr == '\0')
+    return snprintf(str, n, "'\\0'");
+  else if (chr == '\n')
+    return snprintf(str, n, "'\\n'");
+  else if (chr == '\t')
+    return snprintf(str, n, "'\\t'");
+  else if (chr == '\r')
+    return snprintf(str, n, "'\\r'");
+  else if (0 < chr && chr < 128 && isprint(chr))
+    return snprintf(str, n, "'%c'", chr);
+  else
+    return snprintf(str, n, "%d", chr);
+}
+
+static const char *const ROOT_FIELD = "__ROOT__";
+
+static size_t ts_subtree__write_to_string(
+  Subtree self, char *string, size_t limit,
+  const TSLanguage *language, bool include_all,
+  TSSymbol alias_symbol, bool alias_is_named, const char *field_name
+) {
+  if (!self.ptr) return snprintf(string, limit, "(NULL)");
+
+  char *cursor = string;
+  char **writer = (limit > 1) ? &cursor : &string;
+  bool is_root = field_name == ROOT_FIELD;
+  bool is_visible =
+    include_all ||
+    ts_subtree_missing(self) ||
+    (
+      alias_symbol
+        ? alias_is_named
+        : ts_subtree_visible(self) && ts_subtree_named(self)
+    );
+
+  if (is_visible) {
+    if (!is_root) {
+      cursor += snprintf(*writer, limit, " ");
+      if (field_name) {
+        cursor += snprintf(*writer, limit, "%s: ", field_name);
+      }
+    }
+
+    if (ts_subtree_is_error(self) && ts_subtree_child_count(self) == 0 && self.ptr->size.bytes > 0) {
+      cursor += snprintf(*writer, limit, "(UNEXPECTED ");
+      cursor += ts_subtree__write_char_to_string(*writer, limit, self.ptr->lookahead_char);
+    } else {
+      TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
+      const char *symbol_name = ts_language_symbol_name(language, symbol);
+      if (ts_subtree_missing(self)) {
+        cursor += snprintf(*writer, limit, "(MISSING ");
+        if (alias_is_named || ts_subtree_named(self)) {
+          cursor += snprintf(*writer, limit, "%s", symbol_name);
+        } else {
+          cursor += snprintf(*writer, limit, "\"%s\"", symbol_name);
+        }
+      } else {
+        cursor += snprintf(*writer, limit, "(%s", symbol_name);
+      }
+    }
+  } else if (is_root) {
+    TSSymbol symbol = alias_symbol ? alias_symbol : ts_subtree_symbol(self);
+    const char *symbol_name = ts_language_symbol_name(language, symbol);
+    if (ts_subtree_child_count(self) > 0) {
+      cursor += snprintf(*writer, limit, "(%s", symbol_name);
+    } else if (ts_subtree_named(self)) {
+      cursor += snprintf(*writer, limit, "(%s)", symbol_name);
+    } else {
+      cursor += snprintf(*writer, limit, "(\"%s\")", symbol_name);
+    }
+  }
+
+  if (ts_subtree_child_count(self)) {
+    const TSSymbol *alias_sequence = ts_language_alias_sequence(language, self.ptr->production_id);
+    const TSFieldMapEntry *field_map, *field_map_end;
+    ts_language_field_map(
+      language,
+      self.ptr->production_id,
+      &field_map,
+      &field_map_end
+    );
+
+    uint32_t structural_child_index = 0;
+    for (uint32_t i = 0; i < self.ptr->child_count; i++) {
+      Subtree child = ts_subtree_children(self)[i];
+      if (ts_subtree_extra(child)) {
+        cursor += ts_subtree__write_to_string(
+          child, *writer, limit,
+          language, include_all,
+          0, false, NULL
+        );
+      } else {
+        TSSymbol subtree_alias_symbol = alias_sequence
+          ? alias_sequence[structural_child_index]
+          : 0;
+        bool subtree_alias_is_named = subtree_alias_symbol
+          ? ts_language_symbol_metadata(language, subtree_alias_symbol).named
+          : false;
+
+        const char *child_field_name = is_visible ? NULL : field_name;
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+          if (!map->inherited && map->child_index == structural_child_index) {
+            child_field_name = language->field_names[map->field_id];
+            break;
+          }
+        }
+
+        cursor += ts_subtree__write_to_string(
+          child, *writer, limit,
+          language, include_all,
+          subtree_alias_symbol, subtree_alias_is_named, child_field_name
+        );
+        structural_child_index++;
+      }
+    }
+  }
+
+  if (is_visible) cursor += snprintf(*writer, limit, ")");
+
+  return cursor - string;
+}
+
+char *ts_subtree_string(
+  Subtree self,
+  TSSymbol alias_symbol,
+  bool alias_is_named,
+  const TSLanguage *language,
+  bool include_all
+) {
+  char scratch_string[1];
+  size_t size = ts_subtree__write_to_string(
+    self, scratch_string, 1,
+    language, include_all,
+    alias_symbol, alias_is_named, ROOT_FIELD
+  ) + 1;
+  char *result = ts_malloc(size * sizeof(char));
+  ts_subtree__write_to_string(
+    self, result, size,
+    language, include_all,
+    alias_symbol, alias_is_named, ROOT_FIELD
+  );
+  return result;
+}
+
+void ts_subtree__print_dot_graph(const Subtree *self, uint32_t start_offset,
+                                 const TSLanguage *language, TSSymbol alias_symbol,
+                                 FILE *f) {
+  TSSymbol subtree_symbol = ts_subtree_symbol(*self);
+  TSSymbol symbol = alias_symbol ? alias_symbol : subtree_symbol;
+  uint32_t end_offset = start_offset + ts_subtree_total_bytes(*self);
+  fprintf(f, "tree_%p [label=\"", (void *)self);
+  ts_language_write_symbol_as_dot_string(language, f, symbol);
+  fprintf(f, "\"");
+
+  if (ts_subtree_child_count(*self) == 0) fprintf(f, ", shape=plaintext");
+  if (ts_subtree_extra(*self)) fprintf(f, ", fontcolor=gray");
+  if (ts_subtree_has_changes(*self)) fprintf(f, ", color=green, penwidth=2");
+
+  fprintf(f, ", tooltip=\""
+    "range: %u - %u\n"
+    "state: %d\n"
+    "error-cost: %u\n"
+    "has-changes: %u\n"
+    "depends-on-column: %u\n"
+    "descendant-count: %u\n"
+    "repeat-depth: %u\n"
+    "lookahead-bytes: %u",
+    start_offset, end_offset,
+    ts_subtree_parse_state(*self),
+    ts_subtree_error_cost(*self),
+    ts_subtree_has_changes(*self),
+    ts_subtree_depends_on_column(*self),
+    ts_subtree_visible_descendant_count(*self),
+    ts_subtree_repeat_depth(*self),
+    ts_subtree_lookahead_bytes(*self)
+  );
+
+  if (ts_subtree_is_error(*self) && ts_subtree_child_count(*self) == 0 && self->ptr->lookahead_char != 0) {
+    fprintf(f, "\ncharacter: '%c'", self->ptr->lookahead_char);
+  }
+
+  fprintf(f, "\"]\n");
+
+  uint32_t child_start_offset = start_offset;
+  uint32_t child_info_offset =
+    language->max_alias_sequence_length *
+    ts_subtree_production_id(*self);
+  for (uint32_t i = 0, n = ts_subtree_child_count(*self); i < n; i++) {
+    const Subtree *child = &ts_subtree_children(*self)[i];
+    TSSymbol subtree_alias_symbol = 0;
+    if (!ts_subtree_extra(*child) && child_info_offset) {
+      subtree_alias_symbol = language->alias_sequences[child_info_offset];
+      child_info_offset++;
+    }
+    ts_subtree__print_dot_graph(child, child_start_offset, language, subtree_alias_symbol, f);
+    fprintf(f, "tree_%p -> tree_%p [tooltip=%u]\n", (void *)self, (void *)child, i);
+    child_start_offset += ts_subtree_total_bytes(*child);
+  }
+}
+
+void ts_subtree_print_dot_graph(Subtree self, const TSLanguage *language, FILE *f) {
+  fprintf(f, "digraph tree {\n");
+  fprintf(f, "edge [arrowhead=none]\n");
+  ts_subtree__print_dot_graph(&self, 0, language, 0, f);
+  fprintf(f, "}\n");
+}
+
+const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self) {
+  static const ExternalScannerState empty_state = {{.short_data = {0}}, .length = 0};
+  if (
+    self.ptr &&
+    !self.data.is_inline &&
+    self.ptr->has_external_tokens &&
+    self.ptr->child_count == 0
+  ) {
+    return &self.ptr->external_scanner_state;
+  } else {
+    return &empty_state;
+  }
+}
+
+bool ts_subtree_external_scanner_state_eq(Subtree self, Subtree other) {
+  const ExternalScannerState *state_self = ts_subtree_external_scanner_state(self);
+  const ExternalScannerState *state_other = ts_subtree_external_scanner_state(other);
+  return ts_external_scanner_state_eq(
+    state_self,
+    ts_external_scanner_state_data(state_other),
+    state_other->length
+  );
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/subtree.h b/src/library/ts/src/tree-sitter/lib/src/subtree.h
new file mode 100644
index 0000000000..9f6f718fd4
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/subtree.h
@@ -0,0 +1,400 @@
+#ifndef TREE_SITTER_SUBTREE_H_
+#define TREE_SITTER_SUBTREE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include "./length.h"
+#include "./array.h"
+#include "./error_costs.h"
+#include "./host.h"
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+#define TS_TREE_STATE_NONE USHRT_MAX
+#define NULL_SUBTREE ((Subtree) {.ptr = NULL})
+
+// The serialized state of an external scanner.
+//
+// Every time an external token subtree is created after a call to an
+// external scanner, the scanner's `serialize` function is called to
+// retrieve a serialized copy of its state. The bytes are then copied
+// onto the subtree itself so that the scanner's state can later be
+// restored using its `deserialize` function.
+//
+// Small byte arrays are stored inline, and long ones are allocated
+// separately on the heap.
+typedef struct {
+  union {
+    char *long_data;
+    char short_data[24];
+  };
+  uint32_t length;
+} ExternalScannerState;
+
+// A compact representation of a subtree.
+//
+// This representation is used for small leaf nodes that are not
+// errors, and were not created by an external scanner.
+//
+// The idea behind the layout of this struct is that the `is_inline`
+// bit will fall exactly into the same location as the least significant
+// bit of the pointer in `Subtree` or `MutableSubtree`, respectively.
+// Because of alignment, for any valid pointer this will be 0, giving
+// us the opportunity to make use of this bit to signify whether to use
+// the pointer or the inline struct.
+typedef struct SubtreeInlineData SubtreeInlineData;
+
+#define SUBTREE_BITS    \
+  bool visible : 1;     \
+  bool named : 1;       \
+  bool extra : 1;       \
+  bool has_changes : 1; \
+  bool is_missing : 1;  \
+  bool is_keyword : 1;
+
+#define SUBTREE_SIZE           \
+  uint8_t padding_columns;     \
+  uint8_t padding_rows : 4;    \
+  uint8_t lookahead_bytes : 4; \
+  uint8_t padding_bytes;       \
+  uint8_t size_bytes;
+
+#if TS_BIG_ENDIAN
+#if TS_PTR_SIZE == 32
+
+struct SubtreeInlineData {
+  uint16_t parse_state;
+  uint8_t symbol;
+  SUBTREE_BITS
+  bool unused : 1;
+  bool is_inline : 1;
+  SUBTREE_SIZE
+};
+
+#else
+
+struct SubtreeInlineData {
+  SUBTREE_SIZE
+  uint16_t parse_state;
+  uint8_t symbol;
+  SUBTREE_BITS
+  bool unused : 1;
+  bool is_inline : 1;
+};
+
+#endif
+#else
+
+struct SubtreeInlineData {
+  bool is_inline : 1;
+  SUBTREE_BITS
+  uint8_t symbol;
+  uint16_t parse_state;
+  SUBTREE_SIZE
+};
+
+#endif
+
+#undef SUBTREE_BITS
+#undef SUBTREE_SIZE
+
+// A heap-allocated representation of a subtree.
+//
+// This representation is used for parent nodes, external tokens,
+// errors, and other leaf nodes whose data is too large to fit into
+// the inline representation.
+typedef struct {
+  volatile uint32_t ref_count;
+  Length padding;
+  Length size;
+  uint32_t lookahead_bytes;
+  uint32_t error_cost;
+  uint32_t child_count;
+  TSSymbol symbol;
+  TSStateId parse_state;
+
+  bool visible : 1;
+  bool named : 1;
+  bool extra : 1;
+  bool fragile_left : 1;
+  bool fragile_right : 1;
+  bool has_changes : 1;
+  bool has_external_tokens : 1;
+  bool has_external_scanner_state_change : 1;
+  bool depends_on_column: 1;
+  bool is_missing : 1;
+  bool is_keyword : 1;
+
+  union {
+    // Non-terminal subtrees (`child_count > 0`)
+    struct {
+      uint32_t visible_child_count;
+      uint32_t named_child_count;
+      uint32_t visible_descendant_count;
+      int32_t dynamic_precedence;
+      uint16_t repeat_depth;
+      uint16_t production_id;
+      struct {
+        TSSymbol symbol;
+        TSStateId parse_state;
+      } first_leaf;
+    };
+
+    // External terminal subtrees (`child_count == 0 && has_external_tokens`)
+    ExternalScannerState external_scanner_state;
+
+    // Error terminal subtrees (`child_count == 0 && symbol == ts_builtin_sym_error`)
+    int32_t lookahead_char;
+  };
+} SubtreeHeapData;
+
+// The fundamental building block of a syntax tree.
+typedef union {
+  SubtreeInlineData data;
+  const SubtreeHeapData *ptr;
+} Subtree;
+
+// Like Subtree, but mutable.
+typedef union {
+  SubtreeInlineData data;
+  SubtreeHeapData *ptr;
+} MutableSubtree;
+
+typedef Array(Subtree) SubtreeArray;
+typedef Array(MutableSubtree) MutableSubtreeArray;
+
+typedef struct {
+  MutableSubtreeArray free_trees;
+  MutableSubtreeArray tree_stack;
+} SubtreePool;
+
+void ts_external_scanner_state_init(ExternalScannerState *self, const char *data, unsigned length);
+const char *ts_external_scanner_state_data(const ExternalScannerState *self);
+bool ts_external_scanner_state_eq(const ExternalScannerState *self, const char *buffer, unsigned length);
+void ts_external_scanner_state_delete(ExternalScannerState *self);
+
+void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest);
+void ts_subtree_array_clear(SubtreePool *pool, SubtreeArray *self);
+void ts_subtree_array_delete(SubtreePool *pool, SubtreeArray *self);
+void ts_subtree_array_remove_trailing_extras(SubtreeArray *self, SubtreeArray *destination);
+void ts_subtree_array_reverse(SubtreeArray *self);
+
+SubtreePool ts_subtree_pool_new(uint32_t capacity);
+void ts_subtree_pool_delete(SubtreePool *self);
+
+Subtree ts_subtree_new_leaf(
+  SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
+  uint32_t lookahead_bytes, TSStateId parse_state,
+  bool has_external_tokens, bool depends_on_column,
+  bool is_keyword, const TSLanguage *language
+);
+Subtree ts_subtree_new_error(
+  SubtreePool *pool, int32_t lookahead_char, Length padding, Length size,
+  uint32_t bytes_scanned, TSStateId parse_state, const TSLanguage *language
+);
+MutableSubtree ts_subtree_new_node(
+  TSSymbol symbol,
+  SubtreeArray *chiildren,
+  unsigned production_id,
+  const TSLanguage *language
+);
+Subtree ts_subtree_new_error_node(
+  SubtreeArray *children,
+  bool extra,
+  const TSLanguage * language
+);
+Subtree ts_subtree_new_missing_leaf(
+  SubtreePool *pool,
+  TSSymbol symbol,
+  Length padding,
+  uint32_t lookahead_bytes,
+  const TSLanguage *language,
+  TSStateId state
+);
+MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self);
+void ts_subtree_retain(Subtree self);
+void ts_subtree_release(SubtreePool *pool, Subtree self);
+int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool);
+void ts_subtree_set_symbol(MutableSubtree *self, TSSymbol symbol, const TSLanguage *language);
+void ts_subtree_compress(MutableSubtree self, unsigned count, const TSLanguage *language, MutableSubtreeArray *stack);
+void ts_subtree_summarize_children(MutableSubtree self, const TSLanguage *language);
+Subtree ts_subtree_edit(Subtree self, const TSInputEdit *edit, SubtreePool *pool);
+char *ts_subtree_string(Subtree self, TSSymbol alias_symbol, bool alias_is_named, const TSLanguage *language, bool include_all);
+void ts_subtree_print_dot_graph(Subtree self, const TSLanguage *language, FILE *f);
+Subtree ts_subtree_last_external_token(Subtree tree);
+const ExternalScannerState *ts_subtree_external_scanner_state(Subtree self);
+bool ts_subtree_external_scanner_state_eq(Subtree self, Subtree other);
+
+#define SUBTREE_GET(self, name) ((self).data.is_inline ? (self).data.name : (self).ptr->name)
+
+static inline TSSymbol ts_subtree_symbol(Subtree self) { return SUBTREE_GET(self, symbol); }
+static inline bool ts_subtree_visible(Subtree self) { return SUBTREE_GET(self, visible); }
+static inline bool ts_subtree_named(Subtree self) { return SUBTREE_GET(self, named); }
+static inline bool ts_subtree_extra(Subtree self) { return SUBTREE_GET(self, extra); }
+static inline bool ts_subtree_has_changes(Subtree self) { return SUBTREE_GET(self, has_changes); }
+static inline bool ts_subtree_missing(Subtree self) { return SUBTREE_GET(self, is_missing); }
+static inline bool ts_subtree_is_keyword(Subtree self) { return SUBTREE_GET(self, is_keyword); }
+static inline TSStateId ts_subtree_parse_state(Subtree self) { return SUBTREE_GET(self, parse_state); }
+static inline uint32_t ts_subtree_lookahead_bytes(Subtree self) { return SUBTREE_GET(self, lookahead_bytes); }
+
+#undef SUBTREE_GET
+
+// Get the size needed to store a heap-allocated subtree with the given
+// number of children.
+static inline size_t ts_subtree_alloc_size(uint32_t child_count) {
+  return child_count * sizeof(Subtree) + sizeof(SubtreeHeapData);
+}
+
+// Get a subtree's children, which are allocated immediately before the
+// tree's own heap data.
+#define ts_subtree_children(self) \
+  ((self).data.is_inline ? NULL : (Subtree *)((self).ptr) - (self).ptr->child_count)
+
+static inline void ts_subtree_set_extra(MutableSubtree *self, bool is_extra) {
+  if (self->data.is_inline) {
+    self->data.extra = is_extra;
+  } else {
+    self->ptr->extra = is_extra;
+  }
+}
+
+static inline TSSymbol ts_subtree_leaf_symbol(Subtree self) {
+  if (self.data.is_inline) return self.data.symbol;
+  if (self.ptr->child_count == 0) return self.ptr->symbol;
+  return self.ptr->first_leaf.symbol;
+}
+
+static inline TSStateId ts_subtree_leaf_parse_state(Subtree self) {
+  if (self.data.is_inline) return self.data.parse_state;
+  if (self.ptr->child_count == 0) return self.ptr->parse_state;
+  return self.ptr->first_leaf.parse_state;
+}
+
+static inline Length ts_subtree_padding(Subtree self) {
+  if (self.data.is_inline) {
+    Length result = {self.data.padding_bytes, {self.data.padding_rows, self.data.padding_columns}};
+    return result;
+  } else {
+    return self.ptr->padding;
+  }
+}
+
+static inline Length ts_subtree_size(Subtree self) {
+  if (self.data.is_inline) {
+    Length result = {self.data.size_bytes, {0, self.data.size_bytes}};
+    return result;
+  } else {
+    return self.ptr->size;
+  }
+}
+
+static inline Length ts_subtree_total_size(Subtree self) {
+  return length_add(ts_subtree_padding(self), ts_subtree_size(self));
+}
+
+static inline uint32_t ts_subtree_total_bytes(Subtree self) {
+  return ts_subtree_total_size(self).bytes;
+}
+
+static inline uint32_t ts_subtree_child_count(Subtree self) {
+  return self.data.is_inline ? 0 : self.ptr->child_count;
+}
+
+static inline uint32_t ts_subtree_repeat_depth(Subtree self) {
+  return self.data.is_inline ? 0 : self.ptr->repeat_depth;
+}
+
+static inline uint32_t ts_subtree_is_repetition(Subtree self) {
+  return self.data.is_inline
+    ? 0
+    : !self.ptr->named && !self.ptr->visible && self.ptr->child_count != 0;
+}
+
+static inline uint32_t ts_subtree_visible_descendant_count(Subtree self) {
+  return (self.data.is_inline || self.ptr->child_count == 0)
+    ? 0
+    : self.ptr->visible_descendant_count;
+}
+
+static inline uint32_t ts_subtree_visible_child_count(Subtree self) {
+  if (ts_subtree_child_count(self) > 0) {
+    return self.ptr->visible_child_count;
+  } else {
+    return 0;
+  }
+}
+
+static inline uint32_t ts_subtree_error_cost(Subtree self) {
+  if (ts_subtree_missing(self)) {
+    return ERROR_COST_PER_MISSING_TREE + ERROR_COST_PER_RECOVERY;
+  } else {
+    return self.data.is_inline ? 0 : self.ptr->error_cost;
+  }
+}
+
+static inline int32_t ts_subtree_dynamic_precedence(Subtree self) {
+  return (self.data.is_inline || self.ptr->child_count == 0) ? 0 : self.ptr->dynamic_precedence;
+}
+
+static inline uint16_t ts_subtree_production_id(Subtree self) {
+  if (ts_subtree_child_count(self) > 0) {
+    return self.ptr->production_id;
+  } else {
+    return 0;
+  }
+}
+
+static inline bool ts_subtree_fragile_left(Subtree self) {
+  return self.data.is_inline ? false : self.ptr->fragile_left;
+}
+
+static inline bool ts_subtree_fragile_right(Subtree self) {
+  return self.data.is_inline ? false : self.ptr->fragile_right;
+}
+
+static inline bool ts_subtree_has_external_tokens(Subtree self) {
+  return self.data.is_inline ? false : self.ptr->has_external_tokens;
+}
+
+static inline bool ts_subtree_has_external_scanner_state_change(Subtree self) {
+  return self.data.is_inline ? false : self.ptr->has_external_scanner_state_change;
+}
+
+static inline bool ts_subtree_depends_on_column(Subtree self) {
+  return self.data.is_inline ? false : self.ptr->depends_on_column;
+}
+
+static inline bool ts_subtree_is_fragile(Subtree self) {
+  return self.data.is_inline ? false : (self.ptr->fragile_left || self.ptr->fragile_right);
+}
+
+static inline bool ts_subtree_is_error(Subtree self) {
+  return ts_subtree_symbol(self) == ts_builtin_sym_error;
+}
+
+static inline bool ts_subtree_is_eof(Subtree self) {
+  return ts_subtree_symbol(self) == ts_builtin_sym_end;
+}
+
+static inline Subtree ts_subtree_from_mut(MutableSubtree self) {
+  Subtree result;
+  result.data = self.data;
+  return result;
+}
+
+static inline MutableSubtree ts_subtree_to_mut_unsafe(Subtree self) {
+  MutableSubtree result;
+  result.data = self.data;
+  return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_SUBTREE_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/tree.c b/src/library/ts/src/tree-sitter/lib/src/tree.c
new file mode 100644
index 0000000000..6747fd6d06
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/tree.c
@@ -0,0 +1,140 @@
+#include "tree_sitter/api.h"
+#include "./array.h"
+#include "./get_changed_ranges.h"
+#include "./length.h"
+#include "./subtree.h"
+#include "./tree_cursor.h"
+#include "./tree.h"
+
+TSTree *ts_tree_new(
+  Subtree root, const TSLanguage *language,
+  const TSRange *included_ranges, unsigned included_range_count
+) {
+  TSTree *result = ts_malloc(sizeof(TSTree));
+  result->root = root;
+  result->language = ts_language_copy(language);
+  result->included_ranges = ts_calloc(included_range_count, sizeof(TSRange));
+  memcpy(result->included_ranges, included_ranges, included_range_count * sizeof(TSRange));
+  result->included_range_count = included_range_count;
+  return result;
+}
+
+TSTree *ts_tree_copy(const TSTree *self) {
+  ts_subtree_retain(self->root);
+  return ts_tree_new(self->root, self->language, self->included_ranges, self->included_range_count);
+}
+
+void ts_tree_delete(TSTree *self) {
+  if (!self) return;
+
+  SubtreePool pool = ts_subtree_pool_new(0);
+  ts_subtree_release(&pool, self->root);
+  ts_subtree_pool_delete(&pool);
+  ts_language_delete(self->language);
+  ts_free(self->included_ranges);
+  ts_free(self);
+}
+
+TSNode ts_tree_root_node(const TSTree *self) {
+  return ts_node_new(self, &self->root, ts_subtree_padding(self->root), 0);
+}
+
+TSNode ts_tree_root_node_with_offset(
+  const TSTree *self,
+  uint32_t offset_bytes,
+  TSPoint offset_extent
+) {
+  Length offset = {offset_bytes, offset_extent};
+  return ts_node_new(self, &self->root, length_add(offset, ts_subtree_padding(self->root)), 0);
+}
+
+const TSLanguage *ts_tree_language(const TSTree *self) {
+  return self->language;
+}
+
+void ts_tree_edit(TSTree *self, const TSInputEdit *edit) {
+  for (unsigned i = 0; i < self->included_range_count; i++) {
+    ts_range_edit(&self->included_ranges[i], edit);
+  }
+
+  SubtreePool pool = ts_subtree_pool_new(0);
+  self->root = ts_subtree_edit(self->root, edit, &pool);
+  ts_subtree_pool_delete(&pool);
+}
+
+TSRange *ts_tree_included_ranges(const TSTree *self, uint32_t *length) {
+  *length = self->included_range_count;
+  TSRange *ranges = ts_calloc(self->included_range_count, sizeof(TSRange));
+  memcpy(ranges, self->included_ranges, self->included_range_count * sizeof(TSRange));
+  return ranges;
+}
+
+TSRange *ts_tree_get_changed_ranges(const TSTree *old_tree, const TSTree *new_tree, uint32_t *length) {
+  TreeCursor cursor1 = {NULL, array_new(), 0};
+  TreeCursor cursor2 = {NULL, array_new(), 0};
+  ts_tree_cursor_init(&cursor1, ts_tree_root_node(old_tree));
+  ts_tree_cursor_init(&cursor2, ts_tree_root_node(new_tree));
+
+  TSRangeArray included_range_differences = array_new();
+  ts_range_array_get_changed_ranges(
+    old_tree->included_ranges, old_tree->included_range_count,
+    new_tree->included_ranges, new_tree->included_range_count,
+    &included_range_differences
+  );
+
+  TSRange *result;
+  *length = ts_subtree_get_changed_ranges(
+    &old_tree->root, &new_tree->root, &cursor1, &cursor2,
+    old_tree->language, &included_range_differences, &result
+  );
+
+  array_delete(&included_range_differences);
+  array_delete(&cursor1.stack);
+  array_delete(&cursor2.stack);
+  return result;
+}
+
+#ifdef _WIN32
+
+#include <io.h>
+#include <windows.h>
+
+int _ts_dup(HANDLE handle) {
+  HANDLE dup_handle;
+  if (!DuplicateHandle(
+    GetCurrentProcess(), handle,
+    GetCurrentProcess(), &dup_handle,
+    0, FALSE, DUPLICATE_SAME_ACCESS
+  )) return -1;
+
+  return _open_osfhandle((intptr_t)dup_handle, 0);
+}
+
+void ts_tree_print_dot_graph(const TSTree *self, int fd) {
+  FILE *file = _fdopen(_ts_dup((HANDLE)_get_osfhandle(fd)), "a");
+  ts_subtree_print_dot_graph(self->root, self->language, file);
+  fclose(file);
+}
+
+#elif !defined(__wasm__) // Wasm doesn't support dup
+
+#include <unistd.h>
+
+int _ts_dup(int file_descriptor) {
+  return dup(file_descriptor);
+}
+
+void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor) {
+  FILE *file = fdopen(_ts_dup(file_descriptor), "a");
+  ts_subtree_print_dot_graph(self->root, self->language, file);
+  fclose(file);
+}
+
+#else
+
+void ts_tree_print_dot_graph(const TSTree *self, int file_descriptor) {
+  (void)self;
+  (void)file_descriptor;
+}
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/tree.h b/src/library/ts/src/tree-sitter/lib/src/tree.h
new file mode 100644
index 0000000000..9328f55a5b
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/tree.h
@@ -0,0 +1,31 @@
+#ifndef TREE_SITTER_TREE_H_
+#define TREE_SITTER_TREE_H_
+
+#include "./subtree.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  const Subtree *child;
+  const Subtree *parent;
+  Length position;
+  TSSymbol alias_symbol;
+} ParentCacheEntry;
+
+struct TSTree {
+  Subtree root;
+  const TSLanguage *language;
+  TSRange *included_ranges;
+  unsigned included_range_count;
+};
+
+TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *included_ranges, unsigned included_range_count);
+TSNode ts_node_new(const TSTree *tree, const Subtree *subtree, Length position, TSSymbol alias);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_TREE_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/tree_cursor.c b/src/library/ts/src/tree-sitter/lib/src/tree_cursor.c
new file mode 100644
index 0000000000..70ef5e39aa
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/tree_cursor.c
@@ -0,0 +1,716 @@
+#include "tree_sitter/api.h"
+#include "./tree_cursor.h"
+#include "./language.h"
+#include "./tree.h"
+
+typedef struct {
+  Subtree parent;
+  const TSTree *tree;
+  Length position;
+  uint32_t child_index;
+  uint32_t structural_child_index;
+  uint32_t descendant_index;
+  const TSSymbol *alias_sequence;
+} CursorChildIterator;
+
+// CursorChildIterator
+
+static inline bool ts_tree_cursor_is_entry_visible(const TreeCursor *self, uint32_t index) {
+  TreeCursorEntry *entry = array_get(&self->stack, index);
+  if (index == 0 || ts_subtree_visible(*entry->subtree)) {
+    return true;
+  } else if (!ts_subtree_extra(*entry->subtree)) {
+    TreeCursorEntry *parent_entry = array_get(&self->stack, index - 1);
+    return ts_language_alias_at(
+      self->tree->language,
+      parent_entry->subtree->ptr->production_id,
+      entry->structural_child_index
+    );
+  } else {
+    return false;
+  }
+}
+
+static inline CursorChildIterator ts_tree_cursor_iterate_children(const TreeCursor *self) {
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  if (ts_subtree_child_count(*last_entry->subtree) == 0) {
+    return (CursorChildIterator) {NULL_SUBTREE, self->tree, length_zero(), 0, 0, 0, NULL};
+  }
+  const TSSymbol *alias_sequence = ts_language_alias_sequence(
+    self->tree->language,
+    last_entry->subtree->ptr->production_id
+  );
+
+  uint32_t descendant_index = last_entry->descendant_index;
+  if (ts_tree_cursor_is_entry_visible(self, self->stack.size - 1)) {
+    descendant_index += 1;
+  }
+
+  return (CursorChildIterator) {
+    .tree = self->tree,
+    .parent = *last_entry->subtree,
+    .position = last_entry->position,
+    .child_index = 0,
+    .structural_child_index = 0,
+    .descendant_index = descendant_index,
+    .alias_sequence = alias_sequence,
+  };
+}
+
+static inline bool ts_tree_cursor_child_iterator_next(
+  CursorChildIterator *self,
+  TreeCursorEntry *result,
+  bool *visible
+) {
+  if (!self->parent.ptr || self->child_index == self->parent.ptr->child_count) return false;
+  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
+  *result = (TreeCursorEntry) {
+    .subtree = child,
+    .position = self->position,
+    .child_index = self->child_index,
+    .structural_child_index = self->structural_child_index,
+    .descendant_index = self->descendant_index,
+  };
+  *visible = ts_subtree_visible(*child);
+  bool extra = ts_subtree_extra(*child);
+  if (!extra) {
+    if (self->alias_sequence) {
+      *visible |= self->alias_sequence[self->structural_child_index];
+    }
+    self->structural_child_index++;
+  }
+
+  self->descendant_index += ts_subtree_visible_descendant_count(*child);
+  if (*visible) {
+    self->descendant_index += 1;
+  }
+
+  self->position = length_add(self->position, ts_subtree_size(*child));
+  self->child_index++;
+
+  if (self->child_index < self->parent.ptr->child_count) {
+    Subtree next_child = ts_subtree_children(self->parent)[self->child_index];
+    self->position = length_add(self->position, ts_subtree_padding(next_child));
+  }
+
+  return true;
+}
+
+// Return a position that, when `b` is added to it, yields `a`. This
+// can only be computed if `b` has zero rows. Otherwise, this function
+// returns `LENGTH_UNDEFINED`, and the caller needs to recompute
+// the position some other way.
+static inline Length length_backtrack(Length a, Length b) {
+  if (length_is_undefined(a) || b.extent.row != 0) {
+    return LENGTH_UNDEFINED;
+  }
+
+  Length result;
+  result.bytes = a.bytes - b.bytes;
+  result.extent.row = a.extent.row;
+  result.extent.column = a.extent.column - b.extent.column;
+  return result;
+}
+
+static inline bool ts_tree_cursor_child_iterator_previous(
+  CursorChildIterator *self,
+  TreeCursorEntry *result,
+  bool *visible
+) {
+  // this is mostly a reverse `ts_tree_cursor_child_iterator_next` taking into
+  // account unsigned underflow
+  if (!self->parent.ptr || (int8_t)self->child_index == -1) return false;
+  const Subtree *child = &ts_subtree_children(self->parent)[self->child_index];
+  *result = (TreeCursorEntry) {
+    .subtree = child,
+    .position = self->position,
+    .child_index = self->child_index,
+    .structural_child_index = self->structural_child_index,
+  };
+  *visible = ts_subtree_visible(*child);
+  bool extra = ts_subtree_extra(*child);
+
+  self->position = length_backtrack(self->position, ts_subtree_padding(*child));
+  self->child_index--;
+
+  if (!extra && self->alias_sequence) {
+    *visible |= self->alias_sequence[self->structural_child_index];
+    if (self->structural_child_index > 0) {
+      self->structural_child_index--;
+    }
+  }
+
+  // unsigned can underflow so compare it to child_count
+  if (self->child_index < self->parent.ptr->child_count) {
+    Subtree previous_child = ts_subtree_children(self->parent)[self->child_index];
+    Length size = ts_subtree_size(previous_child);
+    self->position = length_backtrack(self->position, size);
+  }
+
+  return true;
+}
+
+// TSTreeCursor - lifecycle
+
+TSTreeCursor ts_tree_cursor_new(TSNode node) {
+  TSTreeCursor self = {NULL, NULL, {0, 0, 0}};
+  ts_tree_cursor_init((TreeCursor *)&self, node);
+  return self;
+}
+
+void ts_tree_cursor_reset(TSTreeCursor *_self, TSNode node) {
+  ts_tree_cursor_init((TreeCursor *)_self, node);
+}
+
+void ts_tree_cursor_init(TreeCursor *self, TSNode node) {
+  self->tree = node.tree;
+  self->root_alias_symbol = node.context[3];
+  array_clear(&self->stack);
+  array_push(&self->stack, ((TreeCursorEntry) {
+    .subtree = (const Subtree *)node.id,
+    .position = {
+      ts_node_start_byte(node),
+      ts_node_start_point(node)
+    },
+    .child_index = 0,
+    .structural_child_index = 0,
+    .descendant_index = 0,
+  }));
+}
+
+void ts_tree_cursor_delete(TSTreeCursor *_self) {
+  TreeCursor *self = (TreeCursor *)_self;
+  array_delete(&self->stack);
+}
+
+// TSTreeCursor - walking the tree
+
+TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *_self) {
+  TreeCursor *self = (TreeCursor *)_self;
+  bool visible;
+  TreeCursorEntry entry;
+  CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+  while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+    if (visible) {
+      array_push(&self->stack, entry);
+      return TreeCursorStepVisible;
+    }
+    if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
+      array_push(&self->stack, entry);
+      return TreeCursorStepHidden;
+    }
+  }
+  return TreeCursorStepNone;
+}
+
+bool ts_tree_cursor_goto_first_child(TSTreeCursor *self) {
+  for (;;) {
+    switch (ts_tree_cursor_goto_first_child_internal(self)) {
+      case TreeCursorStepHidden:
+        continue;
+      case TreeCursorStepVisible:
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+
+TreeCursorStep ts_tree_cursor_goto_last_child_internal(TSTreeCursor *_self) {
+  TreeCursor *self = (TreeCursor *)_self;
+  bool visible;
+  TreeCursorEntry entry;
+  CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+  if (!iterator.parent.ptr || iterator.parent.ptr->child_count == 0) return TreeCursorStepNone;
+
+  TreeCursorEntry last_entry = {0};
+  TreeCursorStep last_step = TreeCursorStepNone;
+  while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+    if (visible) {
+      last_entry = entry;
+      last_step = TreeCursorStepVisible;
+    }
+    else if (ts_subtree_visible_child_count(*entry.subtree) > 0) {
+      last_entry = entry;
+      last_step = TreeCursorStepHidden;
+    }
+  }
+  if (last_entry.subtree) {
+    array_push(&self->stack, last_entry);
+    return last_step;
+  }
+
+  return TreeCursorStepNone;
+}
+
+bool ts_tree_cursor_goto_last_child(TSTreeCursor *self) {
+  for (;;) {
+    switch (ts_tree_cursor_goto_last_child_internal(self)) {
+      case TreeCursorStepHidden:
+        continue;
+      case TreeCursorStepVisible:
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+
+static inline int64_t ts_tree_cursor_goto_first_child_for_byte_and_point(
+  TSTreeCursor *_self,
+  uint32_t goal_byte,
+  TSPoint goal_point
+) {
+  TreeCursor *self = (TreeCursor *)_self;
+  uint32_t initial_size = self->stack.size;
+  uint32_t visible_child_index = 0;
+
+  bool did_descend;
+  do {
+    did_descend = false;
+
+    bool visible;
+    TreeCursorEntry entry;
+    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+      Length entry_end = length_add(entry.position, ts_subtree_size(*entry.subtree));
+      bool at_goal = entry_end.bytes > goal_byte && point_gt(entry_end.extent, goal_point);
+      uint32_t visible_child_count = ts_subtree_visible_child_count(*entry.subtree);
+      if (at_goal) {
+        if (visible) {
+          array_push(&self->stack, entry);
+          return visible_child_index;
+        }
+        if (visible_child_count > 0) {
+          array_push(&self->stack, entry);
+          did_descend = true;
+          break;
+        }
+      } else if (visible) {
+        visible_child_index++;
+      } else {
+        visible_child_index += visible_child_count;
+      }
+    }
+  } while (did_descend);
+
+  self->stack.size = initial_size;
+  return -1;
+}
+
+int64_t ts_tree_cursor_goto_first_child_for_byte(TSTreeCursor *self, uint32_t goal_byte) {
+  return ts_tree_cursor_goto_first_child_for_byte_and_point(self, goal_byte, POINT_ZERO);
+}
+
+int64_t ts_tree_cursor_goto_first_child_for_point(TSTreeCursor *self, TSPoint goal_point) {
+  return ts_tree_cursor_goto_first_child_for_byte_and_point(self, 0, goal_point);
+}
+
+TreeCursorStep ts_tree_cursor_goto_sibling_internal(
+  TSTreeCursor *_self,
+  bool (*advance)(CursorChildIterator *, TreeCursorEntry *, bool *)
+) {
+  TreeCursor *self = (TreeCursor *)_self;
+  uint32_t initial_size = self->stack.size;
+
+  while (self->stack.size > 1) {
+    TreeCursorEntry entry = array_pop(&self->stack);
+    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+    iterator.child_index = entry.child_index;
+    iterator.structural_child_index = entry.structural_child_index;
+    iterator.position = entry.position;
+    iterator.descendant_index = entry.descendant_index;
+
+    bool visible = false;
+    advance(&iterator, &entry, &visible);
+    if (visible && self->stack.size + 1 < initial_size) break;
+
+    while (advance(&iterator, &entry, &visible)) {
+      if (visible) {
+        array_push(&self->stack, entry);
+        return TreeCursorStepVisible;
+      }
+
+      if (ts_subtree_visible_child_count(*entry.subtree)) {
+        array_push(&self->stack, entry);
+        return TreeCursorStepHidden;
+      }
+    }
+  }
+
+  self->stack.size = initial_size;
+  return TreeCursorStepNone;
+}
+
+TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *_self) {
+  return ts_tree_cursor_goto_sibling_internal(_self, ts_tree_cursor_child_iterator_next);
+}
+
+bool ts_tree_cursor_goto_next_sibling(TSTreeCursor *self) {
+  switch (ts_tree_cursor_goto_next_sibling_internal(self)) {
+    case TreeCursorStepHidden:
+      ts_tree_cursor_goto_first_child(self);
+      return true;
+    case TreeCursorStepVisible:
+      return true;
+    default:
+      return false;
+  }
+}
+
+TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(TSTreeCursor *_self) {
+  // since subtracting across row loses column information, we may have to
+  // restore it
+  TreeCursor *self = (TreeCursor *)_self;
+
+  // for that, save current position before traversing
+  TreeCursorStep step = ts_tree_cursor_goto_sibling_internal(
+      _self, ts_tree_cursor_child_iterator_previous);
+  if (step == TreeCursorStepNone)
+    return step;
+
+  // if length is already valid, there's no need to recompute it
+  if (!length_is_undefined(array_back(&self->stack)->position))
+    return step;
+
+  // restore position from the parent node
+  const TreeCursorEntry *parent = array_get(&self->stack, self->stack.size - 2);
+  Length position = parent->position;
+  uint32_t child_index = array_back(&self->stack)->child_index;
+  const Subtree *children = ts_subtree_children((*(parent->subtree)));
+
+  if (child_index > 0) {
+    // skip first child padding since its position should match the position of the parent
+    position = length_add(position, ts_subtree_size(children[0]));
+    for (uint32_t i = 1; i < child_index; ++i) {
+      position = length_add(position, ts_subtree_total_size(children[i]));
+    }
+    position = length_add(position, ts_subtree_padding(children[child_index]));
+  }
+
+  array_back(&self->stack)->position = position;
+
+  return step;
+}
+
+bool ts_tree_cursor_goto_previous_sibling(TSTreeCursor *self) {
+  switch (ts_tree_cursor_goto_previous_sibling_internal(self)) {
+    case TreeCursorStepHidden:
+      ts_tree_cursor_goto_last_child(self);
+      return true;
+    case TreeCursorStepVisible:
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool ts_tree_cursor_goto_parent(TSTreeCursor *_self) {
+  TreeCursor *self = (TreeCursor *)_self;
+  for (unsigned i = self->stack.size - 2; i + 1 > 0; i--) {
+    if (ts_tree_cursor_is_entry_visible(self, i)) {
+      self->stack.size = i + 1;
+      return true;
+    }
+  }
+  return false;
+}
+
+void ts_tree_cursor_goto_descendant(
+  TSTreeCursor *_self,
+  uint32_t goal_descendant_index
+) {
+  TreeCursor *self = (TreeCursor *)_self;
+
+  // Ascend to the lowest ancestor that contains the goal node.
+  for (;;) {
+    uint32_t i = self->stack.size - 1;
+    TreeCursorEntry *entry = array_get(&self->stack, i);
+    uint32_t next_descendant_index =
+      entry->descendant_index +
+      (ts_tree_cursor_is_entry_visible(self, i) ? 1 : 0) +
+      ts_subtree_visible_descendant_count(*entry->subtree);
+    if (
+      (entry->descendant_index <= goal_descendant_index) &&
+      (next_descendant_index > goal_descendant_index)
+    ) {
+      break;
+    } else if (self->stack.size <= 1) {
+      return;
+    } else {
+      self->stack.size--;
+    }
+  }
+
+  // Descend to the goal node.
+  bool did_descend = true;
+  do {
+    did_descend = false;
+    bool visible;
+    TreeCursorEntry entry;
+    CursorChildIterator iterator = ts_tree_cursor_iterate_children(self);
+    if (iterator.descendant_index > goal_descendant_index) {
+      return;
+    }
+
+    while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) {
+      if (iterator.descendant_index > goal_descendant_index) {
+        array_push(&self->stack, entry);
+        if (visible && entry.descendant_index == goal_descendant_index) {
+          return;
+        } else {
+          did_descend = true;
+          break;
+        }
+      }
+    }
+  } while (did_descend);
+}
+
+uint32_t ts_tree_cursor_current_descendant_index(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  return last_entry->descendant_index;
+}
+
+TSNode ts_tree_cursor_current_node(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  bool is_extra = ts_subtree_extra(*last_entry->subtree);
+  TSSymbol alias_symbol = is_extra ? 0 : self->root_alias_symbol;
+  if (self->stack.size > 1 && !is_extra) {
+    TreeCursorEntry *parent_entry = array_get(&self->stack, self->stack.size - 2);
+    alias_symbol = ts_language_alias_at(
+      self->tree->language,
+      parent_entry->subtree->ptr->production_id,
+      last_entry->structural_child_index
+    );
+  }
+  return ts_node_new(
+    self->tree,
+    last_entry->subtree,
+    last_entry->position,
+    alias_symbol
+  );
+}
+
+// Private - Get various facts about the current node that are needed
+// when executing tree queries.
+void ts_tree_cursor_current_status(
+  const TSTreeCursor *_self,
+  TSFieldId *field_id,
+  bool *has_later_siblings,
+  bool *has_later_named_siblings,
+  bool *can_have_later_siblings_with_this_field,
+  TSSymbol *supertypes,
+  unsigned *supertype_count
+) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  unsigned max_supertypes = *supertype_count;
+  *field_id = 0;
+  *supertype_count = 0;
+  *has_later_siblings = false;
+  *has_later_named_siblings = false;
+  *can_have_later_siblings_with_this_field = false;
+
+  // Walk up the tree, visiting the current node and its invisible ancestors,
+  // because fields can refer to nodes through invisible *wrapper* nodes,
+  for (unsigned i = self->stack.size - 1; i > 0; i--) {
+    TreeCursorEntry *entry = array_get(&self->stack, i);
+    TreeCursorEntry *parent_entry = array_get(&self->stack, i - 1);
+
+    const TSSymbol *alias_sequence = ts_language_alias_sequence(
+      self->tree->language,
+      parent_entry->subtree->ptr->production_id
+    );
+
+    #define subtree_symbol(subtree, structural_child_index) \
+      ((                                                    \
+        !ts_subtree_extra(subtree) &&                       \
+        alias_sequence &&                                   \
+        alias_sequence[structural_child_index]              \
+      ) ?                                                   \
+        alias_sequence[structural_child_index] :            \
+        ts_subtree_symbol(subtree))
+
+    // Stop walking up when a visible ancestor is found.
+    TSSymbol entry_symbol = subtree_symbol(
+      *entry->subtree,
+      entry->structural_child_index
+    );
+    TSSymbolMetadata entry_metadata = ts_language_symbol_metadata(
+      self->tree->language,
+      entry_symbol
+    );
+    if (i != self->stack.size - 1 && entry_metadata.visible) break;
+
+    // Record any supertypes
+    if (entry_metadata.supertype && *supertype_count < max_supertypes) {
+      supertypes[*supertype_count] = entry_symbol;
+      (*supertype_count)++;
+    }
+
+    // Determine if the current node has later siblings.
+    if (!*has_later_siblings) {
+      unsigned sibling_count = parent_entry->subtree->ptr->child_count;
+      unsigned structural_child_index = entry->structural_child_index;
+      if (!ts_subtree_extra(*entry->subtree)) structural_child_index++;
+      for (unsigned j = entry->child_index + 1; j < sibling_count; j++) {
+        Subtree sibling = ts_subtree_children(*parent_entry->subtree)[j];
+        TSSymbolMetadata sibling_metadata = ts_language_symbol_metadata(
+          self->tree->language,
+          subtree_symbol(sibling, structural_child_index)
+        );
+        if (sibling_metadata.visible) {
+          *has_later_siblings = true;
+          if (*has_later_named_siblings) break;
+          if (sibling_metadata.named) {
+            *has_later_named_siblings = true;
+            break;
+          }
+        } else if (ts_subtree_visible_child_count(sibling) > 0) {
+          *has_later_siblings = true;
+          if (*has_later_named_siblings) break;
+          if (sibling.ptr->named_child_count > 0) {
+            *has_later_named_siblings = true;
+            break;
+          }
+        }
+        if (!ts_subtree_extra(sibling)) structural_child_index++;
+      }
+    }
+
+    #undef subtree_symbol
+
+    if (!ts_subtree_extra(*entry->subtree)) {
+      const TSFieldMapEntry *field_map, *field_map_end;
+      ts_language_field_map(
+        self->tree->language,
+        parent_entry->subtree->ptr->production_id,
+        &field_map, &field_map_end
+      );
+
+      // Look for a field name associated with the current node.
+      if (!*field_id) {
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+          if (!map->inherited && map->child_index == entry->structural_child_index) {
+            *field_id = map->field_id;
+            break;
+          }
+        }
+      }
+
+      // Determine if the current node can have later siblings with the same field name.
+      if (*field_id) {
+        for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+          if (
+            map->field_id == *field_id &&
+            map->child_index > entry->structural_child_index
+          ) {
+            *can_have_later_siblings_with_this_field = true;
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+uint32_t ts_tree_cursor_current_depth(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  uint32_t depth = 0;
+  for (unsigned i = 1; i < self->stack.size; i++) {
+    if (ts_tree_cursor_is_entry_visible(self, i)) {
+      depth++;
+    }
+  }
+  return depth;
+}
+
+TSNode ts_tree_cursor_parent_node(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  for (int i = (int)self->stack.size - 2; i >= 0; i--) {
+    TreeCursorEntry *entry = array_get(&self->stack, i);
+    bool is_visible = true;
+    TSSymbol alias_symbol = 0;
+    if (i > 0) {
+      TreeCursorEntry *parent_entry = array_get(&self->stack, i - 1);
+      alias_symbol = ts_language_alias_at(
+        self->tree->language,
+        parent_entry->subtree->ptr->production_id,
+        entry->structural_child_index
+      );
+      is_visible = (alias_symbol != 0) || ts_subtree_visible(*entry->subtree);
+    }
+    if (is_visible) {
+      return ts_node_new(
+        self->tree,
+        entry->subtree,
+        entry->position,
+        alias_symbol
+      );
+    }
+  }
+  return ts_node_new(NULL, NULL, length_zero(), 0);
+}
+
+TSFieldId ts_tree_cursor_current_field_id(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+
+  // Walk up the tree, visiting the current node and its invisible ancestors.
+  for (unsigned i = self->stack.size - 1; i > 0; i--) {
+    TreeCursorEntry *entry = array_get(&self->stack, i);
+    TreeCursorEntry *parent_entry = array_get(&self->stack, i - 1);
+
+    // Stop walking up when another visible node is found.
+    if (
+      i != self->stack.size - 1 &&
+      ts_tree_cursor_is_entry_visible(self, i)
+    ) break;
+
+    if (ts_subtree_extra(*entry->subtree)) break;
+
+    const TSFieldMapEntry *field_map, *field_map_end;
+    ts_language_field_map(
+      self->tree->language,
+      parent_entry->subtree->ptr->production_id,
+      &field_map, &field_map_end
+    );
+    for (const TSFieldMapEntry *map = field_map; map < field_map_end; map++) {
+      if (!map->inherited && map->child_index == entry->structural_child_index) {
+        return map->field_id;
+      }
+    }
+  }
+  return 0;
+}
+
+const char *ts_tree_cursor_current_field_name(const TSTreeCursor *_self) {
+  TSFieldId id = ts_tree_cursor_current_field_id(_self);
+  if (id) {
+    const TreeCursor *self = (const TreeCursor *)_self;
+    return self->tree->language->field_names[id];
+  } else {
+    return NULL;
+  }
+}
+
+TSTreeCursor ts_tree_cursor_copy(const TSTreeCursor *_cursor) {
+  const TreeCursor *cursor = (const TreeCursor *)_cursor;
+  TSTreeCursor res = {NULL, NULL, {0, 0}};
+  TreeCursor *copy = (TreeCursor *)&res;
+  copy->tree = cursor->tree;
+  copy->root_alias_symbol = cursor->root_alias_symbol;
+  array_init(&copy->stack);
+  array_push_all(&copy->stack, &cursor->stack);
+  return res;
+}
+
+void ts_tree_cursor_reset_to(TSTreeCursor *_dst, const TSTreeCursor *_src) {
+  const TreeCursor *cursor = (const TreeCursor *)_src;
+  TreeCursor *copy = (TreeCursor *)_dst;
+  copy->tree = cursor->tree;
+  copy->root_alias_symbol = cursor->root_alias_symbol;
+  array_clear(&copy->stack);
+  array_push_all(&copy->stack, &cursor->stack);
+}
diff --git a/src/library/ts/src/tree-sitter/lib/src/tree_cursor.h b/src/library/ts/src/tree-sitter/lib/src/tree_cursor.h
new file mode 100644
index 0000000000..7d4e7ef0a6
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/tree_cursor.h
@@ -0,0 +1,48 @@
+#ifndef TREE_SITTER_TREE_CURSOR_H_
+#define TREE_SITTER_TREE_CURSOR_H_
+
+#include "./subtree.h"
+
+typedef struct {
+  const Subtree *subtree;
+  Length position;
+  uint32_t child_index;
+  uint32_t structural_child_index;
+  uint32_t descendant_index;
+} TreeCursorEntry;
+
+typedef struct {
+  const TSTree *tree;
+  Array(TreeCursorEntry) stack;
+  TSSymbol root_alias_symbol;
+} TreeCursor;
+
+typedef enum {
+  TreeCursorStepNone,
+  TreeCursorStepHidden,
+  TreeCursorStepVisible,
+} TreeCursorStep;
+
+void ts_tree_cursor_init(TreeCursor *self, TSNode node);
+void ts_tree_cursor_current_status(
+  const TSTreeCursor *_self,
+  TSFieldId *field_id,
+  bool *has_later_siblings,
+  bool *has_later_named_siblings,
+  bool *can_have_later_siblings_with_this_field,
+  TSSymbol *supertypes,
+  unsigned *supertype_count
+);
+
+TreeCursorStep ts_tree_cursor_goto_first_child_internal(TSTreeCursor *_self);
+TreeCursorStep ts_tree_cursor_goto_next_sibling_internal(TSTreeCursor *_self);
+
+static inline Subtree ts_tree_cursor_current_subtree(const TSTreeCursor *_self) {
+  const TreeCursor *self = (const TreeCursor *)_self;
+  TreeCursorEntry *last_entry = array_back(&self->stack);
+  return *last_entry->subtree;
+}
+
+TSNode ts_tree_cursor_parent_node(const TSTreeCursor *_self);
+
+#endif  // TREE_SITTER_TREE_CURSOR_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/ts_assert.h b/src/library/ts/src/tree-sitter/lib/src/ts_assert.h
new file mode 100644
index 0000000000..4cb8f36a12
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/ts_assert.h
@@ -0,0 +1,11 @@
+#ifndef TREE_SITTER_ASSERT_H_
+#define TREE_SITTER_ASSERT_H_
+
+#ifdef NDEBUG
+#define ts_assert(e) ((void)(e))
+#else
+#include <assert.h>
+#define ts_assert(e) assert(e)
+#endif
+
+#endif // TREE_SITTER_ASSERT_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode.h b/src/library/ts/src/tree-sitter/lib/src/unicode.h
new file mode 100644
index 0000000000..0fba3f2961
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode.h
@@ -0,0 +1,75 @@
+#ifndef TREE_SITTER_UNICODE_H_
+#define TREE_SITTER_UNICODE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <limits.h>
+#include <stdint.h>
+
+#define U_EXPORT
+#define U_EXPORT2
+#include "unicode/utf8.h"
+#include "unicode/utf16.h"
+#include "portable/endian.h"
+
+#define U16_NEXT_LE(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=le16toh((s)[(i)++]); \
+    if(U16_IS_LEAD(c)) { \
+        uint16_t __c2; \
+        if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \
+            ++(i); \
+            (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+#define U16_NEXT_BE(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=be16toh((s)[(i)++]); \
+    if(U16_IS_LEAD(c)) { \
+        uint16_t __c2; \
+        if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \
+            ++(i); \
+            (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+static const int32_t TS_DECODE_ERROR = U_SENTINEL;
+
+static inline uint32_t ts_decode_utf8(
+  const uint8_t *string,
+  uint32_t length,
+  int32_t *code_point
+) {
+  uint32_t i = 0;
+  U8_NEXT(string, i, length, *code_point);
+  return i;
+}
+
+static inline uint32_t ts_decode_utf16_le(
+  const uint8_t *string,
+  uint32_t length,
+  int32_t *code_point
+) {
+  uint32_t i = 0;
+  U16_NEXT_LE(((uint16_t *)string), i, length, *code_point);
+  return i * 2;
+}
+
+static inline uint32_t ts_decode_utf16_be(
+  const uint8_t *string,
+  uint32_t length,
+  int32_t *code_point
+) {
+  uint32_t i = 0;
+  U16_NEXT_BE(((uint16_t *)string), i, length, *code_point);
+  return i * 2;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_UNICODE_H_
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/ICU_SHA b/src/library/ts/src/tree-sitter/lib/src/unicode/ICU_SHA
new file mode 100644
index 0000000000..3622283ba3
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/ICU_SHA
@@ -0,0 +1 @@
+552b01f61127d30d6589aa4bf99468224979b661
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/LICENSE b/src/library/ts/src/tree-sitter/lib/src/unicode/LICENSE
new file mode 100644
index 0000000000..2e01e36876
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/LICENSE
@@ -0,0 +1,414 @@
+COPYRIGHT AND PERMISSION NOTICE (ICU 58 and later)
+
+Copyright © 1991-2019 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
+
+---------------------
+
+Third-Party Software Licenses
+
+This section contains third-party software notices and/or additional
+terms for licensed third-party software components included within ICU
+libraries.
+
+1. ICU License - ICU 1.8.1 to ICU 57.1
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1995-2016 International Business Machines Corporation and others
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, provided that the above
+copyright notice(s) and this permission notice appear in all copies of
+the Software and that both the above copyright notice(s) and this
+permission notice appear in supporting documentation.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY
+SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+of the copyright holder.
+
+All trademarks and registered trademarks mentioned herein are the
+property of their respective owners.
+
+2. Chinese/Japanese Word Break Dictionary Data (cjdict.txt)
+
+ #     The Google Chrome software developed by Google is licensed under
+ # the BSD license. Other software included in this distribution is
+ # provided under other licenses, as set forth below.
+ #
+ #  The BSD License
+ #  http://opensource.org/licenses/bsd-license.php
+ #  Copyright (C) 2006-2008, Google Inc.
+ #
+ #  All rights reserved.
+ #
+ #  Redistribution and use in source and binary forms, with or without
+ # modification, are permitted provided that the following conditions are met:
+ #
+ #  Redistributions of source code must retain the above copyright notice,
+ # this list of conditions and the following disclaimer.
+ #  Redistributions in binary form must reproduce the above
+ # copyright notice, this list of conditions and the following
+ # disclaimer in the documentation and/or other materials provided with
+ # the distribution.
+ #  Neither the name of  Google Inc. nor the names of its
+ # contributors may be used to endorse or promote products derived from
+ # this software without specific prior written permission.
+ #
+ #
+ #  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ # CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ # INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ # BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ #
+ #
+ #  The word list in cjdict.txt are generated by combining three word lists
+ # listed below with further processing for compound word breaking. The
+ # frequency is generated with an iterative training against Google web
+ # corpora.
+ #
+ #  * Libtabe (Chinese)
+ #    - https://sourceforge.net/project/?group_id=1519
+ #    - Its license terms and conditions are shown below.
+ #
+ #  * IPADIC (Japanese)
+ #    - http://chasen.aist-nara.ac.jp/chasen/distribution.html
+ #    - Its license terms and conditions are shown below.
+ #
+ #  ---------COPYING.libtabe ---- BEGIN--------------------
+ #
+ #  /*
+ #   * Copyright (c) 1999 TaBE Project.
+ #   * Copyright (c) 1999 Pai-Hsiang Hsiao.
+ #   * All rights reserved.
+ #   *
+ #   * Redistribution and use in source and binary forms, with or without
+ #   * modification, are permitted provided that the following conditions
+ #   * are met:
+ #   *
+ #   * . Redistributions of source code must retain the above copyright
+ #   *   notice, this list of conditions and the following disclaimer.
+ #   * . Redistributions in binary form must reproduce the above copyright
+ #   *   notice, this list of conditions and the following disclaimer in
+ #   *   the documentation and/or other materials provided with the
+ #   *   distribution.
+ #   * . Neither the name of the TaBE Project nor the names of its
+ #   *   contributors may be used to endorse or promote products derived
+ #   *   from this software without specific prior written permission.
+ #   *
+ #   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ #   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ #   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ #   * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ #   * REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ #   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ #   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ #   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ #   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ #   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ #   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ #   * OF THE POSSIBILITY OF SUCH DAMAGE.
+ #   */
+ #
+ #  /*
+ #   * Copyright (c) 1999 Computer Systems and Communication Lab,
+ #   *                    Institute of Information Science, Academia
+ #       *                    Sinica. All rights reserved.
+ #   *
+ #   * Redistribution and use in source and binary forms, with or without
+ #   * modification, are permitted provided that the following conditions
+ #   * are met:
+ #   *
+ #   * . Redistributions of source code must retain the above copyright
+ #   *   notice, this list of conditions and the following disclaimer.
+ #   * . Redistributions in binary form must reproduce the above copyright
+ #   *   notice, this list of conditions and the following disclaimer in
+ #   *   the documentation and/or other materials provided with the
+ #   *   distribution.
+ #   * . Neither the name of the Computer Systems and Communication Lab
+ #   *   nor the names of its contributors may be used to endorse or
+ #   *   promote products derived from this software without specific
+ #   *   prior written permission.
+ #   *
+ #   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ #   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ #   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ #   * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ #   * REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ #   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ #   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ #   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ #   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ #   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ #   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ #   * OF THE POSSIBILITY OF SUCH DAMAGE.
+ #   */
+ #
+ #  Copyright 1996 Chih-Hao Tsai @ Beckman Institute,
+ #      University of Illinois
+ #  c-tsai4@uiuc.edu  http://casper.beckman.uiuc.edu/~c-tsai4
+ #
+ #  ---------------COPYING.libtabe-----END--------------------------------
+ #
+ #
+ #  ---------------COPYING.ipadic-----BEGIN-------------------------------
+ #
+ #  Copyright 2000, 2001, 2002, 2003 Nara Institute of Science
+ #  and Technology.  All Rights Reserved.
+ #
+ #  Use, reproduction, and distribution of this software is permitted.
+ #  Any copy of this software, whether in its original form or modified,
+ #  must include both the above copyright notice and the following
+ #  paragraphs.
+ #
+ #  Nara Institute of Science and Technology (NAIST),
+ #  the copyright holders, disclaims all warranties with regard to this
+ #  software, including all implied warranties of merchantability and
+ #  fitness, in no event shall NAIST be liable for
+ #  any special, indirect or consequential damages or any damages
+ #  whatsoever resulting from loss of use, data or profits, whether in an
+ #  action of contract, negligence or other tortuous action, arising out
+ #  of or in connection with the use or performance of this software.
+ #
+ #  A large portion of the dictionary entries
+ #  originate from ICOT Free Software.  The following conditions for ICOT
+ #  Free Software applies to the current dictionary as well.
+ #
+ #  Each User may also freely distribute the Program, whether in its
+ #  original form or modified, to any third party or parties, PROVIDED
+ #  that the provisions of Section 3 ("NO WARRANTY") will ALWAYS appear
+ #  on, or be attached to, the Program, which is distributed substantially
+ #  in the same form as set out herein and that such intended
+ #  distribution, if actually made, will neither violate or otherwise
+ #  contravene any of the laws and regulations of the countries having
+ #  jurisdiction over the User or the intended distribution itself.
+ #
+ #  NO WARRANTY
+ #
+ #  The program was produced on an experimental basis in the course of the
+ #  research and development conducted during the project and is provided
+ #  to users as so produced on an experimental basis.  Accordingly, the
+ #  program is provided without any warranty whatsoever, whether express,
+ #  implied, statutory or otherwise.  The term "warranty" used herein
+ #  includes, but is not limited to, any warranty of the quality,
+ #  performance, merchantability and fitness for a particular purpose of
+ #  the program and the nonexistence of any infringement or violation of
+ #  any right of any third party.
+ #
+ #  Each user of the program will agree and understand, and be deemed to
+ #  have agreed and understood, that there is no warranty whatsoever for
+ #  the program and, accordingly, the entire risk arising from or
+ #  otherwise connected with the program is assumed by the user.
+ #
+ #  Therefore, neither ICOT, the copyright holder, or any other
+ #  organization that participated in or was otherwise related to the
+ #  development of the program and their respective officials, directors,
+ #  officers and other employees shall be held liable for any and all
+ #  damages, including, without limitation, general, special, incidental
+ #  and consequential damages, arising out of or otherwise in connection
+ #  with the use or inability to use the program or any product, material
+ #  or result produced or otherwise obtained by using the program,
+ #  regardless of whether they have been advised of, or otherwise had
+ #  knowledge of, the possibility of such damages at any time during the
+ #  project or thereafter.  Each user will be deemed to have agreed to the
+ #  foregoing by his or her commencement of use of the program.  The term
+ #  "use" as used herein includes, but is not limited to, the use,
+ #  modification, copying and distribution of the program and the
+ #  production of secondary products from the program.
+ #
+ #  In the case where the program, whether in its original form or
+ #  modified, was distributed or delivered to or received by a user from
+ #  any person, organization or entity other than ICOT, unless it makes or
+ #  grants independently of ICOT any specific warranty to the user in
+ #  writing, such person, organization or entity, will also be exempted
+ #  from and not be held liable to the user for any such damages as noted
+ #  above as far as the program is concerned.
+ #
+ #  ---------------COPYING.ipadic-----END----------------------------------
+
+3. Lao Word Break Dictionary Data (laodict.txt)
+
+ #  Copyright (c) 2013 International Business Machines Corporation
+ #  and others. All Rights Reserved.
+ #
+ # Project: http://code.google.com/p/lao-dictionary/
+ # Dictionary: http://lao-dictionary.googlecode.com/git/Lao-Dictionary.txt
+ # License: http://lao-dictionary.googlecode.com/git/Lao-Dictionary-LICENSE.txt
+ #              (copied below)
+ #
+ #  This file is derived from the above dictionary, with slight
+ #  modifications.
+ #  ----------------------------------------------------------------------
+ #  Copyright (C) 2013 Brian Eugene Wilson, Robert Martin Campbell.
+ #  All rights reserved.
+ #
+ #  Redistribution and use in source and binary forms, with or without
+ #  modification,
+ #  are permitted provided that the following conditions are met:
+ #
+ #
+ # Redistributions of source code must retain the above copyright notice, this
+ #  list of conditions and the following disclaimer. Redistributions in
+ #  binary form must reproduce the above copyright notice, this list of
+ #  conditions and the following disclaimer in the documentation and/or
+ #  other materials provided with the distribution.
+ #
+ #
+ # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ # OF THE POSSIBILITY OF SUCH DAMAGE.
+ #  --------------------------------------------------------------------------
+
+4. Burmese Word Break Dictionary Data (burmesedict.txt)
+
+ #  Copyright (c) 2014 International Business Machines Corporation
+ #  and others. All Rights Reserved.
+ #
+ #  This list is part of a project hosted at:
+ #    github.com/kanyawtech/myanmar-karen-word-lists
+ #
+ #  --------------------------------------------------------------------------
+ #  Copyright (c) 2013, LeRoy Benjamin Sharon
+ #  All rights reserved.
+ #
+ #  Redistribution and use in source and binary forms, with or without
+ #  modification, are permitted provided that the following conditions
+ #  are met: Redistributions of source code must retain the above
+ #  copyright notice, this list of conditions and the following
+ #  disclaimer.  Redistributions in binary form must reproduce the
+ #  above copyright notice, this list of conditions and the following
+ #  disclaimer in the documentation and/or other materials provided
+ #  with the distribution.
+ #
+ #    Neither the name Myanmar Karen Word Lists, nor the names of its
+ #    contributors may be used to endorse or promote products derived
+ #    from this software without specific prior written permission.
+ #
+ #  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ #  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ #  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ #  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ #  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+ #  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ #  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ #  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ #  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ #  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ #  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ #  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ #  SUCH DAMAGE.
+ #  --------------------------------------------------------------------------
+
+5. Time Zone Database
+
+  ICU uses the public domain data and code derived from Time Zone
+Database for its time zone support. The ownership of the TZ database
+is explained in BCP 175: Procedure for Maintaining the Time Zone
+Database section 7.
+
+ # 7.  Database Ownership
+ #
+ #    The TZ database itself is not an IETF Contribution or an IETF
+ #    document.  Rather it is a pre-existing and regularly updated work
+ #    that is in the public domain, and is intended to remain in the
+ #    public domain.  Therefore, BCPs 78 [RFC5378] and 79 [RFC3979] do
+ #    not apply to the TZ Database or contributions that individuals make
+ #    to it.  Should any claims be made and substantiated against the TZ
+ #    Database, the organization that is providing the IANA
+ #    Considerations defined in this RFC, under the memorandum of
+ #    understanding with the IETF, currently ICANN, may act in accordance
+ #    with all competent court orders.  No ownership claims will be made
+ #    by ICANN or the IETF Trust on the database or the code.  Any person
+ #    making a contribution to the database or code waives all rights to
+ #    future claims in that contribution or in the TZ Database.
+
+6. Google double-conversion
+
+Copyright 2006-2011, the V8 project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/README.md b/src/library/ts/src/tree-sitter/lib/src/unicode/README.md
new file mode 100644
index 0000000000..623b8e3843
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/README.md
@@ -0,0 +1,29 @@
+# ICU Parts
+
+This directory contains a small subset of files from the Unicode organization's [ICU repository](https://github.com/unicode-org/icu).
+
+### License
+
+The license for these files is contained in the `LICENSE` file within this directory.
+
+### Contents
+
+* Source files taken from the [`icu4c/source/common/unicode`](https://github.com/unicode-org/icu/tree/552b01f61127d30d6589aa4bf99468224979b661/icu4c/source/common/unicode) directory:
+  * `utf8.h`
+  * `utf16.h`
+  * `umachine.h`
+* Empty source files that are referenced by the above source files, but whose original contents in `libicu` are not needed:
+  * `ptypes.h`
+  * `urename.h`
+  * `utf.h`
+* `ICU_SHA` - File containing the Git SHA of the commit in the `icu` repository from which the files were obtained.
+* `LICENSE` - The license file from the [`icu4c`](https://github.com/unicode-org/icu/tree/552b01f61127d30d6589aa4bf99468224979b661/icu4c) directory of the `icu` repository.
+* `README.md` - This text file.
+
+### Updating ICU
+
+To incorporate changes from the upstream `icu` repository:
+
+* Update `ICU_SHA` with the new Git SHA.
+* Update `LICENSE` with the license text from the directory mentioned above.
+* Update `utf8.h`, `utf16.h`, and `umachine.h` with their new contents in the `icu` repository.
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/ptypes.h b/src/library/ts/src/tree-sitter/lib/src/unicode/ptypes.h
new file mode 100644
index 0000000000..ac79ad0f98
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/ptypes.h
@@ -0,0 +1 @@
+// This file must exist in order for `utf8.h` and `utf16.h` to be used.
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/umachine.h b/src/library/ts/src/tree-sitter/lib/src/unicode/umachine.h
new file mode 100644
index 0000000000..9195824d5b
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/umachine.h
@@ -0,0 +1,448 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+******************************************************************************
+*
+*   Copyright (C) 1999-2015, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+******************************************************************************
+*   file name:  umachine.h
+*   encoding:   UTF-8
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 1999sep13
+*   created by: Markus W. Scherer
+*
+*   This file defines basic types and constants for ICU to be
+*   platform-independent. umachine.h and utf.h are included into
+*   utypes.h to provide all the general definitions for ICU.
+*   All of these definitions used to be in utypes.h before
+*   the UTF-handling macros made this unmaintainable.
+*/
+
+#ifndef __UMACHINE_H__
+#define __UMACHINE_H__
+
+
+/**
+ * \file
+ * \brief Basic types and constants for UTF
+ *
+ * <h2> Basic types and constants for UTF </h2>
+ *   This file defines basic types and constants for utf.h to be
+ *   platform-independent. umachine.h and utf.h are included into
+ *   utypes.h to provide all the general definitions for ICU.
+ *   All of these definitions used to be in utypes.h before
+ *   the UTF-handling macros made this unmaintainable.
+ *
+ */
+/*==========================================================================*/
+/* Include platform-dependent definitions                                   */
+/* which are contained in the platform-specific file platform.h             */
+/*==========================================================================*/
+
+#include "unicode/ptypes.h" /* platform.h is included in ptypes.h */
+
+/*
+ * ANSI C headers:
+ * stddef.h defines wchar_t
+ */
+#include <stddef.h>
+
+/*==========================================================================*/
+/* For C wrappers, we use the symbol U_STABLE.                                */
+/* This works properly if the includer is C or C++.                         */
+/* Functions are declared   U_STABLE return-type U_EXPORT2 function-name()... */
+/*==========================================================================*/
+
+/**
+ * \def U_CFUNC
+ * This is used in a declaration of a library private ICU C function.
+ * @stable ICU 2.4
+ */
+
+/**
+ * \def U_CDECL_BEGIN
+ * This is used to begin a declaration of a library private ICU C API.
+ * @stable ICU 2.4
+ */
+
+/**
+ * \def U_CDECL_END
+ * This is used to end a declaration of a library private ICU C API
+ * @stable ICU 2.4
+ */
+
+#ifdef __cplusplus
+#   define U_CFUNC extern "C"
+#   define U_CDECL_BEGIN extern "C" {
+#   define U_CDECL_END   }
+#else
+#   define U_CFUNC extern
+#   define U_CDECL_BEGIN
+#   define U_CDECL_END
+#endif
+
+#ifndef U_ATTRIBUTE_DEPRECATED
+/**
+ * \def U_ATTRIBUTE_DEPRECATED
+ *  This is used for GCC specific attributes
+ * @internal
+ */
+#if U_GCC_MAJOR_MINOR >= 302
+#    define U_ATTRIBUTE_DEPRECATED __attribute__ ((deprecated))
+/**
+ * \def U_ATTRIBUTE_DEPRECATED
+ * This is used for Visual C++ specific attributes
+ * @internal
+ */
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#    define U_ATTRIBUTE_DEPRECATED __declspec(deprecated)
+#else
+#    define U_ATTRIBUTE_DEPRECATED
+#endif
+#endif
+
+/** This is used to declare a function as a public ICU C API @stable ICU 2.0*/
+#define U_CAPI U_CFUNC U_EXPORT
+/** This is used to declare a function as a stable public ICU C API*/
+#define U_STABLE U_CAPI
+/** This is used to declare a function as a draft public ICU C API  */
+#define U_DRAFT  U_CAPI
+/** This is used to declare a function as a deprecated public ICU C API  */
+#define U_DEPRECATED U_CAPI U_ATTRIBUTE_DEPRECATED
+/** This is used to declare a function as an obsolete public ICU C API  */
+#define U_OBSOLETE U_CAPI
+/** This is used to declare a function as an internal ICU C API  */
+#define U_INTERNAL U_CAPI
+
+/**
+ * \def U_OVERRIDE
+ * Defined to the C++11 "override" keyword if available.
+ * Denotes a class or member which is an override of the base class.
+ * May result in an error if it applied to something not an override.
+ * @internal
+ */
+#ifndef U_OVERRIDE
+#define U_OVERRIDE override
+#endif
+
+/**
+ * \def U_FINAL
+ * Defined to the C++11 "final" keyword if available.
+ * Denotes a class or member which may not be overridden in subclasses.
+ * May result in an error if subclasses attempt to override.
+ * @internal
+ */
+#if !defined(U_FINAL) || defined(U_IN_DOXYGEN)
+#define U_FINAL final
+#endif
+
+// Before ICU 65, function-like, multi-statement ICU macros were just defined as
+// series of statements wrapped in { } blocks and the caller could choose to
+// either treat them as if they were actual functions and end the invocation
+// with a trailing ; creating an empty statement after the block or else omit
+// this trailing ; using the knowledge that the macro would expand to { }.
+//
+// But doing so doesn't work well with macros that look like functions and
+// compiler warnings about empty statements (ICU-20601) and ICU 65 therefore
+// switches to the standard solution of wrapping such macros in do { } while.
+//
+// This will however break existing code that depends on being able to invoke
+// these macros without a trailing ; so to be able to remain compatible with
+// such code the wrapper is itself defined as macros so that it's possible to
+// build ICU 65 and later with the old macro behaviour, like this:
+//
+// CPPFLAGS='-DUPRV_BLOCK_MACRO_BEGIN="" -DUPRV_BLOCK_MACRO_END=""'
+// runConfigureICU ...
+
+/**
+ * \def UPRV_BLOCK_MACRO_BEGIN
+ * Defined as the "do" keyword by default.
+ * @internal
+ */
+#ifndef UPRV_BLOCK_MACRO_BEGIN
+#define UPRV_BLOCK_MACRO_BEGIN do
+#endif
+
+/**
+ * \def UPRV_BLOCK_MACRO_END
+ * Defined as "while (FALSE)" by default.
+ * @internal
+ */
+#ifndef UPRV_BLOCK_MACRO_END
+#define UPRV_BLOCK_MACRO_END while (FALSE)
+#endif
+
+/*==========================================================================*/
+/* limits for int32_t etc., like in POSIX inttypes.h                        */
+/*==========================================================================*/
+
+#ifndef INT8_MIN
+/** The smallest value an 8 bit signed integer can hold @stable ICU 2.0 */
+#   define INT8_MIN        ((int8_t)(-128))
+#endif
+#ifndef INT16_MIN
+/** The smallest value a 16 bit signed integer can hold @stable ICU 2.0 */
+#   define INT16_MIN       ((int16_t)(-32767-1))
+#endif
+#ifndef INT32_MIN
+/** The smallest value a 32 bit signed integer can hold @stable ICU 2.0 */
+#   define INT32_MIN       ((int32_t)(-2147483647-1))
+#endif
+
+#ifndef INT8_MAX
+/** The largest value an 8 bit signed integer can hold @stable ICU 2.0 */
+#   define INT8_MAX        ((int8_t)(127))
+#endif
+#ifndef INT16_MAX
+/** The largest value a 16 bit signed integer can hold @stable ICU 2.0 */
+#   define INT16_MAX       ((int16_t)(32767))
+#endif
+#ifndef INT32_MAX
+/** The largest value a 32 bit signed integer can hold @stable ICU 2.0 */
+#   define INT32_MAX       ((int32_t)(2147483647))
+#endif
+
+#ifndef UINT8_MAX
+/** The largest value an 8 bit unsigned integer can hold @stable ICU 2.0 */
+#   define UINT8_MAX       ((uint8_t)(255U))
+#endif
+#ifndef UINT16_MAX
+/** The largest value a 16 bit unsigned integer can hold @stable ICU 2.0 */
+#   define UINT16_MAX      ((uint16_t)(65535U))
+#endif
+#ifndef UINT32_MAX
+/** The largest value a 32 bit unsigned integer can hold @stable ICU 2.0 */
+#   define UINT32_MAX      ((uint32_t)(4294967295U))
+#endif
+
+#if defined(U_INT64_T_UNAVAILABLE)
+# error int64_t is required for decimal format and rule-based number format.
+#else
+# ifndef INT64_C
+/**
+ * Provides a platform independent way to specify a signed 64-bit integer constant.
+ * note: may be wrong for some 64 bit platforms - ensure your compiler provides INT64_C
+ * @stable ICU 2.8
+ */
+#   define INT64_C(c) c ## LL
+# endif
+# ifndef UINT64_C
+/**
+ * Provides a platform independent way to specify an unsigned 64-bit integer constant.
+ * note: may be wrong for some 64 bit platforms - ensure your compiler provides UINT64_C
+ * @stable ICU 2.8
+ */
+#   define UINT64_C(c) c ## ULL
+# endif
+# ifndef U_INT64_MIN
+/** The smallest value a 64 bit signed integer can hold @stable ICU 2.8 */
+#     define U_INT64_MIN       ((int64_t)(INT64_C(-9223372036854775807)-1))
+# endif
+# ifndef U_INT64_MAX
+/** The largest value a 64 bit signed integer can hold @stable ICU 2.8 */
+#     define U_INT64_MAX       ((int64_t)(INT64_C(9223372036854775807)))
+# endif
+# ifndef U_UINT64_MAX
+/** The largest value a 64 bit unsigned integer can hold @stable ICU 2.8 */
+#     define U_UINT64_MAX      ((uint64_t)(UINT64_C(18446744073709551615)))
+# endif
+#endif
+
+/*==========================================================================*/
+/* Boolean data type                                                        */
+/*==========================================================================*/
+
+/** The ICU boolean type @stable ICU 2.0 */
+typedef int8_t UBool;
+
+#ifndef TRUE
+/** The TRUE value of a UBool @stable ICU 2.0 */
+#   define TRUE  1
+#endif
+#ifndef FALSE
+/** The FALSE value of a UBool @stable ICU 2.0 */
+#   define FALSE 0
+#endif
+
+
+/*==========================================================================*/
+/* Unicode data types                                                       */
+/*==========================================================================*/
+
+/* wchar_t-related definitions -------------------------------------------- */
+
+/*
+ * \def U_WCHAR_IS_UTF16
+ * Defined if wchar_t uses UTF-16.
+ *
+ * @stable ICU 2.0
+ */
+/*
+ * \def U_WCHAR_IS_UTF32
+ * Defined if wchar_t uses UTF-32.
+ *
+ * @stable ICU 2.0
+ */
+#if !defined(U_WCHAR_IS_UTF16) && !defined(U_WCHAR_IS_UTF32)
+#   ifdef __STDC_ISO_10646__
+#       if (U_SIZEOF_WCHAR_T==2)
+#           define U_WCHAR_IS_UTF16
+#       elif (U_SIZEOF_WCHAR_T==4)
+#           define  U_WCHAR_IS_UTF32
+#       endif
+#   elif defined __UCS2__
+#       if (U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400) && (U_SIZEOF_WCHAR_T==2)
+#           define U_WCHAR_IS_UTF16
+#       endif
+#   elif defined(__UCS4__) || (U_PLATFORM == U_PF_OS400 && defined(__UTF32__))
+#       if (U_SIZEOF_WCHAR_T==4)
+#           define U_WCHAR_IS_UTF32
+#       endif
+#   elif U_PLATFORM_IS_DARWIN_BASED || (U_SIZEOF_WCHAR_T==4 && U_PLATFORM_IS_LINUX_BASED)
+#       define U_WCHAR_IS_UTF32
+#   elif U_PLATFORM_HAS_WIN32_API
+#       define U_WCHAR_IS_UTF16
+#   endif
+#endif
+
+/* UChar and UChar32 definitions -------------------------------------------- */
+
+/** Number of bytes in a UChar. @stable ICU 2.0 */
+#define U_SIZEOF_UCHAR 2
+
+/**
+ * \def U_CHAR16_IS_TYPEDEF
+ * If 1, then char16_t is a typedef and not a real type (yet)
+ * @internal
+ */
+#if (U_PLATFORM == U_PF_AIX) && defined(__cplusplus) &&(U_CPLUSPLUS_VERSION < 11)
+// for AIX, uchar.h needs to be included
+# include <uchar.h>
+# define U_CHAR16_IS_TYPEDEF 1
+#elif defined(_MSC_VER) && (_MSC_VER < 1900)
+// Versions of Visual Studio/MSVC below 2015 do not support char16_t as a real type,
+// and instead use a typedef.  https://msdn.microsoft.com/library/bb531344.aspx
+# define U_CHAR16_IS_TYPEDEF 1
+#else
+# define U_CHAR16_IS_TYPEDEF 0
+#endif
+
+
+/**
+ * \var UChar
+ *
+ * The base type for UTF-16 code units and pointers.
+ * Unsigned 16-bit integer.
+ * Starting with ICU 59, C++ API uses char16_t directly, while C API continues to use UChar.
+ *
+ * UChar is configurable by defining the macro UCHAR_TYPE
+ * on the preprocessor or compiler command line:
+ * -DUCHAR_TYPE=uint16_t or -DUCHAR_TYPE=wchar_t (if U_SIZEOF_WCHAR_T==2) etc.
+ * (The UCHAR_TYPE can also be \#defined earlier in this file, for outside the ICU library code.)
+ * This is for transitional use from application code that uses uint16_t or wchar_t for UTF-16.
+ *
+ * The default is UChar=char16_t.
+ *
+ * C++11 defines char16_t as bit-compatible with uint16_t, but as a distinct type.
+ *
+ * In C, char16_t is a simple typedef of uint_least16_t.
+ * ICU requires uint_least16_t=uint16_t for data memory mapping.
+ * On macOS, char16_t is not available because the uchar.h standard header is missing.
+ *
+ * @stable ICU 4.4
+ */
+
+#if 1
+    // #if 1 is normal. UChar defaults to char16_t in C++.
+    // For configuration testing of UChar=uint16_t temporarily change this to #if 0.
+    // The intltest Makefile #defines UCHAR_TYPE=char16_t,
+    // so we only #define it to uint16_t if it is undefined so far.
+#elif !defined(UCHAR_TYPE)
+#   define UCHAR_TYPE uint16_t
+#endif
+
+#if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || \
+        defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
+    // Inside the ICU library code, never configurable.
+    typedef char16_t UChar;
+#elif defined(UCHAR_TYPE)
+    typedef UCHAR_TYPE UChar;
+#elif defined(__cplusplus)
+    typedef char16_t UChar;
+#else
+    typedef uint16_t UChar;
+#endif
+
+/**
+ * \var OldUChar
+ * Default ICU 58 definition of UChar.
+ * A base type for UTF-16 code units and pointers.
+ * Unsigned 16-bit integer.
+ *
+ * Define OldUChar to be wchar_t if that is 16 bits wide.
+ * If wchar_t is not 16 bits wide, then define UChar to be uint16_t.
+ *
+ * This makes the definition of OldUChar platform-dependent
+ * but allows direct string type compatibility with platforms with
+ * 16-bit wchar_t types.
+ *
+ * This is how UChar was defined in ICU 58, for transition convenience.
+ * Exception: ICU 58 UChar was defined to UCHAR_TYPE if that macro was defined.
+ * The current UChar responds to UCHAR_TYPE but OldUChar does not.
+ *
+ * @stable ICU 59
+ */
+#if U_SIZEOF_WCHAR_T==2
+    typedef wchar_t OldUChar;
+#elif defined(__CHAR16_TYPE__)
+    typedef __CHAR16_TYPE__ OldUChar;
+#else
+    typedef uint16_t OldUChar;
+#endif
+
+/**
+ * Define UChar32 as a type for single Unicode code points.
+ * UChar32 is a signed 32-bit integer (same as int32_t).
+ *
+ * The Unicode code point range is 0..0x10ffff.
+ * All other values (negative or >=0x110000) are illegal as Unicode code points.
+ * They may be used as sentinel values to indicate "done", "error"
+ * or similar non-code point conditions.
+ *
+ * Before ICU 2.4 (Jitterbug 2146), UChar32 was defined
+ * to be wchar_t if that is 32 bits wide (wchar_t may be signed or unsigned)
+ * or else to be uint32_t.
+ * That is, the definition of UChar32 was platform-dependent.
+ *
+ * @see U_SENTINEL
+ * @stable ICU 2.4
+ */
+typedef int32_t UChar32;
+
+/**
+ * This value is intended for sentinel values for APIs that
+ * (take or) return single code points (UChar32).
+ * It is outside of the Unicode code point range 0..0x10ffff.
+ *
+ * For example, a "done" or "error" value in a new API
+ * could be indicated with U_SENTINEL.
+ *
+ * ICU APIs designed before ICU 2.4 usually define service-specific "done"
+ * values, mostly 0xffff.
+ * Those may need to be distinguished from
+ * actual U+ffff text contents by calling functions like
+ * CharacterIterator::hasNext() or UnicodeString::length().
+ *
+ * @return -1
+ * @see UChar32
+ * @stable ICU 2.4
+ */
+#define U_SENTINEL (-1)
+
+#include "unicode/urename.h"
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/urename.h b/src/library/ts/src/tree-sitter/lib/src/unicode/urename.h
new file mode 100644
index 0000000000..ac79ad0f98
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/urename.h
@@ -0,0 +1 @@
+// This file must exist in order for `utf8.h` and `utf16.h` to be used.
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/utf.h b/src/library/ts/src/tree-sitter/lib/src/unicode/utf.h
new file mode 100644
index 0000000000..ac79ad0f98
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/utf.h
@@ -0,0 +1 @@
+// This file must exist in order for `utf8.h` and `utf16.h` to be used.
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/utf16.h b/src/library/ts/src/tree-sitter/lib/src/unicode/utf16.h
new file mode 100644
index 0000000000..9fd7d5c8a7
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/utf16.h
@@ -0,0 +1,733 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+*
+*   Copyright (C) 1999-2012, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  utf16.h
+*   encoding:   UTF-8
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 1999sep09
+*   created by: Markus W. Scherer
+*/
+
+/**
+ * \file
+ * \brief C API: 16-bit Unicode handling macros
+ * 
+ * This file defines macros to deal with 16-bit Unicode (UTF-16) code units and strings.
+ *
+ * For more information see utf.h and the ICU User Guide Strings chapter
+ * (http://userguide.icu-project.org/strings).
+ *
+ * <em>Usage:</em>
+ * ICU coding guidelines for if() statements should be followed when using these macros.
+ * Compound statements (curly braces {}) must be used  for if-else-while... 
+ * bodies and all macro statements should be terminated with semicolon.
+ */
+
+#ifndef __UTF16_H__
+#define __UTF16_H__
+
+#include "unicode/umachine.h"
+#ifndef __UTF_H__
+#   include "unicode/utf.h"
+#endif
+
+/* single-code point definitions -------------------------------------------- */
+
+/**
+ * Does this code unit alone encode a code point (BMP, not a surrogate)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U16_IS_SINGLE(c) !U_IS_SURROGATE(c)
+
+/**
+ * Is this code unit a lead surrogate (U+d800..U+dbff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
+
+/**
+ * Is this code unit a trail surrogate (U+dc00..U+dfff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
+
+/**
+ * Is this code unit a surrogate (U+d800..U+dfff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U16_IS_SURROGATE(c) U_IS_SURROGATE(c)
+
+/**
+ * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
+ * is it a lead surrogate?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
+
+/**
+ * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
+ * is it a trail surrogate?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 4.2
+ */
+#define U16_IS_SURROGATE_TRAIL(c) (((c)&0x400)!=0)
+
+/**
+ * Helper constant for U16_GET_SUPPLEMENTARY.
+ * @internal
+ */
+#define U16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
+
+/**
+ * Get a supplementary code point value (U+10000..U+10ffff)
+ * from its lead and trail surrogates.
+ * The result is undefined if the input values are not
+ * lead and trail surrogates.
+ *
+ * @param lead lead surrogate (U+d800..U+dbff)
+ * @param trail trail surrogate (U+dc00..U+dfff)
+ * @return supplementary code point (U+10000..U+10ffff)
+ * @stable ICU 2.4
+ */
+#define U16_GET_SUPPLEMENTARY(lead, trail) \
+    (((UChar32)(lead)<<10UL)+(UChar32)(trail)-U16_SURROGATE_OFFSET)
+
+
+/**
+ * Get the lead surrogate (0xd800..0xdbff) for a
+ * supplementary code point (0x10000..0x10ffff).
+ * @param supplementary 32-bit code point (U+10000..U+10ffff)
+ * @return lead surrogate (U+d800..U+dbff) for supplementary
+ * @stable ICU 2.4
+ */
+#define U16_LEAD(supplementary) (UChar)(((supplementary)>>10)+0xd7c0)
+
+/**
+ * Get the trail surrogate (0xdc00..0xdfff) for a
+ * supplementary code point (0x10000..0x10ffff).
+ * @param supplementary 32-bit code point (U+10000..U+10ffff)
+ * @return trail surrogate (U+dc00..U+dfff) for supplementary
+ * @stable ICU 2.4
+ */
+#define U16_TRAIL(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00)
+
+/**
+ * How many 16-bit code units are used to encode this Unicode code point? (1 or 2)
+ * The result is not defined if c is not a Unicode code point (U+0000..U+10ffff).
+ * @param c 32-bit code point
+ * @return 1 or 2
+ * @stable ICU 2.4
+ */
+#define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
+
+/**
+ * The maximum number of 16-bit code units per Unicode code point (U+0000..U+10ffff).
+ * @return 2
+ * @stable ICU 2.4
+ */
+#define U16_MAX_LENGTH 2
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * The offset may point to either the lead or trail surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the adjacent matching surrogate as well.
+ * The result is undefined if the offset points to a single, unpaired surrogate.
+ * Iteration through a string is more efficient with U16_NEXT_UNSAFE or U16_NEXT.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U16_GET
+ * @stable ICU 2.4
+ */
+#define U16_GET_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[i]; \
+    if(U16_IS_SURROGATE(c)) { \
+        if(U16_IS_SURROGATE_LEAD(c)) { \
+            (c)=U16_GET_SUPPLEMENTARY((c), (s)[(i)+1]); \
+        } else { \
+            (c)=U16_GET_SUPPLEMENTARY((s)[(i)-1], (c)); \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The offset may point to either the lead or trail surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the adjacent matching surrogate as well.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * If the offset points to a single, unpaired surrogate, then
+ * c is set to that unpaired surrogate.
+ * Iteration through a string is more efficient with U16_NEXT_UNSAFE or U16_NEXT.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<=i<length
+ * @param length string length
+ * @param c output UChar32 variable
+ * @see U16_GET_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[i]; \
+    if(U16_IS_SURROGATE(c)) { \
+        uint16_t __c2; \
+        if(U16_IS_SURROGATE_LEAD(c)) { \
+            if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \
+                (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+            } \
+        } else { \
+            if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \
+                (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \
+            } \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The offset may point to either the lead or trail surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the adjacent matching surrogate as well.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * If the offset points to a single, unpaired surrogate, then
+ * c is set to U+FFFD.
+ * Iteration through a string is more efficient with U16_NEXT_UNSAFE or U16_NEXT_OR_FFFD.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<=i<length
+ * @param length string length
+ * @param c output UChar32 variable
+ * @see U16_GET_UNSAFE
+ * @stable ICU 60
+ */
+#define U16_GET_OR_FFFD(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[i]; \
+    if(U16_IS_SURROGATE(c)) { \
+        uint16_t __c2; \
+        if(U16_IS_SURROGATE_LEAD(c)) { \
+            if((i)+1!=(length) && U16_IS_TRAIL(__c2=(s)[(i)+1])) { \
+                (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+            } else { \
+                (c)=0xfffd; \
+            } \
+        } else { \
+            if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \
+                (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \
+            } else { \
+                (c)=0xfffd; \
+            } \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/* definitions with forward iteration --------------------------------------- */
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * The offset may point to the lead surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the following trail surrogate as well.
+ * If the offset points to a trail surrogate, then that itself
+ * will be returned as the code point.
+ * The result is undefined if the offset points to a single, unpaired lead surrogate.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U16_NEXT
+ * @stable ICU 2.4
+ */
+#define U16_NEXT_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[(i)++]; \
+    if(U16_IS_LEAD(c)) { \
+        (c)=U16_GET_SUPPLEMENTARY((c), (s)[(i)++]); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the following trail surrogate as well.
+ * If the offset points to a trail surrogate or
+ * to a single, unpaired lead surrogate, then c is set to that unpaired surrogate.
+ *
+ * @param s const UChar * string
+ * @param i string offset, must be i<length
+ * @param length string length
+ * @param c output UChar32 variable
+ * @see U16_NEXT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_NEXT(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[(i)++]; \
+    if(U16_IS_LEAD(c)) { \
+        uint16_t __c2; \
+        if((i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \
+            ++(i); \
+            (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the following trail surrogate as well.
+ * If the offset points to a trail surrogate or
+ * to a single, unpaired lead surrogate, then c is set to U+FFFD.
+ *
+ * @param s const UChar * string
+ * @param i string offset, must be i<length
+ * @param length string length
+ * @param c output UChar32 variable
+ * @see U16_NEXT_UNSAFE
+ * @stable ICU 60
+ */
+#define U16_NEXT_OR_FFFD(s, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[(i)++]; \
+    if(U16_IS_SURROGATE(c)) { \
+        uint16_t __c2; \
+        if(U16_IS_SURROGATE_LEAD(c) && (i)!=(length) && U16_IS_TRAIL(__c2=(s)[(i)])) { \
+            ++(i); \
+            (c)=U16_GET_SUPPLEMENTARY((c), __c2); \
+        } else { \
+            (c)=0xfffd; \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Append a code point to a string, overwriting 1 or 2 code units.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
+ * Otherwise, the result is undefined.
+ *
+ * @param s const UChar * string buffer
+ * @param i string offset
+ * @param c code point to append
+ * @see U16_APPEND
+ * @stable ICU 2.4
+ */
+#define U16_APPEND_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    if((uint32_t)(c)<=0xffff) { \
+        (s)[(i)++]=(uint16_t)(c); \
+    } else { \
+        (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
+        (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Append a code point to a string, overwriting 1 or 2 code units.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Safe" macro, checks for a valid code point.
+ * If a surrogate pair is written, checks for sufficient space in the string.
+ * If the code point is not valid or a trail surrogate does not fit,
+ * then isError is set to TRUE.
+ *
+ * @param s const UChar * string buffer
+ * @param i string offset, must be i<capacity
+ * @param capacity size of the string buffer
+ * @param c code point to append
+ * @param isError output UBool set to TRUE if an error occurs, otherwise not modified
+ * @see U16_APPEND_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \
+    if((uint32_t)(c)<=0xffff) { \
+        (s)[(i)++]=(uint16_t)(c); \
+    } else if((uint32_t)(c)<=0x10ffff && (i)+1<(capacity)) { \
+        (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
+        (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
+    } else /* c>0x10ffff or not enough space */ { \
+        (isError)=TRUE; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the next.
+ * (Post-incrementing iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @see U16_FWD_1
+ * @stable ICU 2.4
+ */
+#define U16_FWD_1_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_LEAD((s)[(i)++])) { \
+        ++(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the next.
+ * (Post-incrementing iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const UChar * string
+ * @param i string offset, must be i<length
+ * @param length string length
+ * @see U16_FWD_1_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_FWD_1(s, i, length) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_LEAD((s)[(i)++]) && (i)!=(length) && U16_IS_TRAIL((s)[i])) { \
+        ++(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the n-th next one,
+ * i.e., move forward by n code points.
+ * (Post-incrementing iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @param n number of code points to skip
+ * @see U16_FWD_N
+ * @stable ICU 2.4
+ */
+#define U16_FWD_N_UNSAFE(s, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0) { \
+        U16_FWD_1_UNSAFE(s, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the n-th next one,
+ * i.e., move forward by n code points.
+ * (Post-incrementing iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const UChar * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @param n number of code points to skip
+ * @see U16_FWD_N_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_FWD_N(s, i, length, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0 && ((i)<(length) || ((length)<0 && (s)[i]!=0))) { \
+        U16_FWD_1(s, i, length); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary
+ * at the start of a code point.
+ * If the offset points to the trail surrogate of a surrogate pair,
+ * then the offset is decremented.
+ * Otherwise, it is not modified.
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @see U16_SET_CP_START
+ * @stable ICU 2.4
+ */
+#define U16_SET_CP_START_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_TRAIL((s)[i])) { \
+        --(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary
+ * at the start of a code point.
+ * If the offset points to the trail surrogate of a surrogate pair,
+ * then the offset is decremented.
+ * Otherwise, it is not modified.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<=i
+ * @see U16_SET_CP_START_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_SET_CP_START(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_TRAIL((s)[i]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \
+        --(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/* definitions with backward iteration -------------------------------------- */
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a trail surrogate unit
+ * for a supplementary code point, then the macro will read
+ * the preceding lead surrogate as well.
+ * If the offset is behind a lead surrogate, then that itself
+ * will be returned as the code point.
+ * The result is undefined if the offset is behind a single, unpaired trail surrogate.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U16_PREV
+ * @stable ICU 2.4
+ */
+#define U16_PREV_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[--(i)]; \
+    if(U16_IS_TRAIL(c)) { \
+        (c)=U16_GET_SUPPLEMENTARY((s)[--(i)], (c)); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a trail surrogate unit
+ * for a supplementary code point, then the macro will read
+ * the preceding lead surrogate as well.
+ * If the offset is behind a lead surrogate or behind a single, unpaired
+ * trail surrogate, then c is set to that unpaired surrogate.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<i
+ * @param c output UChar32 variable
+ * @see U16_PREV_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_PREV(s, start, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[--(i)]; \
+    if(U16_IS_TRAIL(c)) { \
+        uint16_t __c2; \
+        if((i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \
+            --(i); \
+            (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a trail surrogate unit
+ * for a supplementary code point, then the macro will read
+ * the preceding lead surrogate as well.
+ * If the offset is behind a lead surrogate or behind a single, unpaired
+ * trail surrogate, then c is set to U+FFFD.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<i
+ * @param c output UChar32 variable
+ * @see U16_PREV_UNSAFE
+ * @stable ICU 60
+ */
+#define U16_PREV_OR_FFFD(s, start, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(s)[--(i)]; \
+    if(U16_IS_SURROGATE(c)) { \
+        uint16_t __c2; \
+        if(U16_IS_SURROGATE_TRAIL(c) && (i)>(start) && U16_IS_LEAD(__c2=(s)[(i)-1])) { \
+            --(i); \
+            (c)=U16_GET_SUPPLEMENTARY(__c2, (c)); \
+        } else { \
+            (c)=0xfffd; \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @see U16_BACK_1
+ * @stable ICU 2.4
+ */
+#define U16_BACK_1_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_TRAIL((s)[--(i)])) { \
+        --(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * @param s const UChar * string
+ * @param start starting string offset (usually 0)
+ * @param i string offset, must be start<i
+ * @see U16_BACK_1_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_BACK_1(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_TRAIL((s)[--(i)]) && (i)>(start) && U16_IS_LEAD((s)[(i)-1])) { \
+        --(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the n-th one before it,
+ * i.e., move backward by n code points.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @param n number of code points to skip
+ * @see U16_BACK_N
+ * @stable ICU 2.4
+ */
+#define U16_BACK_N_UNSAFE(s, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0) { \
+        U16_BACK_1_UNSAFE(s, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the n-th one before it,
+ * i.e., move backward by n code points.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * @param s const UChar * string
+ * @param start start of string
+ * @param i string offset, must be start<i
+ * @param n number of code points to skip
+ * @see U16_BACK_N_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_BACK_N(s, start, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0 && (i)>(start)) { \
+        U16_BACK_1(s, start, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary after a code point.
+ * If the offset is behind the lead surrogate of a surrogate pair,
+ * then the offset is incremented.
+ * Otherwise, it is not modified.
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-16.
+ *
+ * @param s const UChar * string
+ * @param i string offset
+ * @see U16_SET_CP_LIMIT
+ * @stable ICU 2.4
+ */
+#define U16_SET_CP_LIMIT_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U16_IS_LEAD((s)[(i)-1])) { \
+        ++(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary after a code point.
+ * If the offset is behind the lead surrogate of a surrogate pair,
+ * then the offset is incremented.
+ * Otherwise, it is not modified.
+ * The input offset may be the same as the string length.
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const UChar * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, start<=i<=length
+ * @param length int32_t string length
+ * @see U16_SET_CP_LIMIT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U16_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \
+    if((start)<(i) && ((i)<(length) || (length)<0) && U16_IS_LEAD((s)[(i)-1]) && U16_IS_TRAIL((s)[i])) { \
+        ++(i); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/unicode/utf8.h b/src/library/ts/src/tree-sitter/lib/src/unicode/utf8.h
new file mode 100644
index 0000000000..bb00130374
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/unicode/utf8.h
@@ -0,0 +1,881 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+*
+*   Copyright (C) 1999-2015, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  utf8.h
+*   encoding:   UTF-8
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 1999sep13
+*   created by: Markus W. Scherer
+*/
+
+/**
+ * \file
+ * \brief C API: 8-bit Unicode handling macros
+ *
+ * This file defines macros to deal with 8-bit Unicode (UTF-8) code units (bytes) and strings.
+ *
+ * For more information see utf.h and the ICU User Guide Strings chapter
+ * (http://userguide.icu-project.org/strings).
+ *
+ * <em>Usage:</em>
+ * ICU coding guidelines for if() statements should be followed when using these macros.
+ * Compound statements (curly braces {}) must be used  for if-else-while...
+ * bodies and all macro statements should be terminated with semicolon.
+ */
+
+#ifndef __UTF8_H__
+#define __UTF8_H__
+
+#include "unicode/umachine.h"
+#ifndef __UTF_H__
+#   include "unicode/utf.h"
+#endif
+
+/* internal definitions ----------------------------------------------------- */
+
+/**
+ * Counts the trail bytes for a UTF-8 lead byte.
+ * Returns 0 for 0..0xc1 as well as for 0xf5..0xff.
+ * leadByte might be evaluated multiple times.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is called by public macros in this file and thus must remain stable.
+ *
+ * @param leadByte The first byte of a UTF-8 sequence. Must be 0..0xff.
+ * @internal
+ */
+#define U8_COUNT_TRAIL_BYTES(leadByte) \
+    (U8_IS_LEAD(leadByte) ? \
+        ((uint8_t)(leadByte)>=0xe0)+((uint8_t)(leadByte)>=0xf0)+1 : 0)
+
+/**
+ * Counts the trail bytes for a UTF-8 lead byte of a valid UTF-8 sequence.
+ * Returns 0 for 0..0xc1. Undefined for 0xf5..0xff.
+ * leadByte might be evaluated multiple times.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is called by public macros in this file and thus must remain stable.
+ *
+ * @param leadByte The first byte of a UTF-8 sequence. Must be 0..0xff.
+ * @internal
+ */
+#define U8_COUNT_TRAIL_BYTES_UNSAFE(leadByte) \
+    (((uint8_t)(leadByte)>=0xc2)+((uint8_t)(leadByte)>=0xe0)+((uint8_t)(leadByte)>=0xf0))
+
+/**
+ * Mask a UTF-8 lead byte, leave only the lower bits that form part of the code point value.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is called by public macros in this file and thus must remain stable.
+ * @internal
+ */
+#define U8_MASK_LEAD_BYTE(leadByte, countTrailBytes) ((leadByte)&=(1<<(6-(countTrailBytes)))-1)
+
+/**
+ * Internal bit vector for 3-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD3_AND_T1.
+ * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
+ * Lead byte E0..EF bits 3..0 are used as byte index,
+ * first trail byte bits 7..5 are used as bit index into that byte.
+ * @see U8_IS_VALID_LEAD3_AND_T1
+ * @internal
+ */
+#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
+
+/**
+ * Internal 3-byte UTF-8 validity check.
+ * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid sequence.
+ * @internal
+ */
+#define U8_IS_VALID_LEAD3_AND_T1(lead, t1) (U8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5)))
+
+/**
+ * Internal bit vector for 4-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD4_AND_T1.
+ * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
+ * First trail byte bits 7..4 are used as byte index,
+ * lead byte F0..F4 bits 2..0 are used as bit index into that byte.
+ * @see U8_IS_VALID_LEAD4_AND_T1
+ * @internal
+ */
+#define U8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
+
+/**
+ * Internal 4-byte UTF-8 validity check.
+ * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid sequence.
+ * @internal
+ */
+#define U8_IS_VALID_LEAD4_AND_T1(lead, t1) (U8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7)))
+
+/**
+ * Function for handling "next code point" with error-checking.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * file and thus must remain stable, and should not be hidden when other internal
+ * functions are hidden (otherwise public macros would fail to compile).
+ * @internal
+ */
+U_STABLE UChar32 U_EXPORT2
+utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, UBool strict);
+
+/**
+ * Function for handling "append code point" with error-checking.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * file and thus must remain stable, and should not be hidden when other internal
+ * functions are hidden (otherwise public macros would fail to compile).
+ * @internal
+ */
+U_STABLE int32_t U_EXPORT2
+utf8_appendCharSafeBody(uint8_t *s, int32_t i, int32_t length, UChar32 c, UBool *pIsError);
+
+/**
+ * Function for handling "previous code point" with error-checking.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * file and thus must remain stable, and should not be hidden when other internal
+ * functions are hidden (otherwise public macros would fail to compile).
+ * @internal
+ */
+U_STABLE UChar32 U_EXPORT2
+utf8_prevCharSafeBody(const uint8_t *s, int32_t start, int32_t *pi, UChar32 c, UBool strict);
+
+/**
+ * Function for handling "skip backward one code point" with error-checking.
+ *
+ * This is internal since it is not meant to be called directly by external clients;
+ * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this
+ * file and thus must remain stable, and should not be hidden when other internal
+ * functions are hidden (otherwise public macros would fail to compile).
+ * @internal
+ */
+U_STABLE int32_t U_EXPORT2
+utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i);
+
+/* single-code point definitions -------------------------------------------- */
+
+/**
+ * Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)?
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U8_IS_SINGLE(c) (((c)&0x80)==0)
+
+/**
+ * Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4)
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32)
+// 0x32=0xf4-0xc2
+
+/**
+ * Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF)
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define U8_IS_TRAIL(c) ((int8_t)(c)<-0x40)
+
+/**
+ * How many code units (bytes) are used for the UTF-8 encoding
+ * of this Unicode code point?
+ * @param c 32-bit code point
+ * @return 1..4, or 0 if c is a surrogate or not a Unicode code point
+ * @stable ICU 2.4
+ */
+#define U8_LENGTH(c) \
+    ((uint32_t)(c)<=0x7f ? 1 : \
+        ((uint32_t)(c)<=0x7ff ? 2 : \
+            ((uint32_t)(c)<=0xd7ff ? 3 : \
+                ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \
+                    ((uint32_t)(c)<=0xffff ? 3 : 4)\
+                ) \
+            ) \
+        ) \
+    )
+
+/**
+ * The maximum number of UTF-8 code units (bytes) per Unicode code point (U+0000..U+10ffff).
+ * @return 4
+ * @stable ICU 2.4
+ */
+#define U8_MAX_LENGTH 4
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * The offset may point to either the lead byte or one of the trail bytes
+ * for a code point, in which case the macro will read all of the bytes
+ * for the code point.
+ * The result is undefined if the offset points to an illegal UTF-8
+ * byte sequence.
+ * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U8_GET
+ * @stable ICU 2.4
+ */
+#define U8_GET_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t _u8_get_unsafe_index=(int32_t)(i); \
+    U8_SET_CP_START_UNSAFE(s, _u8_get_unsafe_index); \
+    U8_NEXT_UNSAFE(s, _u8_get_unsafe_index, c); \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * The offset may point to either the lead byte or one of the trail bytes
+ * for a code point, in which case the macro will read all of the bytes
+ * for the code point.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * If the offset points to an illegal UTF-8 byte sequence, then
+ * c is set to a negative value.
+ * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset
+ * @param i int32_t string offset, must be start<=i<length
+ * @param length int32_t string length
+ * @param c output UChar32 variable, set to <0 in case of an error
+ * @see U8_GET_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_GET(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t _u8_get_index=(i); \
+    U8_SET_CP_START(s, start, _u8_get_index); \
+    U8_NEXT(s, _u8_get_index, length, c); \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a random-access offset,
+ * without changing the offset.
+ * The offset may point to either the lead byte or one of the trail bytes
+ * for a code point, in which case the macro will read all of the bytes
+ * for the code point.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * If the offset points to an illegal UTF-8 byte sequence, then
+ * c is set to U+FFFD.
+ * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT_OR_FFFD.
+ *
+ * This macro does not distinguish between a real U+FFFD in the text
+ * and U+FFFD returned for an ill-formed sequence.
+ * Use U8_GET() if that distinction is important.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset
+ * @param i int32_t string offset, must be start<=i<length
+ * @param length int32_t string length
+ * @param c output UChar32 variable, set to U+FFFD in case of an error
+ * @see U8_GET
+ * @stable ICU 51
+ */
+#define U8_GET_OR_FFFD(s, start, i, length, c) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t _u8_get_index=(i); \
+    U8_SET_CP_START(s, start, _u8_get_index); \
+    U8_NEXT_OR_FFFD(s, _u8_get_index, length, c); \
+} UPRV_BLOCK_MACRO_END
+
+/* definitions with forward iteration --------------------------------------- */
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * The offset may point to the lead byte of a multi-byte sequence,
+ * in which case the macro will read the whole sequence.
+ * The result is undefined if the offset points to a trail byte
+ * or an illegal UTF-8 sequence.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U8_NEXT
+ * @stable ICU 2.4
+ */
+#define U8_NEXT_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(uint8_t)(s)[(i)++]; \
+    if(!U8_IS_SINGLE(c)) { \
+        if((c)<0xe0) { \
+            (c)=(((c)&0x1f)<<6)|((s)[(i)++]&0x3f); \
+        } else if((c)<0xf0) { \
+            /* no need for (c&0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ \
+            (c)=(UChar)(((c)<<12)|(((s)[i]&0x3f)<<6)|((s)[(i)+1]&0x3f)); \
+            (i)+=2; \
+        } else { \
+            (c)=(((c)&7)<<18)|(((s)[i]&0x3f)<<12)|(((s)[(i)+1]&0x3f)<<6)|((s)[(i)+2]&0x3f); \
+            (i)+=3; \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead byte of a multi-byte sequence,
+ * in which case the macro will read the whole sequence.
+ * If the offset points to a trail byte or an illegal UTF-8 sequence, then
+ * c is set to a negative value.
+ *
+ * @param s const uint8_t * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @param c output UChar32 variable, set to <0 in case of an error
+ * @see U8_NEXT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_NEXT(s, i, length, c) U8_INTERNAL_NEXT_OR_SUB(s, i, length, c, U_SENTINEL)
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead byte of a multi-byte sequence,
+ * in which case the macro will read the whole sequence.
+ * If the offset points to a trail byte or an illegal UTF-8 sequence, then
+ * c is set to U+FFFD.
+ *
+ * This macro does not distinguish between a real U+FFFD in the text
+ * and U+FFFD returned for an ill-formed sequence.
+ * Use U8_NEXT() if that distinction is important.
+ *
+ * @param s const uint8_t * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @param c output UChar32 variable, set to U+FFFD in case of an error
+ * @see U8_NEXT
+ * @stable ICU 51
+ */
+#define U8_NEXT_OR_FFFD(s, i, length, c) U8_INTERNAL_NEXT_OR_SUB(s, i, length, c, 0xfffd)
+
+/** @internal */
+#define U8_INTERNAL_NEXT_OR_SUB(s, i, length, c, sub) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(uint8_t)(s)[(i)++]; \
+    if(!U8_IS_SINGLE(c)) { \
+        uint8_t __t = 0; \
+        if((i)!=(length) && \
+            /* fetch/validate/assemble all but last trail byte */ \
+            ((c)>=0xe0 ? \
+                ((c)<0xf0 ?  /* U+0800..U+FFFF except surrogates */ \
+                    U8_LEAD3_T1_BITS[(c)&=0xf]&(1<<((__t=(s)[i])>>5)) && \
+                    (__t&=0x3f, 1) \
+                :  /* U+10000..U+10FFFF */ \
+                    ((c)-=0xf0)<=4 && \
+                    U8_LEAD4_T1_BITS[(__t=(s)[i])>>4]&(1<<(c)) && \
+                    ((c)=((c)<<6)|(__t&0x3f), ++(i)!=(length)) && \
+                    (__t=(s)[i]-0x80)<=0x3f) && \
+                /* valid second-to-last trail byte */ \
+                ((c)=((c)<<6)|__t, ++(i)!=(length)) \
+            :  /* U+0080..U+07FF */ \
+                (c)>=0xc2 && ((c)&=0x1f, 1)) && \
+            /* last trail byte */ \
+            (__t=(s)[i]-0x80)<=0x3f && \
+            ((c)=((c)<<6)|__t, ++(i), 1)) { \
+        } else { \
+            (c)=(sub);  /* ill-formed*/ \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Append a code point to a string, overwriting 1 to 4 bytes.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
+ * Otherwise, the result is undefined.
+ *
+ * @param s const uint8_t * string buffer
+ * @param i string offset
+ * @param c code point to append
+ * @see U8_APPEND
+ * @stable ICU 2.4
+ */
+#define U8_APPEND_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    uint32_t __uc=(c); \
+    if(__uc<=0x7f) { \
+        (s)[(i)++]=(uint8_t)__uc; \
+    } else { \
+        if(__uc<=0x7ff) { \
+            (s)[(i)++]=(uint8_t)((__uc>>6)|0xc0); \
+        } else { \
+            if(__uc<=0xffff) { \
+                (s)[(i)++]=(uint8_t)((__uc>>12)|0xe0); \
+            } else { \
+                (s)[(i)++]=(uint8_t)((__uc>>18)|0xf0); \
+                (s)[(i)++]=(uint8_t)(((__uc>>12)&0x3f)|0x80); \
+            } \
+            (s)[(i)++]=(uint8_t)(((__uc>>6)&0x3f)|0x80); \
+        } \
+        (s)[(i)++]=(uint8_t)((__uc&0x3f)|0x80); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Append a code point to a string, overwriting 1 to 4 bytes.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Safe" macro, checks for a valid code point.
+ * If a non-ASCII code point is written, checks for sufficient space in the string.
+ * If the code point is not valid or trail bytes do not fit,
+ * then isError is set to TRUE.
+ *
+ * @param s const uint8_t * string buffer
+ * @param i int32_t string offset, must be i<capacity
+ * @param capacity int32_t size of the string buffer
+ * @param c UChar32 code point to append
+ * @param isError output UBool set to TRUE if an error occurs, otherwise not modified
+ * @see U8_APPEND_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_APPEND(s, i, capacity, c, isError) UPRV_BLOCK_MACRO_BEGIN { \
+    uint32_t __uc=(c); \
+    if(__uc<=0x7f) { \
+        (s)[(i)++]=(uint8_t)__uc; \
+    } else if(__uc<=0x7ff && (i)+1<(capacity)) { \
+        (s)[(i)++]=(uint8_t)((__uc>>6)|0xc0); \
+        (s)[(i)++]=(uint8_t)((__uc&0x3f)|0x80); \
+    } else if((__uc<=0xd7ff || (0xe000<=__uc && __uc<=0xffff)) && (i)+2<(capacity)) { \
+        (s)[(i)++]=(uint8_t)((__uc>>12)|0xe0); \
+        (s)[(i)++]=(uint8_t)(((__uc>>6)&0x3f)|0x80); \
+        (s)[(i)++]=(uint8_t)((__uc&0x3f)|0x80); \
+    } else if(0xffff<__uc && __uc<=0x10ffff && (i)+3<(capacity)) { \
+        (s)[(i)++]=(uint8_t)((__uc>>18)|0xf0); \
+        (s)[(i)++]=(uint8_t)(((__uc>>12)&0x3f)|0x80); \
+        (s)[(i)++]=(uint8_t)(((__uc>>6)&0x3f)|0x80); \
+        (s)[(i)++]=(uint8_t)((__uc&0x3f)|0x80); \
+    } else { \
+        (isError)=TRUE; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the next.
+ * (Post-incrementing iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @see U8_FWD_1
+ * @stable ICU 2.4
+ */
+#define U8_FWD_1_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    (i)+=1+U8_COUNT_TRAIL_BYTES_UNSAFE((s)[i]); \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the next.
+ * (Post-incrementing iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const uint8_t * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @see U8_FWD_1_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_FWD_1(s, i, length) UPRV_BLOCK_MACRO_BEGIN { \
+    uint8_t __b=(s)[(i)++]; \
+    if(U8_IS_LEAD(__b) && (i)!=(length)) { \
+        uint8_t __t1=(s)[i]; \
+        if((0xe0<=__b && __b<0xf0)) { \
+            if(U8_IS_VALID_LEAD3_AND_T1(__b, __t1) && \
+                    ++(i)!=(length) && U8_IS_TRAIL((s)[i])) { \
+                ++(i); \
+            } \
+        } else if(__b<0xe0) { \
+            if(U8_IS_TRAIL(__t1)) { \
+                ++(i); \
+            } \
+        } else /* c>=0xf0 */ { \
+            if(U8_IS_VALID_LEAD4_AND_T1(__b, __t1) && \
+                    ++(i)!=(length) && U8_IS_TRAIL((s)[i]) && \
+                    ++(i)!=(length) && U8_IS_TRAIL((s)[i])) { \
+                ++(i); \
+            } \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the n-th next one,
+ * i.e., move forward by n code points.
+ * (Post-incrementing iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @param n number of code points to skip
+ * @see U8_FWD_N
+ * @stable ICU 2.4
+ */
+#define U8_FWD_N_UNSAFE(s, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0) { \
+        U8_FWD_1_UNSAFE(s, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Advance the string offset from one code point boundary to the n-th next one,
+ * i.e., move forward by n code points.
+ * (Post-incrementing iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const uint8_t * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @param n number of code points to skip
+ * @see U8_FWD_N_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_FWD_N(s, i, length, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0 && ((i)<(length) || ((length)<0 && (s)[i]!=0))) { \
+        U8_FWD_1(s, i, length); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary
+ * at the start of a code point.
+ * If the offset points to a UTF-8 trail byte,
+ * then the offset is moved backward to the corresponding lead byte.
+ * Otherwise, it is not modified.
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @see U8_SET_CP_START
+ * @stable ICU 2.4
+ */
+#define U8_SET_CP_START_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    while(U8_IS_TRAIL((s)[i])) { --(i); } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary
+ * at the start of a code point.
+ * If the offset points to a UTF-8 trail byte,
+ * then the offset is moved backward to the corresponding lead byte.
+ * Otherwise, it is not modified.
+ *
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ * Unlike U8_TRUNCATE_IF_INCOMPLETE(), this macro always reads s[i].
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, must be start<=i
+ * @see U8_SET_CP_START_UNSAFE
+ * @see U8_TRUNCATE_IF_INCOMPLETE
+ * @stable ICU 2.4
+ */
+#define U8_SET_CP_START(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U8_IS_TRAIL((s)[(i)])) { \
+        (i)=utf8_back1SafeBody(s, start, (i)); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * If the string ends with a UTF-8 byte sequence that is valid so far
+ * but incomplete, then reduce the length of the string to end before
+ * the lead byte of that incomplete sequence.
+ * For example, if the string ends with E1 80, the length is reduced by 2.
+ *
+ * In all other cases (the string ends with a complete sequence, or it is not
+ * possible for any further trail byte to extend the trailing sequence)
+ * the length remains unchanged.
+ *
+ * Useful for processing text split across multiple buffers
+ * (save the incomplete sequence for later)
+ * and for optimizing iteration
+ * (check for string length only once per character).
+ *
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ * Unlike U8_SET_CP_START(), this macro never reads s[length].
+ *
+ * (In UTF-16, simply check for U16_IS_LEAD(last code unit).)
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param length int32_t string length (usually start<=length)
+ * @see U8_SET_CP_START
+ * @stable ICU 61
+ */
+#define U8_TRUNCATE_IF_INCOMPLETE(s, start, length) UPRV_BLOCK_MACRO_BEGIN { \
+    if((length)>(start)) { \
+        uint8_t __b1=s[(length)-1]; \
+        if(U8_IS_SINGLE(__b1)) { \
+            /* common ASCII character */ \
+        } else if(U8_IS_LEAD(__b1)) { \
+            --(length); \
+        } else if(U8_IS_TRAIL(__b1) && ((length)-2)>=(start)) { \
+            uint8_t __b2=s[(length)-2]; \
+            if(0xe0<=__b2 && __b2<=0xf4) { \
+                if(__b2<0xf0 ? U8_IS_VALID_LEAD3_AND_T1(__b2, __b1) : \
+                        U8_IS_VALID_LEAD4_AND_T1(__b2, __b1)) { \
+                    (length)-=2; \
+                } \
+            } else if(U8_IS_TRAIL(__b2) && ((length)-3)>=(start)) { \
+                uint8_t __b3=s[(length)-3]; \
+                if(0xf0<=__b3 && __b3<=0xf4 && U8_IS_VALID_LEAD4_AND_T1(__b3, __b2)) { \
+                    (length)-=3; \
+                } \
+            } \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/* definitions with backward iteration -------------------------------------- */
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a multi-byte sequence, then the macro will read
+ * the whole sequence.
+ * If the offset is behind a lead byte, then that itself
+ * will be returned as the code point.
+ * The result is undefined if the offset is behind an illegal UTF-8 sequence.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @param c output UChar32 variable
+ * @see U8_PREV
+ * @stable ICU 2.4
+ */
+#define U8_PREV_UNSAFE(s, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(uint8_t)(s)[--(i)]; \
+    if(U8_IS_TRAIL(c)) { \
+        uint8_t __b, __count=1, __shift=6; \
+\
+        /* c is a trail byte */ \
+        (c)&=0x3f; \
+        for(;;) { \
+            __b=(s)[--(i)]; \
+            if(__b>=0xc0) { \
+                U8_MASK_LEAD_BYTE(__b, __count); \
+                (c)|=(UChar32)__b<<__shift; \
+                break; \
+            } else { \
+                (c)|=(UChar32)(__b&0x3f)<<__shift; \
+                ++__count; \
+                __shift+=6; \
+            } \
+        } \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a multi-byte sequence, then the macro will read
+ * the whole sequence.
+ * If the offset is behind a lead byte, then that itself
+ * will be returned as the code point.
+ * If the offset is behind an illegal UTF-8 sequence, then c is set to a negative value.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, must be start<i
+ * @param c output UChar32 variable, set to <0 in case of an error
+ * @see U8_PREV_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_PREV(s, start, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(uint8_t)(s)[--(i)]; \
+    if(!U8_IS_SINGLE(c)) { \
+        (c)=utf8_prevCharSafeBody((const uint8_t *)s, start, &(i), c, -1); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one
+ * and get the code point between them.
+ * (Pre-decrementing backward iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The input offset may be the same as the string length.
+ * If the offset is behind a multi-byte sequence, then the macro will read
+ * the whole sequence.
+ * If the offset is behind a lead byte, then that itself
+ * will be returned as the code point.
+ * If the offset is behind an illegal UTF-8 sequence, then c is set to U+FFFD.
+ *
+ * This macro does not distinguish between a real U+FFFD in the text
+ * and U+FFFD returned for an ill-formed sequence.
+ * Use U8_PREV() if that distinction is important.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, must be start<i
+ * @param c output UChar32 variable, set to U+FFFD in case of an error
+ * @see U8_PREV
+ * @stable ICU 51
+ */
+#define U8_PREV_OR_FFFD(s, start, i, c) UPRV_BLOCK_MACRO_BEGIN { \
+    (c)=(uint8_t)(s)[--(i)]; \
+    if(!U8_IS_SINGLE(c)) { \
+        (c)=utf8_prevCharSafeBody((const uint8_t *)s, start, &(i), c, -3); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @see U8_BACK_1
+ * @stable ICU 2.4
+ */
+#define U8_BACK_1_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    while(U8_IS_TRAIL((s)[--(i)])) {} \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the previous one.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, must be start<i
+ * @see U8_BACK_1_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_BACK_1(s, start, i) UPRV_BLOCK_MACRO_BEGIN { \
+    if(U8_IS_TRAIL((s)[--(i)])) { \
+        (i)=utf8_back1SafeBody(s, start, (i)); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the n-th one before it,
+ * i.e., move backward by n code points.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @param n number of code points to skip
+ * @see U8_BACK_N
+ * @stable ICU 2.4
+ */
+#define U8_BACK_N_UNSAFE(s, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0) { \
+        U8_BACK_1_UNSAFE(s, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Move the string offset from one code point boundary to the n-th one before it,
+ * i.e., move backward by n code points.
+ * (Pre-decrementing backward iteration.)
+ * The input offset may be the same as the string length.
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t index of the start of the string
+ * @param i int32_t string offset, must be start<i
+ * @param n number of code points to skip
+ * @see U8_BACK_N_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_BACK_N(s, start, i, n) UPRV_BLOCK_MACRO_BEGIN { \
+    int32_t __N=(n); \
+    while(__N>0 && (i)>(start)) { \
+        U8_BACK_1(s, start, i); \
+        --__N; \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary after a code point.
+ * If the offset is behind a partial multi-byte sequence,
+ * then the offset is incremented to behind the whole sequence.
+ * Otherwise, it is not modified.
+ * The input offset may be the same as the string length.
+ * "Unsafe" macro, assumes well-formed UTF-8.
+ *
+ * @param s const uint8_t * string
+ * @param i string offset
+ * @see U8_SET_CP_LIMIT
+ * @stable ICU 2.4
+ */
+#define U8_SET_CP_LIMIT_UNSAFE(s, i) UPRV_BLOCK_MACRO_BEGIN { \
+    U8_BACK_1_UNSAFE(s, i); \
+    U8_FWD_1_UNSAFE(s, i); \
+} UPRV_BLOCK_MACRO_END
+
+/**
+ * Adjust a random-access offset to a code point boundary after a code point.
+ * If the offset is behind a partial multi-byte sequence,
+ * then the offset is incremented to behind the whole sequence.
+ * Otherwise, it is not modified.
+ * The input offset may be the same as the string length.
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * @param s const uint8_t * string
+ * @param start int32_t starting string offset (usually 0)
+ * @param i int32_t string offset, must be start<=i<=length
+ * @param length int32_t string length
+ * @see U8_SET_CP_LIMIT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define U8_SET_CP_LIMIT(s, start, i, length) UPRV_BLOCK_MACRO_BEGIN { \
+    if((start)<(i) && ((i)<(length) || (length)<0)) { \
+        U8_BACK_1(s, start, i); \
+        U8_FWD_1(s, i, length); \
+    } \
+} UPRV_BLOCK_MACRO_END
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib-symbols.txt b/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib-symbols.txt
new file mode 100644
index 0000000000..1b6d789ee5
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib-symbols.txt
@@ -0,0 +1,24 @@
+"calloc",
+"free",
+"iswalnum",
+"iswalpha",
+"iswblank",
+"iswdigit",
+"iswlower",
+"iswspace",
+"iswupper",
+"iswxdigit",
+"malloc",
+"memchr",
+"memcmp",
+"memcpy",
+"memmove",
+"memset",
+"realloc",
+"strcmp",
+"strlen",
+"strncat",
+"strncmp",
+"strncpy",
+"towlower",
+"towupper",
diff --git a/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib.c b/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib.c
new file mode 100644
index 0000000000..e3e59f5df4
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/wasm/stdlib.c
@@ -0,0 +1,113 @@
+// This file implements a very simple allocator for external scanners running
+// in WASM. Allocation is just bumping a static pointer and growing the heap
+// as needed, and freeing is mostly a noop. But in the special case of freeing
+// the last-allocated pointer, we'll reuse that pointer again.
+
+#ifdef TREE_SITTER_FEATURE_WASM
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern void tree_sitter_debug_message(const char *, size_t);
+
+#define PAGESIZE 0x10000
+#define MAX_HEAP_SIZE (4 * 1024 * 1024)
+
+typedef struct {
+  size_t size;
+  char data[0];
+} Region;
+
+static Region *heap_end = NULL;
+static Region *heap_start = NULL;
+static Region *next = NULL;
+
+// Get the region metadata for the given heap pointer.
+static inline Region *region_for_ptr(void *ptr) {
+  return ((Region *)ptr) - 1;
+}
+
+// Get the location of the next region after the given region,
+// if the given region had the given size.
+static inline Region *region_after(Region *self, size_t len) {
+  char *address = self->data + len;
+  char *aligned = (char *)((uintptr_t)(address + 3) & ~0x3);
+  return (Region *)aligned;
+}
+
+static void *get_heap_end() {
+  return (void *)(__builtin_wasm_memory_size(0) * PAGESIZE);
+}
+
+static int grow_heap(size_t size) {
+  size_t new_page_count = ((size - 1) / PAGESIZE) + 1;
+  return __builtin_wasm_memory_grow(0, new_page_count) != SIZE_MAX;
+}
+
+// Clear out the heap, and move it to the given address.
+void reset_heap(void *new_heap_start) {
+  heap_start = new_heap_start;
+  next = new_heap_start;
+  heap_end = get_heap_end();
+}
+
+void *malloc(size_t size) {
+  Region *region_end = region_after(next, size);
+
+  if (region_end > heap_end) {
+    if ((char *)region_end - (char *)heap_start > MAX_HEAP_SIZE) {
+      return NULL;
+    }
+    if (!grow_heap(size)) return NULL;
+    heap_end = get_heap_end();
+  }
+
+  void *result = &next->data;
+  next->size = size;
+  next = region_end;
+
+  return result;
+}
+
+void free(void *ptr) {
+  if (ptr == NULL) return;
+
+  Region *region = region_for_ptr(ptr);
+  Region *region_end = region_after(region, region->size);
+
+  // When freeing the last allocated pointer, re-use that
+  // pointer for the next allocation.
+  if (region_end == next) {
+    next = region;
+  }
+}
+
+void *calloc(size_t count, size_t size) {
+  void *result = malloc(count * size);
+  memset(result, 0, count * size);
+  return result;
+}
+
+void *realloc(void *ptr, size_t new_size) {
+  if (ptr == NULL) {
+    return malloc(new_size);
+  }
+
+  Region *region = region_for_ptr(ptr);
+  Region *region_end = region_after(region, region->size);
+
+  // When reallocating the last allocated region, return
+  // the same pointer, and skip copying the data.
+  if (region_end == next) {
+    next = region;
+    return malloc(new_size);
+  }
+
+  void *result = malloc(new_size);
+  memcpy(result, &region->data, region->size);
+  return result;
+}
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/wasm/wasm-stdlib.h b/src/library/ts/src/tree-sitter/lib/src/wasm/wasm-stdlib.h
new file mode 100644
index 0000000000..753a7abff2
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/wasm/wasm-stdlib.h
@@ -0,0 +1,1209 @@
+unsigned char STDLIB_WASM[] = {
+  0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x1a, 0x05, 0x60,
+  0x01, 0x7f, 0x01, 0x7f, 0x60, 0x03, 0x7f, 0x7f, 0x7f, 0x01, 0x7f, 0x60,
+  0x02, 0x7f, 0x7f, 0x01, 0x7f, 0x60, 0x01, 0x7f, 0x00, 0x60, 0x00, 0x00,
+  0x02, 0x7c, 0x04, 0x16, 0x77, 0x61, 0x73, 0x69, 0x5f, 0x73, 0x6e, 0x61,
+  0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65,
+  0x77, 0x31, 0x08, 0x61, 0x72, 0x67, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x00,
+  0x02, 0x16, 0x77, 0x61, 0x73, 0x69, 0x5f, 0x73, 0x6e, 0x61, 0x70, 0x73,
+  0x68, 0x6f, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x65, 0x77, 0x31,
+  0x0e, 0x61, 0x72, 0x67, 0x73, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x73, 0x5f,
+  0x67, 0x65, 0x74, 0x00, 0x02, 0x16, 0x77, 0x61, 0x73, 0x69, 0x5f, 0x73,
+  0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x76,
+  0x69, 0x65, 0x77, 0x31, 0x09, 0x70, 0x72, 0x6f, 0x63, 0x5f, 0x65, 0x78,
+  0x69, 0x74, 0x00, 0x03, 0x03, 0x65, 0x6e, 0x76, 0x06, 0x6d, 0x65, 0x6d,
+  0x6f, 0x72, 0x79, 0x02, 0x00, 0x02, 0x03, 0x1f, 0x1e, 0x04, 0x04, 0x04,
+  0x03, 0x00, 0x03, 0x02, 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
+  0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01,
+  0x00, 0x00, 0x00, 0x06, 0x08, 0x01, 0x7f, 0x01, 0x41, 0x80, 0x80, 0x04,
+  0x0b, 0x07, 0xad, 0x02, 0x1c, 0x11, 0x5f, 0x5f, 0x77, 0x61, 0x73, 0x6d,
+  0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x00,
+  0x03, 0x0f, 0x5f, 0x5f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x5f, 0x70, 0x6f,
+  0x69, 0x6e, 0x74, 0x65, 0x72, 0x03, 0x00, 0x06, 0x5f, 0x73, 0x74, 0x61,
+  0x72, 0x74, 0x00, 0x05, 0x0a, 0x72, 0x65, 0x73, 0x65, 0x74, 0x5f, 0x68,
+  0x65, 0x61, 0x70, 0x00, 0x06, 0x06, 0x6d, 0x61, 0x6c, 0x6c, 0x6f, 0x63,
+  0x00, 0x07, 0x04, 0x66, 0x72, 0x65, 0x65, 0x00, 0x08, 0x06, 0x63, 0x61,
+  0x6c, 0x6c, 0x6f, 0x63, 0x00, 0x09, 0x06, 0x6d, 0x65, 0x6d, 0x73, 0x65,
+  0x74, 0x00, 0x0d, 0x07, 0x72, 0x65, 0x61, 0x6c, 0x6c, 0x6f, 0x63, 0x00,
+  0x0a, 0x06, 0x6d, 0x65, 0x6d, 0x63, 0x70, 0x79, 0x00, 0x0c, 0x06, 0x73,
+  0x74, 0x72, 0x6c, 0x65, 0x6e, 0x00, 0x0e, 0x08, 0x69, 0x73, 0x77, 0x61,
+  0x6c, 0x6e, 0x75, 0x6d, 0x00, 0x20, 0x08, 0x69, 0x73, 0x77, 0x61, 0x6c,
+  0x70, 0x68, 0x61, 0x00, 0x0f, 0x08, 0x69, 0x73, 0x77, 0x62, 0x6c, 0x61,
+  0x6e, 0x6b, 0x00, 0x1a, 0x08, 0x69, 0x73, 0x77, 0x64, 0x69, 0x67, 0x69,
+  0x74, 0x00, 0x1b, 0x08, 0x69, 0x73, 0x77, 0x6c, 0x6f, 0x77, 0x65, 0x72,
+  0x00, 0x19, 0x08, 0x69, 0x73, 0x77, 0x73, 0x70, 0x61, 0x63, 0x65, 0x00,
+  0x1f, 0x08, 0x69, 0x73, 0x77, 0x75, 0x70, 0x70, 0x65, 0x72, 0x00, 0x17,
+  0x09, 0x69, 0x73, 0x77, 0x78, 0x64, 0x69, 0x67, 0x69, 0x74, 0x00, 0x1e,
+  0x08, 0x74, 0x6f, 0x77, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x13, 0x08,
+  0x74, 0x6f, 0x77, 0x75, 0x70, 0x70, 0x65, 0x72, 0x00, 0x15, 0x06, 0x6d,
+  0x65, 0x6d, 0x63, 0x68, 0x72, 0x00, 0x11, 0x06, 0x6d, 0x65, 0x6d, 0x63,
+  0x6d, 0x70, 0x00, 0x10, 0x07, 0x6d, 0x65, 0x6d, 0x6d, 0x6f, 0x76, 0x65,
+  0x00, 0x18, 0x06, 0x73, 0x74, 0x72, 0x63, 0x6d, 0x70, 0x00, 0x12, 0x07,
+  0x73, 0x74, 0x72, 0x6e, 0x63, 0x61, 0x74, 0x00, 0x1c, 0x07, 0x73, 0x74,
+  0x72, 0x6e, 0x63, 0x6d, 0x70, 0x00, 0x16, 0x07, 0x73, 0x74, 0x72, 0x6e,
+  0x63, 0x70, 0x79, 0x00, 0x1d, 0x08, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x0a,
+  0x8b, 0x28, 0x1e, 0x02, 0x00, 0x0b, 0x0d, 0x00, 0x41, 0xe8, 0xc2, 0x04,
+  0x41, 0x00, 0x41, 0x14, 0xfc, 0x0b, 0x00, 0x0b, 0xa4, 0x01, 0x01, 0x03,
+  0x7f, 0x41, 0xe8, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x45, 0x04, 0x40, 0x41,
+  0xe8, 0xc2, 0x04, 0x41, 0x01, 0x36, 0x02, 0x00, 0x23, 0x00, 0x41, 0x10,
+  0x6b, 0x22, 0x00, 0x24, 0x00, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02,
+  0x40, 0x20, 0x00, 0x41, 0x08, 0x6a, 0x20, 0x00, 0x41, 0x0c, 0x6a, 0x10,
+  0x01, 0x41, 0xff, 0xff, 0x03, 0x71, 0x45, 0x04, 0x40, 0x20, 0x00, 0x28,
+  0x02, 0x08, 0x41, 0x01, 0x6a, 0x22, 0x01, 0x45, 0x0d, 0x01, 0x20, 0x00,
+  0x28, 0x02, 0x0c, 0x10, 0x07, 0x22, 0x02, 0x45, 0x0d, 0x02, 0x20, 0x01,
+  0x41, 0x04, 0x10, 0x09, 0x22, 0x01, 0x45, 0x0d, 0x03, 0x20, 0x01, 0x20,
+  0x02, 0x10, 0x00, 0x41, 0xff, 0xff, 0x03, 0x71, 0x0d, 0x04, 0x20, 0x00,
+  0x28, 0x02, 0x08, 0x00, 0x0b, 0x41, 0xc7, 0x00, 0x10, 0x0b, 0x00, 0x0b,
+  0x41, 0xc6, 0x00, 0x10, 0x0b, 0x00, 0x0b, 0x41, 0xc6, 0x00, 0x10, 0x0b,
+  0x00, 0x0b, 0x20, 0x02, 0x10, 0x08, 0x41, 0xc6, 0x00, 0x10, 0x0b, 0x00,
+  0x0b, 0x20, 0x02, 0x10, 0x08, 0x20, 0x01, 0x10, 0x08, 0x41, 0xc7, 0x00,
+  0x10, 0x0b, 0x00, 0x0b, 0x00, 0x0b, 0x35, 0x01, 0x01, 0x7f, 0x41, 0xf0,
+  0xc2, 0x04, 0x20, 0x00, 0x36, 0x02, 0x00, 0x41, 0xec, 0xc2, 0x04, 0x20,
+  0x00, 0x36, 0x02, 0x00, 0x3f, 0x00, 0x21, 0x00, 0x20, 0x01, 0x41, 0xf8,
+  0xc2, 0x04, 0x6a, 0x41, 0x00, 0x36, 0x02, 0x00, 0x20, 0x01, 0x41, 0xf4,
+  0xc2, 0x04, 0x6a, 0x20, 0x00, 0x41, 0x10, 0x74, 0x36, 0x02, 0x00, 0x0b,
+  0xd7, 0x01, 0x01, 0x04, 0x7f, 0x02, 0x40, 0x20, 0x00, 0x45, 0x0d, 0x00,
+  0x02, 0x40, 0x41, 0xf8, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x22, 0x01, 0x45,
+  0x0d, 0x00, 0x02, 0x40, 0x20, 0x00, 0x20, 0x01, 0x28, 0x02, 0x00, 0x4d,
+  0x04, 0x40, 0x20, 0x01, 0x21, 0x02, 0x0c, 0x01, 0x0b, 0x03, 0x40, 0x20,
+  0x01, 0x28, 0x02, 0x04, 0x22, 0x02, 0x45, 0x0d, 0x02, 0x20, 0x01, 0x21,
+  0x03, 0x20, 0x02, 0x22, 0x01, 0x28, 0x02, 0x00, 0x20, 0x00, 0x49, 0x0d,
+  0x00, 0x0b, 0x0b, 0x20, 0x03, 0x41, 0x04, 0x6a, 0x41, 0xf8, 0xc2, 0x04,
+  0x20, 0x03, 0x1b, 0x20, 0x02, 0x28, 0x02, 0x04, 0x36, 0x02, 0x00, 0x20,
+  0x02, 0x41, 0x08, 0x6a, 0x0f, 0x0b, 0x41, 0xf0, 0xc2, 0x04, 0x28, 0x02,
+  0x00, 0x22, 0x01, 0x20, 0x00, 0x6a, 0x41, 0x0b, 0x6a, 0x41, 0x7c, 0x71,
+  0x22, 0x02, 0x41, 0xf4, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x4b, 0x04, 0x40,
+  0x20, 0x02, 0x41, 0xec, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x6b, 0x41, 0x80,
+  0x80, 0x80, 0x02, 0x4a, 0x0d, 0x01, 0x20, 0x00, 0x41, 0x01, 0x6b, 0x41,
+  0x10, 0x76, 0x41, 0x01, 0x6a, 0x40, 0x00, 0x41, 0x7f, 0x46, 0x0d, 0x01,
+  0x41, 0xf4, 0xc2, 0x04, 0x3f, 0x00, 0x41, 0x10, 0x74, 0x36, 0x02, 0x00,
+  0x41, 0xf0, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x21, 0x01, 0x0b, 0x20, 0x01,
+  0x20, 0x00, 0x36, 0x02, 0x00, 0x41, 0xf0, 0xc2, 0x04, 0x20, 0x02, 0x36,
+  0x02, 0x00, 0x20, 0x01, 0x41, 0x08, 0x6a, 0x21, 0x04, 0x0b, 0x20, 0x04,
+  0x0b, 0x41, 0x01, 0x02, 0x7f, 0x20, 0x00, 0x04, 0x40, 0x41, 0xf0, 0xc2,
+  0x04, 0x22, 0x01, 0x28, 0x02, 0x00, 0x20, 0x00, 0x41, 0x08, 0x6b, 0x22,
+  0x02, 0x28, 0x02, 0x00, 0x20, 0x00, 0x6a, 0x41, 0x03, 0x6a, 0x41, 0x7c,
+  0x71, 0x47, 0x04, 0x40, 0x20, 0x00, 0x41, 0x04, 0x6b, 0x41, 0xf8, 0xc2,
+  0x04, 0x22, 0x01, 0x28, 0x02, 0x00, 0x36, 0x02, 0x00, 0x0b, 0x20, 0x01,
+  0x20, 0x02, 0x36, 0x02, 0x00, 0x0b, 0x0b, 0x11, 0x00, 0x20, 0x00, 0x20,
+  0x01, 0x6c, 0x22, 0x00, 0x10, 0x07, 0x41, 0x00, 0x20, 0x00, 0x10, 0x0d,
+  0x0b, 0x47, 0x01, 0x01, 0x7f, 0x02, 0x40, 0x20, 0x00, 0x45, 0x0d, 0x00,
+  0x41, 0xf0, 0xc2, 0x04, 0x28, 0x02, 0x00, 0x20, 0x00, 0x41, 0x08, 0x6b,
+  0x22, 0x02, 0x28, 0x02, 0x00, 0x20, 0x00, 0x6a, 0x41, 0x03, 0x6a, 0x41,
+  0x7c, 0x71, 0x46, 0x04, 0x40, 0x41, 0xf0, 0xc2, 0x04, 0x20, 0x02, 0x36,
+  0x02, 0x00, 0x0c, 0x01, 0x0b, 0x20, 0x01, 0x10, 0x07, 0x20, 0x00, 0x20,
+  0x02, 0x28, 0x02, 0x00, 0x10, 0x0c, 0x0f, 0x0b, 0x20, 0x01, 0x10, 0x07,
+  0x0b, 0x07, 0x00, 0x20, 0x00, 0x10, 0x02, 0x00, 0x0b, 0xbe, 0x07, 0x01,
+  0x04, 0x7f, 0x02, 0x40, 0x02, 0x7f, 0x02, 0x40, 0x20, 0x02, 0x41, 0x20,
+  0x4d, 0x04, 0x40, 0x20, 0x01, 0x41, 0x03, 0x71, 0x45, 0x20, 0x02, 0x45,
+  0x72, 0x0d, 0x01, 0x20, 0x00, 0x20, 0x01, 0x2d, 0x00, 0x00, 0x3a, 0x00,
+  0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x20, 0x01, 0x41, 0x01, 0x6a, 0x22,
+  0x03, 0x41, 0x03, 0x71, 0x45, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x22, 0x05,
+  0x45, 0x72, 0x0d, 0x02, 0x1a, 0x20, 0x00, 0x20, 0x01, 0x2d, 0x00, 0x01,
+  0x3a, 0x00, 0x01, 0x20, 0x00, 0x41, 0x02, 0x6a, 0x20, 0x01, 0x41, 0x02,
+  0x6a, 0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x20, 0x02, 0x41, 0x02, 0x6b,
+  0x22, 0x05, 0x45, 0x72, 0x0d, 0x02, 0x1a, 0x20, 0x00, 0x20, 0x01, 0x2d,
+  0x00, 0x02, 0x3a, 0x00, 0x02, 0x20, 0x00, 0x41, 0x03, 0x6a, 0x20, 0x01,
+  0x41, 0x03, 0x6a, 0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x20, 0x02, 0x41,
+  0x03, 0x6b, 0x22, 0x05, 0x45, 0x72, 0x0d, 0x02, 0x1a, 0x20, 0x00, 0x20,
+  0x01, 0x2d, 0x00, 0x03, 0x3a, 0x00, 0x03, 0x20, 0x02, 0x41, 0x04, 0x6b,
+  0x21, 0x05, 0x20, 0x01, 0x41, 0x04, 0x6a, 0x21, 0x03, 0x20, 0x00, 0x41,
+  0x04, 0x6a, 0x0c, 0x02, 0x0b, 0x20, 0x00, 0x20, 0x01, 0x20, 0x02, 0xfc,
+  0x0a, 0x00, 0x00, 0x20, 0x00, 0x0f, 0x0b, 0x20, 0x02, 0x21, 0x05, 0x20,
+  0x01, 0x21, 0x03, 0x20, 0x00, 0x0b, 0x22, 0x04, 0x41, 0x03, 0x71, 0x22,
+  0x02, 0x45, 0x04, 0x40, 0x02, 0x40, 0x20, 0x05, 0x41, 0x10, 0x49, 0x04,
+  0x40, 0x20, 0x05, 0x21, 0x02, 0x0c, 0x01, 0x0b, 0x20, 0x05, 0x41, 0x10,
+  0x6b, 0x22, 0x02, 0x41, 0x10, 0x71, 0x45, 0x04, 0x40, 0x20, 0x04, 0x20,
+  0x03, 0x29, 0x02, 0x00, 0x37, 0x02, 0x00, 0x20, 0x04, 0x20, 0x03, 0x29,
+  0x02, 0x08, 0x37, 0x02, 0x08, 0x20, 0x04, 0x41, 0x10, 0x6a, 0x21, 0x04,
+  0x20, 0x03, 0x41, 0x10, 0x6a, 0x21, 0x03, 0x20, 0x02, 0x21, 0x05, 0x0b,
+  0x20, 0x02, 0x41, 0x10, 0x49, 0x0d, 0x00, 0x20, 0x05, 0x21, 0x02, 0x03,
+  0x40, 0x20, 0x04, 0x20, 0x03, 0x29, 0x02, 0x00, 0x37, 0x02, 0x00, 0x20,
+  0x04, 0x20, 0x03, 0x29, 0x02, 0x08, 0x37, 0x02, 0x08, 0x20, 0x04, 0x20,
+  0x03, 0x29, 0x02, 0x10, 0x37, 0x02, 0x10, 0x20, 0x04, 0x20, 0x03, 0x29,
+  0x02, 0x18, 0x37, 0x02, 0x18, 0x20, 0x04, 0x41, 0x20, 0x6a, 0x21, 0x04,
+  0x20, 0x03, 0x41, 0x20, 0x6a, 0x21, 0x03, 0x20, 0x02, 0x41, 0x20, 0x6b,
+  0x22, 0x02, 0x41, 0x0f, 0x4b, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x02, 0x41,
+  0x08, 0x4f, 0x04, 0x40, 0x20, 0x04, 0x20, 0x03, 0x29, 0x02, 0x00, 0x37,
+  0x02, 0x00, 0x20, 0x04, 0x41, 0x08, 0x6a, 0x21, 0x04, 0x20, 0x03, 0x41,
+  0x08, 0x6a, 0x21, 0x03, 0x0b, 0x20, 0x02, 0x41, 0x04, 0x71, 0x04, 0x40,
+  0x20, 0x04, 0x20, 0x03, 0x28, 0x02, 0x00, 0x36, 0x02, 0x00, 0x20, 0x04,
+  0x41, 0x04, 0x6a, 0x21, 0x04, 0x20, 0x03, 0x41, 0x04, 0x6a, 0x21, 0x03,
+  0x0b, 0x20, 0x02, 0x41, 0x02, 0x71, 0x04, 0x40, 0x20, 0x04, 0x20, 0x03,
+  0x2f, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x20, 0x04, 0x41, 0x02, 0x6a, 0x21,
+  0x04, 0x20, 0x03, 0x41, 0x02, 0x6a, 0x21, 0x03, 0x0b, 0x20, 0x02, 0x41,
+  0x01, 0x71, 0x45, 0x0d, 0x01, 0x20, 0x04, 0x20, 0x03, 0x2d, 0x00, 0x00,
+  0x3a, 0x00, 0x00, 0x20, 0x00, 0x0f, 0x0b, 0x02, 0x40, 0x02, 0x40, 0x02,
+  0x7f, 0x02, 0x40, 0x20, 0x05, 0x41, 0x20, 0x4f, 0x04, 0x40, 0x20, 0x04,
+  0x20, 0x03, 0x28, 0x02, 0x00, 0x22, 0x01, 0x3a, 0x00, 0x00, 0x02, 0x40,
+  0x02, 0x40, 0x20, 0x02, 0x41, 0x02, 0x6b, 0x0e, 0x02, 0x00, 0x01, 0x03,
+  0x0b, 0x20, 0x04, 0x20, 0x01, 0x41, 0x08, 0x76, 0x3a, 0x00, 0x01, 0x20,
+  0x04, 0x20, 0x03, 0x41, 0x06, 0x6a, 0x29, 0x01, 0x00, 0x37, 0x02, 0x06,
+  0x20, 0x04, 0x20, 0x03, 0x28, 0x02, 0x04, 0x41, 0x10, 0x74, 0x20, 0x01,
+  0x41, 0x10, 0x76, 0x72, 0x36, 0x02, 0x02, 0x20, 0x03, 0x41, 0x12, 0x6a,
+  0x21, 0x01, 0x41, 0x0e, 0x21, 0x06, 0x20, 0x03, 0x41, 0x0e, 0x6a, 0x28,
+  0x01, 0x00, 0x21, 0x03, 0x41, 0x0e, 0x21, 0x05, 0x20, 0x04, 0x41, 0x12,
+  0x6a, 0x0c, 0x03, 0x0b, 0x20, 0x04, 0x20, 0x03, 0x41, 0x05, 0x6a, 0x29,
+  0x00, 0x00, 0x37, 0x02, 0x05, 0x20, 0x04, 0x20, 0x03, 0x28, 0x02, 0x04,
+  0x41, 0x18, 0x74, 0x20, 0x01, 0x41, 0x08, 0x76, 0x72, 0x36, 0x02, 0x01,
+  0x20, 0x03, 0x41, 0x11, 0x6a, 0x21, 0x01, 0x41, 0x0d, 0x21, 0x06, 0x20,
+  0x03, 0x41, 0x0d, 0x6a, 0x28, 0x00, 0x00, 0x21, 0x03, 0x41, 0x0f, 0x21,
+  0x05, 0x20, 0x04, 0x41, 0x11, 0x6a, 0x0c, 0x02, 0x0b, 0x02, 0x7f, 0x20,
+  0x05, 0x41, 0x10, 0x49, 0x04, 0x40, 0x20, 0x04, 0x21, 0x02, 0x20, 0x03,
+  0x0c, 0x01, 0x0b, 0x20, 0x04, 0x20, 0x03, 0x2d, 0x00, 0x00, 0x3a, 0x00,
+  0x00, 0x20, 0x04, 0x20, 0x03, 0x28, 0x00, 0x01, 0x36, 0x00, 0x01, 0x20,
+  0x04, 0x20, 0x03, 0x29, 0x00, 0x05, 0x37, 0x00, 0x05, 0x20, 0x04, 0x20,
+  0x03, 0x2f, 0x00, 0x0d, 0x3b, 0x00, 0x0d, 0x20, 0x04, 0x20, 0x03, 0x2d,
+  0x00, 0x0f, 0x3a, 0x00, 0x0f, 0x20, 0x04, 0x41, 0x10, 0x6a, 0x21, 0x02,
+  0x20, 0x03, 0x41, 0x10, 0x6a, 0x0b, 0x21, 0x01, 0x20, 0x05, 0x41, 0x08,
+  0x71, 0x0d, 0x02, 0x0c, 0x03, 0x0b, 0x20, 0x04, 0x20, 0x01, 0x41, 0x10,
+  0x76, 0x3a, 0x00, 0x02, 0x20, 0x04, 0x20, 0x01, 0x41, 0x08, 0x76, 0x3a,
+  0x00, 0x01, 0x20, 0x04, 0x20, 0x03, 0x41, 0x07, 0x6a, 0x29, 0x00, 0x00,
+  0x37, 0x02, 0x07, 0x20, 0x04, 0x20, 0x03, 0x28, 0x02, 0x04, 0x41, 0x08,
+  0x74, 0x20, 0x01, 0x41, 0x18, 0x76, 0x72, 0x36, 0x02, 0x03, 0x20, 0x03,
+  0x41, 0x13, 0x6a, 0x21, 0x01, 0x41, 0x0f, 0x21, 0x06, 0x20, 0x03, 0x41,
+  0x0f, 0x6a, 0x28, 0x00, 0x00, 0x21, 0x03, 0x41, 0x0d, 0x21, 0x05, 0x20,
+  0x04, 0x41, 0x13, 0x6a, 0x0b, 0x21, 0x02, 0x20, 0x04, 0x20, 0x06, 0x6a,
+  0x20, 0x03, 0x36, 0x02, 0x00, 0x0b, 0x20, 0x02, 0x20, 0x01, 0x29, 0x00,
+  0x00, 0x37, 0x00, 0x00, 0x20, 0x02, 0x41, 0x08, 0x6a, 0x21, 0x02, 0x20,
+  0x01, 0x41, 0x08, 0x6a, 0x21, 0x01, 0x0b, 0x20, 0x05, 0x41, 0x04, 0x71,
+  0x04, 0x40, 0x20, 0x02, 0x20, 0x01, 0x28, 0x00, 0x00, 0x36, 0x00, 0x00,
+  0x20, 0x02, 0x41, 0x04, 0x6a, 0x21, 0x02, 0x20, 0x01, 0x41, 0x04, 0x6a,
+  0x21, 0x01, 0x0b, 0x20, 0x05, 0x41, 0x02, 0x71, 0x04, 0x40, 0x20, 0x02,
+  0x20, 0x01, 0x2f, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x20, 0x02, 0x41, 0x02,
+  0x6a, 0x21, 0x02, 0x20, 0x01, 0x41, 0x02, 0x6a, 0x21, 0x01, 0x0b, 0x20,
+  0x05, 0x41, 0x01, 0x71, 0x45, 0x0d, 0x00, 0x20, 0x02, 0x20, 0x01, 0x2d,
+  0x00, 0x00, 0x3a, 0x00, 0x00, 0x0b, 0x20, 0x00, 0x0b, 0x86, 0x03, 0x02,
+  0x03, 0x7f, 0x01, 0x7e, 0x20, 0x02, 0x41, 0x21, 0x4f, 0x04, 0x40, 0x20,
+  0x00, 0x20, 0x01, 0x20, 0x02, 0xfc, 0x0b, 0x00, 0x20, 0x00, 0x0f, 0x0b,
+  0x02, 0x40, 0x20, 0x02, 0x45, 0x0d, 0x00, 0x20, 0x00, 0x20, 0x01, 0x3a,
+  0x00, 0x00, 0x20, 0x00, 0x20, 0x02, 0x6a, 0x22, 0x03, 0x41, 0x01, 0x6b,
+  0x20, 0x01, 0x3a, 0x00, 0x00, 0x20, 0x02, 0x41, 0x03, 0x49, 0x0d, 0x00,
+  0x20, 0x00, 0x20, 0x01, 0x3a, 0x00, 0x02, 0x20, 0x00, 0x20, 0x01, 0x3a,
+  0x00, 0x01, 0x20, 0x03, 0x41, 0x03, 0x6b, 0x20, 0x01, 0x3a, 0x00, 0x00,
+  0x20, 0x03, 0x41, 0x02, 0x6b, 0x20, 0x01, 0x3a, 0x00, 0x00, 0x20, 0x02,
+  0x41, 0x07, 0x49, 0x0d, 0x00, 0x20, 0x00, 0x20, 0x01, 0x3a, 0x00, 0x03,
+  0x20, 0x03, 0x41, 0x04, 0x6b, 0x20, 0x01, 0x3a, 0x00, 0x00, 0x20, 0x02,
+  0x41, 0x09, 0x49, 0x0d, 0x00, 0x20, 0x00, 0x41, 0x00, 0x20, 0x00, 0x6b,
+  0x41, 0x03, 0x71, 0x22, 0x05, 0x6a, 0x22, 0x04, 0x20, 0x01, 0x41, 0xff,
+  0x01, 0x71, 0x41, 0x81, 0x82, 0x84, 0x08, 0x6c, 0x22, 0x03, 0x36, 0x02,
+  0x00, 0x20, 0x04, 0x20, 0x02, 0x20, 0x05, 0x6b, 0x41, 0x3c, 0x71, 0x22,
+  0x02, 0x6a, 0x22, 0x01, 0x41, 0x04, 0x6b, 0x20, 0x03, 0x36, 0x02, 0x00,
+  0x20, 0x02, 0x41, 0x09, 0x49, 0x0d, 0x00, 0x20, 0x04, 0x20, 0x03, 0x36,
+  0x02, 0x08, 0x20, 0x04, 0x20, 0x03, 0x36, 0x02, 0x04, 0x20, 0x01, 0x41,
+  0x08, 0x6b, 0x20, 0x03, 0x36, 0x02, 0x00, 0x20, 0x01, 0x41, 0x0c, 0x6b,
+  0x20, 0x03, 0x36, 0x02, 0x00, 0x20, 0x02, 0x41, 0x19, 0x49, 0x0d, 0x00,
+  0x20, 0x04, 0x20, 0x03, 0x36, 0x02, 0x18, 0x20, 0x04, 0x20, 0x03, 0x36,
+  0x02, 0x14, 0x20, 0x04, 0x20, 0x03, 0x36, 0x02, 0x10, 0x20, 0x04, 0x20,
+  0x03, 0x36, 0x02, 0x0c, 0x20, 0x01, 0x41, 0x10, 0x6b, 0x20, 0x03, 0x36,
+  0x02, 0x00, 0x20, 0x01, 0x41, 0x14, 0x6b, 0x20, 0x03, 0x36, 0x02, 0x00,
+  0x20, 0x01, 0x41, 0x18, 0x6b, 0x20, 0x03, 0x36, 0x02, 0x00, 0x20, 0x01,
+  0x41, 0x1c, 0x6b, 0x20, 0x03, 0x36, 0x02, 0x00, 0x20, 0x02, 0x20, 0x04,
+  0x41, 0x04, 0x71, 0x41, 0x18, 0x72, 0x22, 0x02, 0x6b, 0x22, 0x01, 0x41,
+  0x20, 0x49, 0x0d, 0x00, 0x20, 0x03, 0xad, 0x42, 0x81, 0x80, 0x80, 0x80,
+  0x10, 0x7e, 0x21, 0x06, 0x20, 0x02, 0x20, 0x04, 0x6a, 0x21, 0x02, 0x03,
+  0x40, 0x20, 0x02, 0x20, 0x06, 0x37, 0x03, 0x18, 0x20, 0x02, 0x20, 0x06,
+  0x37, 0x03, 0x10, 0x20, 0x02, 0x20, 0x06, 0x37, 0x03, 0x08, 0x20, 0x02,
+  0x20, 0x06, 0x37, 0x03, 0x00, 0x20, 0x02, 0x41, 0x20, 0x6a, 0x21, 0x02,
+  0x20, 0x01, 0x41, 0x20, 0x6b, 0x22, 0x01, 0x41, 0x1f, 0x4b, 0x0d, 0x00,
+  0x0b, 0x0b, 0x20, 0x00, 0x0b, 0xc5, 0x01, 0x01, 0x03, 0x7f, 0x02, 0x40,
+  0x02, 0x40, 0x20, 0x00, 0x22, 0x01, 0x41, 0x03, 0x71, 0x45, 0x0d, 0x00,
+  0x20, 0x01, 0x2d, 0x00, 0x00, 0x45, 0x04, 0x40, 0x41, 0x00, 0x0f, 0x0b,
+  0x20, 0x00, 0x41, 0x01, 0x6a, 0x22, 0x01, 0x41, 0x03, 0x71, 0x45, 0x0d,
+  0x00, 0x20, 0x01, 0x2d, 0x00, 0x00, 0x45, 0x0d, 0x01, 0x20, 0x00, 0x41,
+  0x02, 0x6a, 0x22, 0x01, 0x41, 0x03, 0x71, 0x45, 0x0d, 0x00, 0x20, 0x01,
+  0x2d, 0x00, 0x00, 0x45, 0x0d, 0x01, 0x20, 0x00, 0x41, 0x03, 0x6a, 0x22,
+  0x01, 0x41, 0x03, 0x71, 0x45, 0x0d, 0x00, 0x20, 0x01, 0x2d, 0x00, 0x00,
+  0x45, 0x0d, 0x01, 0x20, 0x00, 0x41, 0x04, 0x6a, 0x22, 0x01, 0x41, 0x03,
+  0x71, 0x0d, 0x01, 0x0b, 0x20, 0x01, 0x41, 0x04, 0x6b, 0x21, 0x02, 0x20,
+  0x01, 0x41, 0x05, 0x6b, 0x21, 0x01, 0x03, 0x40, 0x20, 0x01, 0x41, 0x04,
+  0x6a, 0x21, 0x01, 0x41, 0x80, 0x82, 0x84, 0x08, 0x20, 0x02, 0x41, 0x04,
+  0x6a, 0x22, 0x02, 0x28, 0x02, 0x00, 0x22, 0x03, 0x6b, 0x20, 0x03, 0x72,
+  0x41, 0x80, 0x81, 0x82, 0x84, 0x78, 0x71, 0x41, 0x80, 0x81, 0x82, 0x84,
+  0x78, 0x46, 0x0d, 0x00, 0x0b, 0x03, 0x40, 0x20, 0x01, 0x41, 0x01, 0x6a,
+  0x21, 0x01, 0x20, 0x02, 0x2d, 0x00, 0x00, 0x20, 0x02, 0x41, 0x01, 0x6a,
+  0x21, 0x02, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x01, 0x20, 0x00, 0x6b, 0x0b,
+  0x3e, 0x00, 0x20, 0x00, 0x41, 0xff, 0xff, 0x07, 0x4d, 0x04, 0x40, 0x20,
+  0x00, 0x41, 0x03, 0x76, 0x41, 0x1f, 0x71, 0x20, 0x00, 0x41, 0x08, 0x76,
+  0x41, 0x80, 0x80, 0x04, 0x6a, 0x2d, 0x00, 0x00, 0x41, 0x05, 0x74, 0x72,
+  0x41, 0x80, 0x80, 0x04, 0x6a, 0x2d, 0x00, 0x00, 0x20, 0x00, 0x41, 0x07,
+  0x71, 0x76, 0x41, 0x01, 0x71, 0x0f, 0x0b, 0x20, 0x00, 0x41, 0xfe, 0xff,
+  0x0b, 0x49, 0x0b, 0x43, 0x01, 0x03, 0x7f, 0x02, 0x40, 0x20, 0x02, 0x45,
+  0x0d, 0x00, 0x03, 0x40, 0x20, 0x00, 0x2d, 0x00, 0x00, 0x22, 0x04, 0x20,
+  0x01, 0x2d, 0x00, 0x00, 0x22, 0x05, 0x46, 0x04, 0x40, 0x20, 0x01, 0x41,
+  0x01, 0x6a, 0x21, 0x01, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x21, 0x00, 0x20,
+  0x02, 0x41, 0x01, 0x6b, 0x22, 0x02, 0x0d, 0x01, 0x0c, 0x02, 0x0b, 0x0b,
+  0x20, 0x04, 0x20, 0x05, 0x6b, 0x21, 0x03, 0x0b, 0x20, 0x03, 0x0b, 0xe9,
+  0x02, 0x01, 0x03, 0x7f, 0x20, 0x02, 0x41, 0x00, 0x47, 0x21, 0x05, 0x02,
+  0x40, 0x02, 0x40, 0x02, 0x40, 0x20, 0x00, 0x41, 0x03, 0x71, 0x45, 0x20,
+  0x02, 0x45, 0x72, 0x45, 0x04, 0x40, 0x20, 0x00, 0x2d, 0x00, 0x00, 0x20,
+  0x01, 0x41, 0xff, 0x01, 0x71, 0x46, 0x04, 0x40, 0x20, 0x00, 0x21, 0x03,
+  0x20, 0x02, 0x21, 0x04, 0x0c, 0x03, 0x0b, 0x20, 0x02, 0x41, 0x01, 0x6b,
+  0x22, 0x04, 0x41, 0x00, 0x47, 0x21, 0x05, 0x20, 0x00, 0x41, 0x01, 0x6a,
+  0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x20, 0x04, 0x45, 0x72, 0x0d, 0x01,
+  0x20, 0x03, 0x2d, 0x00, 0x00, 0x20, 0x01, 0x41, 0xff, 0x01, 0x71, 0x46,
+  0x0d, 0x02, 0x20, 0x02, 0x41, 0x02, 0x6b, 0x22, 0x04, 0x41, 0x00, 0x47,
+  0x21, 0x05, 0x20, 0x00, 0x41, 0x02, 0x6a, 0x22, 0x03, 0x41, 0x03, 0x71,
+  0x45, 0x20, 0x04, 0x45, 0x72, 0x0d, 0x01, 0x20, 0x03, 0x2d, 0x00, 0x00,
+  0x20, 0x01, 0x41, 0xff, 0x01, 0x71, 0x46, 0x0d, 0x02, 0x20, 0x02, 0x41,
+  0x03, 0x6b, 0x22, 0x04, 0x41, 0x00, 0x47, 0x21, 0x05, 0x20, 0x00, 0x41,
+  0x03, 0x6a, 0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x20, 0x04, 0x45, 0x72,
+  0x0d, 0x01, 0x20, 0x03, 0x2d, 0x00, 0x00, 0x20, 0x01, 0x41, 0xff, 0x01,
+  0x71, 0x46, 0x0d, 0x02, 0x20, 0x00, 0x41, 0x04, 0x6a, 0x21, 0x03, 0x20,
+  0x02, 0x41, 0x04, 0x6b, 0x22, 0x04, 0x41, 0x00, 0x47, 0x21, 0x05, 0x0c,
+  0x01, 0x0b, 0x20, 0x02, 0x21, 0x04, 0x20, 0x00, 0x21, 0x03, 0x0b, 0x20,
+  0x05, 0x45, 0x0d, 0x01, 0x20, 0x01, 0x41, 0xff, 0x01, 0x71, 0x22, 0x00,
+  0x20, 0x03, 0x2d, 0x00, 0x00, 0x46, 0x20, 0x04, 0x41, 0x04, 0x49, 0x72,
+  0x45, 0x04, 0x40, 0x20, 0x00, 0x41, 0x81, 0x82, 0x84, 0x08, 0x6c, 0x21,
+  0x00, 0x03, 0x40, 0x41, 0x80, 0x82, 0x84, 0x08, 0x20, 0x03, 0x28, 0x02,
+  0x00, 0x20, 0x00, 0x73, 0x22, 0x02, 0x6b, 0x20, 0x02, 0x72, 0x41, 0x80,
+  0x81, 0x82, 0x84, 0x78, 0x71, 0x41, 0x80, 0x81, 0x82, 0x84, 0x78, 0x47,
+  0x0d, 0x02, 0x20, 0x03, 0x41, 0x04, 0x6a, 0x21, 0x03, 0x20, 0x04, 0x41,
+  0x04, 0x6b, 0x22, 0x04, 0x41, 0x03, 0x4b, 0x0d, 0x00, 0x0b, 0x0b, 0x20,
+  0x04, 0x45, 0x0d, 0x01, 0x0b, 0x20, 0x01, 0x41, 0xff, 0x01, 0x71, 0x21,
+  0x00, 0x03, 0x40, 0x20, 0x00, 0x20, 0x03, 0x2d, 0x00, 0x00, 0x46, 0x04,
+  0x40, 0x20, 0x03, 0x0f, 0x0b, 0x20, 0x03, 0x41, 0x01, 0x6a, 0x21, 0x03,
+  0x20, 0x04, 0x41, 0x01, 0x6b, 0x22, 0x04, 0x0d, 0x00, 0x0b, 0x0b, 0x41,
+  0x00, 0x0b, 0x58, 0x01, 0x02, 0x7f, 0x02, 0x40, 0x20, 0x00, 0x2d, 0x00,
+  0x00, 0x22, 0x02, 0x45, 0x20, 0x02, 0x20, 0x01, 0x2d, 0x00, 0x00, 0x22,
+  0x03, 0x47, 0x72, 0x0d, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x21, 0x00,
+  0x20, 0x01, 0x41, 0x01, 0x6a, 0x21, 0x01, 0x03, 0x40, 0x20, 0x01, 0x2d,
+  0x00, 0x00, 0x21, 0x03, 0x20, 0x00, 0x2d, 0x00, 0x00, 0x22, 0x02, 0x45,
+  0x0d, 0x01, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x21, 0x00, 0x20, 0x01, 0x41,
+  0x01, 0x6a, 0x21, 0x01, 0x20, 0x02, 0x20, 0x03, 0x46, 0x0d, 0x00, 0x0b,
+  0x0b, 0x20, 0x02, 0x20, 0x03, 0x6b, 0x0b, 0x08, 0x00, 0x20, 0x00, 0x41,
+  0x00, 0x10, 0x14, 0x0b, 0xa0, 0x02, 0x01, 0x07, 0x7f, 0x02, 0x40, 0x20,
+  0x00, 0x41, 0xff, 0xff, 0x07, 0x4b, 0x0d, 0x00, 0x20, 0x00, 0x20, 0x00,
+  0x41, 0xff, 0x01, 0x71, 0x22, 0x05, 0x41, 0x03, 0x6e, 0x22, 0x02, 0x41,
+  0x03, 0x6c, 0x6b, 0x41, 0xff, 0x01, 0x71, 0x41, 0x02, 0x74, 0x41, 0xc0,
+  0x9e, 0x04, 0x6a, 0x28, 0x02, 0x00, 0x20, 0x02, 0x20, 0x00, 0x41, 0x08,
+  0x76, 0x22, 0x02, 0x41, 0xa0, 0xa9, 0x04, 0x6a, 0x2d, 0x00, 0x00, 0x41,
+  0xd6, 0x00, 0x6c, 0x6a, 0x41, 0xa0, 0xa9, 0x04, 0x6a, 0x2d, 0x00, 0x00,
+  0x6c, 0x41, 0x0b, 0x76, 0x41, 0x06, 0x70, 0x20, 0x02, 0x41, 0x90, 0xbe,
+  0x04, 0x6a, 0x2d, 0x00, 0x00, 0x6a, 0x41, 0x02, 0x74, 0x41, 0xd0, 0x9e,
+  0x04, 0x6a, 0x28, 0x02, 0x00, 0x22, 0x03, 0x41, 0x08, 0x75, 0x21, 0x02,
+  0x20, 0x03, 0x41, 0xff, 0x01, 0x71, 0x22, 0x03, 0x41, 0x01, 0x4d, 0x04,
+  0x40, 0x20, 0x02, 0x41, 0x00, 0x20, 0x01, 0x20, 0x03, 0x73, 0x6b, 0x71,
+  0x20, 0x00, 0x6a, 0x0f, 0x0b, 0x20, 0x02, 0x41, 0xff, 0x01, 0x71, 0x22,
+  0x03, 0x45, 0x0d, 0x00, 0x20, 0x02, 0x41, 0x08, 0x76, 0x21, 0x02, 0x03,
+  0x40, 0x20, 0x03, 0x41, 0x01, 0x76, 0x22, 0x06, 0x20, 0x02, 0x6a, 0x22,
+  0x04, 0x41, 0x01, 0x74, 0x41, 0x90, 0xa6, 0x04, 0x6a, 0x22, 0x07, 0x2d,
+  0x00, 0x00, 0x22, 0x08, 0x20, 0x05, 0x46, 0x04, 0x40, 0x20, 0x07, 0x2d,
+  0x00, 0x01, 0x41, 0x02, 0x74, 0x41, 0xd0, 0x9e, 0x04, 0x6a, 0x28, 0x02,
+  0x00, 0x22, 0x02, 0x41, 0xff, 0x01, 0x71, 0x22, 0x03, 0x41, 0x01, 0x4d,
+  0x04, 0x40, 0x41, 0x00, 0x20, 0x01, 0x20, 0x03, 0x73, 0x6b, 0x20, 0x02,
+  0x41, 0x08, 0x75, 0x71, 0x20, 0x00, 0x6a, 0x0f, 0x0b, 0x41, 0x7f, 0x41,
+  0x01, 0x20, 0x01, 0x1b, 0x20, 0x00, 0x6a, 0x0f, 0x0b, 0x20, 0x02, 0x20,
+  0x04, 0x20, 0x05, 0x20, 0x08, 0x49, 0x22, 0x04, 0x1b, 0x21, 0x02, 0x20,
+  0x06, 0x20, 0x03, 0x20, 0x06, 0x6b, 0x20, 0x04, 0x1b, 0x22, 0x03, 0x0d,
+  0x00, 0x0b, 0x0b, 0x20, 0x00, 0x0b, 0x08, 0x00, 0x20, 0x00, 0x41, 0x01,
+  0x10, 0x14, 0x0b, 0x75, 0x01, 0x02, 0x7f, 0x20, 0x02, 0x45, 0x04, 0x40,
+  0x41, 0x00, 0x0f, 0x0b, 0x02, 0x40, 0x20, 0x00, 0x2d, 0x00, 0x00, 0x22,
+  0x03, 0x45, 0x04, 0x40, 0x41, 0x00, 0x21, 0x03, 0x0c, 0x01, 0x0b, 0x20,
+  0x00, 0x41, 0x01, 0x6a, 0x21, 0x00, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x21,
+  0x02, 0x02, 0x40, 0x03, 0x40, 0x20, 0x02, 0x45, 0x20, 0x03, 0x20, 0x01,
+  0x2d, 0x00, 0x00, 0x22, 0x04, 0x47, 0x20, 0x04, 0x45, 0x72, 0x72, 0x0d,
+  0x01, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x21, 0x02, 0x20, 0x01, 0x41, 0x01,
+  0x6a, 0x21, 0x01, 0x20, 0x00, 0x2d, 0x00, 0x00, 0x21, 0x03, 0x20, 0x00,
+  0x41, 0x01, 0x6a, 0x21, 0x00, 0x20, 0x03, 0x0d, 0x00, 0x0b, 0x41, 0x00,
+  0x21, 0x03, 0x0b, 0x0b, 0x20, 0x03, 0x20, 0x01, 0x2d, 0x00, 0x00, 0x6b,
+  0x0b, 0x09, 0x00, 0x20, 0x00, 0x10, 0x13, 0x20, 0x00, 0x47, 0x0b, 0xa1,
+  0x09, 0x01, 0x04, 0x7f, 0x02, 0x40, 0x02, 0x40, 0x20, 0x02, 0x41, 0x21,
+  0x49, 0x04, 0x40, 0x20, 0x00, 0x20, 0x01, 0x46, 0x0d, 0x02, 0x20, 0x01,
+  0x20, 0x00, 0x20, 0x02, 0x6a, 0x22, 0x04, 0x6b, 0x41, 0x00, 0x20, 0x02,
+  0x41, 0x01, 0x74, 0x6b, 0x4b, 0x0d, 0x01, 0x0b, 0x20, 0x00, 0x20, 0x01,
+  0x20, 0x02, 0xfc, 0x0a, 0x00, 0x00, 0x0c, 0x01, 0x0b, 0x20, 0x00, 0x20,
+  0x01, 0x73, 0x41, 0x03, 0x71, 0x21, 0x03, 0x02, 0x40, 0x02, 0x40, 0x20,
+  0x00, 0x20, 0x01, 0x49, 0x04, 0x40, 0x20, 0x03, 0x04, 0x40, 0x20, 0x02,
+  0x21, 0x04, 0x20, 0x00, 0x21, 0x03, 0x0c, 0x03, 0x0b, 0x20, 0x00, 0x41,
+  0x03, 0x71, 0x45, 0x04, 0x40, 0x20, 0x02, 0x21, 0x04, 0x20, 0x00, 0x21,
+  0x03, 0x0c, 0x02, 0x0b, 0x20, 0x02, 0x45, 0x0d, 0x03, 0x20, 0x00, 0x20,
+  0x01, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x02, 0x41, 0x01, 0x6b,
+  0x21, 0x04, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x22, 0x03, 0x41, 0x03, 0x71,
+  0x45, 0x04, 0x40, 0x20, 0x01, 0x41, 0x01, 0x6a, 0x21, 0x01, 0x0c, 0x02,
+  0x0b, 0x20, 0x04, 0x45, 0x0d, 0x03, 0x20, 0x00, 0x20, 0x01, 0x2d, 0x00,
+  0x01, 0x3a, 0x00, 0x01, 0x20, 0x02, 0x41, 0x02, 0x6b, 0x21, 0x04, 0x20,
+  0x00, 0x41, 0x02, 0x6a, 0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x04, 0x40,
+  0x20, 0x01, 0x41, 0x02, 0x6a, 0x21, 0x01, 0x0c, 0x02, 0x0b, 0x20, 0x04,
+  0x45, 0x0d, 0x03, 0x20, 0x00, 0x20, 0x01, 0x2d, 0x00, 0x02, 0x3a, 0x00,
+  0x02, 0x20, 0x02, 0x41, 0x03, 0x6b, 0x21, 0x04, 0x20, 0x00, 0x41, 0x03,
+  0x6a, 0x22, 0x03, 0x41, 0x03, 0x71, 0x45, 0x04, 0x40, 0x20, 0x01, 0x41,
+  0x03, 0x6a, 0x21, 0x01, 0x0c, 0x02, 0x0b, 0x20, 0x04, 0x45, 0x0d, 0x03,
+  0x20, 0x00, 0x20, 0x01, 0x2d, 0x00, 0x03, 0x3a, 0x00, 0x03, 0x20, 0x00,
+  0x41, 0x04, 0x6a, 0x21, 0x03, 0x20, 0x01, 0x41, 0x04, 0x6a, 0x21, 0x01,
+  0x20, 0x02, 0x41, 0x04, 0x6b, 0x21, 0x04, 0x0c, 0x01, 0x0b, 0x02, 0x40,
+  0x20, 0x03, 0x0d, 0x00, 0x02, 0x40, 0x20, 0x04, 0x41, 0x03, 0x71, 0x45,
+  0x0d, 0x00, 0x20, 0x02, 0x45, 0x0d, 0x04, 0x20, 0x00, 0x20, 0x02, 0x41,
+  0x01, 0x6b, 0x22, 0x03, 0x6a, 0x22, 0x04, 0x20, 0x01, 0x20, 0x03, 0x6a,
+  0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x04, 0x41, 0x03, 0x71, 0x45,
+  0x04, 0x40, 0x20, 0x03, 0x21, 0x02, 0x0c, 0x01, 0x0b, 0x20, 0x03, 0x45,
+  0x0d, 0x04, 0x20, 0x00, 0x20, 0x02, 0x41, 0x02, 0x6b, 0x22, 0x03, 0x6a,
+  0x22, 0x04, 0x20, 0x01, 0x20, 0x03, 0x6a, 0x2d, 0x00, 0x00, 0x3a, 0x00,
+  0x00, 0x20, 0x04, 0x41, 0x03, 0x71, 0x45, 0x04, 0x40, 0x20, 0x03, 0x21,
+  0x02, 0x0c, 0x01, 0x0b, 0x20, 0x03, 0x45, 0x0d, 0x04, 0x20, 0x00, 0x20,
+  0x02, 0x41, 0x03, 0x6b, 0x22, 0x03, 0x6a, 0x22, 0x04, 0x20, 0x01, 0x20,
+  0x03, 0x6a, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x04, 0x41, 0x03,
+  0x71, 0x45, 0x04, 0x40, 0x20, 0x03, 0x21, 0x02, 0x0c, 0x01, 0x0b, 0x20,
+  0x03, 0x45, 0x0d, 0x04, 0x20, 0x00, 0x20, 0x02, 0x41, 0x04, 0x6b, 0x22,
+  0x02, 0x6a, 0x20, 0x01, 0x20, 0x02, 0x6a, 0x2d, 0x00, 0x00, 0x3a, 0x00,
+  0x00, 0x0b, 0x20, 0x02, 0x41, 0x04, 0x49, 0x0d, 0x00, 0x20, 0x02, 0x41,
+  0x04, 0x6b, 0x22, 0x04, 0x41, 0x02, 0x76, 0x41, 0x01, 0x6a, 0x41, 0x03,
+  0x71, 0x22, 0x03, 0x04, 0x40, 0x20, 0x01, 0x41, 0x04, 0x6b, 0x21, 0x05,
+  0x20, 0x00, 0x41, 0x04, 0x6b, 0x21, 0x06, 0x03, 0x40, 0x20, 0x02, 0x20,
+  0x06, 0x6a, 0x20, 0x02, 0x20, 0x05, 0x6a, 0x28, 0x02, 0x00, 0x36, 0x02,
+  0x00, 0x20, 0x02, 0x41, 0x04, 0x6b, 0x21, 0x02, 0x20, 0x03, 0x41, 0x01,
+  0x6b, 0x22, 0x03, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x04, 0x41, 0x0c, 0x49,
+  0x0d, 0x00, 0x20, 0x01, 0x41, 0x10, 0x6b, 0x21, 0x05, 0x20, 0x00, 0x41,
+  0x10, 0x6b, 0x21, 0x06, 0x03, 0x40, 0x20, 0x02, 0x20, 0x06, 0x6a, 0x22,
+  0x03, 0x41, 0x0c, 0x6a, 0x20, 0x02, 0x20, 0x05, 0x6a, 0x22, 0x04, 0x41,
+  0x0c, 0x6a, 0x28, 0x02, 0x00, 0x36, 0x02, 0x00, 0x20, 0x03, 0x41, 0x08,
+  0x6a, 0x20, 0x04, 0x41, 0x08, 0x6a, 0x28, 0x02, 0x00, 0x36, 0x02, 0x00,
+  0x20, 0x03, 0x41, 0x04, 0x6a, 0x20, 0x04, 0x41, 0x04, 0x6a, 0x28, 0x02,
+  0x00, 0x36, 0x02, 0x00, 0x20, 0x03, 0x20, 0x04, 0x28, 0x02, 0x00, 0x36,
+  0x02, 0x00, 0x20, 0x02, 0x41, 0x10, 0x6b, 0x22, 0x02, 0x41, 0x03, 0x4b,
+  0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x02, 0x45, 0x0d, 0x02, 0x20, 0x02, 0x22,
+  0x03, 0x41, 0x03, 0x71, 0x22, 0x05, 0x04, 0x40, 0x20, 0x01, 0x41, 0x01,
+  0x6b, 0x21, 0x04, 0x20, 0x00, 0x41, 0x01, 0x6b, 0x21, 0x06, 0x03, 0x40,
+  0x20, 0x03, 0x20, 0x06, 0x6a, 0x20, 0x03, 0x20, 0x04, 0x6a, 0x2d, 0x00,
+  0x00, 0x3a, 0x00, 0x00, 0x20, 0x03, 0x41, 0x01, 0x6b, 0x21, 0x03, 0x20,
+  0x05, 0x41, 0x01, 0x6b, 0x22, 0x05, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x02,
+  0x41, 0x04, 0x49, 0x0d, 0x02, 0x20, 0x01, 0x41, 0x04, 0x6b, 0x21, 0x04,
+  0x20, 0x00, 0x41, 0x04, 0x6b, 0x21, 0x05, 0x03, 0x40, 0x20, 0x03, 0x20,
+  0x05, 0x6a, 0x22, 0x01, 0x41, 0x03, 0x6a, 0x20, 0x03, 0x20, 0x04, 0x6a,
+  0x22, 0x02, 0x41, 0x03, 0x6a, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20,
+  0x01, 0x41, 0x02, 0x6a, 0x20, 0x02, 0x41, 0x02, 0x6a, 0x2d, 0x00, 0x00,
+  0x3a, 0x00, 0x00, 0x20, 0x01, 0x41, 0x01, 0x6a, 0x20, 0x02, 0x41, 0x01,
+  0x6a, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x01, 0x20, 0x02, 0x2d,
+  0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x03, 0x41, 0x04, 0x6b, 0x22, 0x03,
+  0x0d, 0x00, 0x0b, 0x0c, 0x02, 0x0b, 0x20, 0x04, 0x41, 0x04, 0x49, 0x0d,
+  0x00, 0x20, 0x04, 0x41, 0x04, 0x6b, 0x22, 0x05, 0x41, 0x02, 0x76, 0x41,
+  0x01, 0x6a, 0x41, 0x07, 0x71, 0x22, 0x02, 0x04, 0x40, 0x20, 0x04, 0x20,
+  0x02, 0x41, 0x02, 0x74, 0x6b, 0x21, 0x04, 0x03, 0x40, 0x20, 0x03, 0x20,
+  0x01, 0x28, 0x02, 0x00, 0x36, 0x02, 0x00, 0x20, 0x01, 0x41, 0x04, 0x6a,
+  0x21, 0x01, 0x20, 0x03, 0x41, 0x04, 0x6a, 0x21, 0x03, 0x20, 0x02, 0x41,
+  0x01, 0x6b, 0x22, 0x02, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x05, 0x41, 0x1c,
+  0x49, 0x0d, 0x00, 0x03, 0x40, 0x20, 0x03, 0x20, 0x01, 0x28, 0x02, 0x00,
+  0x36, 0x02, 0x00, 0x20, 0x03, 0x20, 0x01, 0x28, 0x02, 0x04, 0x36, 0x02,
+  0x04, 0x20, 0x03, 0x20, 0x01, 0x28, 0x02, 0x08, 0x36, 0x02, 0x08, 0x20,
+  0x03, 0x20, 0x01, 0x28, 0x02, 0x0c, 0x36, 0x02, 0x0c, 0x20, 0x03, 0x20,
+  0x01, 0x28, 0x02, 0x10, 0x36, 0x02, 0x10, 0x20, 0x03, 0x20, 0x01, 0x28,
+  0x02, 0x14, 0x36, 0x02, 0x14, 0x20, 0x03, 0x20, 0x01, 0x28, 0x02, 0x18,
+  0x36, 0x02, 0x18, 0x20, 0x03, 0x20, 0x01, 0x28, 0x02, 0x1c, 0x36, 0x02,
+  0x1c, 0x20, 0x01, 0x41, 0x20, 0x6a, 0x21, 0x01, 0x20, 0x03, 0x41, 0x20,
+  0x6a, 0x21, 0x03, 0x20, 0x04, 0x41, 0x20, 0x6b, 0x22, 0x04, 0x41, 0x03,
+  0x4b, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x04, 0x45, 0x0d, 0x00, 0x02, 0x40,
+  0x20, 0x04, 0x41, 0x07, 0x71, 0x22, 0x02, 0x45, 0x04, 0x40, 0x20, 0x04,
+  0x21, 0x05, 0x0c, 0x01, 0x0b, 0x20, 0x04, 0x41, 0x78, 0x71, 0x21, 0x05,
+  0x03, 0x40, 0x20, 0x03, 0x20, 0x01, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00,
+  0x20, 0x03, 0x41, 0x01, 0x6a, 0x21, 0x03, 0x20, 0x01, 0x41, 0x01, 0x6a,
+  0x21, 0x01, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x22, 0x02, 0x0d, 0x00, 0x0b,
+  0x0b, 0x20, 0x04, 0x41, 0x08, 0x49, 0x0d, 0x00, 0x03, 0x40, 0x20, 0x03,
+  0x20, 0x01, 0x2d, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x03, 0x20, 0x01,
+  0x2d, 0x00, 0x01, 0x3a, 0x00, 0x01, 0x20, 0x03, 0x20, 0x01, 0x2d, 0x00,
+  0x02, 0x3a, 0x00, 0x02, 0x20, 0x03, 0x20, 0x01, 0x2d, 0x00, 0x03, 0x3a,
+  0x00, 0x03, 0x20, 0x03, 0x20, 0x01, 0x2d, 0x00, 0x04, 0x3a, 0x00, 0x04,
+  0x20, 0x03, 0x20, 0x01, 0x2d, 0x00, 0x05, 0x3a, 0x00, 0x05, 0x20, 0x03,
+  0x20, 0x01, 0x2d, 0x00, 0x06, 0x3a, 0x00, 0x06, 0x20, 0x03, 0x20, 0x01,
+  0x2d, 0x00, 0x07, 0x3a, 0x00, 0x07, 0x20, 0x03, 0x41, 0x08, 0x6a, 0x21,
+  0x03, 0x20, 0x01, 0x41, 0x08, 0x6a, 0x21, 0x01, 0x20, 0x05, 0x41, 0x08,
+  0x6b, 0x22, 0x05, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x00, 0x0b, 0x09, 0x00,
+  0x20, 0x00, 0x10, 0x15, 0x20, 0x00, 0x47, 0x0b, 0x0d, 0x00, 0x20, 0x00,
+  0x41, 0x20, 0x46, 0x20, 0x00, 0x41, 0x09, 0x46, 0x72, 0x0b, 0x0a, 0x00,
+  0x20, 0x00, 0x41, 0x30, 0x6b, 0x41, 0x0a, 0x49, 0x0b, 0x49, 0x01, 0x02,
+  0x7f, 0x20, 0x00, 0x10, 0x0e, 0x20, 0x00, 0x6a, 0x21, 0x03, 0x02, 0x40,
+  0x20, 0x02, 0x45, 0x0d, 0x00, 0x03, 0x40, 0x20, 0x01, 0x2d, 0x00, 0x00,
+  0x22, 0x04, 0x45, 0x0d, 0x01, 0x20, 0x03, 0x20, 0x04, 0x3a, 0x00, 0x00,
+  0x20, 0x03, 0x41, 0x01, 0x6a, 0x21, 0x03, 0x20, 0x01, 0x41, 0x01, 0x6a,
+  0x21, 0x01, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x22, 0x02, 0x0d, 0x00, 0x0b,
+  0x0b, 0x20, 0x03, 0x41, 0x00, 0x3a, 0x00, 0x00, 0x20, 0x00, 0x0b, 0xe6,
+  0x03, 0x01, 0x04, 0x7f, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40,
+  0x20, 0x00, 0x20, 0x01, 0x22, 0x03, 0x73, 0x41, 0x03, 0x71, 0x04, 0x40,
+  0x20, 0x00, 0x21, 0x04, 0x0c, 0x01, 0x0b, 0x20, 0x02, 0x41, 0x00, 0x47,
+  0x21, 0x06, 0x02, 0x40, 0x20, 0x03, 0x41, 0x03, 0x71, 0x45, 0x04, 0x40,
+  0x20, 0x00, 0x21, 0x04, 0x0c, 0x01, 0x0b, 0x20, 0x02, 0x45, 0x04, 0x40,
+  0x20, 0x00, 0x21, 0x04, 0x0c, 0x01, 0x0b, 0x20, 0x00, 0x20, 0x03, 0x2d,
+  0x00, 0x00, 0x22, 0x01, 0x3a, 0x00, 0x00, 0x20, 0x01, 0x45, 0x04, 0x40,
+  0x20, 0x00, 0x21, 0x04, 0x20, 0x02, 0x21, 0x01, 0x0c, 0x05, 0x0b, 0x20,
+  0x00, 0x41, 0x01, 0x6a, 0x21, 0x04, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x22,
+  0x01, 0x41, 0x00, 0x47, 0x21, 0x06, 0x20, 0x03, 0x41, 0x01, 0x6a, 0x22,
+  0x05, 0x41, 0x03, 0x71, 0x45, 0x20, 0x01, 0x45, 0x72, 0x45, 0x04, 0x40,
+  0x20, 0x04, 0x20, 0x05, 0x2d, 0x00, 0x00, 0x22, 0x05, 0x3a, 0x00, 0x00,
+  0x20, 0x05, 0x45, 0x0d, 0x05, 0x20, 0x00, 0x41, 0x02, 0x6a, 0x21, 0x04,
+  0x20, 0x02, 0x41, 0x02, 0x6b, 0x22, 0x01, 0x41, 0x00, 0x47, 0x21, 0x06,
+  0x20, 0x03, 0x41, 0x02, 0x6a, 0x22, 0x05, 0x41, 0x03, 0x71, 0x45, 0x20,
+  0x01, 0x45, 0x72, 0x45, 0x04, 0x40, 0x20, 0x04, 0x20, 0x05, 0x2d, 0x00,
+  0x00, 0x22, 0x05, 0x3a, 0x00, 0x00, 0x20, 0x05, 0x45, 0x0d, 0x06, 0x20,
+  0x00, 0x41, 0x03, 0x6a, 0x21, 0x04, 0x20, 0x02, 0x41, 0x03, 0x6b, 0x22,
+  0x01, 0x41, 0x00, 0x47, 0x21, 0x06, 0x20, 0x03, 0x41, 0x03, 0x6a, 0x22,
+  0x05, 0x41, 0x03, 0x71, 0x45, 0x20, 0x01, 0x45, 0x72, 0x45, 0x04, 0x40,
+  0x20, 0x04, 0x20, 0x05, 0x2d, 0x00, 0x00, 0x22, 0x05, 0x3a, 0x00, 0x00,
+  0x20, 0x05, 0x45, 0x0d, 0x07, 0x20, 0x00, 0x41, 0x04, 0x6a, 0x21, 0x04,
+  0x20, 0x03, 0x41, 0x04, 0x6a, 0x21, 0x03, 0x20, 0x02, 0x41, 0x04, 0x6b,
+  0x22, 0x02, 0x41, 0x00, 0x47, 0x21, 0x06, 0x0c, 0x03, 0x0b, 0x20, 0x05,
+  0x21, 0x03, 0x20, 0x01, 0x21, 0x02, 0x0c, 0x02, 0x0b, 0x20, 0x05, 0x21,
+  0x03, 0x20, 0x01, 0x21, 0x02, 0x0c, 0x01, 0x0b, 0x20, 0x05, 0x21, 0x03,
+  0x20, 0x01, 0x21, 0x02, 0x0b, 0x20, 0x06, 0x45, 0x0d, 0x02, 0x20, 0x03,
+  0x2d, 0x00, 0x00, 0x45, 0x04, 0x40, 0x20, 0x02, 0x21, 0x01, 0x0c, 0x04,
+  0x0b, 0x20, 0x02, 0x41, 0x04, 0x49, 0x0d, 0x00, 0x03, 0x40, 0x41, 0x80,
+  0x82, 0x84, 0x08, 0x20, 0x03, 0x28, 0x02, 0x00, 0x22, 0x01, 0x6b, 0x20,
+  0x01, 0x72, 0x41, 0x80, 0x81, 0x82, 0x84, 0x78, 0x71, 0x41, 0x80, 0x81,
+  0x82, 0x84, 0x78, 0x47, 0x0d, 0x02, 0x20, 0x04, 0x20, 0x01, 0x36, 0x02,
+  0x00, 0x20, 0x04, 0x41, 0x04, 0x6a, 0x21, 0x04, 0x20, 0x03, 0x41, 0x04,
+  0x6a, 0x21, 0x03, 0x20, 0x02, 0x41, 0x04, 0x6b, 0x22, 0x02, 0x41, 0x03,
+  0x4b, 0x0d, 0x00, 0x0b, 0x0b, 0x20, 0x02, 0x45, 0x0d, 0x01, 0x0b, 0x03,
+  0x40, 0x20, 0x04, 0x20, 0x03, 0x2d, 0x00, 0x00, 0x22, 0x01, 0x3a, 0x00,
+  0x00, 0x20, 0x01, 0x45, 0x04, 0x40, 0x20, 0x02, 0x21, 0x01, 0x0c, 0x03,
+  0x0b, 0x20, 0x04, 0x41, 0x01, 0x6a, 0x21, 0x04, 0x20, 0x03, 0x41, 0x01,
+  0x6a, 0x21, 0x03, 0x20, 0x02, 0x41, 0x01, 0x6b, 0x22, 0x02, 0x0d, 0x00,
+  0x0b, 0x0b, 0x41, 0x00, 0x21, 0x01, 0x0b, 0x20, 0x04, 0x41, 0x00, 0x20,
+  0x01, 0x10, 0x0d, 0x1a, 0x20, 0x00, 0x0b, 0x17, 0x00, 0x20, 0x00, 0x41,
+  0x30, 0x6b, 0x41, 0x0a, 0x49, 0x20, 0x00, 0x41, 0x20, 0x72, 0x41, 0xe1,
+  0x00, 0x6b, 0x41, 0x06, 0x49, 0x72, 0x0b, 0x67, 0x01, 0x02, 0x7f, 0x20,
+  0x00, 0x45, 0x04, 0x40, 0x41, 0x00, 0x0f, 0x0b, 0x02, 0x7f, 0x20, 0x00,
+  0x04, 0x40, 0x41, 0x8c, 0xc2, 0x04, 0x21, 0x01, 0x03, 0x40, 0x20, 0x01,
+  0x41, 0x04, 0x6a, 0x22, 0x01, 0x28, 0x02, 0x00, 0x22, 0x02, 0x41, 0x00,
+  0x20, 0x00, 0x20, 0x02, 0x47, 0x1b, 0x0d, 0x00, 0x0b, 0x20, 0x01, 0x41,
+  0x00, 0x20, 0x02, 0x1b, 0x0c, 0x01, 0x0b, 0x41, 0x00, 0x21, 0x00, 0x03,
+  0x40, 0x20, 0x00, 0x41, 0x90, 0xc2, 0x04, 0x6a, 0x20, 0x00, 0x41, 0x04,
+  0x6a, 0x21, 0x00, 0x28, 0x02, 0x00, 0x0d, 0x00, 0x0b, 0x20, 0x00, 0x41,
+  0x04, 0x6b, 0x41, 0x7c, 0x71, 0x41, 0x90, 0xc2, 0x04, 0x6a, 0x0b, 0x41,
+  0x00, 0x47, 0x0b, 0x1d, 0x01, 0x01, 0x7f, 0x41, 0x01, 0x21, 0x01, 0x20,
+  0x00, 0x41, 0x30, 0x6b, 0x41, 0x0a, 0x4f, 0x04, 0x7f, 0x20, 0x00, 0x10,
+  0x0f, 0x41, 0x00, 0x47, 0x05, 0x20, 0x01, 0x0b, 0x0b, 0x0b, 0xf1, 0x42,
+  0x01, 0x00, 0x41, 0x80, 0x80, 0x04, 0x0b, 0xe8, 0x42, 0x12, 0x11, 0x13,
+  0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+  0x20, 0x21, 0x11, 0x22, 0x23, 0x24, 0x11, 0x25, 0x26, 0x27, 0x28, 0x29,
+  0x2a, 0x2b, 0x2c, 0x11, 0x2d, 0x2e, 0x2f, 0x10, 0x10, 0x30, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x31, 0x32, 0x33, 0x10, 0x34, 0x35, 0x10,
+  0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x36, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x37, 0x11, 0x11, 0x11, 0x11, 0x38, 0x11, 0x39, 0x3a, 0x3b, 0x3c, 0x3d,
+  0x3e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x3f, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x40, 0x41, 0x11, 0x42, 0x43,
+  0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x11, 0x4b, 0x4c, 0x4d, 0x4e,
+  0x4f, 0x50, 0x51, 0x10, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+  0x5a, 0x5b, 0x5c, 0x5d, 0x10, 0x5e, 0x5f, 0x60, 0x10, 0x11, 0x11, 0x11,
+  0x61, 0x62, 0x63, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x11, 0x11, 0x11, 0x11, 0x64, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x65,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x66,
+  0x67, 0x10, 0x10, 0x68, 0x69, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0x11, 0x11, 0x6a, 0x11, 0x11, 0x6b, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x6c, 0x6d,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x6e, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x6f, 0x70, 0x71,
+  0x72, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x73, 0x74, 0x75,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x76, 0x77, 0x10, 0x10, 0x10, 0x10, 0x78,
+  0x10, 0x10, 0x79, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x07, 0xfe, 0xff, 0xff,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x04, 0xff, 0xff, 0x7f,
+  0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xff, 0x03, 0x00, 0x1f, 0x50, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xdf, 0xbc, 0x40, 0xd7, 0xff, 0xff, 0xfb, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0x03, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+  0xff, 0xff, 0xff, 0x7f, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xbf, 0xb6, 0x00, 0xff, 0xff, 0xff, 0x87, 0x07,
+  0x00, 0x00, 0x00, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xfe, 0xff, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xef, 0x1f, 0xfe, 0xe1, 0xff, 0x9f, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0x30, 0x04, 0xff, 0xff, 0xff, 0xfc, 0xff, 0x1f, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0x01, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xdf, 0x3f, 0x00, 0x00, 0xf0, 0xff, 0xf8, 0x03, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xdf, 0xe1,
+  0xff, 0xcf, 0xff, 0xfe, 0xff, 0xef, 0x9f, 0xf9, 0xff, 0xff, 0xfd, 0xc5,
+  0xe3, 0x9f, 0x59, 0x80, 0xb0, 0xcf, 0xff, 0x03, 0x10, 0xee, 0x87, 0xf9,
+  0xff, 0xff, 0xfd, 0x6d, 0xc3, 0x87, 0x19, 0x02, 0x5e, 0xc0, 0xff, 0x3f,
+  0x00, 0xee, 0xbf, 0xfb, 0xff, 0xff, 0xfd, 0xed, 0xe3, 0xbf, 0x1b, 0x01,
+  0x00, 0xcf, 0xff, 0x00, 0x1e, 0xee, 0x9f, 0xf9, 0xff, 0xff, 0xfd, 0xed,
+  0xe3, 0x9f, 0x19, 0xc0, 0xb0, 0xcf, 0xff, 0x02, 0x00, 0xec, 0xc7, 0x3d,
+  0xd6, 0x18, 0xc7, 0xff, 0xc3, 0xc7, 0x1d, 0x81, 0x00, 0xc0, 0xff, 0x00,
+  0x00, 0xef, 0xdf, 0xfd, 0xff, 0xff, 0xfd, 0xff, 0xe3, 0xdf, 0x1d, 0x60,
+  0x07, 0xcf, 0xff, 0x00, 0x00, 0xef, 0xdf, 0xfd, 0xff, 0xff, 0xfd, 0xef,
+  0xe3, 0xdf, 0x1d, 0x60, 0x40, 0xcf, 0xff, 0x06, 0x00, 0xef, 0xdf, 0xfd,
+  0xff, 0xff, 0xff, 0xff, 0xe7, 0xdf, 0x5d, 0xf0, 0x80, 0xcf, 0xff, 0x00,
+  0xfc, 0xec, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xfb, 0x2f, 0x7f, 0x80, 0x5f,
+  0xff, 0xc0, 0xff, 0x0c, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff,
+  0x07, 0x3f, 0x20, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xd6, 0xf7, 0xff,
+  0xff, 0xaf, 0xff, 0xff, 0x3b, 0x5f, 0x20, 0xff, 0xf3, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0xff, 0xfe, 0xff,
+  0xff, 0xff, 0x1f, 0xfe, 0xff, 0x03, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x7f, 0xf9, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x20, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x3d, 0x7f, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3d, 0xff,
+  0xff, 0xff, 0xff, 0x3d, 0x7f, 0x3d, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x3f, 0xfe, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xfe, 0xff, 0xff,
+  0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0xff,
+  0x01, 0xff, 0xdf, 0x0f, 0x00, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0x0f,
+  0x00, 0xff, 0xdf, 0x0d, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf,
+  0xff, 0xff, 0x01, 0x80, 0x10, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xff, 0xff, 0x7f, 0xff, 0x0f, 0xff,
+  0x01, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x1f, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x03, 0xff, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x7f, 0xfe, 0xff, 0x1f, 0x00, 0xff, 0x03, 0xff, 0x03, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xef, 0xff, 0xef, 0x0f, 0xff, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xbf, 0xff, 0x03, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
+  0x00, 0xff, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x01, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0x6f,
+  0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x1f, 0x00, 0xff, 0xff, 0x3f,
+  0x3f, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x3f, 0xff, 0xaa, 0xff, 0xff, 0xff,
+  0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x5f, 0xdc, 0x1f, 0xcf,
+  0x0f, 0xff, 0x1f, 0xdc, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0xff,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x84, 0xfc, 0x2f, 0x3e, 0x50, 0xbd, 0xff, 0xf3, 0xe0, 0x43, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x78, 0x0c,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x80, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x7f, 0x7f, 0x7f,
+  0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0xfe, 0x03, 0x3e,
+  0x1f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
+  0xe0, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xf7, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x1f, 0xff,
+  0xff, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xf0,
+  0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xfc, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0x2f, 0x00, 0xff, 0x03, 0x00, 0x00, 0xfc, 0xe8, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0xff,
+  0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0x00, 0x80, 0xff,
+  0x03, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
+  0x00, 0xff, 0x3f, 0xff, 0x03, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x7f, 0x05, 0x00, 0x00, 0x38, 0xff, 0xff, 0x3c,
+  0x00, 0x7e, 0x7e, 0x7e, 0x00, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xf7, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xff, 0x03, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0x7f, 0xf8, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x7f, 0x00, 0xf8, 0xe0, 0xff, 0xfd, 0x7f, 0x5f, 0xdb, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
+  0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x1f, 0x00, 0x00, 0xff, 0x03, 0xfe, 0xff, 0xff, 0x07, 0xfe, 0xff, 0xff,
+  0x07, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x7f, 0xfc, 0xfc, 0xfc, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xef, 0xff,
+  0xff, 0x7f, 0xff, 0xff, 0xb7, 0xff, 0x3f, 0xff, 0x3f, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0xe0, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x07, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0x3e,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x3f, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff,
+  0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xff, 0x3f, 0x00, 0xff, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xbf,
+  0x91, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x37,
+  0x00, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xf0, 0xef,
+  0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0x1f, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff,
+  0xff, 0x1f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0xff, 0xff, 0x3f, 0x00, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x00, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x80, 0x00, 0xff,
+  0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00,
+  0x00, 0xc0, 0xff, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0xff, 0x03, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xc7, 0xff, 0x70, 0x00, 0xff, 0xff, 0xff, 0xff, 0x47,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1e, 0x00, 0xff,
+  0x17, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0x9f,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xbd, 0xff,
+  0xbf, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xff,
+  0x03, 0xef, 0x9f, 0xf9, 0xff, 0xff, 0xfd, 0xed, 0xe3, 0x9f, 0x19, 0x81,
+  0xe0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0x07, 0xff, 0x83, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb3, 0x00, 0xff,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x7f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x11, 0x00, 0xff,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x01, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xe7, 0xff, 0x07, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfc, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xfc, 0x1a, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xe7, 0x7f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x20, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x7f,
+  0x7f, 0x01, 0x00, 0xff, 0x03, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xfc,
+  0xff, 0xff, 0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x7f, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xb4, 0xcb, 0x00, 0xff,
+  0x03, 0xbf, 0xfd, 0xff, 0xff, 0xff, 0x7f, 0x7b, 0x01, 0xff, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0x7f, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x7f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x7f, 0xff, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+  0x00, 0x0f, 0x00, 0xff, 0x03, 0xf8, 0xff, 0xff, 0xe0, 0xff, 0xff, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0xf0, 0x00, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0xff, 0x1f, 0xff, 0x01, 0xff, 0x43, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xdf, 0x64, 0xde, 0xff, 0xeb, 0xef, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xe7, 0xdf, 0xdf, 0xff, 0xff, 0xff,
+  0x7b, 0x5f, 0xfc, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff,
+  0xff, 0xfd, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xdf,
+  0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff,
+  0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xcf, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xf9, 0xdb, 0x07, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x80, 0x3f, 0xff, 0x43, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0x0f, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0x08, 0xff,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xff, 0xff,
+  0xff, 0x96, 0xfe, 0xf7, 0x0a, 0x84, 0xea, 0x96, 0xaa, 0x96, 0xf7, 0xf7,
+  0x5e, 0xff, 0xfb, 0xff, 0x0f, 0xee, 0xfb, 0xff, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x56, 0x01, 0x00, 0x00, 0x39, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00,
+  0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0xbf, 0x1d, 0x00, 0x00, 0xe7, 0x02,
+  0x00, 0x00, 0x79, 0x00, 0x00, 0x02, 0x24, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00,
+  0x00, 0x00, 0xfe, 0xff, 0xff, 0x01, 0x39, 0xff, 0xff, 0x00, 0x18, 0xff,
+  0xff, 0x01, 0x87, 0xff, 0xff, 0x00, 0xd4, 0xfe, 0xff, 0x00, 0xc3, 0x00,
+  0x00, 0x01, 0xd2, 0x00, 0x00, 0x01, 0xce, 0x00, 0x00, 0x01, 0xcd, 0x00,
+  0x00, 0x01, 0x4f, 0x00, 0x00, 0x01, 0xca, 0x00, 0x00, 0x01, 0xcb, 0x00,
+  0x00, 0x01, 0xcf, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x01, 0xd3, 0x00,
+  0x00, 0x01, 0xd1, 0x00, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x01, 0xd5, 0x00,
+  0x00, 0x00, 0x82, 0x00, 0x00, 0x01, 0xd6, 0x00, 0x00, 0x01, 0xda, 0x00,
+  0x00, 0x01, 0xd9, 0x00, 0x00, 0x01, 0xdb, 0x00, 0x00, 0x00, 0x38, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0xb1, 0xff, 0xff, 0x01, 0x9f, 0xff,
+  0xff, 0x01, 0xc8, 0xff, 0xff, 0x02, 0x28, 0x24, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x33, 0xff,
+  0xff, 0x00, 0x26, 0xff, 0xff, 0x01, 0x7e, 0xff, 0xff, 0x01, 0x2b, 0x2a,
+  0x00, 0x01, 0x5d, 0xff, 0xff, 0x01, 0x28, 0x2a, 0x00, 0x00, 0x3f, 0x2a,
+  0x00, 0x01, 0x3d, 0xff, 0xff, 0x01, 0x45, 0x00, 0x00, 0x01, 0x47, 0x00,
+  0x00, 0x00, 0x1f, 0x2a, 0x00, 0x00, 0x1c, 0x2a, 0x00, 0x00, 0x1e, 0x2a,
+  0x00, 0x00, 0x2e, 0xff, 0xff, 0x00, 0x32, 0xff, 0xff, 0x00, 0x36, 0xff,
+  0xff, 0x00, 0x35, 0xff, 0xff, 0x00, 0x4f, 0xa5, 0x00, 0x00, 0x4b, 0xa5,
+  0x00, 0x00, 0x31, 0xff, 0xff, 0x00, 0x28, 0xa5, 0x00, 0x00, 0x44, 0xa5,
+  0x00, 0x00, 0x2f, 0xff, 0xff, 0x00, 0x2d, 0xff, 0xff, 0x00, 0xf7, 0x29,
+  0x00, 0x00, 0x41, 0xa5, 0x00, 0x00, 0xfd, 0x29, 0x00, 0x00, 0x2b, 0xff,
+  0xff, 0x00, 0x2a, 0xff, 0xff, 0x00, 0xe7, 0x29, 0x00, 0x00, 0x43, 0xa5,
+  0x00, 0x00, 0x2a, 0xa5, 0x00, 0x00, 0xbb, 0xff, 0xff, 0x00, 0x27, 0xff,
+  0xff, 0x00, 0xb9, 0xff, 0xff, 0x00, 0x25, 0xff, 0xff, 0x00, 0x15, 0xa5,
+  0x00, 0x00, 0x12, 0xa5, 0x00, 0x02, 0x24, 0x4c, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x54, 0x00, 0x00, 0x01, 0x74, 0x00,
+  0x00, 0x01, 0x26, 0x00, 0x00, 0x01, 0x25, 0x00, 0x00, 0x01, 0x40, 0x00,
+  0x00, 0x01, 0x3f, 0x00, 0x00, 0x00, 0xda, 0xff, 0xff, 0x00, 0xdb, 0xff,
+  0xff, 0x00, 0xe1, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0x00, 0xc1, 0xff,
+  0xff, 0x01, 0x08, 0x00, 0x00, 0x00, 0xc2, 0xff, 0xff, 0x00, 0xc7, 0xff,
+  0xff, 0x00, 0xd1, 0xff, 0xff, 0x00, 0xca, 0xff, 0xff, 0x00, 0xf8, 0xff,
+  0xff, 0x00, 0xaa, 0xff, 0xff, 0x00, 0xb0, 0xff, 0xff, 0x00, 0x07, 0x00,
+  0x00, 0x00, 0x8c, 0xff, 0xff, 0x01, 0xc4, 0xff, 0xff, 0x00, 0xa0, 0xff,
+  0xff, 0x01, 0xf9, 0xff, 0xff, 0x02, 0x1a, 0x70, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x20, 0x00, 0x00, 0x00, 0xe0, 0xff,
+  0xff, 0x01, 0x50, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0xf1, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0xd0, 0xff,
+  0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc0, 0x0b, 0x00, 0x01, 0x60, 0x1c, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0xd0, 0x97, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0xf8, 0xff,
+  0xff, 0x02, 0x05, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0xf4,
+  0xff, 0x00, 0x9e, 0xe7, 0xff, 0x00, 0xc2, 0x89, 0x00, 0x00, 0xdb, 0xe7,
+  0xff, 0x00, 0x92, 0xe7, 0xff, 0x00, 0x93, 0xe7, 0xff, 0x00, 0x9c, 0xe7,
+  0xff, 0x00, 0x9d, 0xe7, 0xff, 0x00, 0xa4, 0xe7, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x38, 0x8a, 0x00, 0x00, 0x04, 0x8a, 0x00, 0x00, 0xe6, 0x0e,
+  0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc5, 0xff, 0xff, 0x01, 0x41, 0xe2, 0xff, 0x02, 0x1d, 0x8f,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0xf8, 0xff, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x56, 0x00, 0x00, 0x01, 0xaa, 0xff, 0xff, 0x00, 0x4a, 0x00,
+  0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x70, 0x00,
+  0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01, 0xb6, 0xff,
+  0xff, 0x01, 0xf7, 0xff, 0xff, 0x00, 0xdb, 0xe3, 0xff, 0x01, 0x9c, 0xff,
+  0xff, 0x01, 0x90, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff, 0x01, 0x82, 0xff,
+  0xff, 0x02, 0x05, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00,
+  0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x1c, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x01, 0xa3, 0xe2, 0xff, 0x01, 0x41, 0xdf, 0xff, 0x01, 0xba, 0xdf,
+  0xff, 0x00, 0xe4, 0xff, 0xff, 0x02, 0x0b, 0xb1, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x30, 0x00, 0x00, 0x00, 0xd0, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x09, 0xd6, 0xff, 0x01, 0x1a, 0xf1,
+  0xff, 0x01, 0x19, 0xd6, 0xff, 0x00, 0xd5, 0xd5, 0xff, 0x00, 0xd8, 0xd5,
+  0xff, 0x01, 0xe4, 0xd5, 0xff, 0x01, 0x03, 0xd6, 0xff, 0x01, 0xe1, 0xd5,
+  0xff, 0x01, 0xe2, 0xd5, 0xff, 0x01, 0xc1, 0xd5, 0xff, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xa0, 0xe3, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0xff, 0xff, 0xff, 0x02, 0x0c, 0xbc, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0xbc, 0x5a,
+  0xff, 0x01, 0xa0, 0x03, 0x00, 0x01, 0xfc, 0x75, 0xff, 0x01, 0xd8, 0x5a,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0x01, 0xb1, 0x5a, 0xff, 0x01, 0xb5, 0x5a,
+  0xff, 0x01, 0xbf, 0x5a, 0xff, 0x01, 0xee, 0x5a, 0xff, 0x01, 0xd6, 0x5a,
+  0xff, 0x01, 0xeb, 0x5a, 0xff, 0x01, 0xd0, 0xff, 0xff, 0x01, 0xbd, 0x5a,
+  0xff, 0x01, 0xc8, 0x75, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x68,
+  0xff, 0x00, 0x60, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00,
+  0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x28, 0x00,
+  0x00, 0x00, 0xd8, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00,
+  0x00, 0x00, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00,
+  0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00,
+  0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x22, 0x00,
+  0x00, 0x00, 0xde, 0xff, 0xff, 0x30, 0x0c, 0x31, 0x0d, 0x78, 0x0e, 0x7f,
+  0x0f, 0x80, 0x10, 0x81, 0x11, 0x86, 0x12, 0x89, 0x13, 0x8a, 0x13, 0x8e,
+  0x14, 0x8f, 0x15, 0x90, 0x16, 0x93, 0x13, 0x94, 0x17, 0x95, 0x18, 0x96,
+  0x19, 0x97, 0x1a, 0x9a, 0x1b, 0x9c, 0x19, 0x9d, 0x1c, 0x9e, 0x1d, 0x9f,
+  0x1e, 0xa6, 0x1f, 0xa9, 0x1f, 0xae, 0x1f, 0xb1, 0x20, 0xb2, 0x20, 0xb7,
+  0x21, 0xbf, 0x22, 0xc5, 0x23, 0xc8, 0x23, 0xcb, 0x23, 0xdd, 0x24, 0xf2,
+  0x23, 0xf6, 0x25, 0xf7, 0x26, 0x20, 0x2d, 0x3a, 0x2e, 0x3d, 0x2f, 0x3e,
+  0x30, 0x3f, 0x31, 0x40, 0x31, 0x43, 0x32, 0x44, 0x33, 0x45, 0x34, 0x50,
+  0x35, 0x51, 0x36, 0x52, 0x37, 0x53, 0x38, 0x54, 0x39, 0x59, 0x3a, 0x5b,
+  0x3b, 0x5c, 0x3c, 0x61, 0x3d, 0x63, 0x3e, 0x65, 0x3f, 0x66, 0x40, 0x68,
+  0x41, 0x69, 0x42, 0x6a, 0x40, 0x6b, 0x43, 0x6c, 0x44, 0x6f, 0x42, 0x71,
+  0x45, 0x72, 0x46, 0x75, 0x47, 0x7d, 0x48, 0x82, 0x49, 0x87, 0x4a, 0x89,
+  0x4b, 0x8a, 0x4c, 0x8b, 0x4c, 0x8c, 0x4d, 0x92, 0x4e, 0x9d, 0x4f, 0x9e,
+  0x50, 0x45, 0x57, 0x7b, 0x1d, 0x7c, 0x1d, 0x7d, 0x1d, 0x7f, 0x58, 0x86,
+  0x59, 0x88, 0x5a, 0x89, 0x5a, 0x8a, 0x5a, 0x8c, 0x5b, 0x8e, 0x5c, 0x8f,
+  0x5c, 0xac, 0x5d, 0xad, 0x5e, 0xae, 0x5e, 0xaf, 0x5e, 0xc2, 0x5f, 0xcc,
+  0x60, 0xcd, 0x61, 0xce, 0x61, 0xcf, 0x62, 0xd0, 0x63, 0xd1, 0x64, 0xd5,
+  0x65, 0xd6, 0x66, 0xd7, 0x67, 0xf0, 0x68, 0xf1, 0x69, 0xf2, 0x6a, 0xf3,
+  0x6b, 0xf4, 0x6c, 0xf5, 0x6d, 0xf9, 0x6e, 0xfd, 0x2d, 0xfe, 0x2d, 0xff,
+  0x2d, 0x50, 0x69, 0x51, 0x69, 0x52, 0x69, 0x53, 0x69, 0x54, 0x69, 0x55,
+  0x69, 0x56, 0x69, 0x57, 0x69, 0x58, 0x69, 0x59, 0x69, 0x5a, 0x69, 0x5b,
+  0x69, 0x5c, 0x69, 0x5d, 0x69, 0x5e, 0x69, 0x5f, 0x69, 0x82, 0x00, 0x83,
+  0x00, 0x84, 0x00, 0x85, 0x00, 0x86, 0x00, 0x87, 0x00, 0x88, 0x00, 0x89,
+  0x00, 0xc0, 0x75, 0xcf, 0x76, 0x80, 0x89, 0x81, 0x8a, 0x82, 0x8b, 0x85,
+  0x8c, 0x86, 0x8d, 0x70, 0x9d, 0x71, 0x9d, 0x76, 0x9e, 0x77, 0x9e, 0x78,
+  0x9f, 0x79, 0x9f, 0x7a, 0xa0, 0x7b, 0xa0, 0x7c, 0xa1, 0x7d, 0xa1, 0xb3,
+  0xa2, 0xba, 0xa3, 0xbb, 0xa3, 0xbc, 0xa4, 0xbe, 0xa5, 0xc3, 0xa2, 0xcc,
+  0xa4, 0xda, 0xa6, 0xdb, 0xa6, 0xe5, 0x6a, 0xea, 0xa7, 0xeb, 0xa7, 0xec,
+  0x6e, 0xf3, 0xa2, 0xf8, 0xa8, 0xf9, 0xa8, 0xfa, 0xa9, 0xfb, 0xa9, 0xfc,
+  0xa4, 0x26, 0xb0, 0x2a, 0xb1, 0x2b, 0xb2, 0x4e, 0xb3, 0x84, 0x08, 0x62,
+  0xba, 0x63, 0xbb, 0x64, 0xbc, 0x65, 0xbd, 0x66, 0xbe, 0x6d, 0xbf, 0x6e,
+  0xc0, 0x6f, 0xc1, 0x70, 0xc2, 0x7e, 0xc3, 0x7f, 0xc3, 0x7d, 0xcf, 0x8d,
+  0xd0, 0x94, 0xd1, 0xab, 0xd2, 0xac, 0xd3, 0xad, 0xd4, 0xb0, 0xd5, 0xb1,
+  0xd6, 0xb2, 0xd7, 0xc4, 0xd8, 0xc5, 0xd9, 0xc6, 0xda, 0x07, 0x08, 0x09,
+  0x0a, 0x0b, 0x0c, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x0d, 0x06, 0x06, 0x0e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x0f, 0x10, 0x11, 0x12, 0x06, 0x13, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x14, 0x15, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x16, 0x17, 0x06, 0x06, 0x06,
+  0x18, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x19, 0x06, 0x06, 0x06, 0x06, 0x1a, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x1b, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x1c, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x1d, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1e, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+  0x06, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x01, 0x00, 0x54, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07, 0x2b,
+  0x2b, 0x5b, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x4a, 0x56, 0x56,
+  0x05, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x24, 0x50, 0x79, 0x31, 0x50, 0x31, 0x50,
+  0x31, 0x38, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x4e, 0x31, 0x02, 0x4e, 0x0d, 0x0d, 0x4e,
+  0x03, 0x4e, 0x00, 0x24, 0x6e, 0x00, 0x4e, 0x31, 0x26, 0x6e, 0x51, 0x4e,
+  0x24, 0x50, 0x4e, 0x39, 0x14, 0x81, 0x1b, 0x1d, 0x1d, 0x53, 0x31, 0x50,
+  0x31, 0x50, 0x0d, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x1b, 0x53, 0x24,
+  0x50, 0x31, 0x02, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c,
+  0x7b, 0x14, 0x79, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x2d, 0x2b, 0x49, 0x03,
+  0x48, 0x03, 0x78, 0x5c, 0x7b, 0x14, 0x00, 0x96, 0x0a, 0x01, 0x2b, 0x28,
+  0x06, 0x06, 0x00, 0x2a, 0x06, 0x2a, 0x2a, 0x2b, 0x07, 0xbb, 0xb5, 0x2b,
+  0x1e, 0x00, 0x2b, 0x07, 0x2b, 0x2b, 0x2b, 0x01, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x01, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0xcd, 0x46, 0xcd, 0x2b, 0x00, 0x25,
+  0x2b, 0x07, 0x01, 0x06, 0x01, 0x55, 0x56, 0x56, 0x56, 0x56, 0x56, 0x55,
+  0x56, 0x56, 0x02, 0x24, 0x81, 0x81, 0x81, 0x81, 0x81, 0x15, 0x81, 0x81,
+  0x81, 0x00, 0x00, 0x2b, 0x00, 0xb2, 0xd1, 0xb2, 0xd1, 0xb2, 0xd1, 0xb2,
+  0xd1, 0x00, 0x00, 0xcd, 0xcc, 0x01, 0x00, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7,
+  0x83, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xac,
+  0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0x1c, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x02, 0x00, 0x00, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x4e,
+  0x31, 0x50, 0x31, 0x50, 0x4e, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x02, 0x87, 0xa6, 0x87,
+  0xa6, 0x87, 0xa6, 0x87, 0xa6, 0x87, 0xa6, 0x87, 0xa6, 0x87, 0xa6, 0x87,
+  0xa6, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x00, 0x00, 0x00, 0x54, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x54, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x0c, 0x00, 0x0c, 0x2a, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07, 0x2a,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x56, 0x56, 0x6c,
+  0x81, 0x15, 0x00, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07, 0x6c, 0x03,
+  0x41, 0x2b, 0x2b, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x2c, 0x56, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x6c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x56, 0x7a, 0x9e,
+  0x26, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06,
+  0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x25, 0x06, 0x01, 0x2b, 0x2b, 0x4f,
+  0x56, 0x56, 0x2c, 0x2b, 0x7f, 0x56, 0x56, 0x39, 0x2b, 0x2b, 0x55, 0x56,
+  0x56, 0x2b, 0x2b, 0x4f, 0x56, 0x56, 0x2c, 0x2b, 0x7f, 0x56, 0x56, 0x81,
+  0x37, 0x75, 0x5b, 0x7b, 0x5c, 0x2b, 0x2b, 0x4f, 0x56, 0x56, 0x02, 0xac,
+  0x04, 0x00, 0x00, 0x39, 0x2b, 0x2b, 0x55, 0x56, 0x56, 0x2b, 0x2b, 0x4f,
+  0x56, 0x56, 0x2c, 0x2b, 0x2b, 0x56, 0x56, 0x32, 0x13, 0x81, 0x57, 0x00,
+  0x6f, 0x81, 0x7e, 0xc9, 0xd7, 0x7e, 0x2d, 0x81, 0x81, 0x0e, 0x7e, 0x39,
+  0x7f, 0x6f, 0x57, 0x00, 0x81, 0x81, 0x7e, 0x15, 0x00, 0x7e, 0x03, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07,
+  0x2b, 0x24, 0x2b, 0x97, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x80, 0x81, 0x81, 0x81, 0x81, 0x39, 0xbb, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x01, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+  0x81, 0x81, 0x81, 0x81, 0xc9, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+  0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xd0, 0x0d, 0x00, 0x4e,
+  0x31, 0x02, 0xb4, 0xc1, 0xc1, 0xd7, 0xd7, 0x24, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0xd7, 0xd7, 0x53, 0xc1, 0x47, 0xd4, 0xd7,
+  0xd7, 0xd7, 0x05, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x07, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x4e, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24,
+  0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x31, 0x50, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x79, 0x5c, 0x7b, 0x5c, 0x7b, 0x4f,
+  0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c,
+  0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x7b, 0x5c, 0x2d, 0x2b, 0x2b, 0x79,
+  0x14, 0x5c, 0x7b, 0x5c, 0x2d, 0x79, 0x2a, 0x5c, 0x27, 0x5c, 0x7b, 0x5c,
+  0x7b, 0x5c, 0x7b, 0xa4, 0x00, 0x0a, 0xb4, 0x5c, 0x7b, 0x5c, 0x7b, 0x4f,
+  0x03, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07, 0x00, 0x48, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x55, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x07,
+  0x00, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x07, 0x00, 0x00, 0x00, 0x00, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+  0x56, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x2b, 0x2b,
+  0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x55, 0x56, 0x56, 0x56,
+  0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x27, 0x51, 0x6f, 0x77, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00,
+  0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x8e, 0x92,
+  0x97, 0x00, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xb4, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xc6, 0xc9, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00,
+  0x00, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xed, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+  0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x01, 0x20, 0x00,
+  0x00, 0x02, 0x20, 0x00, 0x00, 0x03, 0x20, 0x00, 0x00, 0x04, 0x20, 0x00,
+  0x00, 0x05, 0x20, 0x00, 0x00, 0x06, 0x20, 0x00, 0x00, 0x08, 0x20, 0x00,
+  0x00, 0x09, 0x20, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x28, 0x20, 0x00,
+  0x00, 0x29, 0x20, 0x00, 0x00, 0x5f, 0x20, 0x00, 0x00, 0x00, 0x30, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x09, 0x70, 0x72, 0x6f,
+  0x64, 0x75, 0x63, 0x65, 0x72, 0x73, 0x02, 0x08, 0x6c, 0x61, 0x6e, 0x67,
+  0x75, 0x61, 0x67, 0x65, 0x01, 0x03, 0x43, 0x31, 0x31, 0x00, 0x0c, 0x70,
+  0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x64, 0x2d, 0x62, 0x79, 0x01,
+  0x05, 0x63, 0x6c, 0x61, 0x6e, 0x67, 0x5f, 0x31, 0x39, 0x2e, 0x31, 0x2e,
+  0x35, 0x2d, 0x77, 0x61, 0x73, 0x69, 0x2d, 0x73, 0x64, 0x6b, 0x20, 0x28,
+  0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x68,
+  0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x6c, 0x76, 0x6d, 0x2f,
+  0x6c, 0x6c, 0x76, 0x6d, 0x2d, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74,
+  0x20, 0x61, 0x62, 0x34, 0x62, 0x35, 0x61, 0x32, 0x64, 0x62, 0x35, 0x38,
+  0x32, 0x39, 0x35, 0x38, 0x61, 0x66, 0x31, 0x65, 0x65, 0x33, 0x30, 0x38,
+  0x61, 0x37, 0x39, 0x30, 0x63, 0x66, 0x64, 0x62, 0x34, 0x32, 0x62, 0x64,
+  0x32, 0x34, 0x37, 0x32, 0x30, 0x29, 0x00, 0x67, 0x0f, 0x74, 0x61, 0x72,
+  0x67, 0x65, 0x74, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73,
+  0x06, 0x2b, 0x0f, 0x6d, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2d, 0x67,
+  0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x73, 0x2b, 0x0b, 0x62, 0x75, 0x6c, 0x6b,
+  0x2d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2b, 0x08, 0x73, 0x69, 0x67,
+  0x6e, 0x2d, 0x65, 0x78, 0x74, 0x2b, 0x0f, 0x72, 0x65, 0x66, 0x65, 0x72,
+  0x65, 0x6e, 0x63, 0x65, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2b, 0x0a,
+  0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x2b, 0x0f,
+  0x62, 0x75, 0x6c, 0x6b, 0x2d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x2d,
+  0x6f, 0x70, 0x74
+};
+unsigned int STDLIB_WASM_LEN = 14463;
diff --git a/src/library/ts/src/tree-sitter/lib/src/wasm_store.c b/src/library/ts/src/tree-sitter/lib/src/wasm_store.c
new file mode 100644
index 0000000000..3d7cc5e43f
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/wasm_store.c
@@ -0,0 +1,1937 @@
+#include "tree_sitter/api.h"
+#include "./parser.h"
+#include <stdint.h>
+
+#ifdef TREE_SITTER_FEATURE_WASM
+
+#include "./alloc.h"
+#include "./array.h"
+#include "./atomic.h"
+#include "./language.h"
+#include "./lexer.h"
+#include "./wasm/wasm-stdlib.h"
+#include "./wasm_store.h"
+
+#include <string.h>
+#include <wasm.h>
+#include <wasmtime.h>
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4100)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#define array_len(a) (sizeof(a) / sizeof(a[0]))
+
+// The following symbols from the C and C++ standard libraries are available
+// for external scanners to use.
+const char *STDLIB_SYMBOLS[] = {
+  #include "./stdlib-symbols.txt"
+};
+
+// The contents of the `dylink.0` custom section of a Wasm module,
+// as specified by the current WebAssembly dynamic linking ABI proposal.
+typedef struct {
+  uint32_t memory_size;
+  uint32_t memory_align;
+  uint32_t table_size;
+  uint32_t table_align;
+} WasmDylinkInfo;
+
+// WasmLanguageId - A pointer used to identify a language. This language id is
+// reference-counted, so that its ownership can be shared between the language
+// itself and the instances of the language that are held in Wasm stores.
+typedef struct {
+  volatile uint32_t ref_count;
+  volatile uint32_t is_language_deleted;
+} WasmLanguageId;
+
+// LanguageWasmModule - Additional data associated with a Wasm-backed
+// `TSLanguage`. This data is read-only and does not reference a particular
+// Wasm store, so it can be shared by all users of a `TSLanguage`. A pointer to
+// this is stored on the language itself.
+typedef struct {
+  volatile uint32_t ref_count;
+  WasmLanguageId *language_id;
+  wasmtime_module_t *module;
+  const char *name;
+  char *symbol_name_buffer;
+  char *field_name_buffer;
+  WasmDylinkInfo dylink_info;
+} LanguageWasmModule;
+
+// LanguageWasmInstance - Additional data associated with an instantiation of
+// a `TSLanguage` in a particular Wasm store. The Wasm store holds one of
+// these structs for each language that it has instantiated.
+typedef struct {
+  WasmLanguageId *language_id;
+  wasmtime_instance_t instance;
+  int32_t external_states_address;
+  int32_t lex_main_fn_index;
+  int32_t lex_keyword_fn_index;
+  int32_t scanner_create_fn_index;
+  int32_t scanner_destroy_fn_index;
+  int32_t scanner_serialize_fn_index;
+  int32_t scanner_deserialize_fn_index;
+  int32_t scanner_scan_fn_index;
+} LanguageWasmInstance;
+
+typedef struct {
+  uint32_t reset_heap;
+  uint32_t proc_exit;
+  uint32_t abort;
+  uint32_t assert_fail;
+  uint32_t notify_memory_growth;
+  uint32_t debug_message;
+  uint32_t at_exit;
+  uint32_t args_get;
+  uint32_t args_sizes_get;
+} BuiltinFunctionIndices;
+
+// TSWasmStore - A struct that allows a given `Parser` to use Wasm-backed
+// languages. This struct is mutable, and can only be used by one parser at a
+// time.
+struct TSWasmStore {
+  wasm_engine_t *engine;
+  wasmtime_store_t *store;
+  wasmtime_table_t function_table;
+  wasmtime_memory_t memory;
+  TSLexer *current_lexer;
+  LanguageWasmInstance *current_instance;
+  Array(LanguageWasmInstance) language_instances;
+  uint32_t current_memory_offset;
+  uint32_t current_function_table_offset;
+  uint32_t *stdlib_fn_indices;
+  BuiltinFunctionIndices builtin_fn_indices;
+  wasmtime_global_t stack_pointer_global;
+  wasm_globaltype_t *const_i32_type;
+  bool has_error;
+  uint32_t lexer_address;
+};
+
+typedef Array(char) StringData;
+
+// LanguageInWasmMemory - The memory layout of a `TSLanguage` when compiled to
+// wasm32. This is used to copy static language data out of the Wasm memory.
+typedef struct {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  int32_t parse_table;
+  int32_t small_parse_table;
+  int32_t small_parse_table_map;
+  int32_t parse_actions;
+  int32_t symbol_names;
+  int32_t field_names;
+  int32_t field_map_slices;
+  int32_t field_map_entries;
+  int32_t symbol_metadata;
+  int32_t public_symbol_map;
+  int32_t alias_map;
+  int32_t alias_sequences;
+  int32_t lex_modes;
+  int32_t lex_fn;
+  int32_t keyword_lex_fn;
+  TSSymbol keyword_capture_token;
+  struct {
+    int32_t states;
+    int32_t symbol_map;
+    int32_t create;
+    int32_t destroy;
+    int32_t scan;
+    int32_t serialize;
+    int32_t deserialize;
+  } external_scanner;
+  int32_t primary_state_ids;
+  int32_t name;
+  int32_t reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  int32_t supertype_symbols;
+  int32_t supertype_map_slices;
+  int32_t supertype_map_entries;
+  TSLanguageMetadata metadata;
+} LanguageInWasmMemory;
+
+// LexerInWasmMemory - The memory layout of a `TSLexer` when compiled to wasm32.
+// This is used to copy mutable lexing state in and out of the Wasm memory.
+typedef struct {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  int32_t advance;
+  int32_t mark_end;
+  int32_t get_column;
+  int32_t is_at_included_range_start;
+  int32_t eof;
+} LexerInWasmMemory;
+
+// Linear memory layout:
+// [ <-- stack | stdlib statics | lexer | language statics --> | serialization_buffer | heap --> ]
+#define MAX_MEMORY_SIZE (128 * 1024 * 1024 / MEMORY_PAGE_SIZE)
+
+/************************
+ * WasmDylinkMemoryInfo
+ ***********************/
+
+static uint8_t read_u8(const uint8_t **p) {
+  return *(*p)++;
+}
+
+static inline uint64_t read_uleb128(const uint8_t **p, const uint8_t *end) {
+  uint64_t value = 0;
+  unsigned shift = 0;
+  do {
+    if (*p == end)  return UINT64_MAX;
+    value += (uint64_t)(**p & 0x7f) << shift;
+    shift += 7;
+  } while (*((*p)++) >= 128);
+  return value;
+}
+
+static bool wasm_dylink_info__parse(
+  const uint8_t *bytes,
+  size_t length,
+  WasmDylinkInfo *info
+) {
+  const uint8_t WASM_MAGIC_NUMBER[4] = {0, 'a', 's', 'm'};
+  const uint8_t WASM_VERSION[4] = {1, 0, 0, 0};
+  const uint8_t WASM_CUSTOM_SECTION = 0x0;
+  const uint8_t WASM_DYLINK_MEM_INFO = 0x1;
+
+  const uint8_t *p = bytes;
+  const uint8_t *end = bytes + length;
+
+  if (length < 8) return false;
+  if (memcmp(p, WASM_MAGIC_NUMBER, 4) != 0) return false;
+  p += 4;
+  if (memcmp(p, WASM_VERSION, 4) != 0) return false;
+  p += 4;
+
+  while (p < end) {
+    uint8_t section_id = read_u8(&p);
+    uint32_t section_length = read_uleb128(&p, end);
+    const uint8_t *section_end = p + section_length;
+    if (section_end > end) return false;
+
+    if (section_id == WASM_CUSTOM_SECTION) {
+      uint32_t name_length = read_uleb128(&p, section_end);
+      const uint8_t *name_end = p + name_length;
+      if (name_end > section_end) return false;
+
+      if (name_length == 8 && memcmp(p, "dylink.0", 8) == 0) {
+        p = name_end;
+        while (p < section_end) {
+          uint8_t subsection_type = read_u8(&p);
+          uint32_t subsection_size = read_uleb128(&p, section_end);
+          const uint8_t *subsection_end = p + subsection_size;
+          if (subsection_end > section_end) return false;
+          if (subsection_type == WASM_DYLINK_MEM_INFO) {
+            info->memory_size = read_uleb128(&p, subsection_end);
+            info->memory_align = read_uleb128(&p, subsection_end);
+            info->table_size = read_uleb128(&p, subsection_end);
+            info->table_align = read_uleb128(&p, subsection_end);
+            return true;
+          }
+          p = subsection_end;
+        }
+      }
+    }
+    p = section_end;
+  }
+  return false;
+}
+
+/*******************************************
+ * Native callbacks exposed to Wasm modules
+ *******************************************/
+
+ static wasm_trap_t *callback__abort(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  return wasmtime_trap_new("Wasm module called abort", 24);
+}
+
+static wasm_trap_t *callback__debug_message(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  wasmtime_context_t *context = wasmtime_caller_context(caller);
+  TSWasmStore *store = env;
+  ts_assert(args_and_results_len == 2);
+  uint32_t string_address = args_and_results[0].i32;
+  uint32_t value = args_and_results[1].i32;
+  uint8_t *memory = wasmtime_memory_data(context, &store->memory);
+  printf("DEBUG: %s %u\n", &memory[string_address], value);
+  return NULL;
+}
+
+static wasm_trap_t *callback__noop(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  return NULL;
+}
+
+static wasm_trap_t *callback__lexer_advance(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  wasmtime_context_t *context = wasmtime_caller_context(caller);
+  ts_assert(args_and_results_len == 2);
+
+  TSWasmStore *store = env;
+  TSLexer *lexer = store->current_lexer;
+  bool skip = args_and_results[1].i32;
+  lexer->advance(lexer, skip);
+
+  uint8_t *memory = wasmtime_memory_data(context, &store->memory);
+  memcpy(&memory[store->lexer_address], &lexer->lookahead, sizeof(lexer->lookahead));
+  return NULL;
+}
+
+static wasm_trap_t *callback__lexer_mark_end(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  TSWasmStore *store = env;
+  TSLexer *lexer = store->current_lexer;
+  lexer->mark_end(lexer);
+  return NULL;
+}
+
+static wasm_trap_t *callback__lexer_get_column(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  TSWasmStore *store = env;
+  TSLexer *lexer = store->current_lexer;
+  uint32_t result = lexer->get_column(lexer);
+  args_and_results[0].i32 = result;
+  return NULL;
+}
+
+static wasm_trap_t *callback__lexer_is_at_included_range_start(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  TSWasmStore *store = env;
+  TSLexer *lexer = store->current_lexer;
+  bool result = lexer->is_at_included_range_start(lexer);
+  args_and_results[0].i32 = result;
+  return NULL;
+}
+
+static wasm_trap_t *callback__lexer_eof(
+  void *env,
+  wasmtime_caller_t* caller,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  TSWasmStore *store = env;
+  TSLexer *lexer = store->current_lexer;
+  bool result = lexer->eof(lexer);
+  args_and_results[0].i32 = result;
+  return NULL;
+}
+
+typedef struct {
+  uint32_t *storage_location;
+  wasmtime_func_unchecked_callback_t callback;
+  wasm_functype_t *type;
+} FunctionDefinition;
+
+static void *copy(const void *data, size_t size) {
+  void *result = ts_malloc(size);
+  memcpy(result, data, size);
+  return result;
+}
+
+static void *copy_unsized_static_array(
+  const uint8_t *data,
+  int32_t start_address,
+  const int32_t all_addresses[],
+  size_t address_count
+) {
+  int32_t end_address = 0;
+  for (unsigned i = 0; i < address_count; i++) {
+    if (all_addresses[i] > start_address) {
+      if (!end_address || all_addresses[i] < end_address) {
+        end_address = all_addresses[i];
+      }
+    }
+  }
+
+  if (!end_address) return NULL;
+  size_t size = end_address - start_address;
+  void *result = ts_malloc(size);
+  memcpy(result, &data[start_address], size);
+  return result;
+}
+
+static void *copy_strings(
+  const uint8_t *data,
+  int32_t array_address,
+  size_t count,
+  StringData *string_data
+) {
+  const char **result = ts_malloc(count * sizeof(char *));
+  for (unsigned i = 0; i < count; i++) {
+    int32_t address;
+    memcpy(&address, &data[array_address + i * sizeof(address)], sizeof(address));
+    if (address == 0) {
+      result[i] = (const char *)-1;
+    } else {
+      const uint8_t *string = &data[address];
+      uint32_t len = strlen((const char *)string);
+      result[i] = (const char *)(uintptr_t)string_data->size;
+      array_extend(string_data, len + 1, string);
+    }
+  }
+  for (unsigned i = 0; i < count; i++) {
+    if (result[i] == (const char *)-1) {
+      result[i] = NULL;
+    } else {
+      result[i] = string_data->contents + (uintptr_t)result[i];
+    }
+  }
+  return result;
+}
+
+static void *copy_string(
+  const uint8_t *data,
+  int32_t address
+) {
+  const char *string = (const char *)&data[address];
+  size_t len = strlen(string);
+  char *result = ts_malloc(len + 1);
+  memcpy(result, string, len + 1);
+  return result;
+}
+
+static bool name_eq(const wasm_name_t *name, const char *string) {
+  return strncmp(string, name->data, name->size) == 0;
+}
+
+static inline wasm_functype_t* wasm_functype_new_4_0(
+  wasm_valtype_t* p1,
+  wasm_valtype_t* p2,
+  wasm_valtype_t* p3,
+  wasm_valtype_t* p4
+) {
+  wasm_valtype_t* ps[4] = {p1, p2, p3, p4};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 4, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+#define format(output, ...) \
+  do { \
+    size_t message_length = snprintf((char *)NULL, 0, __VA_ARGS__); \
+    *output = ts_malloc(message_length + 1); \
+    snprintf(*output, message_length + 1, __VA_ARGS__); \
+  } while (0)
+
+WasmLanguageId *language_id_new(void) {
+  WasmLanguageId *self = ts_malloc(sizeof(WasmLanguageId));
+  self->is_language_deleted = false;
+  self->ref_count = 1;
+  return self;
+}
+
+WasmLanguageId *language_id_clone(WasmLanguageId *self) {
+  atomic_inc(&self->ref_count);
+  return self;
+}
+
+void language_id_delete(WasmLanguageId *self) {
+  if (atomic_dec(&self->ref_count) == 0) {
+    ts_free(self);
+  }
+}
+
+static wasmtime_extern_t get_builtin_extern(
+  wasmtime_table_t *table,
+  unsigned index
+) {
+  return (wasmtime_extern_t) {
+    .kind = WASMTIME_EXTERN_FUNC,
+    .of.func = (wasmtime_func_t) {
+      .store_id = table->store_id,
+      .__private = index
+    }
+  };
+}
+
+static bool ts_wasm_store__provide_builtin_import(
+  TSWasmStore *self,
+  const wasm_name_t *import_name,
+  wasmtime_extern_t *import
+) {
+  wasmtime_error_t *error = NULL;
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+
+  // Dynamic linking parameters
+  if (name_eq(import_name, "__memory_base")) {
+    wasmtime_val_t value = WASM_I32_VAL(self->current_memory_offset);
+    wasmtime_global_t global;
+    error = wasmtime_global_new(context, self->const_i32_type, &value, &global);
+    ts_assert(!error);
+    *import = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_GLOBAL, .of.global = global};
+  } else if (name_eq(import_name, "__table_base")) {
+    wasmtime_val_t value = WASM_I32_VAL(self->current_function_table_offset);
+    wasmtime_global_t global;
+    error = wasmtime_global_new(context, self->const_i32_type, &value, &global);
+    ts_assert(!error);
+    *import = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_GLOBAL, .of.global = global};
+  } else if (name_eq(import_name, "__stack_pointer")) {
+    *import = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_GLOBAL, .of.global = self->stack_pointer_global};
+  } else if (name_eq(import_name, "__indirect_function_table")) {
+    *import = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_TABLE, .of.table = self->function_table};
+  } else if (name_eq(import_name, "memory")) {
+    *import = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_MEMORY, .of.memory = self->memory};
+  }
+
+  // Builtin functions
+  else if (name_eq(import_name, "__assert_fail")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.assert_fail);
+  } else if (name_eq(import_name, "__cxa_atexit")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.at_exit);
+  } else if (name_eq(import_name, "args_get")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.args_get);
+  } else if (name_eq(import_name, "args_sizes_get")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.args_sizes_get);
+  } else if (name_eq(import_name, "abort")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.abort);
+  } else if (name_eq(import_name, "proc_exit")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.proc_exit);
+  } else if (name_eq(import_name, "emscripten_notify_memory_growth")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.notify_memory_growth);
+  } else if (name_eq(import_name, "tree_sitter_debug_message")) {
+    *import = get_builtin_extern(&self->function_table, self->builtin_fn_indices.debug_message);
+  } else {
+    return false;
+  }
+
+  return true;
+}
+
+static bool ts_wasm_store__call_module_initializer(
+  TSWasmStore *self,
+  const wasm_name_t *export_name,
+  wasmtime_extern_t *export,
+  wasm_trap_t **trap
+) {
+  if (
+    name_eq(export_name, "_initialize") ||
+    name_eq(export_name, "__wasm_apply_data_relocs") ||
+    name_eq(export_name, "__wasm_call_ctors")
+  ) {
+    wasmtime_context_t *context = wasmtime_store_context(self->store);
+    wasmtime_func_t initialization_func = export->of.func;
+    wasmtime_error_t *error = wasmtime_func_call(context, &initialization_func, NULL, 0, NULL, 0, trap);
+    ts_assert(!error);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+TSWasmStore *ts_wasm_store_new(TSWasmEngine *engine, TSWasmError *wasm_error) {
+  TSWasmStore *self = ts_calloc(1, sizeof(TSWasmStore));
+  wasmtime_store_t *store = wasmtime_store_new(engine, self, NULL);
+  wasmtime_context_t *context = wasmtime_store_context(store);
+  wasmtime_error_t *error = NULL;
+  wasm_trap_t *trap = NULL;
+  wasm_message_t message = WASM_EMPTY_VEC;
+  wasm_exporttype_vec_t export_types = WASM_EMPTY_VEC;
+  wasm_importtype_vec_t import_types = WASM_EMPTY_VEC;
+  wasmtime_extern_t *imports = NULL;
+  wasmtime_module_t *stdlib_module = NULL;
+  wasm_memorytype_t *memory_type = NULL;
+  wasm_tabletype_t *table_type = NULL;
+
+  // Define functions called by scanners via function pointers on the lexer.
+  LexerInWasmMemory lexer = {
+    .lookahead = 0,
+    .result_symbol = 0,
+  };
+  FunctionDefinition lexer_definitions[] = {
+    {
+      (uint32_t *)&lexer.advance,
+      callback__lexer_advance,
+      wasm_functype_new_2_0(wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      (uint32_t *)&lexer.mark_end,
+      callback__lexer_mark_end,
+      wasm_functype_new_1_0(wasm_valtype_new_i32())
+    },
+    {
+      (uint32_t *)&lexer.get_column,
+      callback__lexer_get_column,
+      wasm_functype_new_1_1(wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      (uint32_t *)&lexer.is_at_included_range_start,
+      callback__lexer_is_at_included_range_start,
+      wasm_functype_new_1_1(wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      (uint32_t *)&lexer.eof,
+      callback__lexer_eof,
+      wasm_functype_new_1_1(wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+  };
+
+  // Define builtin functions that can be imported by scanners.
+  BuiltinFunctionIndices builtin_fn_indices;
+  FunctionDefinition builtin_definitions[] = {
+    {
+      &builtin_fn_indices.proc_exit,
+      callback__abort,
+      wasm_functype_new_1_0(wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.abort,
+      callback__abort,
+      wasm_functype_new_0_0()
+    },
+    {
+      &builtin_fn_indices.assert_fail,
+      callback__abort,
+      wasm_functype_new_4_0(wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.notify_memory_growth,
+      callback__noop,
+      wasm_functype_new_1_0(wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.debug_message,
+      callback__debug_message,
+      wasm_functype_new_2_0(wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.at_exit,
+      callback__noop,
+      wasm_functype_new_3_1(wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.args_get,
+      callback__noop,
+      wasm_functype_new_2_1(wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+    {
+      &builtin_fn_indices.args_sizes_get,
+      callback__noop,
+      wasm_functype_new_2_1(wasm_valtype_new_i32(), wasm_valtype_new_i32(), wasm_valtype_new_i32())
+    },
+  };
+
+  // Create all of the Wasm functions.
+  unsigned builtin_definitions_len = array_len(builtin_definitions);
+  unsigned lexer_definitions_len = array_len(lexer_definitions);
+  for (unsigned i = 0; i < builtin_definitions_len; i++) {
+    FunctionDefinition *definition = &builtin_definitions[i];
+    wasmtime_func_t func;
+    wasmtime_func_new_unchecked(context, definition->type, definition->callback, self, NULL, &func);
+    *definition->storage_location = func.__private;
+    wasm_functype_delete(definition->type);
+  }
+  for (unsigned i = 0; i < lexer_definitions_len; i++) {
+    FunctionDefinition *definition = &lexer_definitions[i];
+    wasmtime_func_t func;
+    wasmtime_func_new_unchecked(context, definition->type, definition->callback, self, NULL, &func);
+    *definition->storage_location = func.__private;
+    wasm_functype_delete(definition->type);
+  }
+
+  // Compile the stdlib module.
+  error = wasmtime_module_new(engine, STDLIB_WASM, STDLIB_WASM_LEN, &stdlib_module);
+  if (error) {
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindCompile;
+    format(
+      &wasm_error->message,
+      "failed to compile Wasm stdlib: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+
+  // Retrieve the stdlib module's imports.
+  wasmtime_module_imports(stdlib_module, &import_types);
+
+  // Find the initial number of memory pages needed by the stdlib.
+  const wasm_memorytype_t *stdlib_memory_type = NULL;
+  for (unsigned i = 0; i < import_types.size; i++) {
+    wasm_importtype_t *import_type = import_types.data[i];
+    const wasm_name_t *import_name = wasm_importtype_name(import_type);
+    if (name_eq(import_name, "memory")) {
+      const wasm_externtype_t *type = wasm_importtype_type(import_type);
+      stdlib_memory_type = wasm_externtype_as_memorytype_const(type);
+    }
+  }
+  if (!stdlib_memory_type) {
+    wasm_error->kind = TSWasmErrorKindCompile;
+    format(
+      &wasm_error->message,
+      "Wasm stdlib is missing the 'memory' import"
+    );
+    goto error;
+  }
+
+  // Initialize store's memory
+  uint64_t initial_memory_pages = wasmtime_memorytype_minimum(stdlib_memory_type);
+  wasm_limits_t memory_limits = {.min = initial_memory_pages, .max = MAX_MEMORY_SIZE};
+  memory_type = wasm_memorytype_new(&memory_limits);
+  wasmtime_memory_t memory;
+  error = wasmtime_memory_new(context, memory_type, &memory);
+  if (error) {
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindAllocate;
+    format(
+      &wasm_error->message,
+      "failed to allocate Wasm memory: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  wasm_memorytype_delete(memory_type);
+  memory_type = NULL;
+
+  // Initialize store's function table
+  wasm_limits_t table_limits = {.min = 1, .max = wasm_limits_max_default};
+  table_type = wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), &table_limits);
+  wasmtime_val_t initializer = {.kind = WASMTIME_FUNCREF};
+  wasmtime_table_t function_table;
+  error = wasmtime_table_new(context, table_type, &initializer, &function_table);
+  if (error) {
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindAllocate;
+    format(
+      &wasm_error->message,
+      "failed to allocate Wasm table: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  wasm_tabletype_delete(table_type);
+  table_type = NULL;
+
+  unsigned stdlib_symbols_len = array_len(STDLIB_SYMBOLS);
+
+  // Define globals for the stack and heap start addresses.
+  wasm_globaltype_t *const_i32_type = wasm_globaltype_new(wasm_valtype_new_i32(), WASM_CONST);
+  wasm_globaltype_t *var_i32_type = wasm_globaltype_new(wasm_valtype_new_i32(), WASM_VAR);
+
+  wasmtime_val_t stack_pointer_value = WASM_I32_VAL(0);
+  wasmtime_global_t stack_pointer_global;
+  error = wasmtime_global_new(context, var_i32_type, &stack_pointer_value, &stack_pointer_global);
+  wasm_globaltype_delete(var_i32_type);
+  ts_assert(!error);
+
+  *self = (TSWasmStore) {
+    .engine = wasmtime_engine_clone(engine),
+    .store = store,
+    .memory = memory,
+    .function_table = function_table,
+    .language_instances = array_new(),
+    .stdlib_fn_indices = ts_calloc(stdlib_symbols_len, sizeof(uint32_t)),
+    .builtin_fn_indices = builtin_fn_indices,
+    .stack_pointer_global = stack_pointer_global,
+    .current_memory_offset = 0,
+    .current_function_table_offset = 0,
+    .const_i32_type = const_i32_type,
+  };
+
+  // Set up the imports for the stdlib module.
+  imports = ts_calloc(import_types.size, sizeof(wasmtime_extern_t));
+  for (unsigned i = 0; i < import_types.size; i++) {
+    wasm_importtype_t *type = import_types.data[i];
+    const wasm_name_t *import_name = wasm_importtype_name(type);
+    if (!ts_wasm_store__provide_builtin_import(self, import_name, &imports[i])) {
+      wasm_error->kind = TSWasmErrorKindInstantiate;
+      format(
+        &wasm_error->message,
+        "unexpected import in Wasm stdlib: %.*s\n",
+        (int)import_name->size, import_name->data
+      );
+      goto error;
+    }
+  }
+
+  // Instantiate the stdlib module.
+  wasmtime_instance_t instance;
+  error = wasmtime_instance_new(context, stdlib_module, imports, import_types.size, &instance, &trap);
+  ts_free(imports);
+  imports = NULL;
+  if (error) {
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindInstantiate;
+    format(
+      &wasm_error->message,
+      "failed to instantiate Wasm stdlib module: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  if (trap) {
+    wasm_trap_message(trap, &message);
+    wasm_error->kind = TSWasmErrorKindInstantiate;
+    format(
+      &wasm_error->message,
+      "trapped when instantiating Wasm stdlib module: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  wasm_importtype_vec_delete(&import_types);
+
+  // Process the stdlib module's exports.
+  for (unsigned i = 0; i < stdlib_symbols_len; i++) {
+    self->stdlib_fn_indices[i] = UINT32_MAX;
+  }
+  wasmtime_module_exports(stdlib_module, &export_types);
+  for (unsigned i = 0; i < export_types.size; i++) {
+    wasm_exporttype_t *export_type = export_types.data[i];
+    const wasm_name_t *name = wasm_exporttype_name(export_type);
+
+    char *export_name;
+    size_t name_len;
+    wasmtime_extern_t export = {.kind = WASM_EXTERN_GLOBAL};
+    bool exists = wasmtime_instance_export_nth(context, &instance, i, &export_name, &name_len, &export);
+    ts_assert(exists);
+
+    if (export.kind == WASMTIME_EXTERN_GLOBAL) {
+      if (name_eq(name, "__stack_pointer")) {
+        self->stack_pointer_global = export.of.global;
+      }
+    }
+
+    if (export.kind == WASMTIME_EXTERN_FUNC) {
+      if (ts_wasm_store__call_module_initializer(self, name, &export, &trap)) {
+        if (trap) {
+          wasm_trap_message(trap, &message);
+          wasm_error->kind = TSWasmErrorKindInstantiate;
+          format(
+            &wasm_error->message,
+            "trap when calling stdlib relocation function: %.*s\n",
+            (int)message.size, message.data
+          );
+          goto error;
+        }
+        continue;
+      }
+
+      if (name_eq(name, "reset_heap")) {
+        self->builtin_fn_indices.reset_heap = export.of.func.__private;
+        continue;
+      }
+
+      for (unsigned j = 0; j < stdlib_symbols_len; j++) {
+        if (name_eq(name, STDLIB_SYMBOLS[j])) {
+          self->stdlib_fn_indices[j] = export.of.func.__private;
+          break;
+        }
+      }
+    }
+  }
+
+  if (self->builtin_fn_indices.reset_heap == UINT32_MAX) {
+    wasm_error->kind = TSWasmErrorKindInstantiate;
+    format(
+      &wasm_error->message,
+      "missing malloc reset function in Wasm stdlib"
+    );
+    goto error;
+  }
+
+  for (unsigned i = 0; i < stdlib_symbols_len; i++) {
+    if (self->stdlib_fn_indices[i] == UINT32_MAX) {
+      wasm_error->kind = TSWasmErrorKindInstantiate;
+      format(
+        &wasm_error->message,
+        "missing exported symbol in Wasm stdlib: %s",
+        STDLIB_SYMBOLS[i]
+      );
+      goto error;
+    }
+  }
+
+  wasm_exporttype_vec_delete(&export_types);
+  wasmtime_module_delete(stdlib_module);
+
+  // Add all of the lexer callback functions to the function table. Store their function table
+  // indices on the in-memory lexer.
+  uint64_t table_index;
+  error = wasmtime_table_grow(context, &function_table, lexer_definitions_len, &initializer, &table_index);
+  if (error) {
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindAllocate;
+    format(
+      &wasm_error->message,
+      "failed to grow Wasm table to initial size: %.*s",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  for (unsigned i = 0; i < lexer_definitions_len; i++) {
+    FunctionDefinition *definition = &lexer_definitions[i];
+    wasmtime_func_t func = {function_table.store_id, *definition->storage_location};
+    wasmtime_val_t func_val = {.kind = WASMTIME_FUNCREF, .of.funcref = func};
+    error = wasmtime_table_set(context, &function_table, table_index, &func_val);
+    ts_assert(!error);
+    *(int32_t *)(definition->storage_location) = table_index;
+    table_index++;
+  }
+
+  self->current_function_table_offset = table_index;
+  self->lexer_address = initial_memory_pages * MEMORY_PAGE_SIZE;
+  self->current_memory_offset = self->lexer_address + sizeof(LexerInWasmMemory);
+
+  // Grow the memory enough to hold the builtin lexer and serialization buffer.
+  uint32_t new_pages_needed = (self->current_memory_offset - self->lexer_address - 1) / MEMORY_PAGE_SIZE + 1;
+  uint64_t prev_memory_size;
+  wasmtime_memory_grow(context, &memory, new_pages_needed, &prev_memory_size);
+
+  uint8_t *memory_data = wasmtime_memory_data(context, &memory);
+  memcpy(&memory_data[self->lexer_address], &lexer, sizeof(lexer));
+  return self;
+
+error:
+  ts_free(self);
+  if (stdlib_module) wasmtime_module_delete(stdlib_module);
+  if (store) wasmtime_store_delete(store);
+  if (import_types.size) wasm_importtype_vec_delete(&import_types);
+  if (memory_type) wasm_memorytype_delete(memory_type);
+  if (table_type) wasm_tabletype_delete(table_type);
+  if (trap) wasm_trap_delete(trap);
+  if (error) wasmtime_error_delete(error);
+  if (message.size) wasm_byte_vec_delete(&message);
+  if (export_types.size) wasm_exporttype_vec_delete(&export_types);
+  if (imports) ts_free(imports);
+  return NULL;
+}
+
+void ts_wasm_store_delete(TSWasmStore *self) {
+  if (!self) return;
+  ts_free(self->stdlib_fn_indices);
+  wasm_globaltype_delete(self->const_i32_type);
+  wasmtime_store_delete(self->store);
+  wasm_engine_delete(self->engine);
+  for (unsigned i = 0; i < self->language_instances.size; i++) {
+    LanguageWasmInstance *instance = array_get(&self->language_instances, i);
+    language_id_delete(instance->language_id);
+  }
+  array_delete(&self->language_instances);
+  ts_free(self);
+}
+
+size_t ts_wasm_store_language_count(const TSWasmStore *self) {
+  size_t result = 0;
+  for (unsigned i = 0; i < self->language_instances.size; i++) {
+    const WasmLanguageId *id = array_get(&self->language_instances, i)->language_id;
+    if (!id->is_language_deleted) {
+      result++;
+    }
+  }
+  return result;
+}
+
+static uint32_t ts_wasm_store__heap_address(TSWasmStore *self) {
+  return self->current_memory_offset + TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
+}
+
+static uint32_t ts_wasm_store__serialization_buffer_address(TSWasmStore *self) {
+  return self->current_memory_offset;
+}
+
+static bool ts_wasm_store__instantiate(
+  TSWasmStore *self,
+  wasmtime_module_t *module,
+  const char *language_name,
+  const WasmDylinkInfo *dylink_info,
+  wasmtime_instance_t *result,
+  int32_t *language_address,
+  char **error_message
+) {
+  wasmtime_error_t *error = NULL;
+  wasm_trap_t *trap = NULL;
+  wasm_message_t message = WASM_EMPTY_VEC;
+  char *language_function_name = NULL;
+  wasmtime_extern_t *imports = NULL;
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+
+  // Grow the function table to make room for the new functions.
+  wasmtime_val_t initializer = {.kind = WASMTIME_FUNCREF};
+  uint64_t prev_table_size;
+  error = wasmtime_table_grow(context, &self->function_table, dylink_info->table_size, &initializer, &prev_table_size);
+  if (error) {
+    format(error_message, "invalid function table size %u", dylink_info->table_size);
+    goto error;
+  }
+
+  // Grow the memory to make room for the new data.
+  uint32_t needed_memory_size = ts_wasm_store__heap_address(self) + dylink_info->memory_size;
+  uint32_t current_memory_size = wasmtime_memory_data_size(context, &self->memory);
+  if (needed_memory_size > current_memory_size) {
+    uint32_t pages_to_grow = (
+      needed_memory_size - current_memory_size + MEMORY_PAGE_SIZE - 1) /
+      MEMORY_PAGE_SIZE;
+    uint64_t prev_memory_size;
+    error = wasmtime_memory_grow(context, &self->memory, pages_to_grow, &prev_memory_size);
+    if (error) {
+      format(error_message, "invalid memory size %u", dylink_info->memory_size);
+      goto error;
+    }
+  }
+
+  // Construct the language function name as string.
+  format(&language_function_name, "tree_sitter_%s", language_name);
+
+  const uint64_t store_id = self->function_table.store_id;
+
+  // Build the imports list for the module.
+  wasm_importtype_vec_t import_types = WASM_EMPTY_VEC;
+  wasmtime_module_imports(module, &import_types);
+  imports = ts_calloc(import_types.size, sizeof(wasmtime_extern_t));
+
+  for (unsigned i = 0; i < import_types.size; i++) {
+    const wasm_importtype_t *import_type = import_types.data[i];
+    const wasm_name_t *import_name = wasm_importtype_name(import_type);
+    if (import_name->size == 0) {
+      format(error_message, "empty import name");
+      goto error;
+    }
+
+    if (ts_wasm_store__provide_builtin_import(self, import_name, &imports[i])) {
+      continue;
+    }
+
+    bool defined_in_stdlib = false;
+    for (unsigned j = 0; j < array_len(STDLIB_SYMBOLS); j++) {
+      if (name_eq(import_name, STDLIB_SYMBOLS[j])) {
+        uint16_t address = self->stdlib_fn_indices[j];
+        imports[i] = (wasmtime_extern_t) {.kind = WASMTIME_EXTERN_FUNC, .of.func = {store_id, address}};
+        defined_in_stdlib = true;
+        break;
+      }
+    }
+
+    if (!defined_in_stdlib) {
+      format(
+        error_message,
+        "invalid import '%.*s'\n",
+        (int)import_name->size, import_name->data
+      );
+      goto error;
+    }
+  }
+
+  wasmtime_instance_t instance;
+  error = wasmtime_instance_new(context, module, imports, import_types.size, &instance, &trap);
+  wasm_importtype_vec_delete(&import_types);
+  ts_free(imports);
+  imports = NULL;
+  if (error) {
+    wasmtime_error_message(error, &message);
+    format(
+      error_message,
+      "error instantiating Wasm module: %.*s\n",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+  if (trap) {
+    wasm_trap_message(trap, &message);
+    format(
+      error_message,
+      "trap when instantiating Wasm module: %.*s\n",
+      (int)message.size, message.data
+    );
+    goto error;
+  }
+
+  self->current_memory_offset += dylink_info->memory_size;
+  self->current_function_table_offset += dylink_info->table_size;
+
+  // Process the module's exports.
+  bool found_language = false;
+  wasmtime_extern_t language_extern;
+  wasm_exporttype_vec_t export_types = WASM_EMPTY_VEC;
+  wasmtime_module_exports(module, &export_types);
+  for (unsigned i = 0; i < export_types.size; i++) {
+    wasm_exporttype_t *export_type = export_types.data[i];
+    const wasm_name_t *name = wasm_exporttype_name(export_type);
+
+    size_t name_len;
+    char *export_name;
+    wasmtime_extern_t export = {.kind = WASM_EXTERN_GLOBAL};
+    bool exists = wasmtime_instance_export_nth(context, &instance, i, &export_name, &name_len, &export);
+    ts_assert(exists);
+
+    // If the module exports an initialization or data-relocation function, call it.
+    if (ts_wasm_store__call_module_initializer(self, name, &export, &trap)) {
+      if (trap) {
+        wasm_trap_message(trap, &message);
+        format(
+          error_message,
+          "trap when calling data relocation function: %.*s\n",
+          (int)message.size, message.data
+        );
+        goto error;
+      }
+    }
+
+    // Find the main language function for the module.
+    else if (name_eq(name, language_function_name)) {
+      language_extern = export;
+      found_language = true;
+    }
+  }
+  wasm_exporttype_vec_delete(&export_types);
+
+  if (!found_language) {
+    format(
+      error_message,
+      "module did not contain language function: %s",
+      language_function_name
+    );
+    goto error;
+  }
+
+  // Invoke the language function to get the static address of the language object.
+  wasmtime_func_t language_func = language_extern.of.func;
+  wasmtime_val_t language_address_val;
+  error = wasmtime_func_call(context, &language_func, NULL, 0, &language_address_val, 1, &trap);
+  ts_assert(!error);
+  if (trap) {
+    wasm_trap_message(trap, &message);
+    format(
+      error_message,
+      "trapped when calling language function: %s: %.*s\n",
+      language_function_name, (int)message.size, message.data
+    );
+    goto error;
+  }
+
+  if (language_address_val.kind != WASMTIME_I32) {
+    format(
+      error_message,
+      "language function did not return an integer: %s\n",
+      language_function_name
+    );
+    goto error;
+  }
+
+  ts_free(language_function_name);
+  *result = instance;
+  *language_address = language_address_val.of.i32;
+  return true;
+
+error:
+  if (language_function_name) ts_free(language_function_name);
+  if (message.size) wasm_byte_vec_delete(&message);
+  if (error) wasmtime_error_delete(error);
+  if (trap) wasm_trap_delete(trap);
+  if (imports) ts_free(imports);
+  return false;
+}
+
+static bool ts_wasm_store__sentinel_lex_fn(TSLexer *_lexer, TSStateId state) {
+  return false;
+}
+
+const TSLanguage *ts_wasm_store_load_language(
+  TSWasmStore *self,
+  const char *language_name,
+  const char *wasm,
+  uint32_t wasm_len,
+  TSWasmError *wasm_error
+) {
+  WasmDylinkInfo dylink_info;
+  wasmtime_module_t *module = NULL;
+  wasmtime_error_t *error = NULL;
+  wasm_error->kind = TSWasmErrorKindNone;
+
+  if (!wasm_dylink_info__parse((const unsigned char *)wasm, wasm_len, &dylink_info)) {
+    wasm_error->kind = TSWasmErrorKindParse;
+    format(&wasm_error->message, "failed to parse dylink section of Wasm module");
+    goto error;
+  }
+
+  // Compile the Wasm code.
+  error = wasmtime_module_new(self->engine, (const uint8_t *)wasm, wasm_len, &module);
+  if (error) {
+    wasm_message_t message;
+    wasmtime_error_message(error, &message);
+    wasm_error->kind = TSWasmErrorKindCompile;
+    format(&wasm_error->message, "error compiling Wasm module: %.*s", (int)message.size, message.data);
+    wasm_byte_vec_delete(&message);
+    goto error;
+  }
+
+  // Instantiate the module in this store.
+  wasmtime_instance_t instance;
+  int32_t language_address;
+  if (!ts_wasm_store__instantiate(
+    self,
+    module,
+    language_name,
+    &dylink_info,
+    &instance,
+    &language_address,
+    &wasm_error->message
+  )) {
+    wasm_error->kind = TSWasmErrorKindInstantiate;
+    goto error;
+  }
+
+  // Copy all of the static data out of the language object in Wasm memory,
+  // constructing a native language object.
+  LanguageInWasmMemory wasm_language;
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  const uint8_t *memory = wasmtime_memory_data(context, &self->memory);
+  memcpy(&wasm_language, &memory[language_address], sizeof(LanguageInWasmMemory));
+
+  bool has_supertypes =
+    wasm_language.abi_version > LANGUAGE_VERSION_WITH_RESERVED_WORDS &&
+    wasm_language.supertype_count > 0;
+
+  int32_t addresses[] = {
+    wasm_language.parse_table,
+    wasm_language.small_parse_table,
+    wasm_language.small_parse_table_map,
+    wasm_language.parse_actions,
+    wasm_language.symbol_names,
+    wasm_language.field_names,
+    wasm_language.field_map_slices,
+    wasm_language.field_map_entries,
+    wasm_language.symbol_metadata,
+    wasm_language.public_symbol_map,
+    wasm_language.alias_map,
+    wasm_language.alias_sequences,
+    wasm_language.lex_modes,
+    wasm_language.lex_fn,
+    wasm_language.keyword_lex_fn,
+    wasm_language.primary_state_ids,
+    wasm_language.name,
+    wasm_language.reserved_words,
+    has_supertypes ? wasm_language.supertype_symbols : 0,
+    has_supertypes ? wasm_language.supertype_map_entries : 0,
+    has_supertypes ? wasm_language.supertype_map_slices : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.states : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.symbol_map : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.create : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.destroy : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.scan : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.serialize : 0,
+    wasm_language.external_token_count > 0 ? wasm_language.external_scanner.deserialize : 0,
+    language_address,
+    self->current_memory_offset,
+  };
+  uint32_t address_count = array_len(addresses);
+
+  TSLanguage *language = ts_calloc(1, sizeof(TSLanguage));
+  StringData symbol_name_buffer = array_new();
+  StringData field_name_buffer = array_new();
+
+  *language = (TSLanguage) {
+    .abi_version = wasm_language.abi_version,
+    .symbol_count = wasm_language.symbol_count,
+    .alias_count = wasm_language.alias_count,
+    .token_count = wasm_language.token_count,
+    .external_token_count = wasm_language.external_token_count,
+    .state_count = wasm_language.state_count,
+    .large_state_count = wasm_language.large_state_count,
+    .production_id_count = wasm_language.production_id_count,
+    .field_count = wasm_language.field_count,
+    .supertype_count = wasm_language.supertype_count,
+    .max_alias_sequence_length = wasm_language.max_alias_sequence_length,
+    .keyword_capture_token = wasm_language.keyword_capture_token,
+    .metadata = wasm_language.metadata,
+    .parse_table = copy(
+      &memory[wasm_language.parse_table],
+      wasm_language.large_state_count * wasm_language.symbol_count * sizeof(uint16_t)
+    ),
+    .parse_actions = copy_unsized_static_array(
+      memory,
+      wasm_language.parse_actions,
+      addresses,
+      address_count
+    ),
+    .symbol_names = copy_strings(
+      memory,
+      wasm_language.symbol_names,
+      wasm_language.symbol_count + wasm_language.alias_count,
+      &symbol_name_buffer
+    ),
+    .symbol_metadata = copy(
+      &memory[wasm_language.symbol_metadata],
+      (wasm_language.symbol_count + wasm_language.alias_count) * sizeof(TSSymbolMetadata)
+    ),
+    .public_symbol_map = copy(
+      &memory[wasm_language.public_symbol_map],
+      (wasm_language.symbol_count + wasm_language.alias_count) * sizeof(TSSymbol)
+    ),
+    .lex_modes = copy(
+      &memory[wasm_language.lex_modes],
+      wasm_language.state_count * sizeof(TSLexerMode)
+    ),
+  };
+
+  if (language->field_count > 0 && language->production_id_count > 0) {
+    language->field_map_slices = copy(
+      &memory[wasm_language.field_map_slices],
+      wasm_language.production_id_count * sizeof(TSMapSlice)
+    );
+
+    // Determine the number of field map entries by finding the greatest index
+    // in any of the slices.
+    uint32_t field_map_entry_count = 0;
+    for (uint32_t i = 0; i < wasm_language.production_id_count; i++) {
+      TSMapSlice slice = language->field_map_slices[i];
+      uint32_t slice_end = slice.index + slice.length;
+      if (slice_end > field_map_entry_count) {
+        field_map_entry_count = slice_end;
+      }
+    }
+
+    language->field_map_entries = copy(
+      &memory[wasm_language.field_map_entries],
+      field_map_entry_count * sizeof(TSFieldMapEntry)
+    );
+    language->field_names = copy_strings(
+      memory,
+      wasm_language.field_names,
+      wasm_language.field_count + 1,
+      &field_name_buffer
+    );
+  }
+
+  if (has_supertypes) {
+    language->supertype_symbols = copy(
+      &memory[wasm_language.supertype_symbols],
+      wasm_language.supertype_count * sizeof(TSSymbol)
+    );
+
+    // Determine the number of supertype map slices by finding the greatest
+    // supertype ID.
+    int largest_supertype = 0;
+    for (unsigned i = 0; i < language->supertype_count; i++) {
+      TSSymbol supertype = language->supertype_symbols[i];
+      if (supertype > largest_supertype) {
+        largest_supertype = supertype;
+      }
+    }
+
+    language->supertype_map_slices = copy(
+      &memory[wasm_language.supertype_map_slices],
+      (largest_supertype + 1) * sizeof(TSMapSlice)
+    );
+
+    TSSymbol last_supertype = language->supertype_symbols[language->supertype_count - 1];
+    TSMapSlice last_slice = language->supertype_map_slices[last_supertype];
+    uint32_t supertype_map_entry_count = last_slice.index + last_slice.length;
+
+    language->supertype_map_entries = copy(
+      &memory[wasm_language.supertype_map_entries],
+      supertype_map_entry_count * sizeof(char *)
+    );
+  }
+
+  if (language->max_alias_sequence_length > 0 && language->production_id_count > 0) {
+    // The alias map contains symbols, alias counts, and aliases, terminated by a null symbol.
+    int32_t alias_map_size = 0;
+    for (;;) {
+      TSSymbol symbol;
+      memcpy(&symbol, &memory[wasm_language.alias_map + alias_map_size], sizeof(symbol));
+      alias_map_size += sizeof(TSSymbol);
+      if (symbol == 0) break;
+      uint16_t value_count;
+      memcpy(&value_count, &memory[wasm_language.alias_map + alias_map_size], sizeof(value_count));
+      alias_map_size += sizeof(uint16_t);
+      alias_map_size += value_count * sizeof(TSSymbol);
+    }
+    language->alias_map = copy(
+      &memory[wasm_language.alias_map],
+      alias_map_size
+    );
+    language->alias_sequences = copy(
+      &memory[wasm_language.alias_sequences],
+      wasm_language.production_id_count * wasm_language.max_alias_sequence_length * sizeof(TSSymbol)
+    );
+  }
+
+  if (language->state_count > language->large_state_count) {
+    uint32_t small_state_count = wasm_language.state_count - wasm_language.large_state_count;
+    language->small_parse_table_map = copy(
+      &memory[wasm_language.small_parse_table_map],
+      small_state_count * sizeof(uint32_t)
+    );
+    language->small_parse_table = copy_unsized_static_array(
+      memory,
+      wasm_language.small_parse_table,
+      addresses,
+      address_count
+    );
+  }
+
+  if (language->abi_version >= LANGUAGE_VERSION_WITH_PRIMARY_STATES) {
+    language->primary_state_ids = copy(
+      &memory[wasm_language.primary_state_ids],
+      wasm_language.state_count * sizeof(TSStateId)
+    );
+  }
+
+  if (language->abi_version >= LANGUAGE_VERSION_WITH_RESERVED_WORDS) {
+    language->name = copy_string(memory, wasm_language.name);
+    language->reserved_words = copy(
+        &memory[wasm_language.reserved_words],
+        wasm_language.max_reserved_word_set_size * sizeof(TSSymbol)
+    );
+    language->max_reserved_word_set_size = wasm_language.max_reserved_word_set_size;
+  }
+
+  if (language->external_token_count > 0) {
+    language->external_scanner.symbol_map = copy(
+      &memory[wasm_language.external_scanner.symbol_map],
+      wasm_language.external_token_count * sizeof(TSSymbol)
+    );
+    language->external_scanner.states = (void *)(uintptr_t)wasm_language.external_scanner.states;
+  }
+
+  unsigned name_len = strlen(language_name);
+  char *name = ts_malloc(name_len + 1);
+  memcpy(name, language_name, name_len);
+  name[name_len] = '\0';
+
+  LanguageWasmModule *language_module = ts_malloc(sizeof(LanguageWasmModule));
+  *language_module = (LanguageWasmModule) {
+    .language_id = language_id_new(),
+    .module = module,
+    .name = name,
+    .symbol_name_buffer = symbol_name_buffer.contents,
+    .field_name_buffer = field_name_buffer.contents,
+    .dylink_info = dylink_info,
+    .ref_count = 1,
+  };
+
+  // The lex functions are not used for Wasm languages. Use those two fields
+  // to mark this language as Wasm-based and to store the language's
+  // Wasm-specific data.
+  language->lex_fn = ts_wasm_store__sentinel_lex_fn;
+  language->keyword_lex_fn = (bool (*)(TSLexer *, TSStateId))language_module;
+
+  // Clear out any instances of languages that have been deleted.
+  for (unsigned i = 0; i < self->language_instances.size; i++) {
+    WasmLanguageId *id = array_get(&self->language_instances, i)->language_id;
+    if (id->is_language_deleted) {
+      language_id_delete(id);
+      array_erase(&self->language_instances, i);
+      i--;
+    }
+  }
+
+  // Store this store's instance of this language module.
+  array_push(&self->language_instances, ((LanguageWasmInstance) {
+    .language_id = language_id_clone(language_module->language_id),
+    .instance = instance,
+    .external_states_address = wasm_language.external_scanner.states,
+    .lex_main_fn_index = wasm_language.lex_fn,
+    .lex_keyword_fn_index = wasm_language.keyword_lex_fn,
+    .scanner_create_fn_index = wasm_language.external_scanner.create,
+    .scanner_destroy_fn_index = wasm_language.external_scanner.destroy,
+    .scanner_serialize_fn_index = wasm_language.external_scanner.serialize,
+    .scanner_deserialize_fn_index = wasm_language.external_scanner.deserialize,
+    .scanner_scan_fn_index = wasm_language.external_scanner.scan,
+  }));
+
+  return language;
+
+error:
+  if (module) wasmtime_module_delete(module);
+  return NULL;
+}
+
+bool ts_wasm_store_add_language(
+  TSWasmStore *self,
+  const TSLanguage *language,
+  uint32_t *index
+) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  const LanguageWasmModule *language_module = (void *)language->keyword_lex_fn;
+
+  // Search for this store's instance of the language module. Also clear out any
+  // instances of languages that have been deleted.
+  bool exists = false;
+  for (unsigned i = 0; i < self->language_instances.size; i++) {
+    WasmLanguageId *id = array_get(&self->language_instances, i)->language_id;
+    if (id->is_language_deleted) {
+      language_id_delete(id);
+      array_erase(&self->language_instances, i);
+      i--;
+    } else if (id == language_module->language_id) {
+      exists = true;
+      *index = i;
+    }
+  }
+
+  // If the language module has not been instantiated in this store, then add
+  // it to this store.
+  if (!exists) {
+    *index = self->language_instances.size;
+    char *message;
+    wasmtime_instance_t instance;
+    int32_t language_address;
+    if (!ts_wasm_store__instantiate(
+      self,
+      language_module->module,
+      language_module->name,
+      &language_module->dylink_info,
+      &instance,
+      &language_address,
+      &message
+    )) {
+      ts_free(message);
+      return false;
+    }
+
+    LanguageInWasmMemory wasm_language;
+    const uint8_t *memory = wasmtime_memory_data(context, &self->memory);
+    memcpy(&wasm_language, &memory[language_address], sizeof(LanguageInWasmMemory));
+    array_push(&self->language_instances, ((LanguageWasmInstance) {
+      .language_id = language_id_clone(language_module->language_id),
+      .instance = instance,
+      .external_states_address = wasm_language.external_scanner.states,
+      .lex_main_fn_index = wasm_language.lex_fn,
+      .lex_keyword_fn_index = wasm_language.keyword_lex_fn,
+      .scanner_create_fn_index = wasm_language.external_scanner.create,
+      .scanner_destroy_fn_index = wasm_language.external_scanner.destroy,
+      .scanner_serialize_fn_index = wasm_language.external_scanner.serialize,
+      .scanner_deserialize_fn_index = wasm_language.external_scanner.deserialize,
+      .scanner_scan_fn_index = wasm_language.external_scanner.scan,
+    }));
+  }
+
+  return true;
+}
+
+void ts_wasm_store_reset_heap(TSWasmStore *self) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  wasmtime_func_t func = {
+    self->function_table.store_id,
+    self->builtin_fn_indices.reset_heap
+  };
+  wasm_trap_t *trap = NULL;
+  wasmtime_val_t args[1] = {
+    {.of.i32 = ts_wasm_store__heap_address(self), .kind = WASMTIME_I32},
+  };
+
+  wasmtime_error_t *error = wasmtime_func_call(context, &func, args, 1, NULL, 0, &trap);
+  ts_assert(!error);
+  ts_assert(!trap);
+}
+
+bool ts_wasm_store_start(TSWasmStore *self, TSLexer *lexer, const TSLanguage *language) {
+  uint32_t instance_index;
+  if (!ts_wasm_store_add_language(self, language, &instance_index)) return false;
+  self->current_lexer = lexer;
+  self->current_instance = array_get(&self->language_instances, instance_index);
+  self->has_error = false;
+  ts_wasm_store_reset_heap(self);
+  return true;
+}
+
+void ts_wasm_store_reset(TSWasmStore *self) {
+  self->current_lexer = NULL;
+  self->current_instance = NULL;
+  self->has_error = false;
+  ts_wasm_store_reset_heap(self);
+}
+
+static void ts_wasm_store__call(
+  TSWasmStore *self,
+  int32_t function_index,
+  wasmtime_val_raw_t *args_and_results,
+  size_t args_and_results_len
+) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  wasmtime_val_t value;
+  bool succeeded = wasmtime_table_get(context, &self->function_table, function_index, &value);
+  ts_assert(succeeded);
+  ts_assert(value.kind == WASMTIME_FUNCREF);
+  wasmtime_func_t func = value.of.funcref;
+
+  wasm_trap_t *trap = NULL;
+  wasmtime_error_t *error = wasmtime_func_call_unchecked(context, &func, args_and_results, args_and_results_len, &trap);
+  if (error) {
+    // wasm_message_t message;
+    // wasmtime_error_message(error, &message);
+    // fprintf(
+    //   stderr,
+    //   "error in Wasm module: %.*s\n",
+    //   (int)message.size, message.data
+    // );
+    wasmtime_error_delete(error);
+    self->has_error = true;
+  } else if (trap) {
+    // wasm_message_t message;
+    // wasm_trap_message(trap, &message);
+    // fprintf(
+    //   stderr,
+    //   "trap in Wasm module: %.*s\n",
+    //   (int)message.size, message.data
+    // );
+    wasm_trap_delete(trap);
+    self->has_error = true;
+  }
+}
+
+// The data fields of TSLexer, without the function pointers.
+//
+// This portion of the struct needs to be copied in and out
+// of Wasm memory before and after calling a scan function.
+typedef struct {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+} TSLexerDataPrefix;
+
+static bool ts_wasm_store__call_lex_function(TSWasmStore *self, unsigned function_index, TSStateId state) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  uint8_t *memory_data = wasmtime_memory_data(context, &self->memory);
+  memcpy(
+    &memory_data[self->lexer_address],
+    self->current_lexer,
+    sizeof(TSLexerDataPrefix)
+  );
+
+  wasmtime_val_raw_t args[2] = {
+    {.i32 = self->lexer_address},
+    {.i32 = state},
+  };
+  ts_wasm_store__call(self, function_index, args, 2);
+  if (self->has_error) return false;
+  bool result = args[0].i32;
+
+  memcpy(
+    self->current_lexer,
+    &memory_data[self->lexer_address],
+    sizeof(TSLexerDataPrefix)
+  );
+  return result;
+}
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state) {
+  return ts_wasm_store__call_lex_function(
+    self,
+    self->current_instance->lex_main_fn_index,
+    state
+  );
+}
+
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state) {
+  return ts_wasm_store__call_lex_function(
+    self,
+    self->current_instance->lex_keyword_fn_index,
+    state
+  );
+}
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self) {
+  wasmtime_val_raw_t args[1] = {{.i32 = 0}};
+  ts_wasm_store__call(self, self->current_instance->scanner_create_fn_index, args, 1);
+  if (self->has_error) return 0;
+  return args[0].i32;
+}
+
+void ts_wasm_store_call_scanner_destroy(TSWasmStore *self, uint32_t scanner_address) {
+  if (self->current_instance) {
+    wasmtime_val_raw_t args[1] = {{.i32 = scanner_address}};
+    ts_wasm_store__call(self, self->current_instance->scanner_destroy_fn_index, args, 1);
+  }
+}
+
+bool ts_wasm_store_call_scanner_scan(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  uint32_t valid_tokens_ix
+) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  uint8_t *memory_data = wasmtime_memory_data(context, &self->memory);
+
+  memcpy(
+    &memory_data[self->lexer_address],
+    self->current_lexer,
+    sizeof(TSLexerDataPrefix)
+  );
+
+  uint32_t valid_tokens_address =
+    self->current_instance->external_states_address +
+    (valid_tokens_ix * sizeof(bool));
+  wasmtime_val_raw_t args[3] = {
+    {.i32 = scanner_address},
+    {.i32 = self->lexer_address},
+    {.i32 = valid_tokens_address}
+  };
+  ts_wasm_store__call(self, self->current_instance->scanner_scan_fn_index, args, 3);
+  if (self->has_error) return false;
+
+  memcpy(
+    self->current_lexer,
+    &memory_data[self->lexer_address],
+    sizeof(TSLexerDataPrefix)
+  );
+  return args[0].i32;
+}
+
+uint32_t ts_wasm_store_call_scanner_serialize(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  char *buffer
+) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  uint8_t *memory_data = wasmtime_memory_data(context, &self->memory);
+  uint32_t serialization_buffer_address = ts_wasm_store__serialization_buffer_address(self);
+
+  wasmtime_val_raw_t args[2] = {
+    {.i32 = scanner_address},
+    {.i32 = serialization_buffer_address},
+  };
+  ts_wasm_store__call(self, self->current_instance->scanner_serialize_fn_index, args, 2);
+  if (self->has_error) return 0;
+
+  uint32_t length = args[0].i32;
+  if (length > TREE_SITTER_SERIALIZATION_BUFFER_SIZE) {
+      self->has_error = true;
+      return 0;
+  }
+
+  if (length > 0) {
+    memcpy(
+      ((Lexer *)self->current_lexer)->debug_buffer,
+      &memory_data[serialization_buffer_address],
+      length
+    );
+  }
+  return length;
+}
+
+void ts_wasm_store_call_scanner_deserialize(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  const char *buffer,
+  unsigned length
+) {
+  wasmtime_context_t *context = wasmtime_store_context(self->store);
+  uint8_t *memory_data = wasmtime_memory_data(context, &self->memory);
+  uint32_t serialization_buffer_address = ts_wasm_store__serialization_buffer_address(self);
+
+  if (length > 0) {
+    memcpy(
+      &memory_data[serialization_buffer_address],
+      buffer,
+      length
+    );
+  }
+
+  wasmtime_val_raw_t args[3] = {
+    {.i32 = scanner_address},
+    {.i32 = serialization_buffer_address},
+    {.i32 = length},
+  };
+  ts_wasm_store__call(self, self->current_instance->scanner_deserialize_fn_index, args, 3);
+}
+
+bool ts_wasm_store_has_error(const TSWasmStore *self) {
+  return self->has_error;
+}
+
+bool ts_language_is_wasm(const TSLanguage *self) {
+  return self->lex_fn == ts_wasm_store__sentinel_lex_fn;
+}
+
+static inline LanguageWasmModule *ts_language__wasm_module(const TSLanguage *self) {
+  return (LanguageWasmModule *)self->keyword_lex_fn;
+}
+
+void ts_wasm_language_retain(const TSLanguage *self) {
+  LanguageWasmModule *module = ts_language__wasm_module(self);
+  ts_assert(module->ref_count > 0);
+  atomic_inc(&module->ref_count);
+}
+
+void ts_wasm_language_release(const TSLanguage *self) {
+  LanguageWasmModule *module = ts_language__wasm_module(self);
+  ts_assert(module->ref_count > 0);
+  if (atomic_dec(&module->ref_count) == 0) {
+    // Update the language id to reflect that the language is deleted. This allows any Wasm stores
+    // that hold Wasm instances for this language to delete those instances.
+    atomic_inc(&module->language_id->is_language_deleted);
+    language_id_delete(module->language_id);
+
+    ts_free((void *)module->field_name_buffer);
+    ts_free((void *)module->symbol_name_buffer);
+    ts_free((void *)module->name);
+    wasmtime_module_delete(module->module);
+    ts_free(module);
+
+    ts_free((void *)self->alias_map);
+    ts_free((void *)self->alias_sequences);
+    ts_free((void *)self->external_scanner.symbol_map);
+    ts_free((void *)self->field_map_entries);
+    ts_free((void *)self->field_map_slices);
+    ts_free((void *)self->supertype_symbols);
+    ts_free((void *)self->supertype_map_entries);
+    ts_free((void *)self->supertype_map_slices);
+    ts_free((void *)self->field_names);
+    ts_free((void *)self->lex_modes);
+    ts_free((void *)self->name);
+    ts_free((void *)self->reserved_words);
+    ts_free((void *)self->parse_actions);
+    ts_free((void *)self->parse_table);
+    ts_free((void *)self->primary_state_ids);
+    ts_free((void *)self->public_symbol_map);
+    ts_free((void *)self->small_parse_table);
+    ts_free((void *)self->small_parse_table_map);
+    ts_free((void *)self->symbol_metadata);
+    ts_free((void *)self->symbol_names);
+    ts_free((void *)self);
+  }
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic pop
+#endif
+
+#else
+
+// If the Wasm feature is not enabled, define dummy versions of all of the
+// Wasm-related functions.
+
+void ts_wasm_store_delete(TSWasmStore *self) {
+  (void)self;
+}
+
+bool ts_wasm_store_start(
+  TSWasmStore *self,
+  TSLexer *lexer,
+  const TSLanguage *language
+) {
+  (void)self;
+  (void)lexer;
+  (void)language;
+  return false;
+}
+
+void ts_wasm_store_reset(TSWasmStore *self) {
+  (void)self;
+}
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state) {
+  (void)self;
+  (void)state;
+  return false;
+}
+
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state) {
+  (void)self;
+  (void)state;
+  return false;
+}
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self) {
+  (void)self;
+  return 0;
+}
+
+void ts_wasm_store_call_scanner_destroy(
+  TSWasmStore *self,
+  uint32_t scanner_address
+) {
+  (void)self;
+  (void)scanner_address;
+}
+
+bool ts_wasm_store_call_scanner_scan(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  uint32_t valid_tokens_ix
+) {
+  (void)self;
+  (void)scanner_address;
+  (void)valid_tokens_ix;
+  return false;
+}
+
+uint32_t ts_wasm_store_call_scanner_serialize(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  char *buffer
+) {
+  (void)self;
+  (void)scanner_address;
+  (void)buffer;
+  return 0;
+}
+
+void ts_wasm_store_call_scanner_deserialize(
+  TSWasmStore *self,
+  uint32_t scanner_address,
+  const char *buffer,
+  unsigned length
+) {
+  (void)self;
+  (void)scanner_address;
+  (void)buffer;
+  (void)length;
+}
+
+bool ts_wasm_store_has_error(const TSWasmStore *self) {
+  (void)self;
+  return false;
+}
+
+bool ts_language_is_wasm(const TSLanguage *self) {
+  (void)self;
+  return false;
+}
+
+void ts_wasm_language_retain(const TSLanguage *self) {
+  (void)self;
+}
+
+void ts_wasm_language_release(const TSLanguage *self) {
+  (void)self;
+}
+
+#endif
diff --git a/src/library/ts/src/tree-sitter/lib/src/wasm_store.h b/src/library/ts/src/tree-sitter/lib/src/wasm_store.h
new file mode 100644
index 0000000000..0fd17e0d17
--- /dev/null
+++ b/src/library/ts/src/tree-sitter/lib/src/wasm_store.h
@@ -0,0 +1,31 @@
+#ifndef TREE_SITTER_WASM_H_
+#define TREE_SITTER_WASM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+bool ts_wasm_store_start(TSWasmStore *self, TSLexer *lexer, const TSLanguage *language);
+void ts_wasm_store_reset(TSWasmStore *self);
+bool ts_wasm_store_has_error(const TSWasmStore *self);
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state);
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state);
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self);
+void ts_wasm_store_call_scanner_destroy(TSWasmStore *self, uint32_t scanner_address);
+bool ts_wasm_store_call_scanner_scan(TSWasmStore *self, uint32_t scanner_address, uint32_t valid_tokens_ix);
+uint32_t ts_wasm_store_call_scanner_serialize(TSWasmStore *self, uint32_t scanner_address, char *buffer);
+void ts_wasm_store_call_scanner_deserialize(TSWasmStore *self, uint32_t scanner, const char *buffer, unsigned length);
+
+void ts_wasm_language_retain(const TSLanguage *self);
+void ts_wasm_language_release(const TSLanguage *self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_WASM_H_
diff --git a/src/library/ts/tools/ci/Rprofile b/src/library/ts/tools/ci/Rprofile
new file mode 100644
index 0000000000..8d70da9c89
--- /dev/null
+++ b/src/library/ts/tools/ci/Rprofile
@@ -0,0 +1,7 @@
+if (getRversion() <= "3.5.100") {
+  options(repos = c(CRAN = "https://packagemanager.posit.co/cran/2023-10-05"))
+} else if (getRversion() <= "3.6.100") {
+  options(repos = c(CRAN = "https://packagemanager.posit.co/cran/2024-05-25"))
+} else if (getRversion() <= "4.0.100") {
+  options(repos = c(CRAN = "https://packagemanager.posit.co/cran/2025-11-13"))
+}
diff --git a/src/library/ts/tools/dynamic-help.R b/src/library/ts/tools/dynamic-help.R
new file mode 100644
index 0000000000..567c784a68
--- /dev/null
+++ b/src/library/ts/tools/dynamic-help.R
@@ -0,0 +1,5 @@
+cat(
+  sep = "\n",
+  "\\renewcommand{\\eval}{\\Sexpr[stage=render,results=rd]{#1}}",
+  file = "man/macros/eval2.Rd"
+)
diff --git a/src/library/ts/tools/examples.R b/src/library/ts/tools/examples.R
new file mode 100644
index 0000000000..fed67ea7a4
--- /dev/null
+++ b/src/library/ts/tools/examples.R
@@ -0,0 +1,15 @@
+if (getRversion() < "4.1") {
+  dir.create("man/macros", showWarnings = FALSE, recursive = TRUE)
+  cat(
+    paste(
+      "\\renewcommand{\\examples}{\\section{Examples}{",
+      "These examples are designed to work in R >= 4.1 so that we can take",
+      "advantage of modern syntax like the base pipe (\\verb{|>}) and the ",
+      "function shorthand (\\verb{\\(x) x + 1}). They might not work on the ",
+      "version of R that you're using.",
+      "\\preformatted{#1}}}",
+      collapse = ""
+    ),
+    file = "man/macros/examples.Rd"
+  )
+}
diff --git a/src/library/ts/tools/man/about.Rmd b/src/library/ts/tools/man/about.Rmd
new file mode 100644
index 0000000000..f2ad415674
--- /dev/null
+++ b/src/library/ts/tools/man/about.Rmd
@@ -0,0 +1,203 @@
+```{asciicast, load}
+#| include: FALSE
+library(ts)
+```
+
+In this document I show examples with the `tsjsonc` package.
+
+### Create a tree-sitter tree
+
+Create a ts_tree (ts_tree_jsonc) object from a string:
+
+```{asciicast, data}
+#| results: "hide"
+txt <- r"(
+// this is a comment
+{
+  "a": {
+    "a1": [1, 2, 3],
+    // comment
+    "a2": "string"
+  },
+  "b": [
+    {
+      "b11": true,
+      "b12": false
+    },
+    {
+      "b21": false,
+      "b22": false
+    }
+  ]
+}
+)"
+
+json <- tsjsonc::ts_parse_jsonc(txt)
+```
+
+Pretty print a ts_tree object:
+
+```{asciicast}
+#| label: print-json
+json
+```
+
+### Select nodes of a tree
+
+Selecting nodes is the basis of editing and querying tree-sitter trees.
+
+Select element by objects key:
+
+```{asciicast}
+#| label: select-key
+ts_tree_select(json, "a")
+```
+
+Select element inside element:
+
+```{asciicast}
+#| label: select-select
+ts_tree_select(json, "a", "a1")
+```
+
+Select element(s) of an array:
+
+```{asciicast}
+#| label: select-array
+ts_tree_select(json, "a", "a1", 1:2)
+```
+
+Select multiple keys from an object:
+
+```{asciicast}
+#| label: select-multiple
+ts_tree_select(json, "a", c("a1", "a2"))
+```
+
+Select nodes that match a tree-sitter query:
+
+```{asciicast}
+#| label: select-query
+json |> ts_tree_select(query = "((pair value: (false) @val))")
+```
+
+### Delete elements
+
+Delete selected elements:
+
+```{asciicast}
+#| label: delete
+ts_tree_select(json, "a", "a1") |> ts_tree_delete()
+```
+
+### Insert elements
+
+Insert element into an array:
+
+```{asciicast}
+#| label: insert-array
+ts_tree_select(json, "a", "a1") |> ts_tree_insert(at = 2, "new")
+```
+
+Inserting into an array reformats the array.
+
+Insert element into an object, at the specified key:
+
+```{asciicast}
+#| label: insert-object
+ts_tree_select(json, "a") |>
+  ts_tree_insert(key = "a0", at = 0, list("new", "element"))
+```
+
+### Update elements
+
+Update existing element:
+
+```{asciicast}
+#| label: update
+ts_tree_select(json, "a", c("a1", "a2")) |> ts_tree_update("new value")
+```
+
+Inserts the element if some parents are missing:
+
+```{asciicast}
+#| label: update-insert
+json <- ts_parse_jsonc(text = "{ \"a\": { \"b\": true } }")
+json
+```
+
+```{asciicast}
+#| label: update-insert-2
+ts_tree_select(json, "a", "x", "y") |> ts_tree_update(list(1,2,3))
+```
+
+### Write out a document
+
+Use `stdout()` to write it to the screen instread of a file:
+
+```{asciicast}
+#| label: write
+json |> ts_tree_write(stdout())
+```
+
+### Formatting
+
+Format the whole document:
+
+```{asciicast}
+#| label: format
+json |> ts_tree_format()
+```
+
+Format part of the document:
+
+```{asciicast}
+#| label: format-part
+json |> ts_tree_select("a") |>
+  ts_tree_format(options = list(format = "compact"))
+```
+
+### Unserializing
+
+Unserialize a whole document:
+
+```{asciicast}
+#| label: unserialize
+json |> ts_tree_unserialize()
+```
+
+Note that `ts_tree_unserialize()` always returns a list, the first element
+of the list is the unserialized document.
+
+Unserialize part(s) of the document:
+```{asciicast}
+#| label: unserialize-part
+json |> ts_tree_select("b") |> ts_tree_unserialize()
+```
+
+Again, `ts_tree_unserialize()` returns a list, with one element for each
+selected node.
+
+### Exploring a tree-sitter tree
+
+It is often useful to explore the structure of a (JSONC) tree-sitter tree,
+to help writing the right selection or tree-sitter queries.
+
+Print the annotated syntax tree:
+```{asciicast}
+#| label: syntax-tree
+ts_tree_ast(json)
+```
+
+Print the document object model:
+```{asciicast}
+#| label: document-model
+ts_tree_dom(json)
+```
+
+Print the structural summary of a tree:
+```{asciicast}
+#| label: structure
+#| asciicast_rows: 7
+ts_tree_sexpr(json)
+```
\ No newline at end of file
diff --git a/src/library/tstoml/DESCRIPTION b/src/library/tstoml/DESCRIPTION
new file mode 100644
index 0000000000..6077efda4c
--- /dev/null
+++ b/src/library/tstoml/DESCRIPTION
@@ -0,0 +1,31 @@
+Package: tstoml
+Title: Edit TOML files
+Version: 0.0.0.9000
+Authors@R: c(
+    person("Gábor", "Csárdi", , "csardi.gabor@gmail.com", role = c("aut", "cre")),
+    person("Posit Software, PBC", role = c("cph", "fnd"),
+        comment = c(ROR = "03wc8by49")),
+    person(family = "tree-sitter-toml authors", role = "ctb")
+  )
+Description: Extract and manipulate parts of TOML files without touching
+  the formatting and comments in other parts.
+License: MIT + file LICENSE
+Encoding: UTF-8
+Roxygen: list(markdown = TRUE)
+RoxygenNote: 7.3.3
+Depends: R (>= 4.1.0)
+Imports: ts
+Suggests: asciicast, hms, pillar, testthat (>= 3.0.0), withr
+Remotes: gaborcsardi/ts
+Config/Needs/website: r-lib/asciicast, tidyverse/tidytemplate
+Config/testthat/edition: 3
+URL: https://github.com/gaborcsardi/tstoml,
+        https://gaborcsardi.github.io/tstoml/
+BugReports: https://github.com/gaborcsardi/tstoml/issues
+Biarch: true
+NeedsCompilation: yes
+Packaged: 2026-05-13 07:39:13 UTC; gaborcsardi
+Author: Gábor Csárdi [aut, cre],
+  Posit Software, PBC [cph, fnd] (ROR: <https://ror.org/03wc8by49>),
+  tree-sitter-toml authors [ctb]
+Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
diff --git a/src/library/tstoml/LICENSE b/src/library/tstoml/LICENSE
new file mode 100644
index 0000000000..cc6563c615
--- /dev/null
+++ b/src/library/tstoml/LICENSE
@@ -0,0 +1,2 @@
+YEAR: 2025
+COPYRIGHT HOLDER: tstoml authors
diff --git a/src/library/tstoml/NAMESPACE b/src/library/tstoml/NAMESPACE
new file mode 100644
index 0000000000..1b77f63b38
--- /dev/null
+++ b/src/library/tstoml/NAMESPACE
@@ -0,0 +1,27 @@
+# Generated by roxygen2: do not edit by hand
+
+S3method(ts_tree_ast,ts_tree_toml)
+S3method(ts_tree_delete,ts_tree_toml)
+S3method(ts_tree_format,ts_tree_toml)
+S3method(ts_tree_insert,ts_tree_toml)
+S3method(ts_tree_mark_selection1,ts_tree_toml)
+S3method(ts_tree_new,ts_language_toml)
+S3method(ts_tree_query,ts_tree_toml)
+S3method(ts_tree_select1,ts_tree_toml.ts_tree_selector_default)
+S3method(ts_tree_unserialize,ts_tree_toml)
+S3method(ts_tree_update,ts_tree_toml)
+S3method(ts_tree_write,ts_tree_toml)
+export(toml_example_text)
+export(ts_format_toml)
+export(ts_language_toml)
+export(ts_parse_toml)
+export(ts_read_toml)
+export(ts_serialize_toml)
+export(ts_toml_array)
+export(ts_toml_array_of_tables)
+export(ts_toml_inline_table)
+export(ts_toml_table)
+export(ts_tree_select.ts_tree_toml)
+export(ts_unserialize_toml)
+import(ts)
+useDynLib(tstoml, .registration = TRUE, .fixes = "c_")
diff --git a/src/library/tstoml/R/checks.R b/src/library/tstoml/R/checks.R
new file mode 100644
index 0000000000..0a53a25dde
--- /dev/null
+++ b/src/library/tstoml/R/checks.R
@@ -0,0 +1,259 @@
+is_string <- function(x, na = FALSE) {
+  if (na) {
+    is.character(x) && length(x) == 1
+  } else {
+    is.character(x) && length(x) == 1 && !is.na(x)
+  }
+}
+
+is_count <- function(x, positive = FALSE) {
+  limit <- if (positive) 1L else 0L
+  is.numeric(x) &&
+    length(x) == 1 &&
+    !is.na(suppressWarnings(as.integer(x))) &&
+    suppressWarnings(as.integer(x)) == x &&
+    !is.na(x) &&
+    x >= limit
+}
+
+as_count <- function(
+  x,
+  positive = FALSE,
+  null = FALSE,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  if (is.null(x) && null) {
+    return(x)
+  }
+  if (is_count(x, positive = positive)) {
+    return(as.integer(x))
+  }
+
+  if (is_string(x)) {
+    xi <- suppressWarnings(as.integer(x))
+    if (is_count(xi, positive = positive)) {
+      return(xi)
+    }
+  }
+
+  limit <- if (positive) 1L else 0L
+  if (is.numeric(x) && length(x) != 1) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be an integer scalar, not a vector."
+    ))
+  } else if (is.numeric(x) && length(x) == 1 && is.na(x)) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must not be `NA`."
+    ))
+  } else if (is.numeric(x) && length(x) == 1 && !is.na(x) && x < limit) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be \\
+      {if (positive) 'positive' else 'non-negative'}."
+    ))
+  } else {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be a \\
+      {if (positive) 'positive' else 'non-negative'} integer scalar, \\
+      but it is {typename(x)}."
+    ))
+  }
+}
+
+as_choice <- function(
+  x,
+  choices,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  if (is_string(x) && tolower(x) %in% choices) {
+    return(tolower(x))
+  }
+
+  cchoices <- paste0("'", choices, "'", collapse = ", ")
+  if (is_string(x)) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be one of {cchoices}, but it is '{x}'."
+    ))
+  } else {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be a string scalar, one of \\
+       {cchoices}, but it is {typename(x)}."
+    ))
+  }
+}
+
+opt_indent_width_default <- function() {
+  4L
+}
+
+opt_indent_style_default <- function() {
+  "space"
+}
+
+#' tstoml options
+#'
+#' Options that control the behavior of tstoml functions.
+#'
+#' ## Formatting options:
+#'
+#' * `indent_width`: integer, the number of spaces to use for indentation
+#'   when `indent_style` is `"space"`. Default is
+#'   `r opt_indent_width_default()`.
+#' * `indent_style`: string, either `"space"` or `"tab"`, the type of
+#'   indentation to use. Default is `r opt_indent_style_default()`.
+#'
+#' @name tstoml_options
+NULL
+
+as_tstoml_options <- function(
+  x,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  nms <- c(
+    "indent_width",
+    "indent_style",
+    # this is internal only
+    internal = "insert_empty_line_before_tables"
+  )
+  if (
+    (is.list(x) || is.null(x)) &&
+      is_named(x, null = TRUE) &&
+      all(names(x) %in% nms)
+  ) {
+    force(arg)
+    # older R versions would set NULL to logical(), not list()
+    x <- as.list(x)
+
+    x[["indent_width"]] <- as_count(
+      x[["indent_width"]] %||% opt_indent_width_default(),
+      arg = as_ts_caller_arg(substitute(
+        x[["indent_width"]],
+        list(x = arg[[1]])
+      )),
+      call = call
+    )
+
+    x[["indent_style"]] <- as_choice(
+      x[["indent_style"]] %||% opt_indent_style_default(),
+      choices = c("space", "tab"),
+      arg = as_ts_caller_arg(substitute(
+        x[["indent_style"]],
+        list(x = arg[[1]])
+      )),
+      call = call
+    )
+
+    return(x)
+  }
+
+  if (!is.list(x) && !is.null(x)) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be a named list of tsjsonc options \\
+       (see `?tsjsonc_options`), but it is {typename(options)}."
+    ))
+  }
+
+  if (!is_named(x, null = TRUE)) {
+    stop(ts_cnd(
+      call = call,
+      "Invalid argument: `{arg}` must be a named list of tsjsonc options \\
+       (see `?tsjsonc_options`), but not all of its entries are named."
+    ))
+  }
+
+  bad <- paste0("`", unique(setdiff(names(x), nms)), "`")
+  good <- paste0("`", nms[names(nms) != "internal"], "`")
+  stop(ts_cnd(
+    call = call,
+    "Invalid argument: `{arg}` contains unknown tsjsonc \\
+    option{plural(length(bad))}: {ts_collapse(bad)}. Known tsjsonc options \\
+    are: {ts_collapse(good)}."
+  ))
+}
+
+as_toml_float <- function(
+  x,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  if (is.numeric(x) && length(x) == 1) {
+    if (!is.na(x)) {
+      return(as.numeric(x))
+    } else {
+      return(NaN)
+    }
+  }
+
+  stop(ts_cnd(
+    "Invalid argument: `{arg}` contains an atomic numeric vector of length \\
+     {length(x)}. TOML only supports numeric scalars and lists.",
+    call = call
+  ))
+}
+
+as_toml_boolean <- function(
+  x,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  if (is.logical(x) && length(x) == 1 && !is.na(x)) {
+    return(x)
+  }
+
+  if (!is.logical(x) || length(x) != 1) {
+    stop(ts_cnd(
+      "Invalid argument: `{arg}` contains an atomic logical vector of length \\
+       {length(x)}. TOML only supports logical scalars and lists.",
+      call = call
+    ))
+  }
+
+  stop(ts_cnd(
+    "Invalid argument: `{arg}` contains a logical `NA`. TOML does not support \\
+    logical `NA` values.",
+    call = call
+  ))
+}
+
+as_toml_integer <- function(
+  x,
+  arg = ts_caller_arg(x),
+  call = ts_caller_env()
+) {
+  if (is.integer(x) && length(x) == 1 && !is.na(x)) {
+    return(x)
+  }
+
+  if (!is.integer(x) || length(x) != 1) {
+    stop(ts_cnd(
+      "Invalid argument: `{arg}` contains an atomic integer vector of length \\
+       {length(x)}. TOML only supports integer scalars and lists.",
+      call = call
+    ))
+  }
+
+  stop(ts_cnd(
+    "Invalid argument: `{arg}` contains an integer `NA`. TOML does not support \\
+    integer `NA` values.",
+    call = call
+  ))
+}
+
+as_character <- function(x) {
+  # TODO
+  x # nocov
+}
+
+as_existing_file <- function(x) {
+  # TODO
+  x # nocov
+}
diff --git a/src/library/tstoml/R/compat-vctrs.R b/src/library/tstoml/R/compat-vctrs.R
new file mode 100644
index 0000000000..8b4595e4e0
--- /dev/null
+++ b/src/library/tstoml/R/compat-vctrs.R
@@ -0,0 +1,643 @@
+# nocov start
+
+compat_vctrs <- local({
+  # Modified from https://github.com/r-lib/rlang/blob/master/R/compat-vctrs.R
+
+  # Construction ------------------------------------------------------------
+
+  # Constructs data frames inheriting from `"tbl"`. This allows the
+  # pillar package to take over printing as soon as it is loaded.
+  # The data frame otherwise behaves like a base data frame.
+  data_frame <- function(...) {
+    new_data_frame(df_list(...), .class = "tbl")
+  }
+
+  new_data_frame <- function(.x = list(), ..., .size = NULL, .class = NULL) {
+    n_cols <- length(.x)
+    if (n_cols != 0 && is.null(names(.x))) {
+      stop("Columns must be named.", call. = FALSE)
+    }
+
+    if (is.null(.size)) {
+      if (n_cols == 0) {
+        .size <- 0
+      } else {
+        .size <- vec_size(.x[[1]])
+      }
+    }
+
+    structure(
+      .x,
+      class = c(.class, "data.frame"),
+      row.names = .set_row_names(.size),
+      ...
+    )
+  }
+
+  df_list <- function(..., .size = NULL) {
+    vec_recycle_common(list(...), size = .size)
+  }
+
+  # Binding -----------------------------------------------------------------
+
+  vec_rbind <- function(...) {
+    xs <- vec_cast_common(list(...))
+    do.call(base::rbind, xs)
+  }
+
+  vec_cbind <- function(...) {
+    xs <- list(...)
+
+    ptype <- vec_ptype_common(lapply(xs, `[`, 0))
+    class <- setdiff(class(ptype), "data.frame")
+
+    xs <- vec_recycle_common(xs)
+    out <- do.call(base::cbind, xs)
+    new_data_frame(out, .class = class)
+  }
+
+  # Slicing -----------------------------------------------------------------
+
+  vec_size <- function(x) {
+    if (is.data.frame(x)) {
+      nrow(x)
+    } else {
+      length(x)
+    }
+  }
+
+  vec_rep <- function(x, times) {
+    i <- rep.int(seq_len(vec_size(x)), times)
+    vec_slice(x, i)
+  }
+
+  vec_recycle_common <- function(xs, size = NULL) {
+    sizes <- vapply(xs, vec_size, integer(1))
+
+    n <- unique(sizes)
+
+    if (length(n) == 1 && is.null(size)) {
+      return(xs)
+    }
+    n <- setdiff(n, 1L)
+
+    ns <- length(n)
+
+    if (ns == 0) {
+      if (is.null(size)) {
+        return(xs)
+      }
+    } else if (ns == 1) {
+      if (is.null(size)) {
+        size <- n
+      } else if (ns != size) {
+        stop("Inputs can't be recycled to `size`.", call. = FALSE)
+      }
+    } else {
+      stop("Inputs can't be recycled to a common size.", call. = FALSE)
+    }
+
+    to_recycle <- sizes == 1L
+    xs[to_recycle] <- lapply(xs[to_recycle], vec_rep, size)
+
+    xs
+  }
+
+  vec_slice <- function(x, i) {
+    if (is.logical(i)) {
+      i <- which(i)
+    }
+    stopifnot(is.numeric(i) || is.character(i))
+
+    if (is.null(x)) {
+      return(NULL)
+    }
+
+    if (is.data.frame(x)) {
+      # We need to be a bit careful to be generic. First empty all
+      # columns and expand the df to final size.
+      out <- x[i, 0, drop = FALSE]
+
+      # Then fill in with sliced columns
+      out[seq_along(x)] <- lapply(x, vec_slice, i)
+
+      # Reset automatic row names to work around `[` weirdness
+      if (is.numeric(attr(x, "row.names"))) {
+        row_names <- .set_row_names(nrow(out))
+      } else {
+        row_names <- attr(out, "row.names")
+      }
+
+      return(out)
+    }
+
+    d <- vec_dims(x)
+    if (d == 1) {
+      if (is.object(x)) {
+        out <- x[i]
+      } else {
+        out <- x[i, drop = FALSE]
+      }
+    } else if (d == 2) {
+      out <- x[i, , drop = FALSE]
+    } else {
+      j <- rep(list(quote(expr = )), d - 1)
+      out <- eval(as.call(list(
+        quote(`[`),
+        quote(x),
+        quote(i),
+        j,
+        drop = FALSE
+      )))
+    }
+
+    out
+  }
+  vec_dims <- function(x) {
+    d <- dim(x)
+    if (is.null(d)) {
+      1L
+    } else {
+      length(d)
+    }
+  }
+
+  vec_as_location <- function(i, n, names = NULL) {
+    out <- seq_len(n)
+    names(out) <- names
+
+    # Special-case recycling to size 0
+    if (is_logical(i, n = 1) && !length(out)) {
+      return(out)
+    }
+
+    unname(out[i])
+  }
+
+  vec_init <- function(x, n = 1L) {
+    vec_slice(x, rep_len(NA_integer_, n))
+  }
+
+  vec_assign <- function(x, i, value) {
+    if (is.null(x)) {
+      return(NULL)
+    }
+
+    if (is.logical(i)) {
+      i <- which(i)
+    }
+    stopifnot(
+      is.numeric(i) || is.character(i)
+    )
+
+    value <- vec_recycle(value, vec_size(i))
+    value <- vec_cast(value, to = x)
+
+    d <- vec_dims(x)
+
+    if (d == 1) {
+      x[i] <- value
+    } else if (d == 2) {
+      x[i, ] <- value
+    } else {
+      stop("Can't slice-assign arrays.", call. = FALSE)
+    }
+
+    x
+  }
+
+  vec_recycle <- function(x, size) {
+    if (is.null(x) || is.null(size)) {
+      return(NULL)
+    }
+
+    n_x <- vec_size(x)
+
+    if (n_x == size) {
+      x
+    } else if (size == 0L) {
+      vec_slice(x, 0L)
+    } else if (n_x == 1L) {
+      vec_slice(x, rep(1L, size))
+    } else {
+      stop("Incompatible lengths: ", n_x, ", ", size, call. = FALSE)
+    }
+  }
+
+  # Coercion ----------------------------------------------------------------
+
+  vec_cast_common <- function(xs, to = NULL) {
+    ptype <- vec_ptype_common(xs, ptype = to)
+    lapply(xs, vec_cast, to = ptype)
+  }
+
+  vec_cast <- function(x, to) {
+    if (is.null(x)) {
+      return(NULL)
+    }
+    if (is.null(to)) {
+      return(x)
+    }
+
+    if (vec_is_unspecified(x)) {
+      return(vec_init(to, vec_size(x)))
+    }
+
+    stop_incompatible_cast <- function(x, to) {
+      stop(
+        sprintf(
+          "Can't convert <%s> to <%s>.",
+          .rlang_vctrs_typeof(x),
+          .rlang_vctrs_typeof(to)
+        ),
+        call. = FALSE
+      )
+    }
+
+    lgl_cast <- function(x, to) {
+      lgl_cast_from_num <- function(x) {
+        if (any(!x %in% c(0L, 1L))) {
+          stop_incompatible_cast(x, to)
+        }
+        as.logical(x)
+      }
+
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = x,
+        integer = ,
+        double = lgl_cast_from_num(x),
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    int_cast <- function(x, to) {
+      int_cast_from_dbl <- function(x) {
+        out <- suppressWarnings(as.integer(x))
+        if (any((out != x) | xor(is.na(x), is.na(out)))) {
+          stop_incompatible_cast(x, to)
+        } else {
+          out
+        }
+      }
+
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = as.integer(x),
+        integer = x,
+        double = int_cast_from_dbl(x),
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    dbl_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        logical = ,
+        integer = as.double(x),
+        double = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    chr_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        character = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    list_cast <- function(x, to) {
+      switch(
+        .rlang_vctrs_typeof(x),
+        list = x,
+        stop_incompatible_cast(x, to)
+      )
+    }
+
+    df_cast <- function(x, to) {
+      # Check for extra columns
+      if (length(setdiff(names(x), names(to))) > 0) {
+        stop(
+          "Can't convert data frame because of missing columns.",
+          call. = FALSE
+        )
+      }
+
+      # Avoid expensive [.data.frame method
+      out <- as.list(x)
+
+      # Coerce common columns
+      common <- intersect(names(x), names(to))
+      out[common] <- Map(vec_cast, out[common], to[common])
+
+      # Add new columns
+      from_type <- setdiff(names(to), names(x))
+      out[from_type] <- lapply(to[from_type], vec_init, n = vec_size(x))
+
+      # Ensure columns are ordered according to `to`
+      out <- out[names(to)]
+
+      new_data_frame(out)
+    }
+
+    rlib_df_cast <- function(x, to) {
+      new_data_frame(df_cast(x, to), .class = "tbl")
+    }
+    tib_cast <- function(x, to) {
+      new_data_frame(df_cast(x, to), .class = c("tbl_df", "tbl"))
+    }
+
+    switch(
+      .rlang_vctrs_typeof(to),
+      logical = lgl_cast(x, to),
+      integer = int_cast(x, to),
+      double = dbl_cast(x, to),
+      character = chr_cast(x, to),
+      list = list_cast(x, to),
+
+      base_data_frame = df_cast(x, to),
+      rlib_data_frame = rlib_df_cast(x, to),
+      tibble = tib_cast(x, to),
+
+      stop_incompatible_cast(x, to)
+    )
+  }
+
+  vec_ptype_common <- function(xs, ptype = NULL) {
+    if (!is.null(ptype)) {
+      return(vec_ptype(ptype))
+    }
+
+    xs <- Filter(function(x) !is.null(x), xs)
+
+    if (length(xs) == 0) {
+      return(NULL)
+    }
+
+    if (length(xs) == 1) {
+      out <- vec_ptype(xs[[1]])
+    } else {
+      xs <- map(xs, vec_ptype)
+      out <- Reduce(vec_ptype2, xs)
+    }
+
+    vec_ptype_finalise(out)
+  }
+
+  vec_ptype_finalise <- function(x) {
+    if (is.data.frame(x)) {
+      x[] <- lapply(x, vec_ptype_finalise)
+      return(x)
+    }
+
+    if (inherits(x, "rlang_unspecified")) {
+      logical()
+    } else {
+      x
+    }
+  }
+
+  vec_ptype <- function(x) {
+    if (vec_is_unspecified(x)) {
+      return(.rlang_vctrs_unspecified())
+    }
+
+    if (is.data.frame(x)) {
+      out <- new_data_frame(lapply(x, vec_ptype))
+
+      attrib <- attributes(x)
+      attrib$row.names <- attr(out, "row.names")
+      attributes(out) <- attrib
+
+      return(out)
+    }
+
+    vec_slice(x, 0)
+  }
+
+  vec_ptype2 <- function(x, y) {
+    stop_incompatible_type <- function(x, y) {
+      stop(
+        sprintf(
+          "Can't combine types <%s> and <%s>.",
+          .rlang_vctrs_typeof(x),
+          .rlang_vctrs_typeof(y)
+        ),
+        call. = FALSE
+      )
+    }
+
+    x_type <- .rlang_vctrs_typeof(x)
+    y_type <- .rlang_vctrs_typeof(y)
+
+    if (x_type == "unspecified" && y_type == "unspecified") {
+      return(.rlang_vctrs_unspecified())
+    }
+    if (x_type == "unspecified") {
+      return(y)
+    }
+    if (y_type == "unspecified") {
+      return(x)
+    }
+
+    df_ptype2 <- function(x, y) {
+      set_partition <- function(x, y) {
+        list(
+          both = intersect(x, y),
+          only_x = setdiff(x, y),
+          only_y = setdiff(y, x)
+        )
+      }
+
+      # Avoid expensive [.data.frame
+      x <- as.list(vec_slice(x, 0))
+      y <- as.list(vec_slice(y, 0))
+
+      # Find column types
+      names <- set_partition(names(x), names(y))
+      if (length(names$both) > 0) {
+        common_types <- Map(vec_ptype2, x[names$both], y[names$both])
+      } else {
+        common_types <- list()
+      }
+      only_x_types <- x[names$only_x]
+      only_y_types <- y[names$only_y]
+
+      # Combine and construct
+      out <- c(common_types, only_x_types, only_y_types)
+      out <- out[c(names(x), names$only_y)]
+      new_data_frame(out)
+    }
+
+    rlib_df_ptype2 <- function(x, y) {
+      new_data_frame(df_ptype2(x, y), .class = "tbl")
+    }
+    tib_ptype2 <- function(x, y) {
+      new_data_frame(df_ptype2(x, y), .class = c("tbl_df", "tbl"))
+    }
+
+    ptype <- switch(
+      x_type,
+
+      logical = switch(
+        y_type,
+        logical = x,
+        integer = y,
+        double = y,
+        stop_incompatible_type(x, y)
+      ),
+
+      integer = switch(
+        .rlang_vctrs_typeof(y),
+        logical = x,
+        integer = x,
+        double = y,
+        stop_incompatible_type(x, y)
+      ),
+
+      double = switch(
+        .rlang_vctrs_typeof(y),
+        logical = x,
+        integer = x,
+        double = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      character = switch(
+        .rlang_vctrs_typeof(y),
+        character = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      list = switch(
+        .rlang_vctrs_typeof(y),
+        list = x,
+        stop_incompatible_type(x, y)
+      ),
+
+      base_data_frame = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        s3_data_frame = df_ptype2(x, y),
+        rlib_data_frame = rlib_df_ptype2(x, y),
+        tibble = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      rlib_data_frame = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        rlib_data_frame = ,
+        s3_data_frame = rlib_df_ptype2(x, y),
+        tibble = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      tibble = switch(
+        .rlang_vctrs_typeof(y),
+        base_data_frame = ,
+        rlib_data_frame = ,
+        tibble = ,
+        s3_data_frame = tib_ptype2(x, y),
+        stop_incompatible_type(x, y)
+      ),
+
+      stop_incompatible_type(x, y)
+    )
+
+    vec_slice(ptype, 0)
+  }
+
+  .rlang_vctrs_typeof <- function(x) {
+    if (is.object(x)) {
+      class <- class(x)
+
+      if (identical(class, "rlang_unspecified")) {
+        return("unspecified")
+      }
+      if (identical(class, "data.frame")) {
+        return("base_data_frame")
+      }
+      if (identical(class, c("tbl", "data.frame"))) {
+        return("rlib_data_frame")
+      }
+      if (identical(class, c("tbl_df", "tbl", "data.frame"))) {
+        return("tibble")
+      }
+      if (inherits(x, "data.frame")) {
+        return("s3_data_frame")
+      }
+
+      class <- paste0(class, collapse = "/")
+      stop(sprintf("Unimplemented class <%s>.", class), call. = FALSE)
+    }
+
+    type <- typeof(x)
+    switch(
+      type,
+      NULL = return("null"),
+      logical = if (vec_is_unspecified(x)) {
+        return("unspecified")
+      } else {
+        return(type)
+      },
+      integer = ,
+      double = ,
+      character = ,
+      raw = ,
+      list = return(type)
+    )
+
+    stop(sprintf("Unimplemented type <%s>.", type), call. = FALSE)
+  }
+
+  vec_is_unspecified <- function(x) {
+    !is.object(x) &&
+      typeof(x) == "logical" &&
+      length(x) &&
+      all(vapply(x, identical, logical(1), NA))
+  }
+
+  .rlang_vctrs_unspecified <- function(x = NULL) {
+    structure(
+      rep(NA, length(x)),
+      class = "rlang_unspecified"
+    )
+  }
+
+  .rlang_vctrs_s3_method <- function(generic, class, env = parent.frame()) {
+    fn <- get(generic, envir = env)
+
+    ns <- asNamespace(topenv(fn))
+    tbl <- ns$.__S3MethodsTable__.
+
+    for (c in class) {
+      name <- paste0(generic, ".", c)
+      if (exists(name, envir = tbl, inherits = FALSE)) {
+        return(get(name, envir = tbl))
+      }
+      if (exists(name, envir = globalenv(), inherits = FALSE)) {
+        return(get(name, envir = globalenv()))
+      }
+    }
+
+    NULL
+  }
+
+  environment()
+})
+
+data_frame <- compat_vctrs$data_frame
+
+as_data_frame <- function(x) {
+  if (is.matrix(x)) {
+    x <- as.data.frame(x, stringsAsFactors = FALSE)
+  } else {
+    x <- compat_vctrs$vec_recycle_common(x)
+  }
+  compat_vctrs$new_data_frame(x, .class = "tbl")
+}
+
+# nocov end
diff --git a/src/library/tstoml/R/friendly-type.R b/src/library/tstoml/R/friendly-type.R
new file mode 100644
index 0000000000..d1dc5b3826
--- /dev/null
+++ b/src/library/tstoml/R/friendly-type.R
@@ -0,0 +1,184 @@
+# This is based on rlang:::obj_type_friendly, but adapted to base R
+
+friendly_type <- local({
+  friendly_type <- function(x, value = TRUE, length = FALSE) {
+    if (is_missing(x)) {
+      return("absent")
+    }
+
+    if (is.object(x)) {
+      if (inherits(x, "quosure")) {
+        return("a <quosure> object")
+      } else if (identical(class(x), "data.frame")) {
+        return("a data frame")
+      } else if (identical(class(x), c("tbl_df", "tbl", "data.frame"))) {
+        return("a tibble")
+      } else {
+        # this is sometimes wrong for 'h', but ce la vie
+        fst <- tolower(substr(class(x)[1], 1, 1))
+        prop <- if (fst %in% c("a", "e", "i", "o", "u")) {
+          "an"
+        } else {
+          "a"
+        }
+        return(paste0(prop, " <", class(x)[1], "> object"))
+      }
+    }
+
+    if (!is_vector(x)) {
+      return(as_friendly_type(typeof(x)))
+    }
+
+    n_dim <- length(dim(x))
+
+    if (value && !n_dim) {
+      if (is_na(x)) {
+        return(switch(
+          typeof(x),
+          logical = "`NA`",
+          integer = "an integer `NA`",
+          double = "a numeric `NA`",
+          complex = "a complex `NA`",
+          character = "a character `NA`",
+          typeof(x)
+        ))
+      }
+      if (length(x) == 1 && !is_list(x)) {
+        return(switch(
+          typeof(x),
+          logical = if (x) "`TRUE`" else "`FALSE`",
+          integer = "an integer",
+          double = "a number",
+          complex = "a complex number",
+          character = if (nzchar(x)) "a string" else "`\"\"`",
+          raw = "a raw value",
+          sprintf("a %s value", typeof(x))
+        ))
+      }
+      if (length(x) == 0) {
+        return(switch(
+          typeof(x),
+          logical = "an empty logical vector",
+          integer = "an empty integer vector",
+          double = "an empty numeric vector",
+          complex = "an empty complex vector",
+          character = "an empty character vector",
+          raw = "an empty raw vector",
+          list = "an empty list",
+          sprintf("a %s of length one", typeof(x))
+        ))
+      }
+    }
+
+    type <- friendly_vector_type(typeof(x), n_dim)
+
+    if (length && !n_dim) {
+      type <- paste0(type, sprintf(" of length %s", length(x)))
+    }
+
+    type
+  }
+
+  friendly_vector_type <- function(type, n_dim) {
+    if (type == "list") {
+      if (n_dim < 2) {
+        return("a list")
+      } else if (n_dim == 2) {
+        return("a list matrix")
+      } else {
+        return("a list array")
+      }
+    }
+
+    type <- switch(
+      type,
+      logical = "a logical %s",
+      integer = "an integer %s",
+      numeric = ,
+      double = "a double %s",
+      complex = "a complex %s",
+      character = "a character %s",
+      raw = "a raw %s",
+      type = paste0("a ", type, " %s")
+    )
+
+    if (n_dim < 2) {
+      kind <- "vector"
+    } else if (n_dim == 2) {
+      kind <- "matrix"
+    } else {
+      kind <- "array"
+    }
+    sprintf(type, kind)
+  }
+
+  as_friendly_type <- function(type) {
+    switch(
+      type,
+
+      list = "a list",
+
+      NULL = "NULL",
+      environment = "an environment",
+      externalptr = "a pointer",
+      weakref = "a weak reference",
+      S4 = "an S4 object",
+
+      name = ,
+      symbol = "a symbol",
+      language = "a call",
+      pairlist = "a pairlist node",
+      expression = "an expression vector",
+
+      char = "an internal string",
+      promise = "an internal promise",
+      ... = "an internal dots object",
+      any = "an internal `any` object",
+      bytecode = "an internal bytecode object",
+
+      primitive = ,
+      builtin = ,
+      special = "a primitive function",
+      closure = "a function",
+
+      type
+    )
+  }
+
+  is_missing <- function(x) {
+    missing(x) || identical(x, quote(expr = ))
+  }
+
+  is_vector <- function(x) {
+    t <- typeof(x)
+    t %in%
+      c(
+        "logical",
+        "integer",
+        "double",
+        "complex",
+        "character",
+        "raw",
+        "list"
+      )
+  }
+
+  is_scalar_vector <- function(x) {
+    is_vector(x) && length(x) == 1L
+  }
+
+  is_na <- function(x) {
+    is_scalar_vector(x) && is.na(x)
+  }
+
+  is_list <- function(x) {
+    typeof(x) == "list"
+  }
+
+  list(
+    .internal = environment(),
+    friendly_type = friendly_type
+  )
+})
+
+typename <- friendly_type$friendly_type
diff --git a/src/library/tstoml/R/parsedate-package.R b/src/library/tstoml/R/parsedate-package.R
new file mode 100644
index 0000000000..2137ae0408
--- /dev/null
+++ b/src/library/tstoml/R/parsedate-package.R
@@ -0,0 +1,151 @@
+milliseconds <- function(x) as.difftime(as.numeric(x) / 1000, units = "secs")
+seconds <- function(x) as.difftime(as.numeric(x), units = "secs")
+minutes <- function(x) as.difftime(as.numeric(x), units = "mins")
+hours <- function(x) as.difftime(as.numeric(x), units = "hours")
+days <- function(x) as.difftime(as.numeric(x), units = "days")
+weeks <- function(x) as.difftime(as.numeric(x), units = "weeks")
+wday <- function(x) as.POSIXlt(x, tz = "UTC")$wday + 1
+with_tz <- function(x, tzone = "") as.POSIXct(as.POSIXlt(x, tz = tzone))
+ymd <- function(x) as.POSIXct(x, format = "%Y %m %d", tz = "UTC")
+yj <- function(x) as.POSIXct(x, format = "%Y %j", tz = "UTC")
+
+parse_iso_8601 <- function(dates, default_tz = "UTC") {
+  if (default_tz == "") {
+    default_tz <- Sys.timezone()
+  }
+  dates <- as.character(dates)
+  match <- re_match(dates, iso_regex)
+  matching <- !is.na(match$.match)
+  result <- rep(.POSIXct(NA_real_, tz = ""), length.out = length(dates))
+  result[matching] <- parse_iso_parts(match[matching, ], default_tz)
+  class(result) <- c("POSIXct", "POSIXt")
+  with_tz(result, "UTC")
+}
+
+parse_iso_parts <- function(mm, default_tz) {
+  num <- nrow(mm)
+
+  ## -----------------------------------------------------------------
+  ## Date first
+
+  date <- .POSIXct(rep(NA_real_, num), tz = "")
+
+  ## Years-days
+  fyd <- is.na(date) & mm$yearday != ""
+  date[fyd] <- yj(paste(mm$year[fyd], mm$yearday[fyd]))
+
+  ## Years-weeks-days
+  fywd <- is.na(date) & mm$week != "" & mm$weekday != ""
+  date[fywd] <- iso_week(mm$year[fywd], mm$week[fywd], mm$weekday[fywd])
+
+  ## Years-weeks
+  fyw <- is.na(date) & mm$week != ""
+  date[fyw] <- iso_week(mm$year[fyw], mm$week[fyw], "1")
+
+  ## Years-months-days
+  fymd <- is.na(date) & mm$month != "" & mm$day != ""
+  date[fymd] <- ymd(paste(mm$year[fymd], mm$month[fymd], mm$day[fymd]))
+
+  ## Years-months
+  fym <- is.na(date) & mm$month != ""
+  date[fym] <- ymd(paste(mm$year[fym], mm$month[fym], "01"))
+
+  ## Years
+  fy <- is.na(date)
+  date[fy] <- ymd(paste(mm$year, "01", "01"))
+
+  ## -----------------------------------------------------------------
+  ## Now the time
+
+  th <- mm$hour != ""
+  date[th] <- date[th] + hours(mm$hour[th])
+
+  tm <- mm$min != ""
+  date[tm] <- date[tm] + minutes(mm$min[tm])
+
+  ts <- mm$sec != ""
+  date[ts] <- date[ts] + seconds(mm$sec[ts])
+
+  ## -----------------------------------------------------------------
+  ## Fractional time
+
+  frac <- as.numeric(sub(",", ".", mm$frac))
+
+  tfs <- !is.na(frac) & mm$sec != ""
+  date[tfs] <- date[tfs] + milliseconds(round(frac[tfs] * 1000))
+
+  tfm <- !is.na(frac) & mm$sec == "" & mm$min != ""
+  sec <- trunc(frac[tfm] * 60)
+  mil <- round((frac[tfm] * 60 - sec) * 1000)
+  date[tfm] <- date[tfm] + seconds(sec) + milliseconds(mil)
+
+  tfh <- !is.na(frac) & mm$sec == "" & mm$min == ""
+  min <- trunc(frac[tfh] * 60)
+  sec <- trunc((frac[tfh] * 60 - min) * 60)
+  mil <- round((((frac[tfh] * 60) - min) * 60 - sec) * 1000)
+  date[tfh] <- date[tfh] + minutes(min) + seconds(sec) + milliseconds(mil)
+
+  ## -----------------------------------------------------------------
+  ## Time zone
+
+  ftzpm <- mm$tzpm != ""
+  m <- ifelse(mm$tzpm[ftzpm] == "+", -1, 1)
+  ftzpmh <- ftzpm & mm$tzhour != ""
+  date[ftzpmh] <- date[ftzpmh] + m * hours(mm$tzhour[ftzpmh])
+  ftzpmm <- ftzpm & mm$tzmin != ""
+  date[ftzpmm] <- date[ftzpmm] + m * minutes(mm$tzmin[ftzpmm])
+
+  ftzz <- mm$tz == "Z"
+  date[ftzz] <- as.POSIXct(date[ftzz], "UTC")
+
+  ftz <- mm$tz != "Z" & mm$tz != ""
+  date[ftz] <- as.POSIXct(date[ftz], mm$tz[ftz])
+
+  if (default_tz != "UTC") {
+    ftna <- mm$tzpm == "" & mm$tz == ""
+    if (any(ftna)) {
+      dd <- as.POSIXct(
+        format_iso_8601(date[ftna]),
+        "%Y-%m-%dT%H:%M:%S+00:00",
+        tz = default_tz
+      )
+      date[ftna] <- dd
+    }
+  }
+
+  as.POSIXct(date, "UTC")
+}
+
+iso_regex <- paste0(
+  "^\\s*",
+  "(?<year>[\\+-]?\\d{4}(?!\\d{2}\\b))",
+  "(?:(?<dash>-?)",
+  "(?:(?<month>0[1-9]|1[0-2])",
+  "(?:\\g{dash}(?<day>[12]\\d|0[1-9]|3[01]))?",
+  "|W(?<week>[0-4]\\d|5[0-3])(?:-?(?<weekday>[1-7]))?",
+  "|(?<yearday>00[1-9]|0[1-9]\\d|[12]\\d{2}|3",
+  "(?:[0-5]\\d|6[1-6])))",
+  "(?<time>[T\\s](?:(?:(?<hour>[01]\\d|2[0-3])",
+  "(?:(?<colon>:?)(?<min>[0-5]\\d))?|24\\:?00)",
+  "(?<frac>[\\.,]\\d+(?!:))?)?",
+  "(?:\\g{colon}(?<sec>[0-5]\\d)(?:[\\.,]\\d+)?)?",
+  "(?<tz>[zZ]|(?<tzpm>[\\+-])",
+  "(?<tzhour>[01]\\d|2[0-3]):?(?<tzmin>[0-5]\\d)?)?)?)?$"
+)
+
+iso_week <- function(year, week, weekday) {
+  wdmon <- function(date) {
+    (wday(date) + 5L) %% 7L
+  }
+  thu <- function(date) {
+    date - days(wdmon(date) - 3L)
+  }
+
+  thu(ymd(paste(year, "01", "04"))) +
+    weeks(as.numeric(week) - 1L) +
+    days(as.numeric(weekday) - 4L)
+}
+
+format_iso_8601 <- function(date) {
+  format(as.POSIXlt(date, tz = "UTC"), "%Y-%m-%dT%H:%M:%S+00:00")
+}
diff --git a/src/library/tstoml/R/rematch2.R b/src/library/tstoml/R/rematch2.R
new file mode 100644
index 0000000000..5214bbcdd3
--- /dev/null
+++ b/src/library/tstoml/R/rematch2.R
@@ -0,0 +1,37 @@
+
+re_match <- function(text, pattern, perl = TRUE, ...) {
+
+  stopifnot(is.character(pattern), length(pattern) == 1, !is.na(pattern))
+  text <- as.character(text)
+
+  match <- regexpr(pattern, text, perl = perl, ...)
+
+  start  <- as.vector(match)
+  length <- attr(match, "match.length")
+  end    <- start + length - 1L
+
+  matchstr <- substring(text, start, end)
+  matchstr[ start == -1 ] <- NA_character_
+
+  res <- data.frame(
+    .text = text,
+    .match = matchstr,
+    stringsAsFactors = FALSE
+  )
+
+  if (!is.null(attr(match, "capture.start"))) {
+
+    gstart  <- attr(match, "capture.start")
+    glength <- attr(match, "capture.length")
+    gend    <- gstart + glength - 1L
+
+    groupstr <- substring(text, gstart, gend)
+    groupstr[ gstart == -1 ] <- NA_character_
+    dim(groupstr) <- dim(gstart)
+
+    res <- cbind(groupstr, res, stringsAsFactors = FALSE)
+  }
+  names(res) <- c(attr(match, "capture.names"), ".text", ".match")
+  class(res) <- c("tbl", class(res))
+  res
+}
diff --git a/src/library/tstoml/R/ts-format-toml.R b/src/library/tstoml/R/ts-format-toml.R
new file mode 100644
index 0000000000..8b72628c98
--- /dev/null
+++ b/src/library/tstoml/R/ts-format-toml.R
@@ -0,0 +1,28 @@
+#' Format a TOML file
+#'
+#' @param file Path to a TOML file. Use one of `file` or `text`.
+#' @param text TOML content as a raw vector or a character vector. Use one
+#'  of `file` or `text`.
+#' @param options Named list of parsing and formatting options, see
+#'  [tstoml options][tstoml_options].
+#' @export
+
+ts_format_toml <- function(
+  file = NULL,
+  text = NULL,
+  options = NULL
+) {
+  if (!missing(options)) {
+    ts_check_named_arg(options)
+  }
+  options <- as_tstoml_options(options)
+
+  # parse file/text
+  tree <- ts_tree_new(
+    ts_language_toml(),
+    file = file,
+    text = text,
+    options = options
+  )
+  format_element(tree, 1L, options = options)
+}
diff --git a/src/library/tstoml/R/ts-language-toml.R b/src/library/tstoml/R/ts-language-toml.R
new file mode 100644
index 0000000000..3234f5c54e
--- /dev/null
+++ b/src/library/tstoml/R/ts-language-toml.R
@@ -0,0 +1,6 @@
+#' TODO
+#' @export
+
+ts_language_toml <- function() {
+  .Call(c_ts_language_toml)
+}
diff --git a/src/library/tstoml/R/ts-parse-toml.R b/src/library/tstoml/R/ts-parse-toml.R
new file mode 100644
index 0000000000..21397e641a
--- /dev/null
+++ b/src/library/tstoml/R/ts-parse-toml.R
@@ -0,0 +1,44 @@
+#' Parse a TOML file or string into a ts_tree_toml object
+#'
+#' @inheritParams ts::ts_tree_new
+#' @param options Named list of parsing options, see
+#'   [tstoml options][tstoml_options].
+#' @return A `ts_tree_toml` object.
+#' @export
+
+ts_parse_toml <- function(
+  text,
+  ranges = NULL,
+  fail_on_parse_error = TRUE,
+  options = NULL
+) {
+  text <- as_character(text)
+  ts_tree_new(
+    language = ts_language_toml(),
+    file = NULL,
+    text = text,
+    ranges = ranges,
+    fail_on_parse_error = fail_on_parse_error,
+    options = options
+  )
+}
+
+#' @rdname ts_parse_toml
+#' @export
+
+ts_read_toml <- function(
+  file,
+  ranges = NULL,
+  fail_on_parse_error = TRUE,
+  options = NULL
+) {
+  file <- as_existing_file(file)
+  ts_tree_new(
+    language = ts_language_toml(),
+    text = NULL,
+    file = file,
+    ranges = ranges,
+    fail_on_parse_error = fail_on_parse_error,
+    options = options
+  )
+}
diff --git a/src/library/tstoml/R/ts-serialize-toml.R b/src/library/tstoml/R/ts-serialize-toml.R
new file mode 100644
index 0000000000..6b966f5f89
--- /dev/null
+++ b/src/library/tstoml/R/ts-serialize-toml.R
@@ -0,0 +1,445 @@
+#' Serialize an R object to TOML
+#'
+#' Create TOML from an R object.
+#' Note that this function is not a generic serializer that can represent
+#' any R object in TOML. Also, you cannot expect that
+#' [ts_unserialize_toml()] will do the exact inverse of
+#' [ts_serialize_toml()].
+#'
+#  tstoml functions [update_selected()] and [insert_into_selected()] use
+# [ts_serialize_toml()] to create new TOML code.
+#'
+#' See the examples below on how to create all possible TOML elements with
+#' [ts_serialize_toml()].
+#'
+#' @param obj R object to serialize.
+#' @param file If not `NULL` then the result if written to this file.
+#' @param collapse If `file` is `NULL` then whether to return a character
+#'   scalar or a character vector.
+#' @param options A named list of `tstoml` options, see
+#'   [tstoml_options()].
+#' @return If `file` is `NULL` then a character scalar (`collapse` = TRUE)
+#'   or vector (`collapse` = FALSE). If `file` is not `NULL` then nothing.
+#'
+#' @export
+#' @seealso [ts_unserialize_toml()] for the opposite.
+
+ts_serialize_toml <- function(
+  obj,
+  file = NULL,
+  collapse = FALSE,
+  options = NULL
+) {
+  lns <- stl_table(
+    NULL,
+    obj,
+    options = options,
+    arg = ts_caller_arg(obj),
+    call = ts_caller_env()
+  )
+
+  # if it starts with a table or array of tables, there is an empty line
+  if (lns[1] == "") {
+    lns <- lns[-1]
+  }
+
+  if (is.null(file)) {
+    if (collapse) {
+      paste0(lns, collapse = "\n")
+    } else {
+      lns
+    }
+  } else {
+    writeLines(lns, con = file)
+    invisible(NULL)
+  }
+}
+
+#' @export
+#' @rdname ts_serialize_toml
+#' @param ... Elements of the TOML table, array, inline table or array
+#'   of tables.
+#' @details Use `ts_toml_table()` to make a list to be serialized as a TOML
+#'   table. All named lists are serialized as TOML tables by default, so
+#'   this is only readability.
+
+ts_toml_table <- function(...) {
+  structure(
+    list(...),
+    class = c("ts_toml_table", "list")
+  )
+}
+
+#' @export
+#' @rdname ts_serialize_toml
+#' @details Use `ts_toml_inline_table()` to make a list to be serialized
+#'   as an inline TOML table. By default named lists are serialized as
+#'   regular TOML tables, if possible.
+
+ts_toml_inline_table <- function(...) {
+  tab <- list(...)
+  if (!is_named(tab)) {
+    stop(ts_cnd("All elements of TOML tables must be named."))
+  }
+  structure(
+    tab,
+    class = c("ts_toml_inline_table", "list")
+  )
+}
+
+#' @export
+#' @rdname ts_serialize_toml
+#' @details Use `ts_toml_array()` to make a list to be serialized as a TOML
+#'   array. By default un-named lists are serialized as arrays, unless they
+#'   are lists of named lists (which are serialized as arrays of tables).
+#'   Use this funtion to mark any list to be serialized as an array.
+
+ts_toml_array <- function(...) {
+  structure(
+    list(...),
+    class = c("ts_toml_array", "list")
+  )
+}
+
+#' @export
+#' @rdname ts_serialize_toml
+#' @details Use `ts_toml_array_of_tables()` to make a list to be serialized
+#'   as a TOML array of tables. It must a list of named lists. By default
+#'   lists of named lists are serialized as arrays of tables, so this is
+#'   only for readability.
+
+ts_toml_array_of_tables <- function(...) {
+  aot <- list(...)
+  if (length(aot) == 0L) {
+    stop(ts_cnd("TOML array of tables must have at least one element."))
+  }
+  if (!all(map_lgl(aot, is_named))) {
+    stop(ts_cnd("All elements of a TOML array of tables must be named lists."))
+  }
+  structure(
+    aot,
+    class = c("ts_toml_array_of_tables", "list")
+  )
+}
+
+ts_toml_key <- function(...) {
+  key <- c(...)
+  # TODO: argument check
+  # TODO: escape keys, quote if needed
+  paste(key, collapse = ".")
+}
+
+get_stl_type <- function(x) {
+  if (inherits(x, "ts_toml_inline_table")) {
+    "pair"
+  } else if (inherits(x, "ts_toml_array")) {
+    "pair"
+  } else if (inherits(x, "ts_toml_table")) {
+    "table"
+  } else if (inherits(x, "ts_toml_array_of_tables")) {
+    "array_of_tables"
+  } else if (!is.list(x)) {
+    "pair"
+  } else if (is_named(x)) {
+    "table"
+  } else if (length(x) > 0 && all(map_lgl(x, is_named))) {
+    "array_of_tables"
+  } else {
+    "pair"
+  }
+}
+
+stl_type_names <- c(
+  "pair" = "key-value pair",
+  "table" = "table",
+  "array_of_tables" = "array of tables"
+)
+
+stl_table <- function(
+  name,
+  obj,
+  options = NULL,
+  path = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  stopifnot(is_named(obj))
+  c(
+    if (!is.null(name)) {
+      c("", paste0("[", paste(c(path, name), collapse = "."), "]"))
+    },
+    stl_table_body(
+      obj,
+      options = options,
+      path = c(path, name),
+      arg = arg,
+      call = call
+    )
+  )
+}
+
+stl_inline <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  if (inherits(obj, "POSIXct")) {
+    stl_offset_date_time(obj, options = options, arg = arg, call = call)
+  } else if (inherits(obj, "POSIXlt")) {
+    stl_local_date_time(obj, options = options, arg = arg, call = call)
+  } else if (inherits(obj, "Date")) {
+    stl_local_date(obj, options = options, arg = arg, call = call)
+  } else if (inherits(obj, "difftime")) {
+    stl_local_time(obj, options = options, arg = arg, call = call)
+  } else if (is.list(obj) && is_named(obj)) {
+    stl_inline_table(obj, options = options, arg = arg, call = call)
+  } else if (is.list(obj)) {
+    stl_inline_array(obj, options = options, arg = arg, call = call)
+  } else if (is.double(obj)) {
+    stl_float(obj, options = options, arg = arg, call = call)
+  } else if (is.character(obj)) {
+    stl_string(obj, options = options, arg = arg, call = call)
+  } else if (is.integer(obj)) {
+    stl_integer(obj, options = options, arg = arg, call = call)
+  } else if (is.logical(obj)) {
+    stl_boolean(obj, options = options, arg = arg, call = call)
+  } else {
+    stop(ts_cnd(
+      "Invalid argument: `{arg}`. Cannot convert {typename(obj)} to TOML.",
+      call = call
+    ))
+  }
+}
+
+#' Serialize a TOML value
+#'
+#' @param obj R object to serialize as a TOML value.
+#' @param options A named list of `tstoml` options, see
+#'   [tstoml_options()].
+# '@export
+
+ts_serialize_toml_value <- function(obj, options = NULL) {
+  stl_inline(obj, options = options)
+}
+
+stl_table_body <- function(
+  obj,
+  options = NULL,
+  inline = FALSE,
+  path = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  types <- map_chr(obj, get_stl_type)
+  wpairs <- which(types == "pair")
+  wtables <- which(types == "table")
+  waots <- which(types == "array_of_tables")
+
+  c(
+    unlist(
+      use.names = FALSE,
+      lapply(wpairs, function(idx) {
+        paste0(
+          names(obj)[idx],
+          " = ",
+          stl_inline(obj[[idx]], options = options, arg = arg, call = call)
+        )
+      })
+    ),
+    unlist(
+      use.names = FALSE,
+      lapply(wtables, function(idx) {
+        stl_table(
+          names(obj)[idx],
+          obj[[idx]],
+          options = options,
+          path = path,
+          arg = arg,
+          call = call
+        )
+      })
+    ),
+    unlist(
+      use.names = FALSE,
+      lapply(waots, function(idx) {
+        stl_array_of_tables(
+          names(obj)[idx],
+          obj[[idx]],
+          options = options,
+          path = path,
+          arg = arg,
+          call = call
+        )
+      })
+    )
+  )
+}
+
+stl_array_of_tables <- function(
+  name,
+  obj,
+  options = options,
+  path = path,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  unlist(lapply(seq_along(obj), function(i) {
+    c(
+      "",
+      paste0("[[", paste0(c(path, name), collapse = "."), "]]"),
+      stl_table_body(
+        obj[[i]],
+        options = options,
+        path = c(path, name),
+        arg = arg,
+        call = call
+      )
+    )
+  }))
+}
+
+stl_float <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  obj <- as_toml_float(obj, arg = arg, call = call)
+  if (is.nan(obj)) {
+    "nan"
+  } else if (obj == Inf) {
+    "inf"
+  } else if (obj == -Inf) {
+    "-inf"
+  } else {
+    format(obj, nsmall = 1)
+  }
+}
+
+# TODO: check scalar, escape, not NA, etc.
+# TODO: select between various string types
+stl_string <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  encodeString(obj, quote = "\"")
+}
+
+stl_integer <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  obj <- as_toml_integer(obj, arg = arg, call = call)
+  as.character(obj)
+}
+
+stl_boolean <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  obj <- as_toml_boolean(obj, arg = arg, call = call)
+  if (obj) "true" else "false"
+}
+
+# TODO: check scalar, not NA
+stl_offset_date_time <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  z <- format(obj, "%z")
+  paste0(
+    format(obj, "%Y-%m-%dT%H:%M:%S"),
+    substr(z, 1, 3),
+    ":",
+    substr(z, 4, 5)
+  )
+}
+
+# TODO: check scalar, not NA
+stl_local_date_time <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  format(obj, "%Y-%m-%dT%H:%M:%S")
+}
+
+# TODO: check scalar, not NA
+stl_local_date <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  format(obj, "%Y-%m-%d")
+}
+
+# TODO: check scalar, not NA
+stl_local_time <- function(
+  obj,
+  options = NULL,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  secs <- as.double(obj, units = "secs")
+  tics_per_second <- 1e+06
+  tics_per_minute <- 6e+07
+  tics_per_hour <- 3.6e+09
+  tics <- secs * tics_per_second
+  h <- trunc(tics / tics_per_hour)
+  tics <- tics - h * tics_per_hour
+  m <- trunc(tics / tics_per_minute)
+  tics <- tics - m * tics_per_minute
+  s <- trunc(tics / tics_per_second)
+  tics <- tics - s * tics_per_second
+  paste0(
+    formatC(h, format = "d", width = 2, flag = "0"),
+    ":",
+    formatC(m, format = "d", width = 2, flag = "0"),
+    ":",
+    formatC(s, format = "d", width = 2, flag = "0"),
+    ".",
+    formatC(as.integer(tics), format = "d", width = 6, flag = "0")
+  )
+}
+
+stl_inline_table <- function(
+  obj,
+  options = options,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  paste0(
+    "{ ",
+    paste0(
+      names(obj),
+      " = ",
+      map_chr(obj, stl_inline, options = options),
+      collapse = ", "
+    ),
+    " }"
+  )
+}
+
+stl_inline_array <- function(
+  obj,
+  options = options,
+  arg = ts_caller_arg(obj),
+  call = ts_caller_env()
+) {
+  paste0(
+    "[ ",
+    paste(map_chr(obj, stl_inline, options = options), collapse = ", "),
+    " ]"
+  )
+}
diff --git a/src/library/tstoml/R/ts-tree-ast.R b/src/library/tstoml/R/ts-tree-ast.R
new file mode 100644
index 0000000000..b619cda71a
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-ast.R
@@ -0,0 +1,24 @@
+#' @ts ts_tree_ast_details_syntax_vs_dom
+#'
+#' ```{asciicast}
+#' #| results = "hide"
+#' tree <- ts_parse_toml("
+#'   [package]
+#'   name = 'tstoml'
+#'   version = '0.1.0'"
+#' )
+#' ```
+#'
+#' ```{asciicast}
+#' ts_tree_ast(tree)
+#' ```
+#'
+#' ```{asciicast}
+#' ts_tree_dom(tree)
+#' ```
+#'
+#' @export
+
+ts_tree_ast.ts_tree_toml <- function(tree) {
+  NextMethod()
+}
diff --git a/src/library/tstoml/R/ts-tree-delete.R b/src/library/tstoml/R/ts-tree-delete.R
new file mode 100644
index 0000000000..ebe2e7f3c4
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-delete.R
@@ -0,0 +1,195 @@
+#' Delete selected elements from a tstoml object
+#'
+#' The formatting of the rest of TOML document is kept as is. Comments
+#' appearing inside the deleted elements are also deleted. Other comments
+#' are left as is.
+#'
+#' @ts ts_tree_delete_details_formatting TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("
+#'   [package]
+#'   name = 'tstoml'
+#'   version = '0.1.0'
+#' ")
+#' toml
+#' ```
+#'
+#' ```{asciicast}
+#' toml |> ts_tree_select("package", "name") |> ts_tree_delete()
+#' ```
+#'
+#' @ts ts_tree_delete_details_no_selection TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("
+#'   [package]
+#'   name = 'tstoml'
+#'   version = '0.1.0'
+#' ") |> ts::ts_tree_format()
+#' toml |> ts_tree_delete()
+#' ```
+#'
+#' @ts ts_tree_delete_details_empty_selection
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("
+#'   [package]
+#'   name = 'tstoml'
+#'   version = '0.1.0'
+#' ") |> ts::ts_tree_format()
+#' toml |> ts_tree_select("nothere") |> ts_tree_delete()
+#' ```
+#'
+#' @ts ts_tree_delete_details_comments
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("
+#'   # top comment
+#'   [package]
+#'   name = 'tstoml' # inline comment
+#'   version = '0.1.0'
+#' ") |> ts::ts_tree_format()
+#' toml
+#' ```
+#'
+#' ```{asciicast}
+#' toml |> ts_tree_select("package", "name") |> ts_tree_delete()
+#' ```
+#'
+#' @details
+#' If `toml` has no selection then the the whole document is deleted.
+#' If `toml` has an empty selection, then nothing is delted.
+#'
+#' @param tree tstoml object.
+#' @param ... Reserved for future use.
+#' @return Modified tstoml object.
+#'
+#' @export
+#' @keywords internal
+#' @examples
+#' library(ts)
+#' toml <- ts_parse_toml(text = toml_example_text())
+#' toml
+#'
+#' toml |> ts_tree_select("owner", "name") |> ts_tree_delete()
+#' toml |> ts_tree_select("owner") |> ts_tree_delete()
+
+ts_tree_delete.ts_tree_toml <- function(tree, ...) {
+  select <- ts_tree_selected_nodes(tree)
+
+  if (length(select) == 0) {
+    attr(tree, "selection") <- NULL
+    return(tree)
+  }
+
+  # if deleting from an array, then we need to look at the array and
+  # remove some commas, probably
+  pares <- tree$parent[select]
+  ptypes <- tree$type[pares]
+  trimmed_arrays <- unique(pares[ptypes == "array"])
+  trimmed_pairs <- pares[ptypes == "pair"]
+  select <- c(select, trimmed_pairs)
+  trimmed_objects <- unique(tree$parent[trimmed_pairs])
+  trimmed_objects <- trimmed_objects[
+    tree$type[trimmed_objects] == "inline_table"
+  ]
+
+  # get the full subtree of nodes to delete
+  subtrees <- lapply(select, get_dom_subtree, tree = tree, with_root = TRUE)
+  subtrees <- lapply(subtrees, function(st) {
+    # when deleting values, we are deleting their keys as well
+    # which to remove NA coming from the document node
+    is_pair_value <- which(tree$type[tree$parent[st]] == "pair")
+
+    st[is_pair_value] <- tree$parent[st[is_pair_value]]
+    st
+  })
+  subtrees <- lapply(subtrees, function(st) {
+    unlist(lapply(st, get_subtree, tree = tree, with_root = TRUE))
+  })
+  deleted <- unique(unlist(subtrees))
+
+  # if deleting an AOT element, remove the whole element
+  del_pares <- tree$parent[deleted]
+  aot_elements <- (tree$type[deleted] %in% key_types) &
+    tree$type[del_pares] == "table_array_element"
+  deleted <- unique(c(deleted, unlist(tree$children[del_pares[aot_elements]])))
+
+  trim_commas <- function(id, open, close) {
+    # remove deleted children and see what is left
+    allchld <- tree$children[[id]]
+    chld <- setdiff(allchld, deleted)
+    nc <- length(chld)
+    # if nothing left, then nothing to do
+    if (nc == 2) {
+      return()
+    }
+    ctypes <- tree$type[chld]
+    todel <- rep(FALSE, length(chld))
+    # this is hard to write in a vectorized form, it is easier iteratively
+    # leading commas
+    for (i in seq_along(todel)[-1]) {
+      if (ctypes[i] == ',') {
+        todel[i] <- TRUE
+      } else {
+        break
+      }
+    }
+    # trailing commas
+    for (i in rev(seq_along(todel))[-1]) {
+      if (ctypes[i] == ',') {
+        todel[i] <- TRUE
+      } else {
+        break
+      }
+    }
+    # duplicate commas
+    todel[ctypes[-nc] == ',' & ctypes[-1] == ','] <- TRUE
+    chdel <- chld[which(todel)]
+    deleted <<- c(deleted, chdel)
+
+    # if the last element is deleted, take the trailing whitespace of
+    # its last token and add it to the last token of the last kept element
+    chdeld <- intersect(allchld, deleted)
+    chkept <- setdiff(allchld, chdeld)
+    last_deld <- chdeld[length(chdeld)]
+    last_kept <- chkept[length(chkept) - 1L]
+    if (last_deld > last_kept) {
+      while (is.na(tree$code[last_deld])) {
+        last_deld <- utils::tail(tree$children[[last_deld]], 1)
+      }
+      while (is.na(tree$code[last_kept])) {
+        last_kept <- utils::tail(tree$children[[last_kept]], 1)
+      }
+      tree$tws[last_kept] <<- tree$tws[last_deld]
+    }
+  }
+
+  # trim commas from arrays
+  trimmed_arrays <- setdiff(trimmed_arrays, deleted)
+  for (arr in trimmed_arrays) {
+    trim_commas(arr, "[", "]")
+  }
+
+  # trim pairs and commas from objects
+  trimmed_objects <- setdiff(trimmed_objects, deleted)
+  for (obj in trimmed_objects) {
+    trim_commas(obj, "{", "}")
+  }
+
+  # NA happens if the whole document is deleted, the parent of 1 is NA
+  tree2 <- tree[-na_omit(deleted), ]
+
+  # update text
+  parts <- c(rbind(tree2$code, tree2$tws))
+  text <- as.raw(unlist(lapply(na_omit(parts), charToRaw)))
+
+  # TODO: update coordinates without reparsing
+  new <- ts_parse_toml(text = text)
+  attr(new, "file") <- attr(tree, "file")
+
+  new
+}
+
+key_types <- c("bare_key", "quoted_key", "dotted_key")
diff --git a/src/library/tstoml/R/ts-tree-format.R b/src/library/tstoml/R/ts-tree-format.R
new file mode 100644
index 0000000000..b807c59522
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-format.R
@@ -0,0 +1,325 @@
+#' Format the selected TOML elements
+#'
+#' @ts ts_tree_format_details_no_selection
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("a = [1,2,3]")
+#' toml |> ts_tree_format()
+#' ```
+#'
+#' @ts ts_tree_format_details_empty_selection
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("a = [1,2,3]")
+#' toml |> ts_tree_select("c") |> ts_tree_format()
+#' ```
+#'
+# TODO: @ts ts_tree_format_details_options
+#'
+#' @details
+#' If `tree` does not have a selection, then all of it is formatted.
+#' If `tree` has an empty selection, then nothing happens.
+#'
+#' @inheritParams ts_parse_toml
+#' @param tree tstoml object.
+#' @param ... Reserved for future use.
+#' @return The updated tstoml object.
+#'
+#' @export
+#' @keywords internal
+
+ts_tree_format.ts_tree_toml <- function(
+  tree,
+  options = NULL,
+  ...
+) {
+  if (!missing(options)) {
+    ts_check_named_arg(options)
+  }
+  options <- as_tstoml_options(options)
+  select <- ts_tree_selected_nodes(tree)
+  fmt <- lapply(
+    select,
+    format_element,
+    tree = tree,
+    options = options
+  )
+  for (i in seq_along(select)) {
+    sel1 <- select[i]
+    prevline <- rev(which(tree$end_row == tree$start_row[sel1] - 1))[1]
+    ind0 <- sub("^.*\n", "", tree$tws[prevline])
+    if (!is.na(prevline)) {
+      fmt[[i]] <- paste0(c("", rep(ind0, length(fmt[[i]]) - 1L)), fmt[[i]])
+    }
+  }
+
+  subtrees <- lapply(select, get_subtree, tree = tree, with_root = FALSE)
+  deleted <- unique(unlist(subtrees))
+
+  # need to keep the trailing ws of the last element
+  lasts <- map_int(subtrees, max_or_na)
+  tws <- tree$tws[lasts]
+  tree$code[deleted] <- NA_character_
+  tree$tws[deleted] <- NA_character_
+  tree$code[select] <- paste0(
+    map_chr(fmt, paste, collapse = "\n"),
+    ifelse(is.na(tws), "", tws)
+  )
+  tree$tws[select] <- NA_character_
+
+  parts <- c(rbind(tree$code, tree$tws))
+  text <- unlist(lapply(na_omit(parts), charToRaw))
+
+  # TODO: update coordinates without reparsing
+  new <- ts_parse_toml(text = text)
+  attr(new, "file") <- attr(tree, "file")
+
+  new
+}
+
+get_subtree <- function(tree, id, with_root = FALSE) {
+  sel <- c(if (with_root) id, tree$children[[id]])
+  while (TRUE) {
+    sel2 <- unique(c(sel, unlist(tree$children[sel])))
+    if (length(sel2) == length(sel)) {
+      return(sel)
+    }
+    sel <- sel2
+  }
+}
+
+
+format_element <- function(tree, id, options) {
+  type <- tree$type[id]
+  switch(
+    type,
+    table = {
+      format_table(tree, id, options)
+    },
+    document = {
+      format_document(tree, id, options)
+    },
+    table_array_element = {
+      format_table_array_element(tree, id, options)
+    },
+    inline_table = {
+      format_inline_table(tree, id, options)
+    },
+    array = {
+      format_array(tree, id, options)
+    },
+    pair = {
+      format_pair(tree, id, options)
+    },
+    integer = {
+      format_integer(tree, id, options)
+    },
+    float = {
+      format_float(tree, id, options)
+    },
+    boolean = {
+      format_boolean(tree, id, options)
+    },
+    offset_date_time = {
+      format_offset_date_time(tree, id, options)
+    },
+    local_date_time = {
+      format_local_date_time(tree, id, options)
+    },
+    local_date = {
+      format_local_date(tree, id, options)
+    },
+    local_time = {
+      format_local_time(tree, id, options)
+    },
+    string = {
+      format_string(tree, id, options)
+    },
+    comment = {
+      format_comment(tree, id, options)
+    },
+    "," = {
+      ", "
+    },
+    stop(ts_cnd("Internal tstoml error, unknown TOML node type: {type}."))
+  )
+}
+
+format_table <- function(tree, id, options) {
+  hdr_chld <- get_subtree(tree, tree$children[[id]][2L], with_root = TRUE)
+  hdr <- paste(na_omit(tree$code[hdr_chld]), collapse = "")
+  chld <- tree$children[[id]][-(1:3)]
+  c(
+    if (!is_false(options$insert_empty_line_before_tables)) "",
+    paste0("[", hdr, "]"),
+    unlist(lapply(chld, format_element, tree = tree, options = options))
+  )
+}
+
+format_document <- function(tree, id, options) {
+  chld <- tree$children[[id]]
+  lns <- unlist(lapply(chld, format_element, tree = tree, options = options))
+  if (length(lns) > 0 && lns[1] == "") {
+    lns <- lns[-1]
+  }
+  lns
+}
+
+format_table_array_element <- function(tree, id, options) {
+  hdr_chld <- get_subtree(tree, tree$children[[id]][2L], with_root = TRUE)
+  hdr <- paste(na_omit(tree$code[hdr_chld]), collapse = "")
+  chld <- tree$children[[id]][-(1:3)]
+  c(
+    if (!is_false(options$insert_empty_line_before_tables)) "",
+    paste0("[[", hdr, "]]"),
+    unlist(lapply(chld, format_element, tree = tree, options = options))
+  )
+}
+
+format_inline_table <- function(tree, id, options) {
+  chld <- tree$children[[id]]
+  chld <- chld[!tree$type[chld] %in% c("{", "}", ",")]
+  paste0(
+    "{ ",
+    paste(
+      map_chr(chld, format_pair, tree = tree, options = options),
+      collapse = ", "
+    ),
+    " }"
+  )
+}
+
+which_line_comments <- function(tree, ids) {
+  # this only works because `start_row` is sorted
+  which(
+    tree$type[ids] == "comment" &
+      tree$end_row[ids - 1] == tree$start_row[ids]
+  )
+}
+
+format_line_comments <- function(tree, elts, ids) {
+  cmts <- which_line_comments(tree, ids)
+  for (i in cmts) {
+    # may happen if an array or object starts with a comment
+    if (i == 1L) {
+      next
+    }
+    elts[[i - 1]][length(elts[[i - 1]])] <- paste(
+      elts[[i - 1]][length(elts[[i - 1]])],
+      elts[[i]]
+    )
+    elts[i] <- list(NULL)
+  }
+  elts
+}
+
+format_post_process_commas <- function(tree, elts, ids) {
+  commas <- map_lgl(elts, function(x) {
+    length(x) == 1 && startsWith(x, ",")
+  })
+  for (i in which(commas)) {
+    if (tree$type[ids[i - 1]] == "comment") {
+      next
+    }
+    elts[[i - 1]][length(elts[[i - 1]])] <- paste0(
+      elts[[i - 1]][length(elts[[i - 1]])],
+      elts[[i]]
+    )
+    elts[i] <- list(NULL)
+  }
+  elts
+}
+
+format_create_indent <- function(options) {
+  if (options[["indent_style"]] == "space") {
+    strrep(" ", options[["indent_width"]])
+  } else {
+    "\t"
+  }
+}
+
+# TODO: use multiple lines for long arrays
+format_array <- function(tree, id, options) {
+  chdn <- tree$children[[id]]
+
+  if (length(chdn) == 2) {
+    return("[]")
+  }
+
+  chdn <- middle(chdn)
+  elts <- lapply(
+    chdn,
+    format_element,
+    tree = tree,
+    options = options
+  )
+
+  elts <- format_line_comments(tree, elts, chdn)
+  elts <- format_post_process_commas(tree, elts, chdn)
+
+  has_comments <- any(tree$type[chdn] == "comment")
+  if (has_comments) {
+    indent <- format_create_indent(options)
+    c("[", paste0(indent, unlist(elts)), "]")
+  } else {
+    paste0("[ ", paste0(unlist(elts), collapse = ""), " ]")
+  }
+}
+
+format_pair <- function(tree, id, options) {
+  key_chld <- get_subtree(tree, tree$children[[id]][1L], with_root = TRUE)
+  key <- paste(na_omit(tree$code[key_chld]), collapse = "")
+  val <- format_element(tree, tree$children[[id]][3L], options = options)
+  cmt <- if (length(tree$children[[id]]) > 3L) {
+    paste0(
+      " ",
+      format_element(tree, tree$children[[id]][4L], options = options)
+    )
+  }
+  paste0(key, " = ", val, cmt)
+}
+
+format_integer <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_float <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_boolean <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_offset_date_time <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_local_date_time <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_local_date <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_local_time <- function(tree, id, options) {
+  tree$code[id]
+}
+
+format_string <- function(tree, id, options) {
+  chld <- get_subtree(tree, id, with_root = TRUE)
+  paste(na_omit(tree$code[chld]), collapse = "")
+}
+
+format_comment <- function(tree, id, options) {
+  code <- trimws(tree$code[id], "left")
+  paste0(
+    "#",
+    if (substr(code, 2, 2) != " ") {
+      paste0(" ", substr(code, 2, nchar(code)))
+    } else {
+      substr(code, 2, nchar(code))
+    }
+  )
+}
diff --git a/src/library/tstoml/R/ts-tree-insert.R b/src/library/tstoml/R/ts-tree-insert.R
new file mode 100644
index 0000000000..cad09b27dd
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-insert.R
@@ -0,0 +1,623 @@
+#' @ts ts_tree_insert_details_errors
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("a = true\nb = [1, 2, 3]")
+#' toml |> ts_tree_select("a") |> ts_tree_insert("foo")
+#' ```
+#'
+#' @ts ts_tree_insert_details_no_selection
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("a = true\nb = [1, 2, 3]")
+#' toml |> ts_tree_insert(key = "c", new = "foo")
+#' ```
+#'
+#' @ts ts_tree_insert_details_empty_selection
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml("a = true\nb = [1, 2, 3]")
+#' toml |> ts_tree_select("nonexistent") |> ts_tree_insert("foo")
+#' ```
+#'
+#' @export
+
+ts_tree_insert.ts_tree_toml <- function(
+  tree,
+  new,
+  key = NULL,
+  at = Inf,
+  options = NULL,
+  ...
+) {
+  select <- ts_tree_selected_nodes(tree)
+
+  if (length(select) == 0) {
+    return(tree)
+  }
+
+  insertions <- lapply(select, function(sel1) {
+    dom_type <- tree$dom_type[sel1]
+    switch(
+      dom_type,
+      document = {
+        insert_into_document(tree, sel1, new, key = key)
+      },
+      subtable = {
+        insert_into_subtable(tree, sel1, new, key = key)
+      },
+      inline_table = {
+        insert_into_inline_table(tree, sel1, new, key = key, at = at)
+      },
+      table = {
+        insert_into_table(tree, sel1, new, key = key, at = at)
+      },
+      array_of_tables = {
+        insert_into_aot(tree, sel1, new, at = at)
+      },
+      table_array_element = {
+        insert_into_aot_element(tree, sel1, new, key = key, at = at)
+      },
+      array = {
+        insert_into_array(tree, sel1, new, key = key, at = at)
+      },
+      stop(ts_cnd("Cannot insert into a `{dom_type}` TOML element."))
+    )
+  })
+
+  insertions <- insertions[order(map_int(insertions, "[[", "after"))]
+
+  for (ins in insertions) {
+    if (!isFALSE(ins$leading_comma)) {
+      aft <- last_descendant(tree, ins$leading_comma)
+      tree$tws[aft] <- paste0(",", tree$tws[aft])
+    }
+
+    aft <- last_descendant(tree, ins$after)
+    firstchld <- tree$children[[ins$select]][1]
+    # mark first child for reformatting the whole array
+    before_tws <- isTRUE(ins$before_trailing_ws)
+    tree$tws[firstchld] <- paste0(reformat_mark, tree$tws[firstchld])
+    tree$tws[aft] <- paste0(
+      if (!before_tws) tree$tws[aft],
+      ins$code,
+      if (ins$trailing_comma) ", ",
+      if (before_tws) tree$tws[aft],
+      if (ins$trailing_newline) "\n",
+      ins$tws
+    )
+  }
+
+  parts <- c(rbind(tree$code, tree$tws))
+  text <- unlist(lapply(na_omit(parts), charToRaw))
+
+  # get the reformatting positions and remove the marks
+  # (the toml parser does not handle the \f reformatting mark)
+
+  refmt_pos <- grepRaw(reformat_mark, text, fixed = TRUE, all = TRUE)
+  if (length(refmt_pos) > 0) {
+    text <- text[-refmt_pos]
+    refmt_pos <- refmt_pos - seq_along(refmt_pos)
+  }
+
+  # TODO: update coordinates without reparsing
+  new <- ts_parse_toml(text = text)
+  attr(new, "file") <- attr(tree, "file")
+
+  # now reformat the new parts, or the newly non-empty arrays/objects
+  fws <- new$end_byte %in% refmt_pos
+  tofmt2 <- unique(new$parent[which(fws)])
+
+  # do not refortmat the whole document
+  tofmt2 <- setdiff(tofmt2, 1L)
+
+  # auto format then each insertion might need a different format
+  new <- ts_tree_select(new, I(tofmt2))
+  options$insert_empty_line_before_tables <- FALSE
+  new <- ts_tree_format(new, options = options)
+
+  new
+}
+
+last_descendant <- function(toml, node) {
+  while (node != 1 && is.na(toml$code[node])) {
+    node <- utils::tail(toml$children[[node]], 1)
+  }
+  node
+}
+
+last_dom_descendant <- function(toml, node) {
+  while (length(toml$dom_children[[node]]) >= 1) {
+    node <- utils::tail(toml$dom_children[[node]], 1)
+  }
+  node
+}
+
+# this has to be a single byte for TOML!
+reformat_mark <- "\f"
+stopifnot(nchar(reformat_mark, type = "bytes") == 1)
+
+# ------------------------------------------------------------------------------
+
+insert_into_document <- function(toml, sel1, new, key = NULL) {
+  newtype <- get_stl_type(new)
+  newtypename <- stl_type_names[[newtype]]
+  if (is.null(key)) {
+    stop(ts_cnd(
+      "The `key` argument is required when inserting a {newtypename} \\
+       into the document."
+    ))
+  }
+  if (length(key) != 1) {
+    stop(ts_cnd("The `key` argument must be a single string for now."))
+  }
+  chdn <- toml$dom_children[[1]]
+  keys <- toml$dom_name[chdn]
+  if (key %in% keys) {
+    stop(ts_cnd("Key `{key}` already exists in the document."))
+  }
+
+  switch(
+    newtype,
+    "pair" = {
+      insert_into_document_pair(toml, sel1, new, key = key)
+    },
+    "table" = {
+      insert_into_document_table(toml, sel1, new, key = key)
+    },
+    "array_of_tables" = {
+      insert_into_document_aot(toml, sel1, new, key = key)
+    },
+    stop(ts_cnd(
+      "Cannot insert {newtypename} ({newtype)} into document. \\
+       This is an internal error in tstoml"
+    ))
+  )
+}
+
+insert_into_document_pair <- function(toml, sel1, new, key) {
+  # need to put it before the first table or AOT
+  chdn <- toml$children[[1]]
+  wtable <- which(toml$type[chdn] %in% c("table", "table_array_element"))[1]
+  # if no table or AOT, append to the end
+  after <- if (is.na(wtable)) nrow(toml) else chdn[wtable] - 1L
+  code <- paste0(
+    if (nrow(toml) > 1) {
+      "\n"
+    },
+    key,
+    " = ",
+    paste0(ts_serialize_toml_value(new), collapse = "\n")
+  )
+
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = TRUE
+  )
+}
+
+insert_into_document_table <- function(toml, sel1, new, key) {
+  code <- paste0(
+    if (nrow(toml) > 1) {
+      "\n"
+    },
+    paste0(
+      ts_serialize_toml(structure(list(new), names = key)),
+      collapse = "\n"
+    )
+  )
+  list(
+    select = sel1,
+    after = nrow(toml),
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = TRUE
+  )
+}
+
+insert_into_document_aot <- function(toml, sel1, new, key) {
+  code <- paste0(
+    if (nrow(toml) > 1) {
+      "\n"
+    },
+    paste0(
+      ts_serialize_toml(structure(list(new), names = key)),
+      collapse = "\n"
+    )
+  )
+  list(
+    select = sel1,
+    after = nrow(toml),
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = TRUE
+  )
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_subtable <- function(toml, sel1, new, key = key) {
+  newtype <- get_stl_type(new)
+  newtypename <- stl_type_names[[newtype]]
+  if (is.null(key)) {
+    stop(ts_cnd(
+      "The `key` argument is required when inserting a {newtypename} \\
+       into a subtable."
+    ))
+  }
+  if (length(key) != 1) {
+    stop(ts_cnd("The `key` argument must be a single string for now."))
+  }
+  chdn <- toml$dom_children[[sel1]]
+  keys <- toml$dom_name[chdn]
+  if (key %in% keys) {
+    stop(ts_cnd("Key `{key}` already exists in the subtable."))
+  }
+
+  # check if the subtable was created from the key of a pair or table/AOT
+  pkey <- sel1
+  while (toml$type[pkey] %in% key_types) {
+    pkey <- toml$parent[pkey]
+  }
+
+  # the key is the key of the subtable plus the new key
+  newkey <- key
+  dompkey <- sel1
+  while (toml$type[dompkey] %in% key_types) {
+    newkey <- c(unserialize_key(toml, dompkey), newkey)
+    dompkey <- toml$dom_parent[dompkey]
+  }
+
+  if (toml$type[pkey] == "pair") {
+    after <- last_descendant(
+      toml,
+      last_dom_descendant(toml, chdn[length(chdn)])
+    )
+    trailing_newline <- FALSE
+  } else {
+    # we cannot create a table with the key of sel1, and a bare key in that
+    # because the Rust parser might not parse that. E.g.
+    # a.y = 100
+    # [a]
+    # x = 100
+    # [a.b]
+    # c.d.e = 1
+    # does not parse (just insertd the [a] table here).
+    # So we create a dotted pair at the beginning of the document, before
+    # all tables and AOTs
+    dchdn <- toml$children[[1]]
+    wtable <- which(toml$type[dchdn] %in% c("table", "table_array_element"))[1]
+    after <- if (is.na(wtable)) nrow(toml) else dchdn[wtable] - 1L
+    trailing_newline <- TRUE
+  }
+
+  code <- paste0(
+    if (after != 1L) "\n",
+    ts_toml_key(newkey),
+    " = ",
+    paste0(ts_serialize_toml_value(new), collapse = "\n")
+  )
+
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    # there must be a trailing newline after the table already
+    trailing_newline = trailing_newline,
+    before_trailing_ws = TRUE
+  )
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_inline_table <- function(toml, sel1, new, key = key, at = at) {
+  newtype <- get_stl_type(new)
+  newtypename <- stl_type_names[[newtype]]
+  if (is.null(key)) {
+    stop(ts_cnd(
+      "The `key` argument is required when inserting a {newtypename} \\
+       into an inline table."
+    ))
+  }
+  if (length(key) != 1) {
+    stop(ts_cnd("The `key` argument must be a single string for now."))
+  }
+  chdn <- toml$dom_children[[sel1]]
+  keys <- toml$dom_name[chdn]
+  if (key %in% keys) {
+    stop(ts_cnd("Key `{key}` already exists in the inline table."))
+  }
+
+  chdn <- toml$children[[sel1]]
+  isxtr <- toml$type[chdn] != "pair"
+  idx <- seq_along(chdn)[!isxtr]
+  nchdn <- length(idx)
+
+  if (is.character(at)) {
+    if (length(at) != 1) {
+      stop(ts_cnd("The `at` argument must be a single string for now."))
+    }
+    rchdn <- chdn[toml$type[chdn] == "pair"]
+    keys <- map_chr(rchdn, function(id) {
+      keyid <- toml$children[[id]][1]
+      unserialize_key(toml, keyid)
+    })
+    at <- match(at, keys)
+    if (is.na(at)) {
+      at <- Inf
+    }
+  }
+
+  after_comma <- after <- if (at < 1 || nchdn == 0) {
+    1
+  } else if (at >= nchdn) {
+    idx[nchdn]
+  } else {
+    idx[at]
+  }
+
+  # Comments are not allowed inside inline tables, so we don't need to
+  # deal with them here.
+
+  # skip comma
+  if (toml$type[chdn[after + 1L]] == ",") {
+    after <- after + 1L
+  }
+
+  code <- paste0(key, " = ", ts_serialize_toml_value(new))
+
+  add_leading_comma <- at >= nchdn && nchdn > 0
+  add_trailing_comma <- (at < nchdn && nchdn > 0)
+
+  list(
+    select = sel1,
+    after = chdn[after],
+    code = paste0(code, collapse = "\n"),
+    # need a leading comma if inserting at the end into non-empty array
+    leading_comma = if (add_leading_comma) chdn[after_comma] else FALSE,
+    # need a trailing comma everywhere except at the end or in an empty array
+    trailing_comma = add_trailing_comma,
+    trailing_newline = toml$type[chdn[after + 1L]] == "comment"
+  )
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_table <- function(toml, sel1, new, key = key, at = at) {
+  newtype <- get_stl_type(new)
+  newtypename <- stl_type_names[[newtype]]
+  if (is.null(key)) {
+    stop(ts_cnd(
+      "The `key` argument is required when inserting a {newtypename} \\
+       into a table."
+    ))
+  }
+  if (length(key) != 1) {
+    stop(ts_cnd("The `key` argument must be a single string for now."))
+  }
+  chdn <- toml$dom_children[[sel1]]
+  keys <- toml$dom_name[chdn]
+  if (key %in% keys) {
+    stop(ts_cnd("Key `{key}` already exists in the table."))
+  }
+
+  switch(
+    newtype,
+    "pair" = {
+      insert_into_table_pair(toml, sel1, new, key = key)
+    },
+    "table" = {
+      insert_into_table_table(toml, sel1, new, key = key)
+    },
+    "array_of_tables" = {
+      insert_into_table_aot(toml, sel1, new, key = key)
+    },
+    stop(ts_cnd(
+      "Cannot insert {newtypename} ({newtype)} into table. \\
+       This is an internal error in tstoml"
+    ))
+  )
+}
+
+insert_into_table_pair <- function(toml, sel1, new, key) {
+  #  we also this for aot elements
+  tid <- if (toml$type[sel1] == "table") {
+    sel1
+  } else {
+    toml$parent[sel1]
+  }
+  after <- last_descendant(toml, tid)
+  code <- paste0(
+    "\n",
+    key,
+    " = ",
+    paste0(ts_serialize_toml_value(new), collapse = "\n")
+  )
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    # there must be a trailing newline after the table already
+    trailing_newline = FALSE,
+    before_trailing_ws = TRUE
+  )
+}
+
+insert_into_table_table <- function(toml, sel1, new, key) {
+  #  we also this for aot elements
+  tid <- if (toml$type[sel1] == "table") {
+    sel1
+  } else {
+    toml$parent[sel1]
+  }
+  after <- last_descendant(toml, tid)
+  keyid <- toml$children[[tid]][2]
+  newkey <- ts_toml_key(c(unserialize_key(toml, keyid), key))
+  code <- paste0(
+    "\n\n",
+    paste0(
+      ts_serialize_toml(structure(list(new), names = newkey)),
+      collapse = "\n"
+    )
+  )
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = FALSE,
+    before_trailing_ws = TRUE
+  )
+}
+
+insert_into_table_aot <- function(toml, sel1, new, key) {
+  #  we also this for aot elements
+  tid <- if (toml$type[sel1] == "table") {
+    sel1
+  } else {
+    toml$parent[sel1]
+  }
+  after <- last_descendant(toml, tid)
+  keyid <- toml$children[[tid]][2]
+  newkey <- ts_toml_key(c(unserialize_key(toml, keyid), key))
+  code <- paste0(
+    "\n\n",
+    paste0(
+      ts_serialize_toml(structure(list(new), names = newkey)),
+      collapse = "\n"
+    )
+  )
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = FALSE,
+    before_trailing_ws = TRUE
+  )
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_aot <- function(toml, sel1, new, at = Inf) {
+  chdn <- toml$dom_children[[sel1]]
+  after <- if (at < 1) {
+    leading_newline <- FALSE
+    sel1 - 1L
+  } else if (at >= length(chdn)) {
+    leading_newline <- TRUE
+    last_descendant(toml, toml$parent[chdn[length(chdn)]])
+  } else {
+    leading_newline <- FALSE
+    last_descendant(toml, toml$parent[chdn[at]])
+  }
+
+  key <- unserialize_key(toml, toml$children[[sel1]][2])
+  code <- paste0(
+    if (leading_newline) "\n",
+    "[[",
+    key,
+    "]]\n",
+    paste(stl_table_body(new), collapse = "\n"),
+    "\n"
+  )
+
+  list(
+    select = sel1,
+    after = after,
+    code = code,
+    leading_comma = FALSE,
+    trailing_comma = FALSE,
+    trailing_newline = after != nrow(toml)
+  )
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_aot_element <- function(toml, sel1, new, key = key, at = at) {
+  insert_into_table(toml, sel1, new, key = key, at = at)
+}
+
+# ------------------------------------------------------------------------------
+
+insert_into_array <- function(toml, sel1, new, key = key, at = at) {
+  # this is complicated by comments inside the array
+  # we need to build an index to map non-comment children to actual children
+  # we might as well treat the [ ] and comma nodes the same way
+  chdn <- toml$children[[sel1]]
+  isxtr <- toml$type[chdn] %in% c("comment", "[", "]", ",")
+  idx <- seq_along(chdn)[!isxtr]
+  nchdn <- length(idx)
+
+  after_comma <- after <- if (at < 1 || nchdn == 0) {
+    1
+  } else if (at >= nchdn) {
+    idx[nchdn]
+  } else {
+    idx[at]
+  }
+
+  if (
+    toml$type[chdn[after + 1L]] == "," &&
+      toml$type[chdn[after + 2L]] == "comment" &&
+      toml$end_row[chdn[after + 1L]] == toml$start_row[chdn[after + 2L]]
+  ) {
+    # skip comma + comment on the same line!
+    after <- after + 2L
+  } else if (
+    toml$type[chdn[after + 1L]] == "comment" &&
+      toml$end_row[chdn[after]] == toml$start_row[chdn[after + 1L]]
+  ) {
+    # skip comment on the same line
+    after <- after + 1L
+    # maybe more comments
+    while (toml$type[chdn[after + 1L]] == "comment") {
+      after <- after + 1L
+    }
+    # maybe a comma
+    if (toml$type[chdn[after + 1L]] == ",") {
+      after <- after + 1L
+    }
+  } else if (toml$type[chdn[after + 1L]] == ",") {
+    # skip comma w/o comment on the same line
+    # keep non-line comment as non-line comment
+    after <- after + 1L
+  } else {
+    # skip comments and potentially a comma
+    while (toml$type[chdn[after + 1L]] == "comment") {
+      after <- after + 1L
+    }
+    if (toml$type[chdn[after + 1L]] == ",") {
+      after <- after + 1L
+    }
+  }
+
+  # handle appending when there is a trailig comma
+  chdnx <- chdn[toml$type[chdn] != "comment"]
+  has_trailing_comma <- toml$type[rev(chdnx)][2] == ","
+  add_leading_comma <- !has_trailing_comma && at >= nchdn && nchdn > 0
+  add_trailing_comma <- (at < nchdn && nchdn > 0) ||
+    (at >= nchdn && has_trailing_comma)
+
+  list(
+    select = sel1,
+    after = chdn[after],
+    code = ts_serialize_toml_value(new),
+    # need a leading comma if inserting at the end into non-empty array
+    leading_comma = if (add_leading_comma) chdn[after_comma] else FALSE,
+    # need a trailing comma everywhere except at the end or in an empty array
+    trailing_comma = add_trailing_comma,
+    trailing_newline = toml$type[chdn[after + 1L]] == "comment"
+  )
+}
diff --git a/src/library/tstoml/R/ts-tree-new.R b/src/library/tstoml/R/ts-tree-new.R
new file mode 100644
index 0000000000..e1247320be
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-new.R
@@ -0,0 +1,349 @@
+#' @export
+#'
+#' @ts ts_tree_new_examples TOML examples
+#'
+#' ```{asciicast}
+#' toml <- ts::ts_tree_new(
+#'   tstoml::ts_language_toml(),
+#'   text = "[table]\nkey = \"value\""
+#' )
+#' toml
+#' ```
+#'
+#' @ts ts_tree_select_refine TOML example
+#'
+#' ```{asciicast}
+#' #| results = "hide"
+#' toml <- tstoml::ts_parse_toml(
+#'   '[table]\na = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = [] }\n'
+#' )
+#' toml <- toml |> ts_tree_select("table", "b")
+#' ```
+#'
+#' ```{asciicast}
+#' # selects the first two elements in the document node, ie. "table"
+#' toml |> ts_tree_select(1:2)
+#' ```
+#'
+#' ```{asciicast}
+#' # selects the first two elements inside "table" and "b"
+#' toml |> ts_tree_select(1:2, refine = TRUE)
+#' ```
+#'
+#' @ts ts_tree_select_set TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   '[table]\na = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = [] }\n'
+#' )
+#' toml
+#' ```
+#'
+#' ```{asciicast}
+#' toml |> ts_tree_select("table", "b", 1)
+#' ```
+#'
+#' ```{asciicast}
+#' ts_tree_select(toml, "table", "b", 1) <- 100
+#' toml
+#' ```
+#'
+#' @ts ts_tree_select_brackets TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   '[table]\na = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = [] }\n'
+#' )
+#' toml |> ts_tree_select("table", "b", 1)
+#' ```
+#'
+#' ```{asciicast}
+#' toml[[list("table", "b", 1)]]
+#' ```
+#'
+#' @ts ts_tree_select_brackets_set TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   '[table]\na = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = [] }\n'
+#' )
+#' toml
+#' ```
+#'
+#' ```{asciicast}
+#' toml |> ts_tree_select("table", "b", 1)
+#' ```
+#'
+#' ```{asciicast}
+#' toml[[list("table", "b", 1)]] <- 100
+#' toml
+#' ```
+
+ts_tree_new.ts_language_toml <- function(
+  language,
+  file = NULL,
+  text = NULL,
+  ranges = NULL,
+  fail_on_parse_error = TRUE,
+  options = NULL,
+  ...
+) {
+  if (!missing(options)) {
+    ts_check_named_arg(options)
+  }
+  options <- as_tstoml_options(options)
+
+  tree <- NextMethod()
+
+  # this is a workarond for TS adding code to a non-terminal array/object node
+  tree$code[tree$type %in% c("array", "inline_table")] <- NA_character_
+
+  tree <- add_dom(tree)
+
+  tree
+}
+
+# ------------------------------------------------------------------------------
+
+encode_key <- function(key) {
+  paste0(".", paste0(nchar(key, type = "bytes"), ":", key, collapse = "."))
+}
+
+add_dom <- function(tab) {
+  tab$dom_parent <- rep(NA_integer_, nrow(tab))
+  tab$dom_type <- rep(NA_character_, nrow(tab))
+  tab$dom_type[1] <- "document"
+  tab$dom_name <- rep(NA_character_, nrow(tab))
+  dict <- new.env(parent = emptyenv())
+  current_table <- 1L
+  current_prefix <- character()
+
+  check_sub_keys <- function(key, prefix = NULL) {
+    ec <- if (length(prefix) == 0) "" else encode_key(prefix)
+    for (idx in seq_along(key$key[-1])) {
+      ec <- paste0(ec, encode_key(key$key[idx]))
+      rec <- dict[[ec]]
+      if (is.null(rec)) {
+        dict[[ec]] <- rec <- list(id = key$ids[[idx]], type = "subtable")
+        tab$dom_parent[key$ids[[idx]]] <<- current_table
+        tab$dom_name[key$ids[[idx]]] <<- key$key[idx]
+        tab$dom_type[key$ids[[idx]]] <<- "subtable"
+      } else if (rec$type == "pair") {
+        stop(ts_cnd(
+          "Cannot define subtable under pair: \\
+          {paste(c(prefix, key$key[1:idx]), collapse = '.')}."
+        ))
+      }
+      current_table <<- rec$id
+      current_prefix <<- key$key[1:idx]
+    }
+  }
+
+  add_dom_pair <- function(id) {
+    current_table_save <- current_table
+    current_prefix_save <- current_prefix
+    # make sure subtables exist
+    key <- unserialize_key_with_ids(tab, tab$children[[id]][1])
+    check_sub_keys(key, prefix = current_prefix_save)
+
+    # check for duplicate keys
+    ec <- encode_key(c(current_prefix_save, key$key))
+    rec <- dict[[ec]]
+    if (!is.null(rec)) {
+      stop(ts_cnd(
+        "Duplicate key definition: {paste(key$key, collapse = '.')}."
+      ))
+    } else {
+      dict[[ec]] <- list(id = id, type = "pair")
+    }
+
+    # add pair to current table
+    tab$dom_parent[id] <<- current_table
+    tab$dom_name[id] <<- last(key$key)
+    tab$dom_type[id] <<- "pair"
+    tab$dom_parent[tab$children[[id]][3]] <<- id
+    tab$dom_type[tab$children[[id]][3]] <<- "value"
+    current_table <<- current_table_save
+    current_prefix <<- current_prefix_save
+  }
+
+  add_dom_table <- function(id) {
+    # make sure subtables exist, create if not
+    current_table <<- 1L
+    current_prefix <<- character()
+    key <- unserialize_key_with_ids(tab, tab$children[[id]][2])
+    check_sub_keys(key)
+
+    # create new table of upgrade a subtable to a table
+    ec <- encode_key(key$key)
+    rec <- dict[[ec]]
+    if (is.null(rec)) {
+      dict[[ec]] <- rec <- list(id = id, type = "table")
+      tab$dom_parent[id] <<- current_table
+      tab$dom_name[id] <<- last(key$key)
+      tab$dom_type[id] <<- "table"
+    } else if (rec$type == "subtable") {
+      dict[[ec]] <- list(id = rec$id, type = "table")
+    } else if (rec$type == "table") {
+      stop(ts_cnd(
+        "Duplicate table definition: {paste(key$key, collapse = '.')}."
+      ))
+    } else {
+      stop(ts_cnd(
+        "Cannot redefine array of tables as table: \\
+        {paste(key$key, collapse = '.')}."
+      ))
+    }
+    # this is the current table now
+    current_table <<- rec$id
+    current_prefix <<- key$key
+  }
+
+  add_dom_table_array_element <- function(id) {
+    # make sure subtables exist, create if not
+    current_table <<- 1L
+    current_prefix <<- character()
+    key <- unserialize_key_with_ids(tab, tab$children[[id]][2])
+    check_sub_keys(key)
+
+    # create new array of tables if it does not exist
+    element_id <- tab$children[[id]][2]
+    ec <- encode_key(key$key)
+    rec <- dict[[ec]]
+    if (is.null(rec)) {
+      dict[[ec]] <- rec <- list(id = element_id, type = "array_of_tables")
+      tab$dom_parent[id] <<- current_table
+      tab$dom_name[id] <<- last(key$key)
+      tab$dom_type[id] <<- "array_of_tables"
+      tab$dom_parent[element_id] <<- id
+      tab$dom_type[element_id] <<- "table_array_element"
+    } else if (rec$type == "array_of_tables") {
+      nms <- ls(dict, all.names = TRUE)
+      subs <- nms[startsWith(nms, paste0(ec, "."))]
+      rm(list = subs, envir = dict)
+      tab$dom_parent[element_id] <<- tab$dom_parent[rec$id]
+      tab$dom_type[element_id] <<- "table_array_element"
+      rec$id <- element_id
+      dict[[ec]] <- rec
+    } else {
+      stop(ts_cnd(
+        "Cannot redefine table as array of tables: \\
+        {paste(key$key, collapse = '.')}."
+      ))
+    }
+
+    current_table <<- element_id
+    current_prefix <<- key$key
+  }
+
+  tables <- c(1L, which(tab$type %in% c("table", "table_array_element")))
+  tabchld <- unlist(tab$children[tables])
+  pairs <- tabchld[tab$type[tabchld] == "pair"]
+  todo <- sort(c(tables, pairs))
+
+  for (i in todo) {
+    switch(
+      tab$type[i],
+      pair = {
+        add_dom_pair(i)
+      },
+      table = {
+        add_dom_table(i)
+      },
+      table_array_element = {
+        add_dom_table_array_element(i)
+      }
+    )
+  }
+
+  check_inline_table <- function(id) {
+    # We can use a local dictionary for each inline table
+    dict <- new.env(parent = emptyenv())
+    children <- tab$children[[id]]
+    pairs <- children[tab$type[children] == "pair"]
+
+    check_keys <- function(key) {
+      ec <- ""
+      for (idx in seq_along(key$key[-1])) {
+        ec <- paste0(ec, encode_key(key$key[idx]))
+        rec <- dict[[ec]]
+        if (is.null(rec)) {
+          dict[[ec]] <- rec <- list(id = key$ids[[idx]], type = "subtable")
+          tab$dom_parent[key$ids[[idx]]] <<- parent
+          tab$dom_name[key$ids[[idx]]] <<- key$key[idx]
+          tab$dom_type[key$ids[[idx]]] <<- "subtable"
+        } else if (rec$type == "pair") {
+          stop(ts_cnd(
+            "Cannot define subtable under pair in inline table: \\
+            {paste(key$key[1:idx], collapse = '.')}."
+          ))
+        }
+        parent <<- rec$id
+      }
+    }
+
+    for (p in pairs) {
+      parent <- id
+      key <- unserialize_key_with_ids(tab, tab$children[[p]][1])
+      check_keys(key)
+      ec <- encode_key(key$key)
+      rec <- dict[[ec]]
+      if (!is.null(rec)) {
+        stop(ts_cnd(
+          "Duplicate key definition in inline table: \\
+          {paste(key$key, collapse = '.')}."
+        ))
+      } else {
+        rec <- dict[[ec]] <- list(id = p, type = "pair")
+      }
+      tab$dom_parent[p] <<- parent
+      tab$dom_name[p] <<- last(key$key)
+      tab$dom_type[p] <<- "pair"
+      tab$dom_parent[tab$children[[p]][3]] <<- p
+      tab$dom_type[tab$children[[p]][3]] <<- "value"
+    }
+  }
+
+  for (i in which(tab$type == "inline_table")) {
+    tab$dom_type[i] <- "inline_table"
+    check_inline_table(i)
+  }
+
+  # wire up arrays as well
+  for (i in which(tab$type == "array")) {
+    tab$dom_type[i] <- "array"
+    children <- tab$children[[i]]
+    children <- children[!tab$type[children] %in% c("[", "]", ",", "comment")]
+    for (cx in seq_along(children)) {
+      el <- children[cx]
+      tab$dom_parent[el] <- i
+      if (is.na(tab$dom_type[el])) tab$dom_type[el] <- "value"
+    }
+  }
+
+  # pairs should not be in the DOM
+  parent_is_pair <- which(tab$dom_type[tab$dom_parent] == "pair")
+  pairs <- tab$dom_parent[parent_is_pair]
+  tab$dom_parent[parent_is_pair] <- tab$dom_parent[pairs]
+  tab$dom_name[parent_is_pair] <- tab$dom_name[pairs]
+  tab$dom_type[pairs] <- NA_character_
+  tab$dom_name[pairs] <- NA_character_
+  tab$dom_parent[pairs] <- NA_integer_
+
+  # add dom_children
+  lvls <- seq_len(nrow(tab))
+  tab$dom_children <- I(unname(split(
+    lvls,
+    factor(tab$dom_parent, levels = lvls)
+  )))
+
+  # name dom_children
+  for (i in seq_len(nrow(tab))) {
+    nmsi <- tab$dom_name[tab$dom_children[[i]]]
+    if (length(nmsi) > 0 && any(!is.na(nmsi))) {
+      names(tab$dom_children[[i]]) <- tab$dom_name[tab$dom_children[[i]]]
+    }
+  }
+
+  tab
+}
diff --git a/src/library/tstoml/R/ts-tree-query.R b/src/library/tstoml/R/ts-tree-query.R
new file mode 100644
index 0000000000..327f50b2cb
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-query.R
@@ -0,0 +1,40 @@
+#' Run tree-sitter queries on TOML tree-sitter trees
+#'
+#' @usage
+#' \method{ts_tree_query}{ts_tree_toml}(tree, query)
+#'
+#' @description
+#' \eval{ts:::doc_insert("ts_tree_query_description", "tsjtoml")}
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts_tree_query_details", "tsjtoml")}
+#' \eval{ts:::doc_extra()}
+#'
+#' @ts ts_tree_query_details_examples
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   'a = 1\nb = [10.0, 20, 30]\nc = { c1 = true, c2 = 100 }'
+#' )
+#' toml |> ts_tree_query("[(float) (integer)] @number")
+#' ```
+#'
+#' @param tree
+#' \eval{ts:::doc_insert("ts_tree_query_param_tree", "tsjtoml")}
+#' @param query
+#' \eval{ts:::doc_insert("ts_tree_query_param_query", "tsjtoml")}
+#'
+#' @return \eval{ts:::doc_insert("ts_tree_query_return", "tsjtoml")}
+#'
+#' @export
+#' @examples
+#' # Select all numbers in a TOML document ------------------------------------
+#' library(ts)
+#' toml <- tstoml::ts_parse_toml(
+#'   'a = 1\nb = [10.0, 20, 30]\nc = { c1 = true, c2 = 100 }'
+#' )
+#' toml |> ts_tree_query("[(float) (integer)] @number")
+
+ts_tree_query.ts_tree_toml <- function(tree, query) {
+  NextMethod()
+}
diff --git a/src/library/tstoml/R/ts-tree-select.R b/src/library/tstoml/R/ts-tree-select.R
new file mode 100644
index 0000000000..98ad60178e
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-select.R
@@ -0,0 +1,216 @@
+#' @ts ts_tree_select_true TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml('
+#'   a = 1
+#'   b = [10, 20, 30]
+#'   [c]
+#'   c1 = true
+#'   c2 = []
+#' ')
+#' toml |> ts_tree_select(c("b", "c"), TRUE)
+#' ```
+#'
+#' @ts ts_tree_select_character TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml('
+#'   a = 1
+#'   b = [10, 20, 30]
+#'   [c]
+#'   c1 = true
+#'   c2 = []
+#' ')
+#' toml |> ts_tree_select(c("a", "c"), "c1")
+#' ```
+#'
+#' @ts ts_tree_select_integer TOML example
+#'
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml('
+#'   a = 1
+#'   b = [10, 20, 30]
+#'   [c]
+#'   c1 = true
+#'   c2 = []
+#' ')
+#' toml |> ts_tree_select(c("b", "c"), -1)
+#' ```
+#'
+#' @ts ts_tree_select_regex TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'  'apple = 1\nalmond = 2\nbanana = 3\ncherry = 4\n'
+#' )
+#' toml |> ts_tree_select(regex = "^a")
+#' ```
+#'
+#' @ts ts_tree_select_tsquery TOML example
+#'
+#' See [tstoml::ts_language_toml()] for details on the TOML grammar.
+#'
+#' <p>
+#'
+#' This example selects all integers in the TOML document.
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   'a = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = 100 }\n'
+#' )
+#' toml |> ts_tree_select(query = "(integer) @integer")
+#' ```
+#'
+#' @ts ts_tree_select_ids TOML example
+#'
+#' ```{asciicast}
+#' toml <- tstoml::ts_parse_toml(
+#'   'a = 1\nb = [10, 20, 30]\nc = { c1 = true, c2 = [] }\n'
+#' )
+#' ts_tree_dom(toml)
+#' ```
+#'
+#' ```{asciicast}
+#' toml |> ts_tree_select(I(9))
+#' ```
+#'
+#' @ts ts_tree_select_examples TOML examples
+#'
+#' ## Examples
+#'
+#' ```{asciicast}
+#' #| results: hide
+#' txt <- r"(
+#' # This is a TOML document
+#'
+#' title = "TOML Example"
+#'
+#' [owner]
+#' name = "Tom Preston-Werner"
+#' dob = 1979-05-27T07:32:00-08:00
+#'
+#' [database]
+#' enabled = true
+#' ports = [ 8000, 8001, 8002 ]
+#' data = [ ["delta", "phi"], [3.14] ]
+#' temp_targets = { cpu = 79.5, case = 72.0 }
+#'
+#' [servers]
+#'
+#' [servers.alpha]
+#' ip = "10.0.0.1"
+#' role = "frontend"
+#'
+#' [servers.beta]
+#' ip = "10.0.0.2"
+#' role = "backend"
+#' )"
+#' toml <- ts_parse_toml(text = txt)
+#' ```
+#'
+#' Pretty print a tstoml object:
+#'
+#' ```{asciicast}
+#' #| label: print-toml
+#' toml
+#' ```
+#'
+#' Select elements in a tstoml object
+#'
+#' ```{asciicast}
+#' #| label: select-table
+#' ts_tree_select(toml, "owner")
+#' ```
+#'
+#' Select element(s) inside elements:
+#'
+#' ```{asciicast}
+#' #| label: select-select
+#' ts_tree_select(toml, "owner", "name")
+#' ```
+#'
+#' Select element(s) of an array:
+#'
+#' ```{asciicast}
+#' #| label: select-array
+#' ts_tree_select(toml, "database", "ports", 1:2)
+#' ```
+#'
+#' Select multiple keys from a table:
+#'
+#' ```{asciicast}
+#' #| label: select-multiple
+#' ts_tree_select(toml, "owner", c("name", "dob"))
+#' ```
+NULL
+
+#' @export
+
+ts_tree_select1.ts_tree_toml.ts_tree_selector_default <- function(
+  tree,
+  node,
+  slt
+) {
+  1L
+}
+
+#' @export
+
+ts_tree_mark_selection1.ts_tree_toml <- function(tree, node) {
+  parent <- tree$parent[node]
+  if (tree$type[node] == "table_array_element") {
+    tree$parent[tree$dom_children[[node]]]
+  } else if (
+    !is.na(parent) &&
+      tree$type[parent] == "table_array_element" &&
+      tree$type[node] %in% c("bare_key", "quoted_key", "dotted_key")
+  ) {
+    # this is AOT _element_, select it like a table, but not the [[ ]] tokens
+    tree$children[[parent]][c(-1, -3)]
+  } else if (tree$type[node] %in% c("bare_key", "quoted_key")) {
+    get_dom_subtree(tree, node, with_root = FALSE)
+  } else {
+    node
+  }
+}
+
+get_dom_subtree <- function(tree, id, with_root = FALSE) {
+  sel <- c(if (with_root) id, tree$dom_children[[id]])
+  while (TRUE) {
+    sel2 <- unique(c(sel, unlist(tree$dom_children[sel])))
+    if (length(sel2) == length(sel)) {
+      return(sel)
+    }
+    sel <- sel2
+  }
+}
+
+#' @title
+#' Select parts of a TOML tree-sitter tree
+#' @usage
+#' \method{ts_tree_select}{ts_tree_toml}(tree, ..., refine = FALSE)
+#' @param tree
+#' \eval{ts:::doc_insert("ts::ts_tree_select_param_tree", "tstoml")}
+#' @param ...
+#' \eval{ts:::doc_insert("ts::ts_tree_select_param_dots", "tstoml")}
+#' @param refine
+#' \eval{ts:::doc_insert("ts::ts_tree_select_param_refine", "tstoml")}
+#' @return
+#' \eval{ts:::doc_insert("ts::ts_tree_select_return", "tstoml")}
+#'
+#' @description
+#' \eval{ts:::doc_insert("ts::ts_tree_select_description", "tstoml")}
+#'
+#' This is the S3 method of the [ts::ts_tree_select()] generic,
+#' for [tstoml] objects.
+#'
+#' @details
+#' \eval{ts:::doc_insert("ts::ts_tree_select_details", "tstoml")}
+#' \eval{ts:::doc_insert("tstoml::ts_tree_select_examples", "tstoml")}
+#' \eval{ts:::doc_extra()}
+#' @export
+
+ts_tree_select.ts_tree_toml <- function(tree, ..., refine = FALSE) {
+  NextMethod()
+}
diff --git a/src/library/tstoml/R/ts-tree-unserialize.R b/src/library/tstoml/R/ts-tree-unserialize.R
new file mode 100644
index 0000000000..33e054692e
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-unserialize.R
@@ -0,0 +1,32 @@
+#' @ts ts_tree_unserialize_details_no_selection
+#'
+#' ```{asciicast}
+#' #| results = "hide"
+#' tree <- tstoml::ts_parse_toml(
+#' "a = 1\nb = [10.0, 20, 30]\nc = { c1 = true, c2 = [] }"
+#' )
+#' ```
+#'
+#' ```{asciicast}
+#' ts_tree_unserialize(tree)
+#' ```
+#'
+#' @ts ts_tree_unserialize_details_empty_selection
+#'
+#' ```{asciicast}
+#' #| results = "hide"
+#' tree <- tstoml::ts_parse_toml(
+#'   "a = 1\nb = [10.0, 20, 30]\nc = { c1 = true, c2 = [] }"
+#' )
+#' ```
+#'
+#' ```{asciicast}
+#' tree |> ts_tree_select("nope") |> ts_tree_unserialize()
+#' ```
+#'
+#' @export
+
+ts_tree_unserialize.ts_tree_toml <- function(tree) {
+  sel <- ts_tree_selected_nodes(tree)
+  as.list(lapply(sel, unserialize_element, tree = tree))
+}
diff --git a/src/library/tstoml/R/ts-tree-update.R b/src/library/tstoml/R/ts-tree-update.R
new file mode 100644
index 0000000000..3eb05ad397
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-update.R
@@ -0,0 +1,122 @@
+#' Replace selected TOML values with new content
+#'
+#' Replace all selected elements with a new element. If `toml` has no
+#' selection then the whole document is replaced. If `toml` has an empty
+#' selection, then nothing happens.
+#'
+# TODO: this does not work yet https://github.com/gaborcsardi/tstoml/issues/6
+# @ts ts_tree_update_details_no_selection
+#
+# ```{asciicast}
+# tree <- tstoml::ts_parse_toml("a = true\nb = [1, 2, 3]")
+# tree |> ts_tree_update(as.list(4:6))
+# ```
+#
+#' @ts ts_tree_update_details_empty_selection
+#'
+#' ```{asciicast}
+#' tree <- tstoml::ts_parse_toml("a = true\nb = [1, 2, 3]")
+#' tree |> ts_tree_select("new") |> ts_tree_update(as.list(4:6))
+#' ```
+#'
+#' @param tree A tstoml object
+#' @param new A R object to be converted to TOML using [ts_serialize_toml_value()]
+#'  and used as the new value.
+#' @param options A named list of `tstoml` options, see
+#'   [tstoml_options()]. Passed to [ts_serialize_toml_value()].
+#' @param ... Reserved for future use.
+#' @export
+#' @keywords internal
+
+ts_tree_update.ts_tree_toml <- function(tree, new, options = NULL, ...) {
+  if (!missing(options)) {
+    ts_check_named_arg(options)
+  }
+  options <- as_tstoml_options(options)
+
+  selection <- ts_tree_selection(tree)
+  ptr <- length(selection)
+  select <- selection[[ptr]]$nodes
+
+  # if no selection, then maybe this is an insert
+  if (length(select) == 0) {
+    while (length(selection[[ptr]]$nodes) == 0) {
+      slt <- selection[[ptr]]$selector
+      # only if characters
+      if (inherits(slt, "ts_tree_selector") || !is.character(slt)) {
+        return(tree)
+      }
+      ptr <- ptr - 1L
+      new <- structure(
+        replicate(length(slt), new, simplify = FALSE),
+        names = slt
+      )
+    }
+    attr(tree, "selection") <- selection[1:ptr]
+    return(ts_tree_insert(tree, new[[1]], key = names(new)))
+  }
+
+  types <- tree$type[select]
+  if (any(!types %in% value_types)) {
+    stop(ts_cnd(
+      "Can only update values ({ts_collapse(value_types)})."
+    ))
+  }
+
+  fmt <- replicate(
+    length(select),
+    ts_serialize_toml_value(new, options = options),
+    simplify = FALSE
+  )
+
+  # keep original indentation at the start row
+  for (i in seq_along(select)) {
+    sel1 <- select[i]
+    prevline <- rev(which(tree$end_row == tree$start_row[sel1] - 1))[1]
+    ind0 <- sub("^.*\n", "", tree$tws[prevline])
+    if (!is.na(prevline)) {
+      fmt[[i]] <- paste0(c("", rep(ind0, length(fmt[[i]]) - 1L)), fmt[[i]])
+    }
+  }
+
+  subtrees <- lapply(select, get_dom_subtree, tree = tree, with_root = TRUE)
+  subtrees <- lapply(subtrees, function(st) {
+    unlist(lapply(st, get_subtree, tree = tree, with_root = TRUE))
+  })
+  deleted <- unique(unlist(subtrees))
+
+  # need to keep the trailing ws of the last element
+  lasts <- map_int(subtrees, max_or_na)
+  tws <- tree$tws[lasts]
+  tree$code[deleted] <- NA_character_
+  tree$tws[deleted] <- NA_character_
+
+  # keep select nodes to inject the new elements
+  tree$code[select] <- paste0(
+    map_chr(fmt, paste, collapse = "\n"),
+    ifelse(is.na(tws), "", tws)
+  )
+  tree$tws[select] <- NA_character_
+
+  parts <- c(rbind(tree$code, tree$tws))
+  text <- unlist(lapply(na_omit(parts), charToRaw))
+
+  # TODO: update coordinates without reparsing
+  new <- ts_parse_toml(text = text)
+  attr(new, "file") <- attr(tree, "file")
+
+  new
+}
+
+value_types <- c(
+  "string",
+  "integer",
+  "float",
+  "boolean",
+  "offset_date_time",
+  "local_date_time",
+  "local_date",
+  "local_time",
+  "array",
+  "inline_table"
+)
diff --git a/src/library/tstoml/R/ts-tree-write.R b/src/library/tstoml/R/ts-tree-write.R
new file mode 100644
index 0000000000..350d1dbafa
--- /dev/null
+++ b/src/library/tstoml/R/ts-tree-write.R
@@ -0,0 +1,15 @@
+#' @ts ts_tree_write_details_file
+#'
+#' Format a TOML file:
+#'
+#' ```{r}
+#' #| eval = FALSE
+#' tree <- tstoml::ts_parse_toml("config.toml")
+#' tree |> ts_tree_format() |> ts_tree_write()
+#' ```
+#'
+#' @export
+
+ts_tree_write.ts_tree_toml <- function(tree, file = NULL) {
+  NextMethod()
+}
diff --git a/src/library/tstoml/R/ts-unserialize-toml.R b/src/library/tstoml/R/ts-unserialize-toml.R
new file mode 100644
index 0000000000..ec359c04df
--- /dev/null
+++ b/src/library/tstoml/R/ts-unserialize-toml.R
@@ -0,0 +1,312 @@
+#' Unserialize TOML to R objects
+#'
+#' @inheritParams ts_parse_toml
+#' @export
+
+ts_unserialize_toml <- function(
+  file = NULL,
+  text = NULL,
+  ranges = NULL,
+  options = NULL
+) {
+  # if (!missing(options)) {
+  #   check_named_arg(options)
+  # }
+  # options <- as_tstoml_options(options)
+
+  tab <- ts_tree_new(
+    language = ts_language_toml(),
+    file = file,
+    text = text,
+    ranges = ranges,
+    options = options
+  )
+  unserialize_element(tab, 1L)
+}
+
+unserialize_element <- function(tree, id) {
+  type <- tree$type[id]
+  parent <- tree$parent[id]
+  if (
+    !is.na(parent) &&
+      tree$type[parent] == "table_array_element" &&
+      type %in% c("bare_key", "quoted_key", "dotted_key")
+  ) {
+    # this is an AOT _element_, unserialize like a table
+    type <- "table"
+  }
+
+  elt <- switch(
+    type,
+    table = ,
+    document = ,
+    inline_table = ,
+    bare_key = ,
+    quoted_key = {
+      unserialize_table(tree, id)
+    },
+    array = ,
+    table_array_element = {
+      unserialize_array(tree, id)
+    },
+    integer = {
+      unserialize_integer(tree, id)
+    },
+    float = {
+      unserialize_float(tree, id)
+    },
+    boolean = {
+      unserialize_boolean(tree, id)
+    },
+    offset_date_time = {
+      unserialize_offset_date_time(tree, id)
+    },
+    local_date_time = {
+      unserialize_local_date_time(tree, id)
+    },
+    local_date = {
+      unserialize_local_date(tree, id)
+    },
+    local_time = {
+      unserialize_local_time(tree, id)
+    },
+    string = {
+      unserialize_string(tree, id)
+    },
+    basic_string = {
+      unserialize_basic_string(tree, id)
+    },
+    multiline_basic_string = {
+      unserialize_multiline_basic_string(tree, id)
+    },
+    literal_string = {
+      unserialize_literal_string(tree, id)
+    },
+    multiline_literal_string = {
+      unserialize_multiline_literal_string(tree, id)
+    },
+    stop("Unsupported token type: ", tree$type[id])
+  )
+  elt
+}
+
+unserialize_key <- function(tree, id) {
+  switch(
+    tree$type[id],
+    bare_key = {
+      unserialize_bare_key(tree, id)
+    },
+    quoted_key = {
+      unserialize_quoted_key(tree, id)
+    },
+    dotted_key = {
+      unserialize_dotted_key(tree, id)
+    },
+    stop("Unsupported key type in pair: ", tree$type[id])
+  )
+}
+
+unserialize_bare_key <- function(tree, id) {
+  stopifnot(tree$type[id] == "bare_key")
+  tree$code[id]
+}
+
+unserialize_quoted_key <- function(tree, id) {
+  stopifnot(tree$type[id] == "quoted_key")
+  unserialize_element(tree, tree$children[[id]][1])
+}
+
+unserialize_dotted_key <- function(tree, id) {
+  stopifnot(tree$type[id] == "dotted_key")
+  children <- tree$children[[id]]
+  c(
+    unserialize_key(tree, children[1]),
+    unserialize_key(tree, children[3])
+  )
+}
+
+unserialize_key_with_ids <- function(tree, id) {
+  switch(
+    tree$type[id],
+    bare_key = {
+      unserialize_bare_key_with_ids(tree, id)
+    },
+    quoted_key = {
+      unserialize_quoted_key_with_ids(tree, id)
+    },
+    dotted_key = {
+      unserialize_dotted_key_with_ids(tree, id)
+    },
+    stop("Unsupported key type in pair: ", tree$type[id])
+  )
+}
+
+unserialize_bare_key_with_ids <- function(tree, id) {
+  stopifnot(tree$type[id] == "bare_key")
+  list(key = tree$code[id], ids = id)
+}
+
+unserialize_quoted_key_with_ids <- function(tree, id) {
+  stopifnot(tree$type[id] == "quoted_key")
+  list(
+    key = unserialize_element(tree, tree$children[[id]][1]),
+    ids = id
+  )
+}
+
+unserialize_dotted_key_with_ids <- function(tree, id) {
+  stopifnot(tree$type[id] == "dotted_key")
+  children <- tree$children[[id]]
+  ki1 <- unserialize_key_with_ids(tree, children[1])
+  ki2 <- unserialize_key_with_ids(tree, children[3])
+  list(key = c(ki1$key, ki2$key), ids = c(ki1$ids, ki2$ids))
+}
+
+
+# TODO: support 64 bit integers
+unserialize_integer <- function(tree, id) {
+  stopifnot(tree$type[id] == "integer")
+  code <- tree$code[id]
+  base <- if (startsWith(code, "0x")) {
+    16L
+  } else if (startsWith(code, "0o")) {
+    code <- substr(code, 3L, nchar(code))
+    8L
+  } else if (startsWith(code, "0b")) {
+    code <- substr(code, 3L, nchar(code))
+    2L
+  } else {
+    10L
+  }
+  code <- gsub("_", "", code, fixed = TRUE)
+  strtoi(code, base = base)
+}
+
+unserialize_float <- function(tree, id) {
+  stopifnot(tree$type[id] == "float")
+  code <- tree$code[id]
+  code <- gsub("_", "", code, fixed = TRUE)
+  as.numeric(code)
+}
+
+unserialize_boolean <- function(tree, id) {
+  stopifnot(tree$type[id] == "boolean")
+  if (tree$code[id] == "true") {
+    TRUE
+  } else {
+    FALSE
+  }
+}
+
+unserialize_offset_date_time <- function(tree, id) {
+  stopifnot(tree$type[id] == "offset_date_time")
+  code <- tree$code[id]
+  parse_iso_8601(code)
+}
+
+unserialize_local_date_time <- function(tree, id) {
+  stopifnot(tree$type[id] == "local_date_time")
+  code <- tree$code[id]
+  # parse it as a local time
+  t <- parse_iso_8601(code, "")
+  as.POSIXlt(.POSIXct(t, tz = ""))
+}
+
+unserialize_local_date <- function(tree, id) {
+  stopifnot(tree$type[id] == "local_date")
+  code <- tree$code[id]
+  as.Date(code, tryFormats = "%Y-%m-%d")
+}
+
+unserialize_local_time <- function(tree, id) {
+  stopifnot(tree$type[id] == "local_time")
+  code <- tree$code[id]
+  hms <- strsplit(code, ":", fixed = TRUE)[[1]]
+  structure(
+    as.difftime(
+      strtoi(hms[1]) * 3600 + strtoi(hms[2]) * 60 + as.numeric(hms[3]),
+      units = "secs"
+    ),
+    class = c("hms", "difftime")
+  )
+}
+
+# TODO: embedded NULL not supported
+
+unserialize_string <- function(tree, id, type = "string") {
+  stopifnot(tree$type[id] == type)
+  chdn <- tree$children[[id]]
+  unserialize_element(tree, chdn[1])
+}
+
+# - Embedded zero is not supported in R, so \u0000 will error.
+# - All other escapes supported by TOML are also supported by R, hence
+#   we use `eval(parse())`.
+# - The parser will error for the escapes that are not supported by TOML,
+#   even if they are supported by R.
+
+unserialize_basic_string <- function(tree, id) {
+  stopifnot(tree$type[id] == "basic_string")
+  # also has " delimiters
+  chdn <- tree$children[[id]]
+  str <- paste(tree$code[chdn], collapse = "")
+  eval(parse(text = str, keep.source = FALSE))
+}
+
+unserialize_multiline_basic_string <- function(tree, id) {
+  stopifnot(tree$type[id] == "multiline_basic_string")
+  chdn <- tree$children[[id]]
+  str <- paste(tree$code[chdn], collapse = "")
+  # trim delimiters first
+  str <- substr(str, 4L, nchar(str) - 3L)
+  # remove leading newline if present
+  if (startsWith(str, "\n")) {
+    str <- substr(str, 2L, nchar(str))
+  }
+  # replace \ + \n + whitespace with nothing
+  str <- gsub("\\\\\n\\s*", "", str, perl = TRUE)
+  # if we escape the single quotes, then we can use R's parser
+  str <- gsub("'", "\\'", str, fixed = TRUE)
+  eval(parse(text = paste0("'", str, "'"), keep.source = FALSE))
+}
+
+unserialize_literal_string <- function(tree, id) {
+  stopifnot(tree$type[id] == "literal_string")
+  chdn <- tree$children[[id]]
+  str <- paste(tree$code[chdn], collapse = "")
+  # trim delimiters first
+  str <- substr(str, 2L, nchar(str) - 1L)
+  str
+}
+
+unserialize_multiline_literal_string <- function(tree, id) {
+  stopifnot(tree$type[id] == "multiline_literal_string")
+  chdn <- tree$children[[id]]
+  str <- paste(tree$code[chdn], collapse = "")
+  # trim delimiters first
+  str <- substr(str, 4L, nchar(str) - 3L)
+  # remove leading newline if present
+  if (startsWith(str, "\n")) {
+    str <- substr(str, 2L, nchar(str))
+  }
+  str
+}
+
+unserialize_array <- function(tree, id) {
+  children <- tree$dom_children[[id]]
+  result <- vector("list", length(children))
+  for (i in seq_along(children)) {
+    result[[i]] <- unserialize_element(tree, children[i])
+  }
+  result
+}
+
+unserialize_table <- function(tree, id) {
+  children <- tree$dom_children[[id]]
+  res <- named_list(length(children))
+  names(res) <- tree$dom_name[children]
+  for (i in seq_along(children)) {
+    res[[i]] <- unserialize_element(tree, children[i])
+  }
+  res
+}
diff --git a/src/library/tstoml/R/tstoml-package.R b/src/library/tstoml/R/tstoml-package.R
new file mode 100644
index 0000000000..fedc46a6c1
--- /dev/null
+++ b/src/library/tstoml/R/tstoml-package.R
@@ -0,0 +1,50 @@
+#' @keywords internal
+"_PACKAGE"
+
+#' @import ts
+NULL
+
+## usethis namespace: start
+#' @useDynLib tstoml, .registration = TRUE, .fixes = "c_"
+## usethis namespace: end
+NULL
+
+#' @name quickstart
+#' @title tstoml quickstart
+#' @details
+#'
+#' ```{r, child = "tools/man/quickstart.Rmd"}
+#' ```
+NULL
+
+#' Example TOML text
+#' @export
+#' @examples
+#' writeLines(toml_example_text())
+
+toml_example_text <- function() {
+  '# This is a TOML document
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+dob = 1979-05-27T07:32:00-08:00
+
+[database]
+enabled = true
+ports = [ 8000, 8001, 8002 ]
+data = [ ["delta", "phi"], [3.14] ]
+temp_targets = { cpu = 79.5, case = 72.0 }
+
+[servers]
+
+[servers.alpha]
+ip = "10.0.0.1"
+role = "frontend"
+
+[servers.beta]
+ip = "10.0.0.2"
+role = "backend"
+'
+}
diff --git a/src/library/tstoml/R/utils.R b/src/library/tstoml/R/utils.R
new file mode 100644
index 0000000000..38c6f66487
--- /dev/null
+++ b/src/library/tstoml/R/utils.R
@@ -0,0 +1,77 @@
+`%||%` <- function(l, r) {
+  if (is.null(l)) {
+    r
+  } else {
+    l
+  }
+}
+
+is_false <- function(x) {
+  is.logical(x) && length(x) == 1L && !is.na(x) && !x
+}
+
+named_list <- function(n = 0) {
+  structure(vector("list", n), names = character(n))
+}
+
+map_int <- function(.x, .f, ...) {
+  vapply(.x, .f, integer(1), ...)
+}
+
+map_chr <- function(.x, .f, ...) {
+  vapply(.x, .f, character(1), ...)
+}
+
+map_lgl <- function(.x, .f, ...) {
+  vapply(.x, .f, logical(1), ...)
+}
+
+na_omit <- function(x) {
+  x[!is.na(x)]
+}
+
+middle <- function(x) {
+  if (length(x) <= 2) {
+    x[numeric()]
+  } else {
+    x[-c(1, length(x))]
+  }
+}
+
+max_or_na <- function(x, na.rm = FALSE) {
+  if (length(x)) {
+    max(x, na.rm = na.rm)
+  } else if (is.integer(x)) {
+    NA_integer_
+  } else {
+    NA_real_
+  }
+}
+
+is_named <- function(x, null = FALSE) {
+  nms <- names(x)
+  (null || !is.null(nms)) &&
+    length(x) == length(nms) &&
+    !anyNA(nms) &&
+    all(nms != "")
+}
+
+last <- function(x) {
+  x[[length(x)]]
+}
+
+plural <- function(x) {
+  if (x != 1) {
+    "s"
+  } else {
+    ""
+  }
+}
+
+# For roxygen2 -----------------------------------------------------------------
+
+# nocov start
+doclist <- function(x) {
+  paste0("`", x, "`", collapse = ", ")
+}
+#nocov end
diff --git a/src/library/tstoml/cleanup b/src/library/tstoml/cleanup
new file mode 100755
index 0000000000..597abaccad
--- /dev/null
+++ b/src/library/tstoml/cleanup
@@ -0,0 +1,3 @@
+#! /usr/bin/env sh
+
+rm -f man/macros/eval2.Rd
diff --git a/src/library/tstoml/configure b/src/library/tstoml/configure
new file mode 100755
index 0000000000..0c6626f41c
--- /dev/null
+++ b/src/library/tstoml/configure
@@ -0,0 +1,18 @@
+#! /usr/bin/env sh
+
+echo "** Running ./configure"
+
+# Check that this is not just ./configure. We need to run this
+# from R CMD INSTALL, to have the R env vars set.
+
+if [ -z "$R_HOME" ]; then
+  echo >&2 R_HOME is not set, are you running R CMD INSTALL?
+  exit 1
+fi
+
+# Find the R binary we need to use. This is a bit trickier on
+# Windows, because it has two architectures. On windows R_ARCH_BIN
+# is set, so this should work everywhere.
+export RBIN="${R_HOME}/bin${R_ARCH_BIN}/R"
+
+"$RBIN" --vanilla --slave -f tools/dynamic-help.R
diff --git a/src/library/tstoml/configure.win b/src/library/tstoml/configure.win
new file mode 100755
index 0000000000..994f9fdcd9
--- /dev/null
+++ b/src/library/tstoml/configure.win
@@ -0,0 +1,3 @@
+#! /usr/bin/env sh
+
+sh ./configure
diff --git a/src/library/tstoml/man/macros/eval.Rd b/src/library/tstoml/man/macros/eval.Rd
new file mode 100644
index 0000000000..3b9a267675
--- /dev/null
+++ b/src/library/tstoml/man/macros/eval.Rd
@@ -0,0 +1 @@
+\newcommand{\eval}{\code{#1}}
diff --git a/src/library/tstoml/man/roxygen/meta.R b/src/library/tstoml/man/roxygen/meta.R
new file mode 100644
index 0000000000..386f1dddb7
--- /dev/null
+++ b/src/library/tstoml/man/roxygen/meta.R
@@ -0,0 +1,32 @@
+if (exists(".knitr_asciicast_process", envir = .GlobalEnv)) {
+  rm(list = ".knitr_asciicast_process", envir = .GlobalEnv)
+}
+
+asciicast::init_knitr_engine(
+  echo = TRUE,
+  echo_input = FALSE,
+  timeout = as.integer(Sys.getenv("ASCIICAST_TIMEOUT", 10)),
+  startup = quote({
+    options(cli.num_colors = 256)
+    library(ts)
+    library(tstoml)
+  })
+)
+
+knitr::opts_chunk$set(
+  asciicast_knitr_output = "html",
+  asciicast_include_style = FALSE,
+  cache = FALSE,
+  cache.path = file.path(getwd(), "man/_cache/"),
+  fig.path = file.path(getwd(), "man/figures"),
+  error = FALSE
+)
+
+Sys.setenv("R_TS_PACKAGE" = "tstoml")
+ts:::ts_roclet_register()
+
+list(
+  markdown = TRUE,
+  restrict_image_formats = TRUE,
+  roclets = c("rd", "namespace", "collate", "ts:::roclet_ts")
+)
diff --git a/src/library/tstoml/src/Makevars b/src/library/tstoml/src/Makevars
new file mode 100644
index 0000000000..1d5966e29d
--- /dev/null
+++ b/src/library/tstoml/src/Makevars
@@ -0,0 +1,25 @@
+tree-sitter-files = \
+	tree-sitter/toml/parser.o \
+	tree-sitter/toml/scanner.o
+
+lib-files = \
+        init.o
+
+PKG_LIBS = -L. tree-sitter.a
+
+OBJECTS =  $(lib-files)
+
+all: $(SHLIB) mrproper
+
+$(SHLIB): tree-sitter.a
+
+tree-sitter.a: $(tree-sitter-files)
+	$(AR) rs tree-sitter.a $^
+
+clean:
+	rm -rf $(SHLIB) $(OBJECTS)
+
+mrproper: $(SHLIB)
+	@rm -rf *.a
+
+.PHONY: all clean
diff --git a/src/library/tstoml/src/init.c b/src/library/tstoml/src/init.c
new file mode 100644
index 0000000000..390a7b0ce3
--- /dev/null
+++ b/src/library/tstoml/src/init.c
@@ -0,0 +1,34 @@
+#define R_NO_REMAP
+#include <R.h>
+#include <Rinternals.h>
+
+#include "tree-sitter/toml/tree_sitter/parser.h"
+extern const TSLanguage *tree_sitter_toml(void);
+
+static const TSLanguage *toml_lang = NULL;
+
+SEXP ts_language_toml() {
+  if (toml_lang == NULL) {
+    toml_lang = tree_sitter_toml();
+  }
+  SEXP res = Rf_protect(
+    R_MakeExternalPtr((void *)toml_lang, R_NilValue, R_NilValue)
+  );
+  SEXP cls = Rf_protect(Rf_allocVector(STRSXP, 2));
+  SET_STRING_ELT(cls, 0, Rf_mkChar("ts_language_toml"));
+  SET_STRING_ELT(cls, 1, Rf_mkChar("ts_language"));
+  Rf_setAttrib(res, R_ClassSymbol, cls);
+  Rf_unprotect(2);
+  return res;
+}
+
+static const R_CallMethodDef callMethods[]  = {
+  { "ts_language_toml", (DL_FUNC) &ts_language_toml, 0 },
+  { NULL, NULL, 0 }
+};
+
+void R_init_tstoml(DllInfo *dll) {
+  R_registerRoutines(dll, NULL, callMethods, NULL, NULL);
+  R_useDynamicSymbols(dll, FALSE);
+  R_forceSymbols(dll, TRUE);
+}
diff --git a/src/library/tstoml/src/tree-sitter/toml/grammar.js b/src/library/tstoml/src/tree-sitter/toml/grammar.js
new file mode 100644
index 0000000000..1daf4ebeaa
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/grammar.js
@@ -0,0 +1,220 @@
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+const newline = /\r?\n/;
+
+const decimal_integer = /[+-]?(0|[1-9](_?[0-9])*)/;
+const decimal_integer_in_float_exponent_part = /[+-]?[0-9](_?[0-9])*/; // allow leading zeros
+const hexadecimal_integer = /0x[0-9a-fA-F](_?[0-9a-fA-F])*/;
+const octal_integer = /0o[0-7](_?[0-7])*/;
+const binary_integer = /0b[01](_?[01])*/;
+const float_fractional_part = /[.][0-9](_?[0-9])*/;
+const float_exponent_part = seq(/[eE]/, decimal_integer_in_float_exponent_part);
+
+const rfc3339_date = /([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])/;
+const rfc3339_delimiter = /[ tT]/;
+const rfc3339_time = /([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)([.][0-9]+)?/;
+const rfc3339_offset = /([zZ])|([+-]([01][0-9]|2[0-3]):[0-5][0-9])/;
+
+module.exports = grammar({
+  name: 'toml',
+
+  externals: $ => [
+    $._line_ending_or_eof,
+    $._multiline_basic_string_content_internal,
+    $.multiline_basic_string_end,
+    $._multiline_literal_string_content_internal,
+    $.multiline_literal_string_end,
+  ],
+
+  extras: $ => [$.comment, /[ \t]/],
+
+  rules: {
+    document: $ =>
+      seq(
+        repeat(choice($.pair, newline)),
+        repeat(choice($.table, $.table_array_element)),
+      ),
+
+    comment: $ =>
+      token(prec(-1, seq(
+        '#',
+        repeat(/[^\x00-\x08\x0a-\x1f\x7f]/),
+      ))),
+
+    table: $ =>
+      seq(
+        '[',
+        choice($.dotted_key, $._key),
+        ']',
+        $._line_ending_or_eof,
+        repeat(choice($.pair, newline)),
+      ),
+
+    table_array_element: $ =>
+      seq(
+        '[[',
+        choice($.dotted_key, $._key),
+        ']]',
+        $._line_ending_or_eof,
+        repeat(choice($.pair, newline)),
+      ),
+
+    pair: $ => seq($._inline_pair, $._line_ending_or_eof),
+    _inline_pair: $ => seq(choice($.dotted_key, $._key), '=', $._inline_value),
+
+    _key: $ => choice($.bare_key, $.quoted_key),
+    dotted_key: $ => seq(choice($.dotted_key, $._key), '.', $._key),
+    bare_key: $ => /[A-Za-z0-9_-]+/,
+    quoted_key: $ => choice($.basic_string, $.literal_string),
+
+    _inline_value: $ =>
+      choice(
+        $.string,
+        $.integer,
+        $.float,
+        $.boolean,
+        $.offset_date_time,
+        $.local_date_time,
+        $.local_date,
+        $.local_time,
+        $.array,
+        $.inline_table,
+      ),
+
+    string: $ =>
+      choice(
+        $.basic_string,
+        $.multiline_basic_string,
+        $.literal_string,
+        $.multiline_literal_string,
+      ),
+    basic_string: $ =>
+      seq(
+        '"',
+        repeat(
+          choice(
+            $.basic_string_content,
+            $.escape_sequence,
+          ),
+        ),
+        token.immediate('"'),
+      ),
+    basic_string_content: _ =>
+      token.immediate(
+        repeat1(/[^\x00-\x08\x0a-\x1f\x22\x5c\x7f]/),
+      ),
+
+    multiline_basic_string: $ =>
+      seq(
+        '"""',
+        repeat(
+          choice(
+            $.multiline_basic_string_content,
+            $.escape_sequence,
+            alias($._escape_line_ending, $.escape_sequence),
+          ),
+        ),
+        $.multiline_basic_string_end,
+      ),
+    multiline_basic_string_content: $ =>
+      choice(
+        token.immediate(
+          repeat1(/[^\x00-\x08\x0a-\x1f\x22\x5c\x7f]/),
+        ),
+        $._multiline_basic_string_content_internal,
+        token.immediate(newline),
+      ),
+    escape_sequence: $ =>
+      token.immediate(/\\([btnfr"\\]|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})/),
+    _escape_line_ending: $ => token.immediate(seq(/\\/, newline)),
+    literal_string: $ =>
+      seq(
+        '\'',
+        optional(
+          $.literal_string_content,
+        ),
+        token.immediate('\''),
+      ),
+    literal_string_content: _ =>
+      token.immediate(
+        repeat1(/[^\x00-\x08\x0a-\x1f\x27\x7f]/),
+      ),
+    multiline_literal_string: $ =>
+      seq(
+        '\'\'\'',
+        repeat(
+          choice(
+            $.multiline_literal_string_content,
+          ),
+        ),
+        $.multiline_literal_string_end,
+      ),
+    multiline_literal_string_content: $ =>
+      choice(
+        token.immediate(
+          repeat1(/[^\x00-\x08\x0a-\x1f\x27\x7f]/),
+        ),
+        $._multiline_literal_string_content_internal,
+        token.immediate(newline),
+      ),
+
+    integer: $ =>
+      choice(
+        decimal_integer,
+        hexadecimal_integer,
+        octal_integer,
+        binary_integer,
+      ),
+
+    float: $ =>
+      choice(
+        token(
+          seq(
+            decimal_integer,
+            choice(
+              float_fractional_part,
+              seq(optional(float_fractional_part), float_exponent_part),
+            ),
+          ),
+        ),
+        /[+-]?(inf|nan)/,
+      ),
+
+    boolean: $ => /true|false/,
+
+    offset_date_time: $ =>
+      token(seq(rfc3339_date, rfc3339_delimiter, rfc3339_time, rfc3339_offset)),
+    local_date_time: $ =>
+      token(seq(rfc3339_date, rfc3339_delimiter, rfc3339_time)),
+    local_date: $ => rfc3339_date,
+    local_time: $ => rfc3339_time,
+
+    array: $ =>
+      seq(
+        '[',
+        repeat(newline),
+        optional(
+          seq(
+            $._inline_value,
+            repeat(newline),
+            repeat(seq(',', repeat(newline), $._inline_value, repeat(newline))),
+            optional(seq(',', repeat(newline))),
+          ),
+        ),
+        ']',
+      ),
+
+    inline_table: $ =>
+      seq(
+        '{',
+        optional(
+          seq(
+            alias($._inline_pair, $.pair),
+            repeat(seq(',', alias($._inline_pair, $.pair))),
+          ),
+        ),
+        '}',
+      ),
+  },
+});
diff --git a/src/library/tstoml/src/tree-sitter/toml/grammar.json b/src/library/tstoml/src/tree-sitter/toml/grammar.json
new file mode 100644
index 0000000000..4b8851b06a
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/grammar.json
@@ -0,0 +1,865 @@
+{
+  "$schema": "https://tree-sitter.github.io/tree-sitter/assets/schemas/grammar.schema.json",
+  "name": "toml",
+  "rules": {
+    "document": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "pair"
+              },
+              {
+                "type": "PATTERN",
+                "value": "\\r?\\n"
+              }
+            ]
+          }
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "table"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "table_array_element"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "comment": {
+      "type": "TOKEN",
+      "content": {
+        "type": "PREC",
+        "value": -1,
+        "content": {
+          "type": "SEQ",
+          "members": [
+            {
+              "type": "STRING",
+              "value": "#"
+            },
+            {
+              "type": "REPEAT",
+              "content": {
+                "type": "PATTERN",
+                "value": "[^\\x00-\\x08\\x0a-\\x1f\\x7f]"
+              }
+            }
+          ]
+        }
+      }
+    },
+    "table": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "["
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "dotted_key"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "_key"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "]"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_line_ending_or_eof"
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "pair"
+              },
+              {
+                "type": "PATTERN",
+                "value": "\\r?\\n"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "table_array_element": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "[["
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "dotted_key"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "_key"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "]]"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_line_ending_or_eof"
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "pair"
+              },
+              {
+                "type": "PATTERN",
+                "value": "\\r?\\n"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "pair": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "_inline_pair"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_line_ending_or_eof"
+        }
+      ]
+    },
+    "_inline_pair": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "dotted_key"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "_key"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "="
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_inline_value"
+        }
+      ]
+    },
+    "_key": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "bare_key"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "quoted_key"
+        }
+      ]
+    },
+    "dotted_key": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "dotted_key"
+            },
+            {
+              "type": "SYMBOL",
+              "name": "_key"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "."
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_key"
+        }
+      ]
+    },
+    "bare_key": {
+      "type": "PATTERN",
+      "value": "[A-Za-z0-9_-]+"
+    },
+    "quoted_key": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "basic_string"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "literal_string"
+        }
+      ]
+    },
+    "_inline_value": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "string"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "integer"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "float"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "boolean"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "offset_date_time"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "local_date_time"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "local_date"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "local_time"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "array"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "inline_table"
+        }
+      ]
+    },
+    "string": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "SYMBOL",
+          "name": "basic_string"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "multiline_basic_string"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "literal_string"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "multiline_literal_string"
+        }
+      ]
+    },
+    "basic_string": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "\""
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "basic_string_content"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "escape_sequence"
+              }
+            ]
+          }
+        },
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "STRING",
+            "value": "\""
+          }
+        }
+      ]
+    },
+    "basic_string_content": {
+      "type": "IMMEDIATE_TOKEN",
+      "content": {
+        "type": "REPEAT1",
+        "content": {
+          "type": "PATTERN",
+          "value": "[^\\x00-\\x08\\x0a-\\x1f\\x22\\x5c\\x7f]"
+        }
+      }
+    },
+    "multiline_basic_string": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "\"\"\""
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "multiline_basic_string_content"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "escape_sequence"
+              },
+              {
+                "type": "ALIAS",
+                "content": {
+                  "type": "SYMBOL",
+                  "name": "_escape_line_ending"
+                },
+                "named": true,
+                "value": "escape_sequence"
+              }
+            ]
+          }
+        },
+        {
+          "type": "SYMBOL",
+          "name": "multiline_basic_string_end"
+        }
+      ]
+    },
+    "multiline_basic_string_content": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "REPEAT1",
+            "content": {
+              "type": "PATTERN",
+              "value": "[^\\x00-\\x08\\x0a-\\x1f\\x22\\x5c\\x7f]"
+            }
+          }
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_multiline_basic_string_content_internal"
+        },
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "PATTERN",
+            "value": "\\r?\\n"
+          }
+        }
+      ]
+    },
+    "escape_sequence": {
+      "type": "IMMEDIATE_TOKEN",
+      "content": {
+        "type": "PATTERN",
+        "value": "\\\\([btnfr\"\\\\]|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})"
+      }
+    },
+    "_escape_line_ending": {
+      "type": "IMMEDIATE_TOKEN",
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "PATTERN",
+            "value": "\\\\"
+          },
+          {
+            "type": "PATTERN",
+            "value": "\\r?\\n"
+          }
+        ]
+      }
+    },
+    "literal_string": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "'"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SYMBOL",
+              "name": "literal_string_content"
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "STRING",
+            "value": "'"
+          }
+        }
+      ]
+    },
+    "literal_string_content": {
+      "type": "IMMEDIATE_TOKEN",
+      "content": {
+        "type": "REPEAT1",
+        "content": {
+          "type": "PATTERN",
+          "value": "[^\\x00-\\x08\\x0a-\\x1f\\x27\\x7f]"
+        }
+      }
+    },
+    "multiline_literal_string": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "'''"
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "multiline_literal_string_content"
+              }
+            ]
+          }
+        },
+        {
+          "type": "SYMBOL",
+          "name": "multiline_literal_string_end"
+        }
+      ]
+    },
+    "multiline_literal_string_content": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "REPEAT1",
+            "content": {
+              "type": "PATTERN",
+              "value": "[^\\x00-\\x08\\x0a-\\x1f\\x27\\x7f]"
+            }
+          }
+        },
+        {
+          "type": "SYMBOL",
+          "name": "_multiline_literal_string_content_internal"
+        },
+        {
+          "type": "IMMEDIATE_TOKEN",
+          "content": {
+            "type": "PATTERN",
+            "value": "\\r?\\n"
+          }
+        }
+      ]
+    },
+    "integer": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "PATTERN",
+          "value": "[+-]?(0|[1-9](_?[0-9])*)"
+        },
+        {
+          "type": "PATTERN",
+          "value": "0x[0-9a-fA-F](_?[0-9a-fA-F])*"
+        },
+        {
+          "type": "PATTERN",
+          "value": "0o[0-7](_?[0-7])*"
+        },
+        {
+          "type": "PATTERN",
+          "value": "0b[01](_?[01])*"
+        }
+      ]
+    },
+    "float": {
+      "type": "CHOICE",
+      "members": [
+        {
+          "type": "TOKEN",
+          "content": {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "PATTERN",
+                "value": "[+-]?(0|[1-9](_?[0-9])*)"
+              },
+              {
+                "type": "CHOICE",
+                "members": [
+                  {
+                    "type": "PATTERN",
+                    "value": "[.][0-9](_?[0-9])*"
+                  },
+                  {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "CHOICE",
+                        "members": [
+                          {
+                            "type": "PATTERN",
+                            "value": "[.][0-9](_?[0-9])*"
+                          },
+                          {
+                            "type": "BLANK"
+                          }
+                        ]
+                      },
+                      {
+                        "type": "SEQ",
+                        "members": [
+                          {
+                            "type": "PATTERN",
+                            "value": "[eE]"
+                          },
+                          {
+                            "type": "PATTERN",
+                            "value": "[+-]?[0-9](_?[0-9])*"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "type": "PATTERN",
+          "value": "[+-]?(inf|nan)"
+        }
+      ]
+    },
+    "boolean": {
+      "type": "PATTERN",
+      "value": "true|false"
+    },
+    "offset_date_time": {
+      "type": "TOKEN",
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "PATTERN",
+            "value": "([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"
+          },
+          {
+            "type": "PATTERN",
+            "value": "[ tT]"
+          },
+          {
+            "type": "PATTERN",
+            "value": "([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)([.][0-9]+)?"
+          },
+          {
+            "type": "PATTERN",
+            "value": "([zZ])|([+-]([01][0-9]|2[0-3]):[0-5][0-9])"
+          }
+        ]
+      }
+    },
+    "local_date_time": {
+      "type": "TOKEN",
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "PATTERN",
+            "value": "([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"
+          },
+          {
+            "type": "PATTERN",
+            "value": "[ tT]"
+          },
+          {
+            "type": "PATTERN",
+            "value": "([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)([.][0-9]+)?"
+          }
+        ]
+      }
+    },
+    "local_date": {
+      "type": "PATTERN",
+      "value": "([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"
+    },
+    "local_time": {
+      "type": "PATTERN",
+      "value": "([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)([.][0-9]+)?"
+    },
+    "array": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "["
+        },
+        {
+          "type": "REPEAT",
+          "content": {
+            "type": "PATTERN",
+            "value": "\\r?\\n"
+          }
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "SYMBOL",
+                  "name": "_inline_value"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "PATTERN",
+                    "value": "\\r?\\n"
+                  }
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "REPEAT",
+                        "content": {
+                          "type": "PATTERN",
+                          "value": "\\r?\\n"
+                        }
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "_inline_value"
+                      },
+                      {
+                        "type": "REPEAT",
+                        "content": {
+                          "type": "PATTERN",
+                          "value": "\\r?\\n"
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "CHOICE",
+                  "members": [
+                    {
+                      "type": "SEQ",
+                      "members": [
+                        {
+                          "type": "STRING",
+                          "value": ","
+                        },
+                        {
+                          "type": "REPEAT",
+                          "content": {
+                            "type": "PATTERN",
+                            "value": "\\r?\\n"
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      "type": "BLANK"
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "]"
+        }
+      ]
+    },
+    "inline_table": {
+      "type": "SEQ",
+      "members": [
+        {
+          "type": "STRING",
+          "value": "{"
+        },
+        {
+          "type": "CHOICE",
+          "members": [
+            {
+              "type": "SEQ",
+              "members": [
+                {
+                  "type": "ALIAS",
+                  "content": {
+                    "type": "SYMBOL",
+                    "name": "_inline_pair"
+                  },
+                  "named": true,
+                  "value": "pair"
+                },
+                {
+                  "type": "REPEAT",
+                  "content": {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": ","
+                      },
+                      {
+                        "type": "ALIAS",
+                        "content": {
+                          "type": "SYMBOL",
+                          "name": "_inline_pair"
+                        },
+                        "named": true,
+                        "value": "pair"
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              "type": "BLANK"
+            }
+          ]
+        },
+        {
+          "type": "STRING",
+          "value": "}"
+        }
+      ]
+    }
+  },
+  "extras": [
+    {
+      "type": "SYMBOL",
+      "name": "comment"
+    },
+    {
+      "type": "PATTERN",
+      "value": "[ \\t]"
+    }
+  ],
+  "conflicts": [],
+  "precedences": [],
+  "externals": [
+    {
+      "type": "SYMBOL",
+      "name": "_line_ending_or_eof"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "_multiline_basic_string_content_internal"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "multiline_basic_string_end"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "_multiline_literal_string_content_internal"
+    },
+    {
+      "type": "SYMBOL",
+      "name": "multiline_literal_string_end"
+    }
+  ],
+  "inline": [],
+  "supertypes": [],
+  "reserved": {}
+}
\ No newline at end of file
diff --git a/src/library/tstoml/src/tree-sitter/toml/node-types.json b/src/library/tstoml/src/tree-sitter/toml/node-types.json
new file mode 100644
index 0000000000..a7d9b03ccd
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/node-types.json
@@ -0,0 +1,477 @@
+[
+  {
+    "type": "array",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "array",
+          "named": true
+        },
+        {
+          "type": "boolean",
+          "named": true
+        },
+        {
+          "type": "float",
+          "named": true
+        },
+        {
+          "type": "inline_table",
+          "named": true
+        },
+        {
+          "type": "integer",
+          "named": true
+        },
+        {
+          "type": "local_date",
+          "named": true
+        },
+        {
+          "type": "local_date_time",
+          "named": true
+        },
+        {
+          "type": "local_time",
+          "named": true
+        },
+        {
+          "type": "offset_date_time",
+          "named": true
+        },
+        {
+          "type": "string",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "basic_string",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "basic_string_content",
+          "named": true
+        },
+        {
+          "type": "escape_sequence",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "basic_string_content",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "document",
+    "named": true,
+    "root": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "pair",
+          "named": true
+        },
+        {
+          "type": "table",
+          "named": true
+        },
+        {
+          "type": "table_array_element",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "dotted_key",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "bare_key",
+          "named": true
+        },
+        {
+          "type": "dotted_key",
+          "named": true
+        },
+        {
+          "type": "quoted_key",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "float",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "inline_table",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "pair",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "integer",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "literal_string",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": false,
+      "types": [
+        {
+          "type": "literal_string_content",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "literal_string_content",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "multiline_basic_string",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "escape_sequence",
+          "named": true
+        },
+        {
+          "type": "multiline_basic_string_content",
+          "named": true
+        },
+        {
+          "type": "multiline_basic_string_end",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "multiline_basic_string_content",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "multiline_literal_string",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "multiline_literal_string_content",
+          "named": true
+        },
+        {
+          "type": "multiline_literal_string_end",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "multiline_literal_string_content",
+    "named": true,
+    "fields": {}
+  },
+  {
+    "type": "pair",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "array",
+          "named": true
+        },
+        {
+          "type": "bare_key",
+          "named": true
+        },
+        {
+          "type": "boolean",
+          "named": true
+        },
+        {
+          "type": "dotted_key",
+          "named": true
+        },
+        {
+          "type": "float",
+          "named": true
+        },
+        {
+          "type": "inline_table",
+          "named": true
+        },
+        {
+          "type": "integer",
+          "named": true
+        },
+        {
+          "type": "local_date",
+          "named": true
+        },
+        {
+          "type": "local_date_time",
+          "named": true
+        },
+        {
+          "type": "local_time",
+          "named": true
+        },
+        {
+          "type": "offset_date_time",
+          "named": true
+        },
+        {
+          "type": "quoted_key",
+          "named": true
+        },
+        {
+          "type": "string",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "quoted_key",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "basic_string",
+          "named": true
+        },
+        {
+          "type": "literal_string",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "string",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "basic_string",
+          "named": true
+        },
+        {
+          "type": "literal_string",
+          "named": true
+        },
+        {
+          "type": "multiline_basic_string",
+          "named": true
+        },
+        {
+          "type": "multiline_literal_string",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "table",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "bare_key",
+          "named": true
+        },
+        {
+          "type": "dotted_key",
+          "named": true
+        },
+        {
+          "type": "pair",
+          "named": true
+        },
+        {
+          "type": "quoted_key",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "table_array_element",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": true,
+      "types": [
+        {
+          "type": "bare_key",
+          "named": true
+        },
+        {
+          "type": "dotted_key",
+          "named": true
+        },
+        {
+          "type": "pair",
+          "named": true
+        },
+        {
+          "type": "quoted_key",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "\"",
+    "named": false
+  },
+  {
+    "type": "\"\"\"",
+    "named": false
+  },
+  {
+    "type": "'",
+    "named": false
+  },
+  {
+    "type": "'''",
+    "named": false
+  },
+  {
+    "type": ",",
+    "named": false
+  },
+  {
+    "type": ".",
+    "named": false
+  },
+  {
+    "type": "=",
+    "named": false
+  },
+  {
+    "type": "[",
+    "named": false
+  },
+  {
+    "type": "[[",
+    "named": false
+  },
+  {
+    "type": "]",
+    "named": false
+  },
+  {
+    "type": "]]",
+    "named": false
+  },
+  {
+    "type": "bare_key",
+    "named": true
+  },
+  {
+    "type": "boolean",
+    "named": true
+  },
+  {
+    "type": "comment",
+    "named": true,
+    "extra": true
+  },
+  {
+    "type": "escape_sequence",
+    "named": true
+  },
+  {
+    "type": "local_date",
+    "named": true
+  },
+  {
+    "type": "local_date_time",
+    "named": true
+  },
+  {
+    "type": "local_time",
+    "named": true
+  },
+  {
+    "type": "multiline_basic_string_end",
+    "named": true
+  },
+  {
+    "type": "multiline_literal_string_end",
+    "named": true
+  },
+  {
+    "type": "offset_date_time",
+    "named": true
+  },
+  {
+    "type": "{",
+    "named": false
+  },
+  {
+    "type": "}",
+    "named": false
+  }
+]
\ No newline at end of file
diff --git a/src/library/tstoml/src/tree-sitter/toml/parser.c b/src/library/tstoml/src/tree-sitter/toml/parser.c
new file mode 100644
index 0000000000..2818cf5d06
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/parser.c
@@ -0,0 +1,4860 @@
+/* Automatically @generated by tree-sitter v0.25.5 */
+
+#include "tree_sitter/parser.h"
+
+#if defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+#define LANGUAGE_VERSION 15
+#define STATE_COUNT 156
+#define LARGE_STATE_COUNT 2
+#define SYMBOL_COUNT 70
+#define ALIAS_COUNT 0
+#define TOKEN_COUNT 40
+#define EXTERNAL_TOKEN_COUNT 5
+#define FIELD_COUNT 0
+#define MAX_ALIAS_SEQUENCE_LENGTH 8
+#define MAX_RESERVED_WORD_SET_SIZE 0
+#define PRODUCTION_ID_COUNT 2
+#define SUPERTYPE_COUNT 0
+
+enum ts_symbol_identifiers {
+  aux_sym_document_token1 = 1,
+  sym_comment = 2,
+  anon_sym_LBRACK = 3,
+  anon_sym_RBRACK = 4,
+  anon_sym_LBRACK_LBRACK = 5,
+  anon_sym_RBRACK_RBRACK = 6,
+  anon_sym_EQ = 7,
+  anon_sym_DOT = 8,
+  sym_bare_key = 9,
+  anon_sym_DQUOTE = 10,
+  anon_sym_DQUOTE2 = 11,
+  aux_sym_basic_string_content_token1 = 12,
+  anon_sym_DQUOTE_DQUOTE_DQUOTE = 13,
+  aux_sym_multiline_basic_string_content_token1 = 14,
+  sym_escape_sequence = 15,
+  sym__escape_line_ending = 16,
+  anon_sym_SQUOTE = 17,
+  anon_sym_SQUOTE2 = 18,
+  aux_sym_literal_string_content_token1 = 19,
+  anon_sym_SQUOTE_SQUOTE_SQUOTE = 20,
+  aux_sym_integer_token1 = 21,
+  aux_sym_integer_token2 = 22,
+  aux_sym_integer_token3 = 23,
+  aux_sym_integer_token4 = 24,
+  aux_sym_float_token1 = 25,
+  aux_sym_float_token2 = 26,
+  sym_boolean = 27,
+  sym_offset_date_time = 28,
+  sym_local_date_time = 29,
+  sym_local_date = 30,
+  sym_local_time = 31,
+  anon_sym_COMMA = 32,
+  anon_sym_LBRACE = 33,
+  anon_sym_RBRACE = 34,
+  sym__line_ending_or_eof = 35,
+  sym__multiline_basic_string_content_internal = 36,
+  sym_multiline_basic_string_end = 37,
+  sym__multiline_literal_string_content_internal = 38,
+  sym_multiline_literal_string_end = 39,
+  sym_document = 40,
+  sym_table = 41,
+  sym_table_array_element = 42,
+  sym_pair = 43,
+  sym__inline_pair = 44,
+  sym__key = 45,
+  sym_dotted_key = 46,
+  sym_quoted_key = 47,
+  sym__inline_value = 48,
+  sym_string = 49,
+  sym_basic_string = 50,
+  sym_basic_string_content = 51,
+  sym_multiline_basic_string = 52,
+  sym_multiline_basic_string_content = 53,
+  sym_literal_string = 54,
+  sym_literal_string_content = 55,
+  sym_multiline_literal_string = 56,
+  sym_multiline_literal_string_content = 57,
+  sym_integer = 58,
+  sym_float = 59,
+  sym_array = 60,
+  sym_inline_table = 61,
+  aux_sym_document_repeat1 = 62,
+  aux_sym_document_repeat2 = 63,
+  aux_sym_basic_string_repeat1 = 64,
+  aux_sym_multiline_basic_string_repeat1 = 65,
+  aux_sym_multiline_literal_string_repeat1 = 66,
+  aux_sym_array_repeat1 = 67,
+  aux_sym_array_repeat2 = 68,
+  aux_sym_inline_table_repeat1 = 69,
+};
+
+static const char * const ts_symbol_names[] = {
+  [ts_builtin_sym_end] = "end",
+  [aux_sym_document_token1] = "document_token1",
+  [sym_comment] = "comment",
+  [anon_sym_LBRACK] = "[",
+  [anon_sym_RBRACK] = "]",
+  [anon_sym_LBRACK_LBRACK] = "[[",
+  [anon_sym_RBRACK_RBRACK] = "]]",
+  [anon_sym_EQ] = "=",
+  [anon_sym_DOT] = ".",
+  [sym_bare_key] = "bare_key",
+  [anon_sym_DQUOTE] = "\"",
+  [anon_sym_DQUOTE2] = "\"",
+  [aux_sym_basic_string_content_token1] = "basic_string_content_token1",
+  [anon_sym_DQUOTE_DQUOTE_DQUOTE] = "\"\"\"",
+  [aux_sym_multiline_basic_string_content_token1] = "multiline_basic_string_content_token1",
+  [sym_escape_sequence] = "escape_sequence",
+  [sym__escape_line_ending] = "escape_sequence",
+  [anon_sym_SQUOTE] = "'",
+  [anon_sym_SQUOTE2] = "'",
+  [aux_sym_literal_string_content_token1] = "literal_string_content_token1",
+  [anon_sym_SQUOTE_SQUOTE_SQUOTE] = "'''",
+  [aux_sym_integer_token1] = "integer_token1",
+  [aux_sym_integer_token2] = "integer_token2",
+  [aux_sym_integer_token3] = "integer_token3",
+  [aux_sym_integer_token4] = "integer_token4",
+  [aux_sym_float_token1] = "float_token1",
+  [aux_sym_float_token2] = "float_token2",
+  [sym_boolean] = "boolean",
+  [sym_offset_date_time] = "offset_date_time",
+  [sym_local_date_time] = "local_date_time",
+  [sym_local_date] = "local_date",
+  [sym_local_time] = "local_time",
+  [anon_sym_COMMA] = ",",
+  [anon_sym_LBRACE] = "{",
+  [anon_sym_RBRACE] = "}",
+  [sym__line_ending_or_eof] = "_line_ending_or_eof",
+  [sym__multiline_basic_string_content_internal] = "_multiline_basic_string_content_internal",
+  [sym_multiline_basic_string_end] = "multiline_basic_string_end",
+  [sym__multiline_literal_string_content_internal] = "_multiline_literal_string_content_internal",
+  [sym_multiline_literal_string_end] = "multiline_literal_string_end",
+  [sym_document] = "document",
+  [sym_table] = "table",
+  [sym_table_array_element] = "table_array_element",
+  [sym_pair] = "pair",
+  [sym__inline_pair] = "_inline_pair",
+  [sym__key] = "_key",
+  [sym_dotted_key] = "dotted_key",
+  [sym_quoted_key] = "quoted_key",
+  [sym__inline_value] = "_inline_value",
+  [sym_string] = "string",
+  [sym_basic_string] = "basic_string",
+  [sym_basic_string_content] = "basic_string_content",
+  [sym_multiline_basic_string] = "multiline_basic_string",
+  [sym_multiline_basic_string_content] = "multiline_basic_string_content",
+  [sym_literal_string] = "literal_string",
+  [sym_literal_string_content] = "literal_string_content",
+  [sym_multiline_literal_string] = "multiline_literal_string",
+  [sym_multiline_literal_string_content] = "multiline_literal_string_content",
+  [sym_integer] = "integer",
+  [sym_float] = "float",
+  [sym_array] = "array",
+  [sym_inline_table] = "inline_table",
+  [aux_sym_document_repeat1] = "document_repeat1",
+  [aux_sym_document_repeat2] = "document_repeat2",
+  [aux_sym_basic_string_repeat1] = "basic_string_repeat1",
+  [aux_sym_multiline_basic_string_repeat1] = "multiline_basic_string_repeat1",
+  [aux_sym_multiline_literal_string_repeat1] = "multiline_literal_string_repeat1",
+  [aux_sym_array_repeat1] = "array_repeat1",
+  [aux_sym_array_repeat2] = "array_repeat2",
+  [aux_sym_inline_table_repeat1] = "inline_table_repeat1",
+};
+
+static const TSSymbol ts_symbol_map[] = {
+  [ts_builtin_sym_end] = ts_builtin_sym_end,
+  [aux_sym_document_token1] = aux_sym_document_token1,
+  [sym_comment] = sym_comment,
+  [anon_sym_LBRACK] = anon_sym_LBRACK,
+  [anon_sym_RBRACK] = anon_sym_RBRACK,
+  [anon_sym_LBRACK_LBRACK] = anon_sym_LBRACK_LBRACK,
+  [anon_sym_RBRACK_RBRACK] = anon_sym_RBRACK_RBRACK,
+  [anon_sym_EQ] = anon_sym_EQ,
+  [anon_sym_DOT] = anon_sym_DOT,
+  [sym_bare_key] = sym_bare_key,
+  [anon_sym_DQUOTE] = anon_sym_DQUOTE,
+  [anon_sym_DQUOTE2] = anon_sym_DQUOTE,
+  [aux_sym_basic_string_content_token1] = aux_sym_basic_string_content_token1,
+  [anon_sym_DQUOTE_DQUOTE_DQUOTE] = anon_sym_DQUOTE_DQUOTE_DQUOTE,
+  [aux_sym_multiline_basic_string_content_token1] = aux_sym_multiline_basic_string_content_token1,
+  [sym_escape_sequence] = sym_escape_sequence,
+  [sym__escape_line_ending] = sym_escape_sequence,
+  [anon_sym_SQUOTE] = anon_sym_SQUOTE,
+  [anon_sym_SQUOTE2] = anon_sym_SQUOTE,
+  [aux_sym_literal_string_content_token1] = aux_sym_literal_string_content_token1,
+  [anon_sym_SQUOTE_SQUOTE_SQUOTE] = anon_sym_SQUOTE_SQUOTE_SQUOTE,
+  [aux_sym_integer_token1] = aux_sym_integer_token1,
+  [aux_sym_integer_token2] = aux_sym_integer_token2,
+  [aux_sym_integer_token3] = aux_sym_integer_token3,
+  [aux_sym_integer_token4] = aux_sym_integer_token4,
+  [aux_sym_float_token1] = aux_sym_float_token1,
+  [aux_sym_float_token2] = aux_sym_float_token2,
+  [sym_boolean] = sym_boolean,
+  [sym_offset_date_time] = sym_offset_date_time,
+  [sym_local_date_time] = sym_local_date_time,
+  [sym_local_date] = sym_local_date,
+  [sym_local_time] = sym_local_time,
+  [anon_sym_COMMA] = anon_sym_COMMA,
+  [anon_sym_LBRACE] = anon_sym_LBRACE,
+  [anon_sym_RBRACE] = anon_sym_RBRACE,
+  [sym__line_ending_or_eof] = sym__line_ending_or_eof,
+  [sym__multiline_basic_string_content_internal] = sym__multiline_basic_string_content_internal,
+  [sym_multiline_basic_string_end] = sym_multiline_basic_string_end,
+  [sym__multiline_literal_string_content_internal] = sym__multiline_literal_string_content_internal,
+  [sym_multiline_literal_string_end] = sym_multiline_literal_string_end,
+  [sym_document] = sym_document,
+  [sym_table] = sym_table,
+  [sym_table_array_element] = sym_table_array_element,
+  [sym_pair] = sym_pair,
+  [sym__inline_pair] = sym__inline_pair,
+  [sym__key] = sym__key,
+  [sym_dotted_key] = sym_dotted_key,
+  [sym_quoted_key] = sym_quoted_key,
+  [sym__inline_value] = sym__inline_value,
+  [sym_string] = sym_string,
+  [sym_basic_string] = sym_basic_string,
+  [sym_basic_string_content] = sym_basic_string_content,
+  [sym_multiline_basic_string] = sym_multiline_basic_string,
+  [sym_multiline_basic_string_content] = sym_multiline_basic_string_content,
+  [sym_literal_string] = sym_literal_string,
+  [sym_literal_string_content] = sym_literal_string_content,
+  [sym_multiline_literal_string] = sym_multiline_literal_string,
+  [sym_multiline_literal_string_content] = sym_multiline_literal_string_content,
+  [sym_integer] = sym_integer,
+  [sym_float] = sym_float,
+  [sym_array] = sym_array,
+  [sym_inline_table] = sym_inline_table,
+  [aux_sym_document_repeat1] = aux_sym_document_repeat1,
+  [aux_sym_document_repeat2] = aux_sym_document_repeat2,
+  [aux_sym_basic_string_repeat1] = aux_sym_basic_string_repeat1,
+  [aux_sym_multiline_basic_string_repeat1] = aux_sym_multiline_basic_string_repeat1,
+  [aux_sym_multiline_literal_string_repeat1] = aux_sym_multiline_literal_string_repeat1,
+  [aux_sym_array_repeat1] = aux_sym_array_repeat1,
+  [aux_sym_array_repeat2] = aux_sym_array_repeat2,
+  [aux_sym_inline_table_repeat1] = aux_sym_inline_table_repeat1,
+};
+
+static const TSSymbolMetadata ts_symbol_metadata[] = {
+  [ts_builtin_sym_end] = {
+    .visible = false,
+    .named = true,
+  },
+  [aux_sym_document_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [sym_comment] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_LBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LBRACK_LBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RBRACK_RBRACK] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_EQ] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DOT] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym_bare_key] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_DQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_DQUOTE2] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym_basic_string_content_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [anon_sym_DQUOTE_DQUOTE_DQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym_multiline_basic_string_content_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [sym_escape_sequence] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__escape_line_ending] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_SQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_SQUOTE2] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym_literal_string_content_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [anon_sym_SQUOTE_SQUOTE_SQUOTE] = {
+    .visible = true,
+    .named = false,
+  },
+  [aux_sym_integer_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_integer_token2] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_integer_token3] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_integer_token4] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_float_token1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_float_token2] = {
+    .visible = false,
+    .named = false,
+  },
+  [sym_boolean] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_offset_date_time] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_local_date_time] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_local_date] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_local_time] = {
+    .visible = true,
+    .named = true,
+  },
+  [anon_sym_COMMA] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_LBRACE] = {
+    .visible = true,
+    .named = false,
+  },
+  [anon_sym_RBRACE] = {
+    .visible = true,
+    .named = false,
+  },
+  [sym__line_ending_or_eof] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__multiline_basic_string_content_internal] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_multiline_basic_string_end] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__multiline_literal_string_content_internal] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_multiline_literal_string_end] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_document] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_table] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_table_array_element] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_pair] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__inline_pair] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym__key] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_dotted_key] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_quoted_key] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym__inline_value] = {
+    .visible = false,
+    .named = true,
+  },
+  [sym_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_basic_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_basic_string_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_multiline_basic_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_multiline_basic_string_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_literal_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_literal_string_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_multiline_literal_string] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_multiline_literal_string_content] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_integer] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_float] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_array] = {
+    .visible = true,
+    .named = true,
+  },
+  [sym_inline_table] = {
+    .visible = true,
+    .named = true,
+  },
+  [aux_sym_document_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_document_repeat2] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_basic_string_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_multiline_basic_string_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_multiline_literal_string_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_array_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_array_repeat2] = {
+    .visible = false,
+    .named = false,
+  },
+  [aux_sym_inline_table_repeat1] = {
+    .visible = false,
+    .named = false,
+  },
+};
+
+static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = {
+  [0] = {0},
+  [1] = {
+    [1] = sym_pair,
+  },
+};
+
+static const uint16_t ts_non_terminal_alias_map[] = {
+  sym__inline_pair, 2,
+    sym__inline_pair,
+    sym_pair,
+  0,
+};
+
+static const TSStateId ts_primary_state_ids[STATE_COUNT] = {
+  [0] = 0,
+  [1] = 1,
+  [2] = 2,
+  [3] = 3,
+  [4] = 4,
+  [5] = 5,
+  [6] = 6,
+  [7] = 7,
+  [8] = 8,
+  [9] = 9,
+  [10] = 10,
+  [11] = 7,
+  [12] = 12,
+  [13] = 9,
+  [14] = 3,
+  [15] = 5,
+  [16] = 6,
+  [17] = 8,
+  [18] = 2,
+  [19] = 4,
+  [20] = 10,
+  [21] = 12,
+  [22] = 22,
+  [23] = 23,
+  [24] = 24,
+  [25] = 24,
+  [26] = 26,
+  [27] = 27,
+  [28] = 28,
+  [29] = 29,
+  [30] = 30,
+  [31] = 31,
+  [32] = 32,
+  [33] = 33,
+  [34] = 33,
+  [35] = 35,
+  [36] = 36,
+  [37] = 37,
+  [38] = 38,
+  [39] = 39,
+  [40] = 37,
+  [41] = 41,
+  [42] = 41,
+  [43] = 43,
+  [44] = 44,
+  [45] = 43,
+  [46] = 46,
+  [47] = 47,
+  [48] = 48,
+  [49] = 49,
+  [50] = 50,
+  [51] = 51,
+  [52] = 52,
+  [53] = 53,
+  [54] = 54,
+  [55] = 55,
+  [56] = 56,
+  [57] = 47,
+  [58] = 56,
+  [59] = 59,
+  [60] = 60,
+  [61] = 61,
+  [62] = 62,
+  [63] = 63,
+  [64] = 63,
+  [65] = 65,
+  [66] = 59,
+  [67] = 65,
+  [68] = 62,
+  [69] = 61,
+  [70] = 70,
+  [71] = 70,
+  [72] = 63,
+  [73] = 65,
+  [74] = 74,
+  [75] = 75,
+  [76] = 76,
+  [77] = 77,
+  [78] = 78,
+  [79] = 79,
+  [80] = 80,
+  [81] = 81,
+  [82] = 82,
+  [83] = 83,
+  [84] = 84,
+  [85] = 85,
+  [86] = 86,
+  [87] = 87,
+  [88] = 88,
+  [89] = 89,
+  [90] = 90,
+  [91] = 91,
+  [92] = 92,
+  [93] = 93,
+  [94] = 94,
+  [95] = 95,
+  [96] = 96,
+  [97] = 97,
+  [98] = 98,
+  [99] = 96,
+  [100] = 100,
+  [101] = 101,
+  [102] = 102,
+  [103] = 103,
+  [104] = 104,
+  [105] = 105,
+  [106] = 106,
+  [107] = 98,
+  [108] = 103,
+  [109] = 109,
+  [110] = 106,
+  [111] = 102,
+  [112] = 105,
+  [113] = 105,
+  [114] = 114,
+  [115] = 115,
+  [116] = 109,
+  [117] = 117,
+  [118] = 46,
+  [119] = 48,
+  [120] = 50,
+  [121] = 121,
+  [122] = 97,
+  [123] = 123,
+  [124] = 54,
+  [125] = 114,
+  [126] = 126,
+  [127] = 54,
+  [128] = 87,
+  [129] = 79,
+  [130] = 75,
+  [131] = 94,
+  [132] = 117,
+  [133] = 88,
+  [134] = 134,
+  [135] = 135,
+  [136] = 136,
+  [137] = 95,
+  [138] = 80,
+  [139] = 91,
+  [140] = 126,
+  [141] = 76,
+  [142] = 77,
+  [143] = 93,
+  [144] = 81,
+  [145] = 89,
+  [146] = 146,
+  [147] = 74,
+  [148] = 78,
+  [149] = 46,
+  [150] = 90,
+  [151] = 48,
+  [152] = 50,
+  [153] = 153,
+  [154] = 126,
+  [155] = 86,
+};
+
+static bool ts_lex(TSLexer *lexer, TSStateId state) {
+  START_LEXER();
+  eof = lexer->eof(lexer);
+  switch (state) {
+    case 0:
+      if (eof) ADVANCE(77);
+      ADVANCE_MAP(
+        '\n', 129,
+        '\r', 1,
+        '"', 125,
+        '#', 79,
+        '\'', 135,
+        '+', 15,
+        ',', 161,
+        '-', 95,
+        '.', 86,
+        '0', 92,
+        '1', 90,
+        '2', 89,
+        '=', 85,
+        '[', 81,
+        '\\', 5,
+        ']', 82,
+        'f', 102,
+        'i', 108,
+        'n', 103,
+        't', 109,
+        '{', 162,
+        '}', 163,
+      );
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(75);
+      if (('3' <= lookahead && lookahead <= '9')) ADVANCE(91);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 1:
+      if (lookahead == '\n') ADVANCE(129);
+      END_STATE();
+    case 2:
+      if (lookahead == '\n') ADVANCE(129);
+      if (lookahead == '\r') ADVANCE(1);
+      if (lookahead == '"') ADVANCE(124);
+      if (lookahead == '#') ADVANCE(127);
+      if (lookahead == '\\') ADVANCE(5);
+      if (lookahead == '\t' ||
+          lookahead == ' ') ADVANCE(126);
+      if (lookahead > ' ' &&
+          lookahead != 0x7f) ADVANCE(127);
+      END_STATE();
+    case 3:
+      if (lookahead == '\n') ADVANCE(129);
+      if (lookahead == '\r') ADVANCE(1);
+      if (lookahead == '#') ADVANCE(137);
+      if (lookahead == '\'') ADVANCE(134);
+      if (lookahead == '\t' ||
+          lookahead == ' ') ADVANCE(136);
+      if (lookahead > ' ' &&
+          lookahead != 0x7f) ADVANCE(137);
+      END_STATE();
+    case 4:
+      if (lookahead == '\n') ADVANCE(131);
+      END_STATE();
+    case 5:
+      ADVANCE_MAP(
+        '\n', 131,
+        '\r', 4,
+        'U', 74,
+        'u', 70,
+        '"', 130,
+        '\\', 130,
+        'b', 130,
+        'f', 130,
+        'n', 130,
+        'r', 130,
+        't', 130,
+      );
+      END_STATE();
+    case 6:
+      if (lookahead == '\n') ADVANCE(78);
+      END_STATE();
+    case 7:
+      ADVANCE_MAP(
+        '\n', 78,
+        '\r', 6,
+        '"', 123,
+        '#', 79,
+        '\'', 133,
+        ',', 161,
+        '0', 144,
+        '1', 142,
+        '2', 141,
+        '[', 80,
+        ']', 82,
+        'f', 30,
+        'i', 35,
+        'n', 31,
+        't', 37,
+        '{', 162,
+      );
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(7);
+      if (('+' <= lookahead && lookahead <= '-')) ADVANCE(17);
+      if (('3' <= lookahead && lookahead <= '9')) ADVANCE(143);
+      END_STATE();
+    case 8:
+      if (lookahead == '"') ADVANCE(128);
+      END_STATE();
+    case 9:
+      if (lookahead == '#') ADVANCE(79);
+      if (lookahead == '\'') ADVANCE(134);
+      if (lookahead == '.') ADVANCE(86);
+      if (lookahead == ']') ADVANCE(29);
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(10);
+      END_STATE();
+    case 10:
+      if (lookahead == '#') ADVANCE(79);
+      if (lookahead == '.') ADVANCE(86);
+      if (lookahead == ']') ADVANCE(29);
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(10);
+      END_STATE();
+    case 11:
+      if (lookahead == '\'') ADVANCE(138);
+      END_STATE();
+    case 12:
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == ':') ADVANCE(46);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(13);
+      END_STATE();
+    case 13:
+      if (lookahead == '-') ADVANCE(18);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(13);
+      END_STATE();
+    case 14:
+      if (lookahead == '-') ADVANCE(20);
+      END_STATE();
+    case 15:
+      if (lookahead == '0') ADVANCE(139);
+      if (lookahead == 'i') ADVANCE(35);
+      if (lookahead == 'n') ADVANCE(31);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(147);
+      END_STATE();
+    case 16:
+      if (lookahead == '0') ADVANCE(159);
+      END_STATE();
+    case 17:
+      if (lookahead == '0') ADVANCE(146);
+      if (lookahead == 'i') ADVANCE(35);
+      if (lookahead == 'n') ADVANCE(31);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(145);
+      END_STATE();
+    case 18:
+      if (lookahead == '0') ADVANCE(50);
+      if (lookahead == '1') ADVANCE(43);
+      END_STATE();
+    case 19:
+      if (lookahead == '0') ADVANCE(156);
+      END_STATE();
+    case 20:
+      if (lookahead == '0') ADVANCE(51);
+      if (lookahead == '3') ADVANCE(42);
+      if (lookahead == '1' ||
+          lookahead == '2') ADVANCE(59);
+      END_STATE();
+    case 21:
+      if (lookahead == '2') ADVANCE(44);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(63);
+      END_STATE();
+    case 22:
+      if (lookahead == '2') ADVANCE(45);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(64);
+      END_STATE();
+    case 23:
+      if (lookahead == '6') ADVANCE(16);
+      if (('0' <= lookahead && lookahead <= '5')) ADVANCE(54);
+      END_STATE();
+    case 24:
+      if (lookahead == '6') ADVANCE(19);
+      if (('0' <= lookahead && lookahead <= '5')) ADVANCE(60);
+      END_STATE();
+    case 25:
+      if (lookahead == ':') ADVANCE(23);
+      END_STATE();
+    case 26:
+      if (lookahead == ':') ADVANCE(47);
+      END_STATE();
+    case 27:
+      if (lookahead == ':') ADVANCE(24);
+      END_STATE();
+    case 28:
+      if (lookahead == ':') ADVANCE(48);
+      END_STATE();
+    case 29:
+      if (lookahead == ']') ADVANCE(84);
+      END_STATE();
+    case 30:
+      if (lookahead == 'a') ADVANCE(34);
+      END_STATE();
+    case 31:
+      if (lookahead == 'a') ADVANCE(36);
+      END_STATE();
+    case 32:
+      if (lookahead == 'e') ADVANCE(154);
+      END_STATE();
+    case 33:
+      if (lookahead == 'f') ADVANCE(153);
+      END_STATE();
+    case 34:
+      if (lookahead == 'l') ADVANCE(38);
+      END_STATE();
+    case 35:
+      if (lookahead == 'n') ADVANCE(33);
+      END_STATE();
+    case 36:
+      if (lookahead == 'n') ADVANCE(153);
+      END_STATE();
+    case 37:
+      if (lookahead == 'r') ADVANCE(39);
+      END_STATE();
+    case 38:
+      if (lookahead == 's') ADVANCE(32);
+      END_STATE();
+    case 39:
+      if (lookahead == 'u') ADVANCE(32);
+      END_STATE();
+    case 40:
+      if (lookahead == '+' ||
+          lookahead == '-') ADVANCE(58);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(152);
+      END_STATE();
+    case 41:
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(150);
+      END_STATE();
+    case 42:
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(158);
+      END_STATE();
+    case 43:
+      if (('0' <= lookahead && lookahead <= '2')) ADVANCE(14);
+      END_STATE();
+    case 44:
+      if (('0' <= lookahead && lookahead <= '3')) ADVANCE(28);
+      END_STATE();
+    case 45:
+      if (('0' <= lookahead && lookahead <= '3')) ADVANCE(26);
+      END_STATE();
+    case 46:
+      if (('0' <= lookahead && lookahead <= '5')) ADVANCE(53);
+      END_STATE();
+    case 47:
+      if (('0' <= lookahead && lookahead <= '5')) ADVANCE(61);
+      END_STATE();
+    case 48:
+      if (('0' <= lookahead && lookahead <= '5')) ADVANCE(65);
+      END_STATE();
+    case 49:
+      if (('0' <= lookahead && lookahead <= '7')) ADVANCE(149);
+      END_STATE();
+    case 50:
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(14);
+      END_STATE();
+    case 51:
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(158);
+      END_STATE();
+    case 52:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(147);
+      END_STATE();
+    case 53:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(25);
+      END_STATE();
+    case 54:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(159);
+      END_STATE();
+    case 55:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(160);
+      END_STATE();
+    case 56:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(145);
+      END_STATE();
+    case 57:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(151);
+      END_STATE();
+    case 58:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(152);
+      END_STATE();
+    case 59:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(158);
+      END_STATE();
+    case 60:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(156);
+      END_STATE();
+    case 61:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(155);
+      END_STATE();
+    case 62:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(157);
+      END_STATE();
+    case 63:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(28);
+      END_STATE();
+    case 64:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(26);
+      END_STATE();
+    case 65:
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(27);
+      END_STATE();
+    case 66:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(130);
+      END_STATE();
+    case 67:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(148);
+      END_STATE();
+    case 68:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(66);
+      END_STATE();
+    case 69:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(68);
+      END_STATE();
+    case 70:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(69);
+      END_STATE();
+    case 71:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(70);
+      END_STATE();
+    case 72:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(71);
+      END_STATE();
+    case 73:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(72);
+      END_STATE();
+    case 74:
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(73);
+      END_STATE();
+    case 75:
+      if (eof) ADVANCE(77);
+      ADVANCE_MAP(
+        '\n', 78,
+        '\r', 6,
+        '"', 123,
+        '#', 79,
+        '\'', 133,
+        '+', 15,
+        ',', 161,
+        '-', 95,
+        '.', 86,
+        '0', 92,
+        '1', 90,
+        '2', 89,
+        '=', 85,
+        '[', 81,
+        ']', 82,
+        'f', 102,
+        'i', 108,
+        'n', 103,
+        't', 109,
+        '{', 162,
+        '}', 163,
+      );
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(75);
+      if (('3' <= lookahead && lookahead <= '9')) ADVANCE(91);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 76:
+      if (eof) ADVANCE(77);
+      ADVANCE_MAP(
+        '\n', 78,
+        '\r', 6,
+        '"', 122,
+        '#', 79,
+        '\'', 132,
+        ',', 161,
+        '.', 86,
+        '=', 85,
+        '[', 81,
+        ']', 82,
+        '}', 163,
+      );
+      if (lookahead == '\t' ||
+          lookahead == ' ') SKIP(76);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 77:
+      ACCEPT_TOKEN(ts_builtin_sym_end);
+      END_STATE();
+    case 78:
+      ACCEPT_TOKEN(aux_sym_document_token1);
+      END_STATE();
+    case 79:
+      ACCEPT_TOKEN(sym_comment);
+      if (lookahead > 0x08 &&
+          (lookahead < '\n' || 0x1f < lookahead) &&
+          lookahead != 0x7f) ADVANCE(79);
+      END_STATE();
+    case 80:
+      ACCEPT_TOKEN(anon_sym_LBRACK);
+      END_STATE();
+    case 81:
+      ACCEPT_TOKEN(anon_sym_LBRACK);
+      if (lookahead == '[') ADVANCE(83);
+      END_STATE();
+    case 82:
+      ACCEPT_TOKEN(anon_sym_RBRACK);
+      END_STATE();
+    case 83:
+      ACCEPT_TOKEN(anon_sym_LBRACK_LBRACK);
+      END_STATE();
+    case 84:
+      ACCEPT_TOKEN(anon_sym_RBRACK_RBRACK);
+      END_STATE();
+    case 85:
+      ACCEPT_TOKEN(anon_sym_EQ);
+      END_STATE();
+    case 86:
+      ACCEPT_TOKEN(anon_sym_DOT);
+      END_STATE();
+    case 87:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == ':') ADVANCE(46);
+      if (lookahead == '_') ADVANCE(119);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 88:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == ':') ADVANCE(46);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 89:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == '_') ADVANCE(119);
+      if (('0' <= lookahead && lookahead <= '3')) ADVANCE(87);
+      if (('4' <= lookahead && lookahead <= '9')) ADVANCE(91);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 90:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == '_') ADVANCE(119);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 91:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == '_') ADVANCE(119);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(91);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 92:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (lookahead == 'b') ADVANCE(113);
+      if (lookahead == 'o') ADVANCE(115);
+      if (lookahead == 'x') ADVANCE(120);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(88);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 93:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(96);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(93);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 94:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-') ADVANCE(97);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 95:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '0') ADVANCE(121);
+      if (lookahead == 'i') ADVANCE(108);
+      if (lookahead == 'n') ADVANCE(103);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(101);
+      if (lookahead == '-' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 96:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '0') ADVANCE(117);
+      if (lookahead == '1') ADVANCE(114);
+      if (lookahead == '-' ||
+          ('2' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 97:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '0') ADVANCE(116);
+      if (lookahead == '3') ADVANCE(112);
+      if (lookahead == '1' ||
+          lookahead == '2') ADVANCE(118);
+      if (lookahead == '-' ||
+          ('4' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 98:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '_') ADVANCE(113);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(98);
+      if (lookahead == '-' ||
+          ('2' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 99:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '_') ADVANCE(115);
+      if (('0' <= lookahead && lookahead <= '7')) ADVANCE(99);
+      if (lookahead == '-' ||
+          lookahead == '8' ||
+          lookahead == '9' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 100:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '_') ADVANCE(120);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(100);
+      if (lookahead == '-' ||
+          ('G' <= lookahead && lookahead <= 'Z') ||
+          ('g' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 101:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '_') ADVANCE(119);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(101);
+      if (lookahead == '-' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 102:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'a') ADVANCE(106);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('b' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 103:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'a') ADVANCE(107);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('b' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 104:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'e') ADVANCE(121);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 105:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'f') ADVANCE(121);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 106:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'l') ADVANCE(110);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 107:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'n') ADVANCE(121);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 108:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'n') ADVANCE(105);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 109:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'r') ADVANCE(111);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 110:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 's') ADVANCE(104);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 111:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == 'u') ADVANCE(104);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 112:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(121);
+      if (lookahead == '-' ||
+          ('2' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 113:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(98);
+      if (lookahead == '-' ||
+          ('2' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 114:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('0' <= lookahead && lookahead <= '2')) ADVANCE(94);
+      if (lookahead == '-' ||
+          ('3' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 115:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('0' <= lookahead && lookahead <= '7')) ADVANCE(99);
+      if (lookahead == '-' ||
+          lookahead == '8' ||
+          lookahead == '9' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 116:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121);
+      if (lookahead == '-' ||
+          lookahead == '0' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 117:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('1' <= lookahead && lookahead <= '9')) ADVANCE(94);
+      if (lookahead == '-' ||
+          lookahead == '0' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 118:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(121);
+      if (lookahead == '-' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 119:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(101);
+      if (lookahead == '-' ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 120:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(100);
+      if (lookahead == '-' ||
+          ('G' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('g' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 121:
+      ACCEPT_TOKEN(sym_bare_key);
+      if (lookahead == '-' ||
+          ('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(121);
+      END_STATE();
+    case 122:
+      ACCEPT_TOKEN(anon_sym_DQUOTE);
+      END_STATE();
+    case 123:
+      ACCEPT_TOKEN(anon_sym_DQUOTE);
+      if (lookahead == '"') ADVANCE(8);
+      END_STATE();
+    case 124:
+      ACCEPT_TOKEN(anon_sym_DQUOTE2);
+      END_STATE();
+    case 125:
+      ACCEPT_TOKEN(anon_sym_DQUOTE2);
+      if (lookahead == '"') ADVANCE(8);
+      END_STATE();
+    case 126:
+      ACCEPT_TOKEN(aux_sym_basic_string_content_token1);
+      if (lookahead == '#') ADVANCE(127);
+      if (lookahead == '\t' ||
+          lookahead == ' ') ADVANCE(126);
+      if (lookahead > ' ' &&
+          lookahead != '"' &&
+          lookahead != '#' &&
+          lookahead != '\\' &&
+          lookahead != 0x7f) ADVANCE(127);
+      END_STATE();
+    case 127:
+      ACCEPT_TOKEN(aux_sym_basic_string_content_token1);
+      if (lookahead > 0x08 &&
+          (lookahead < '\n' || 0x1f < lookahead) &&
+          lookahead != '"' &&
+          lookahead != '\\' &&
+          lookahead != 0x7f) ADVANCE(127);
+      END_STATE();
+    case 128:
+      ACCEPT_TOKEN(anon_sym_DQUOTE_DQUOTE_DQUOTE);
+      END_STATE();
+    case 129:
+      ACCEPT_TOKEN(aux_sym_multiline_basic_string_content_token1);
+      END_STATE();
+    case 130:
+      ACCEPT_TOKEN(sym_escape_sequence);
+      END_STATE();
+    case 131:
+      ACCEPT_TOKEN(sym__escape_line_ending);
+      END_STATE();
+    case 132:
+      ACCEPT_TOKEN(anon_sym_SQUOTE);
+      END_STATE();
+    case 133:
+      ACCEPT_TOKEN(anon_sym_SQUOTE);
+      if (lookahead == '\'') ADVANCE(11);
+      END_STATE();
+    case 134:
+      ACCEPT_TOKEN(anon_sym_SQUOTE2);
+      END_STATE();
+    case 135:
+      ACCEPT_TOKEN(anon_sym_SQUOTE2);
+      if (lookahead == '\'') ADVANCE(11);
+      END_STATE();
+    case 136:
+      ACCEPT_TOKEN(aux_sym_literal_string_content_token1);
+      if (lookahead == '#') ADVANCE(137);
+      if (lookahead == '\t' ||
+          lookahead == ' ') ADVANCE(136);
+      if (lookahead > ' ' &&
+          lookahead != '\'' &&
+          lookahead != 0x7f) ADVANCE(137);
+      END_STATE();
+    case 137:
+      ACCEPT_TOKEN(aux_sym_literal_string_content_token1);
+      if (lookahead > 0x08 &&
+          (lookahead < '\n' || 0x1f < lookahead) &&
+          lookahead != '\'' &&
+          lookahead != 0x7f) ADVANCE(137);
+      END_STATE();
+    case 138:
+      ACCEPT_TOKEN(anon_sym_SQUOTE_SQUOTE_SQUOTE);
+      END_STATE();
+    case 139:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      END_STATE();
+    case 140:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == ':') ADVANCE(46);
+      if (lookahead == '_') ADVANCE(56);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(143);
+      END_STATE();
+    case 141:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == '_') ADVANCE(56);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '3')) ADVANCE(140);
+      if (('4' <= lookahead && lookahead <= '9')) ADVANCE(143);
+      END_STATE();
+    case 142:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == '_') ADVANCE(56);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(140);
+      END_STATE();
+    case 143:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == '_') ADVANCE(56);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(143);
+      END_STATE();
+    case 144:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '-') ADVANCE(18);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == 'b') ADVANCE(41);
+      if (lookahead == 'o') ADVANCE(49);
+      if (lookahead == 'x') ADVANCE(67);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(12);
+      END_STATE();
+    case 145:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == '_') ADVANCE(56);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(145);
+      END_STATE();
+    case 146:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '.') ADVANCE(57);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      END_STATE();
+    case 147:
+      ACCEPT_TOKEN(aux_sym_integer_token1);
+      if (lookahead == '_') ADVANCE(52);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(147);
+      END_STATE();
+    case 148:
+      ACCEPT_TOKEN(aux_sym_integer_token2);
+      if (lookahead == '_') ADVANCE(67);
+      if (('0' <= lookahead && lookahead <= '9') ||
+          ('A' <= lookahead && lookahead <= 'F') ||
+          ('a' <= lookahead && lookahead <= 'f')) ADVANCE(148);
+      END_STATE();
+    case 149:
+      ACCEPT_TOKEN(aux_sym_integer_token3);
+      if (lookahead == '_') ADVANCE(49);
+      if (('0' <= lookahead && lookahead <= '7')) ADVANCE(149);
+      END_STATE();
+    case 150:
+      ACCEPT_TOKEN(aux_sym_integer_token4);
+      if (lookahead == '_') ADVANCE(41);
+      if (lookahead == '0' ||
+          lookahead == '1') ADVANCE(150);
+      END_STATE();
+    case 151:
+      ACCEPT_TOKEN(aux_sym_float_token1);
+      if (lookahead == '_') ADVANCE(57);
+      if (lookahead == 'E' ||
+          lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(151);
+      END_STATE();
+    case 152:
+      ACCEPT_TOKEN(aux_sym_float_token1);
+      if (lookahead == '_') ADVANCE(58);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(152);
+      END_STATE();
+    case 153:
+      ACCEPT_TOKEN(aux_sym_float_token2);
+      END_STATE();
+    case 154:
+      ACCEPT_TOKEN(sym_boolean);
+      END_STATE();
+    case 155:
+      ACCEPT_TOKEN(sym_offset_date_time);
+      END_STATE();
+    case 156:
+      ACCEPT_TOKEN(sym_local_date_time);
+      if (lookahead == '.') ADVANCE(62);
+      if (lookahead == '+' ||
+          lookahead == '-') ADVANCE(22);
+      if (lookahead == 'Z' ||
+          lookahead == 'z') ADVANCE(155);
+      END_STATE();
+    case 157:
+      ACCEPT_TOKEN(sym_local_date_time);
+      if (lookahead == '+' ||
+          lookahead == '-') ADVANCE(22);
+      if (lookahead == 'Z' ||
+          lookahead == 'z') ADVANCE(155);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(157);
+      END_STATE();
+    case 158:
+      ACCEPT_TOKEN(sym_local_date);
+      if (lookahead == ' ' ||
+          lookahead == 'T' ||
+          lookahead == 't') ADVANCE(21);
+      END_STATE();
+    case 159:
+      ACCEPT_TOKEN(sym_local_time);
+      if (lookahead == '.') ADVANCE(55);
+      END_STATE();
+    case 160:
+      ACCEPT_TOKEN(sym_local_time);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(160);
+      END_STATE();
+    case 161:
+      ACCEPT_TOKEN(anon_sym_COMMA);
+      END_STATE();
+    case 162:
+      ACCEPT_TOKEN(anon_sym_LBRACE);
+      END_STATE();
+    case 163:
+      ACCEPT_TOKEN(anon_sym_RBRACE);
+      END_STATE();
+    default:
+      return false;
+  }
+}
+
+static const TSLexerMode ts_lex_modes[STATE_COUNT] = {
+  [0] = {.lex_state = 0, .external_lex_state = 1},
+  [1] = {.lex_state = 76},
+  [2] = {.lex_state = 7},
+  [3] = {.lex_state = 7},
+  [4] = {.lex_state = 7},
+  [5] = {.lex_state = 7},
+  [6] = {.lex_state = 7},
+  [7] = {.lex_state = 7},
+  [8] = {.lex_state = 7},
+  [9] = {.lex_state = 7},
+  [10] = {.lex_state = 7},
+  [11] = {.lex_state = 7},
+  [12] = {.lex_state = 7},
+  [13] = {.lex_state = 7},
+  [14] = {.lex_state = 7},
+  [15] = {.lex_state = 7},
+  [16] = {.lex_state = 7},
+  [17] = {.lex_state = 7},
+  [18] = {.lex_state = 7},
+  [19] = {.lex_state = 7},
+  [20] = {.lex_state = 7},
+  [21] = {.lex_state = 7},
+  [22] = {.lex_state = 7},
+  [23] = {.lex_state = 7},
+  [24] = {.lex_state = 7},
+  [25] = {.lex_state = 7},
+  [26] = {.lex_state = 7},
+  [27] = {.lex_state = 76},
+  [28] = {.lex_state = 76},
+  [29] = {.lex_state = 76},
+  [30] = {.lex_state = 76},
+  [31] = {.lex_state = 76},
+  [32] = {.lex_state = 76},
+  [33] = {.lex_state = 76},
+  [34] = {.lex_state = 76},
+  [35] = {.lex_state = 76},
+  [36] = {.lex_state = 76},
+  [37] = {.lex_state = 2, .external_lex_state = 2},
+  [38] = {.lex_state = 2, .external_lex_state = 2},
+  [39] = {.lex_state = 76},
+  [40] = {.lex_state = 2, .external_lex_state = 2},
+  [41] = {.lex_state = 2, .external_lex_state = 2},
+  [42] = {.lex_state = 2, .external_lex_state = 2},
+  [43] = {.lex_state = 76},
+  [44] = {.lex_state = 76},
+  [45] = {.lex_state = 76},
+  [46] = {.lex_state = 76},
+  [47] = {.lex_state = 3, .external_lex_state = 3},
+  [48] = {.lex_state = 76},
+  [49] = {.lex_state = 0},
+  [50] = {.lex_state = 76},
+  [51] = {.lex_state = 3, .external_lex_state = 3},
+  [52] = {.lex_state = 0},
+  [53] = {.lex_state = 0},
+  [54] = {.lex_state = 76},
+  [55] = {.lex_state = 2, .external_lex_state = 2},
+  [56] = {.lex_state = 3, .external_lex_state = 3},
+  [57] = {.lex_state = 3, .external_lex_state = 3},
+  [58] = {.lex_state = 3, .external_lex_state = 3},
+  [59] = {.lex_state = 76},
+  [60] = {.lex_state = 2},
+  [61] = {.lex_state = 76},
+  [62] = {.lex_state = 76},
+  [63] = {.lex_state = 2},
+  [64] = {.lex_state = 2},
+  [65] = {.lex_state = 2},
+  [66] = {.lex_state = 76},
+  [67] = {.lex_state = 2},
+  [68] = {.lex_state = 76},
+  [69] = {.lex_state = 76},
+  [70] = {.lex_state = 76},
+  [71] = {.lex_state = 76},
+  [72] = {.lex_state = 2},
+  [73] = {.lex_state = 2},
+  [74] = {.lex_state = 76},
+  [75] = {.lex_state = 76},
+  [76] = {.lex_state = 76},
+  [77] = {.lex_state = 76},
+  [78] = {.lex_state = 76},
+  [79] = {.lex_state = 76},
+  [80] = {.lex_state = 76},
+  [81] = {.lex_state = 76},
+  [82] = {.lex_state = 76},
+  [83] = {.lex_state = 76},
+  [84] = {.lex_state = 76},
+  [85] = {.lex_state = 76},
+  [86] = {.lex_state = 76},
+  [87] = {.lex_state = 76},
+  [88] = {.lex_state = 76},
+  [89] = {.lex_state = 76},
+  [90] = {.lex_state = 76},
+  [91] = {.lex_state = 76},
+  [92] = {.lex_state = 3, .external_lex_state = 3},
+  [93] = {.lex_state = 76},
+  [94] = {.lex_state = 76},
+  [95] = {.lex_state = 76},
+  [96] = {.lex_state = 0},
+  [97] = {.lex_state = 0},
+  [98] = {.lex_state = 0},
+  [99] = {.lex_state = 0},
+  [100] = {.lex_state = 0},
+  [101] = {.lex_state = 0},
+  [102] = {.lex_state = 0},
+  [103] = {.lex_state = 0},
+  [104] = {.lex_state = 2},
+  [105] = {.lex_state = 3},
+  [106] = {.lex_state = 0},
+  [107] = {.lex_state = 0},
+  [108] = {.lex_state = 0},
+  [109] = {.lex_state = 0},
+  [110] = {.lex_state = 0},
+  [111] = {.lex_state = 0},
+  [112] = {.lex_state = 3},
+  [113] = {.lex_state = 3},
+  [114] = {.lex_state = 0},
+  [115] = {.lex_state = 0},
+  [116] = {.lex_state = 9},
+  [117] = {.lex_state = 0},
+  [118] = {.lex_state = 9},
+  [119] = {.lex_state = 9},
+  [120] = {.lex_state = 9},
+  [121] = {.lex_state = 9},
+  [122] = {.lex_state = 9},
+  [123] = {.lex_state = 0},
+  [124] = {.lex_state = 9},
+  [125] = {.lex_state = 0},
+  [126] = {.lex_state = 9},
+  [127] = {.lex_state = 0, .external_lex_state = 4},
+  [128] = {.lex_state = 0, .external_lex_state = 4},
+  [129] = {.lex_state = 0, .external_lex_state = 4},
+  [130] = {.lex_state = 0, .external_lex_state = 4},
+  [131] = {.lex_state = 0, .external_lex_state = 4},
+  [132] = {.lex_state = 0, .external_lex_state = 4},
+  [133] = {.lex_state = 0, .external_lex_state = 4},
+  [134] = {.lex_state = 0, .external_lex_state = 4},
+  [135] = {.lex_state = 9},
+  [136] = {.lex_state = 0, .external_lex_state = 4},
+  [137] = {.lex_state = 0, .external_lex_state = 4},
+  [138] = {.lex_state = 0, .external_lex_state = 4},
+  [139] = {.lex_state = 0, .external_lex_state = 4},
+  [140] = {.lex_state = 9},
+  [141] = {.lex_state = 0, .external_lex_state = 4},
+  [142] = {.lex_state = 0, .external_lex_state = 4},
+  [143] = {.lex_state = 0, .external_lex_state = 4},
+  [144] = {.lex_state = 0, .external_lex_state = 4},
+  [145] = {.lex_state = 0, .external_lex_state = 4},
+  [146] = {.lex_state = 0, .external_lex_state = 4},
+  [147] = {.lex_state = 0, .external_lex_state = 4},
+  [148] = {.lex_state = 0, .external_lex_state = 4},
+  [149] = {.lex_state = 0, .external_lex_state = 4},
+  [150] = {.lex_state = 0, .external_lex_state = 4},
+  [151] = {.lex_state = 0, .external_lex_state = 4},
+  [152] = {.lex_state = 0, .external_lex_state = 4},
+  [153] = {.lex_state = 0},
+  [154] = {.lex_state = 9},
+  [155] = {.lex_state = 0, .external_lex_state = 4},
+};
+
+static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
+  [STATE(0)] = {
+    [ts_builtin_sym_end] = ACTIONS(1),
+    [aux_sym_document_token1] = ACTIONS(1),
+    [sym_comment] = ACTIONS(3),
+    [anon_sym_LBRACK] = ACTIONS(1),
+    [anon_sym_RBRACK] = ACTIONS(1),
+    [anon_sym_LBRACK_LBRACK] = ACTIONS(1),
+    [anon_sym_EQ] = ACTIONS(1),
+    [anon_sym_DOT] = ACTIONS(1),
+    [sym_bare_key] = ACTIONS(1),
+    [anon_sym_DQUOTE] = ACTIONS(1),
+    [anon_sym_DQUOTE2] = ACTIONS(1),
+    [anon_sym_DQUOTE_DQUOTE_DQUOTE] = ACTIONS(1),
+    [aux_sym_multiline_basic_string_content_token1] = ACTIONS(1),
+    [sym_escape_sequence] = ACTIONS(1),
+    [sym__escape_line_ending] = ACTIONS(1),
+    [anon_sym_SQUOTE] = ACTIONS(1),
+    [anon_sym_SQUOTE2] = ACTIONS(1),
+    [anon_sym_SQUOTE_SQUOTE_SQUOTE] = ACTIONS(1),
+    [aux_sym_integer_token1] = ACTIONS(1),
+    [aux_sym_integer_token2] = ACTIONS(1),
+    [aux_sym_integer_token3] = ACTIONS(1),
+    [aux_sym_integer_token4] = ACTIONS(1),
+    [aux_sym_float_token2] = ACTIONS(1),
+    [sym_boolean] = ACTIONS(1),
+    [sym_local_date] = ACTIONS(1),
+    [sym_local_time] = ACTIONS(1),
+    [anon_sym_COMMA] = ACTIONS(1),
+    [anon_sym_LBRACE] = ACTIONS(1),
+    [anon_sym_RBRACE] = ACTIONS(1),
+    [sym__line_ending_or_eof] = ACTIONS(1),
+    [sym__multiline_basic_string_content_internal] = ACTIONS(1),
+    [sym_multiline_basic_string_end] = ACTIONS(1),
+    [sym__multiline_literal_string_content_internal] = ACTIONS(1),
+    [sym_multiline_literal_string_end] = ACTIONS(1),
+  },
+  [STATE(1)] = {
+    [sym_document] = STATE(153),
+    [sym_table] = STATE(53),
+    [sym_table_array_element] = STATE(53),
+    [sym_pair] = STATE(27),
+    [sym__inline_pair] = STATE(134),
+    [sym__key] = STATE(125),
+    [sym_dotted_key] = STATE(125),
+    [sym_quoted_key] = STATE(125),
+    [sym_basic_string] = STATE(97),
+    [sym_literal_string] = STATE(97),
+    [aux_sym_document_repeat1] = STATE(27),
+    [aux_sym_document_repeat2] = STATE(53),
+    [ts_builtin_sym_end] = ACTIONS(5),
+    [aux_sym_document_token1] = ACTIONS(7),
+    [sym_comment] = ACTIONS(3),
+    [anon_sym_LBRACK] = ACTIONS(9),
+    [anon_sym_LBRACK_LBRACK] = ACTIONS(11),
+    [sym_bare_key] = ACTIONS(13),
+    [anon_sym_DQUOTE] = ACTIONS(15),
+    [anon_sym_SQUOTE] = ACTIONS(17),
+  },
+};
+
+static const uint16_t ts_small_parse_table[] = {
+  [0] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(19), 1,
+      aux_sym_document_token1,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(23), 1,
+      anon_sym_RBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    STATE(10), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [66] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(23), 1,
+      anon_sym_RBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [132] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(51), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [198] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(53), 1,
+      aux_sym_document_token1,
+    ACTIONS(55), 1,
+      anon_sym_RBRACK,
+    STATE(8), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(59), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(57), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(70), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [264] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(61), 1,
+      aux_sym_document_token1,
+    ACTIONS(63), 1,
+      anon_sym_RBRACK,
+    STATE(4), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [330] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(51), 1,
+      anon_sym_RBRACK,
+    ACTIONS(65), 1,
+      aux_sym_document_token1,
+    STATE(3), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [396] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(67), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(71), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(69), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(62), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [462] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(73), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [528] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(75), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [594] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(77), 1,
+      aux_sym_document_token1,
+    ACTIONS(79), 1,
+      anon_sym_RBRACK,
+    STATE(14), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [660] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(75), 1,
+      anon_sym_RBRACK,
+    ACTIONS(81), 1,
+      aux_sym_document_token1,
+    STATE(13), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [726] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(83), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [792] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(85), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [858] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(87), 1,
+      aux_sym_document_token1,
+    ACTIONS(89), 1,
+      anon_sym_RBRACK,
+    STATE(17), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(93), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(91), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(71), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [924] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(95), 1,
+      aux_sym_document_token1,
+    ACTIONS(97), 1,
+      anon_sym_RBRACK,
+    STATE(19), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [990] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(99), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(103), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(101), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(68), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1056] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(85), 1,
+      anon_sym_RBRACK,
+    ACTIONS(105), 1,
+      aux_sym_document_token1,
+    STATE(20), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1122] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(79), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1188] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(107), 1,
+      anon_sym_RBRACK,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1254] = 17,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(107), 1,
+      anon_sym_RBRACK,
+    ACTIONS(109), 1,
+      aux_sym_document_token1,
+    STATE(9), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1320] = 16,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(111), 1,
+      aux_sym_document_token1,
+    STATE(23), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(41), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(39), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(83), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1383] = 16,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(49), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(47), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(82), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1446] = 14,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(113), 1,
+      anon_sym_LBRACK,
+    ACTIONS(115), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(117), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(119), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(121), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(123), 1,
+      aux_sym_integer_token1,
+    ACTIONS(133), 1,
+      anon_sym_LBRACE,
+    ACTIONS(127), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(131), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(125), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(129), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(133), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(132), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1503] = 14,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(21), 1,
+      anon_sym_LBRACK,
+    ACTIONS(25), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(27), 1,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+    ACTIONS(29), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(31), 1,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+    ACTIONS(33), 1,
+      aux_sym_integer_token1,
+    ACTIONS(43), 1,
+      anon_sym_LBRACE,
+    ACTIONS(37), 2,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+    ACTIONS(137), 2,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(35), 3,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+    ACTIONS(135), 3,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+    STATE(88), 4,
+      sym_basic_string,
+      sym_multiline_basic_string,
+      sym_literal_string,
+      sym_multiline_literal_string,
+    STATE(117), 6,
+      sym__inline_value,
+      sym_string,
+      sym_integer,
+      sym_float,
+      sym_array,
+      sym_inline_table,
+  [1560] = 5,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(139), 1,
+      aux_sym_document_token1,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(144), 5,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+      aux_sym_integer_token1,
+      sym_local_date_time,
+      sym_local_date,
+    ACTIONS(142), 14,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_DQUOTE_DQUOTE_DQUOTE,
+      anon_sym_SQUOTE_SQUOTE_SQUOTE,
+      aux_sym_integer_token2,
+      aux_sym_integer_token3,
+      aux_sym_integer_token4,
+      aux_sym_float_token1,
+      aux_sym_float_token2,
+      sym_boolean,
+      sym_offset_date_time,
+      sym_local_time,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+  [1593] = 13,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(9), 1,
+      anon_sym_LBRACK,
+    ACTIONS(11), 1,
+      anon_sym_LBRACK_LBRACK,
+    ACTIONS(13), 1,
+      sym_bare_key,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(146), 1,
+      ts_builtin_sym_end,
+    ACTIONS(148), 1,
+      aux_sym_document_token1,
+    STATE(134), 1,
+      sym__inline_pair,
+    STATE(30), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(52), 3,
+      sym_table,
+      sym_table_array_element,
+      aux_sym_document_repeat2,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1639] = 11,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(13), 1,
+      sym_bare_key,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(152), 1,
+      aux_sym_document_token1,
+    ACTIONS(154), 1,
+      anon_sym_LBRACK,
+    STATE(134), 1,
+      sym__inline_pair,
+    ACTIONS(150), 2,
+      ts_builtin_sym_end,
+      anon_sym_LBRACK_LBRACK,
+    STATE(31), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1678] = 11,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(13), 1,
+      sym_bare_key,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(148), 1,
+      aux_sym_document_token1,
+    ACTIONS(158), 1,
+      anon_sym_LBRACK,
+    STATE(134), 1,
+      sym__inline_pair,
+    ACTIONS(156), 2,
+      ts_builtin_sym_end,
+      anon_sym_LBRACK_LBRACK,
+    STATE(30), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1717] = 11,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(162), 1,
+      aux_sym_document_token1,
+    ACTIONS(165), 1,
+      anon_sym_LBRACK,
+    ACTIONS(167), 1,
+      sym_bare_key,
+    ACTIONS(170), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(173), 1,
+      anon_sym_SQUOTE,
+    STATE(134), 1,
+      sym__inline_pair,
+    ACTIONS(160), 2,
+      ts_builtin_sym_end,
+      anon_sym_LBRACK_LBRACK,
+    STATE(30), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1756] = 11,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(13), 1,
+      sym_bare_key,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(148), 1,
+      aux_sym_document_token1,
+    ACTIONS(178), 1,
+      anon_sym_LBRACK,
+    STATE(134), 1,
+      sym__inline_pair,
+    ACTIONS(176), 2,
+      ts_builtin_sym_end,
+      anon_sym_LBRACK_LBRACK,
+    STATE(30), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1795] = 11,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(13), 1,
+      sym_bare_key,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(182), 1,
+      aux_sym_document_token1,
+    ACTIONS(184), 1,
+      anon_sym_LBRACK,
+    STATE(134), 1,
+      sym__inline_pair,
+    ACTIONS(180), 2,
+      ts_builtin_sym_end,
+      anon_sym_LBRACK_LBRACK,
+    STATE(29), 2,
+      sym_pair,
+      aux_sym_document_repeat1,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(125), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1834] = 8,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(186), 1,
+      sym_bare_key,
+    ACTIONS(188), 1,
+      anon_sym_RBRACE,
+    STATE(108), 1,
+      sym__inline_pair,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(114), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1862] = 8,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(186), 1,
+      sym_bare_key,
+    ACTIONS(190), 1,
+      anon_sym_RBRACE,
+    STATE(103), 1,
+      sym__inline_pair,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(114), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1890] = 7,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(186), 1,
+      sym_bare_key,
+    STATE(115), 1,
+      sym__inline_pair,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(114), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1915] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(192), 1,
+      sym_bare_key,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(123), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1937] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(200), 1,
+      sym_multiline_basic_string_end,
+    ACTIONS(198), 2,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+    STATE(38), 2,
+      sym_multiline_basic_string_content,
+      aux_sym_multiline_basic_string_repeat1,
+    ACTIONS(196), 3,
+      sym__multiline_basic_string_content_internal,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+  [1957] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(208), 1,
+      sym_multiline_basic_string_end,
+    ACTIONS(205), 2,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+    STATE(38), 2,
+      sym_multiline_basic_string_content,
+      aux_sym_multiline_basic_string_repeat1,
+    ACTIONS(202), 3,
+      sym__multiline_basic_string_content_internal,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+  [1977] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(210), 1,
+      sym_bare_key,
+    ACTIONS(212), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(214), 1,
+      anon_sym_SQUOTE,
+    STATE(122), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(121), 3,
+      sym__key,
+      sym_dotted_key,
+      sym_quoted_key,
+  [1999] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(216), 1,
+      sym_multiline_basic_string_end,
+    ACTIONS(198), 2,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+    STATE(38), 2,
+      sym_multiline_basic_string_content,
+      aux_sym_multiline_basic_string_repeat1,
+    ACTIONS(196), 3,
+      sym__multiline_basic_string_content_internal,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+  [2019] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(220), 1,
+      sym_multiline_basic_string_end,
+    ACTIONS(218), 2,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+    STATE(40), 2,
+      sym_multiline_basic_string_content,
+      aux_sym_multiline_basic_string_repeat1,
+    ACTIONS(196), 3,
+      sym__multiline_basic_string_content_internal,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+  [2039] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(224), 1,
+      sym_multiline_basic_string_end,
+    ACTIONS(222), 2,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+    STATE(37), 2,
+      sym_multiline_basic_string_content,
+      aux_sym_multiline_basic_string_repeat1,
+    ACTIONS(196), 3,
+      sym__multiline_basic_string_content_internal,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+  [2059] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(15), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(17), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(226), 1,
+      sym_bare_key,
+    STATE(97), 2,
+      sym_basic_string,
+      sym_literal_string,
+    STATE(109), 2,
+      sym__key,
+      sym_quoted_key,
+  [2080] = 3,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(230), 1,
+      anon_sym_LBRACK,
+    ACTIONS(228), 6,
+      ts_builtin_sym_end,
+      aux_sym_document_token1,
+      anon_sym_LBRACK_LBRACK,
+      sym_bare_key,
+      anon_sym_DQUOTE,
+      anon_sym_SQUOTE,
+  [2095] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(212), 1,
+      anon_sym_DQUOTE,
+    ACTIONS(214), 1,
+      anon_sym_SQUOTE,
+    ACTIONS(232), 1,
+      sym_bare_key,
+    STATE(116), 2,
+      sym__key,
+      sym_quoted_key,
+    STATE(122), 2,
+      sym_basic_string,
+      sym_literal_string,
+  [2116] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(234), 6,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2128] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(238), 1,
+      sym_multiline_literal_string_end,
+    STATE(51), 2,
+      sym_multiline_literal_string_content,
+      aux_sym_multiline_literal_string_repeat1,
+    ACTIONS(236), 3,
+      sym__multiline_literal_string_content_internal,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2144] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(240), 6,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2156] = 5,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(242), 1,
+      ts_builtin_sym_end,
+    ACTIONS(244), 1,
+      anon_sym_LBRACK,
+    ACTIONS(247), 1,
+      anon_sym_LBRACK_LBRACK,
+    STATE(49), 3,
+      sym_table,
+      sym_table_array_element,
+      aux_sym_document_repeat2,
+  [2174] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(250), 6,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2186] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(255), 1,
+      sym_multiline_literal_string_end,
+    STATE(51), 2,
+      sym_multiline_literal_string_content,
+      aux_sym_multiline_literal_string_repeat1,
+    ACTIONS(252), 3,
+      sym__multiline_literal_string_content_internal,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2202] = 5,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(9), 1,
+      anon_sym_LBRACK,
+    ACTIONS(11), 1,
+      anon_sym_LBRACK_LBRACK,
+    ACTIONS(257), 1,
+      ts_builtin_sym_end,
+    STATE(49), 3,
+      sym_table,
+      sym_table_array_element,
+      aux_sym_document_repeat2,
+  [2220] = 5,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(9), 1,
+      anon_sym_LBRACK,
+    ACTIONS(11), 1,
+      anon_sym_LBRACK_LBRACK,
+    ACTIONS(146), 1,
+      ts_builtin_sym_end,
+    STATE(49), 3,
+      sym_table,
+      sym_table_array_element,
+      aux_sym_document_repeat2,
+  [2238] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(259), 6,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2250] = 2,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(261), 6,
+      sym__multiline_basic_string_content_internal,
+      sym_multiline_basic_string_end,
+      aux_sym_basic_string_content_token1,
+      aux_sym_multiline_basic_string_content_token1,
+      sym_escape_sequence,
+      sym__escape_line_ending,
+  [2262] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(263), 1,
+      sym_multiline_literal_string_end,
+    STATE(47), 2,
+      sym_multiline_literal_string_content,
+      aux_sym_multiline_literal_string_repeat1,
+    ACTIONS(236), 3,
+      sym__multiline_literal_string_content_internal,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2278] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(265), 1,
+      sym_multiline_literal_string_end,
+    STATE(51), 2,
+      sym_multiline_literal_string_content,
+      aux_sym_multiline_literal_string_repeat1,
+    ACTIONS(236), 3,
+      sym__multiline_literal_string_content_internal,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2294] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(267), 1,
+      sym_multiline_literal_string_end,
+    STATE(57), 2,
+      sym_multiline_literal_string_content,
+      aux_sym_multiline_literal_string_repeat1,
+    ACTIONS(236), 3,
+      sym__multiline_literal_string_content_internal,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2310] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(63), 1,
+      anon_sym_RBRACK,
+    ACTIONS(269), 1,
+      anon_sym_COMMA,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    STATE(102), 1,
+      aux_sym_array_repeat2,
+  [2329] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(271), 1,
+      anon_sym_DQUOTE2,
+    ACTIONS(273), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(276), 1,
+      sym_escape_sequence,
+    STATE(60), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2346] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(51), 1,
+      anon_sym_RBRACK,
+    ACTIONS(279), 1,
+      anon_sym_COMMA,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    STATE(106), 1,
+      aux_sym_array_repeat2,
+  [2365] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(63), 1,
+      anon_sym_RBRACK,
+    ACTIONS(269), 1,
+      anon_sym_COMMA,
+    ACTIONS(281), 1,
+      aux_sym_document_token1,
+    STATE(61), 1,
+      aux_sym_array_repeat1,
+    STATE(102), 1,
+      aux_sym_array_repeat2,
+  [2384] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(283), 1,
+      anon_sym_DQUOTE2,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(287), 1,
+      sym_escape_sequence,
+    STATE(67), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2401] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(289), 1,
+      anon_sym_DQUOTE2,
+    ACTIONS(291), 1,
+      sym_escape_sequence,
+    STATE(65), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2418] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(293), 1,
+      anon_sym_DQUOTE2,
+    ACTIONS(295), 1,
+      sym_escape_sequence,
+    STATE(60), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2435] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(97), 1,
+      anon_sym_RBRACK,
+    ACTIONS(297), 1,
+      anon_sym_COMMA,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    STATE(111), 1,
+      aux_sym_array_repeat2,
+  [2454] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(295), 1,
+      sym_escape_sequence,
+    ACTIONS(299), 1,
+      anon_sym_DQUOTE2,
+    STATE(60), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2471] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(97), 1,
+      anon_sym_RBRACK,
+    ACTIONS(297), 1,
+      anon_sym_COMMA,
+    ACTIONS(301), 1,
+      aux_sym_document_token1,
+    STATE(69), 1,
+      aux_sym_array_repeat1,
+    STATE(111), 1,
+      aux_sym_array_repeat2,
+  [2490] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    ACTIONS(79), 1,
+      anon_sym_RBRACK,
+    ACTIONS(303), 1,
+      anon_sym_COMMA,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    STATE(110), 1,
+      aux_sym_array_repeat2,
+  [2509] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(67), 1,
+      anon_sym_RBRACK,
+    ACTIONS(305), 1,
+      aux_sym_document_token1,
+    ACTIONS(307), 1,
+      anon_sym_COMMA,
+    STATE(59), 1,
+      aux_sym_array_repeat1,
+    STATE(99), 1,
+      aux_sym_array_repeat2,
+  [2528] = 6,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(99), 1,
+      anon_sym_RBRACK,
+    ACTIONS(309), 1,
+      aux_sym_document_token1,
+    ACTIONS(311), 1,
+      anon_sym_COMMA,
+    STATE(66), 1,
+      aux_sym_array_repeat1,
+    STATE(96), 1,
+      aux_sym_array_repeat2,
+  [2547] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(313), 1,
+      anon_sym_DQUOTE2,
+    ACTIONS(315), 1,
+      sym_escape_sequence,
+    STATE(73), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2564] = 5,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(285), 1,
+      aux_sym_basic_string_content_token1,
+    ACTIONS(295), 1,
+      sym_escape_sequence,
+    ACTIONS(317), 1,
+      anon_sym_DQUOTE2,
+    STATE(60), 2,
+      sym_basic_string_content,
+      aux_sym_basic_string_repeat1,
+  [2581] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(319), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2591] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(321), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2601] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(323), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2611] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(325), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2621] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(327), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2631] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(329), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2641] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(331), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2651] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(333), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2661] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(335), 1,
+      aux_sym_document_token1,
+    STATE(84), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(337), 2,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+  [2675] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(339), 1,
+      aux_sym_document_token1,
+    STATE(85), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(341), 2,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+  [2689] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(343), 2,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+  [2703] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(45), 1,
+      aux_sym_document_token1,
+    STATE(26), 1,
+      aux_sym_array_repeat1,
+    ACTIONS(337), 2,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+  [2717] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(345), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2727] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(347), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2737] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(349), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2747] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(351), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2757] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(353), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2767] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(355), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2777] = 2,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(357), 4,
+      sym__multiline_literal_string_content_internal,
+      sym_multiline_literal_string_end,
+      aux_sym_multiline_basic_string_content_token1,
+      aux_sym_literal_string_content_token1,
+  [2787] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(359), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2797] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(361), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2807] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(363), 4,
+      aux_sym_document_token1,
+      anon_sym_RBRACK,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [2817] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(97), 1,
+      anon_sym_RBRACK,
+    ACTIONS(297), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [2830] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(365), 3,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+  [2839] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(367), 1,
+      anon_sym_COMMA,
+    ACTIONS(369), 1,
+      anon_sym_RBRACE,
+    STATE(101), 1,
+      aux_sym_inline_table_repeat1,
+  [2852] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(63), 1,
+      anon_sym_RBRACK,
+    ACTIONS(269), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [2865] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(341), 1,
+      anon_sym_RBRACK,
+    ACTIONS(371), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [2878] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(374), 1,
+      anon_sym_COMMA,
+    ACTIONS(377), 1,
+      anon_sym_RBRACE,
+    STATE(101), 1,
+      aux_sym_inline_table_repeat1,
+  [2891] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(51), 1,
+      anon_sym_RBRACK,
+    ACTIONS(279), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [2904] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(367), 1,
+      anon_sym_COMMA,
+    ACTIONS(379), 1,
+      anon_sym_RBRACE,
+    STATE(98), 1,
+      aux_sym_inline_table_repeat1,
+  [2917] = 2,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(381), 3,
+      anon_sym_DQUOTE2,
+      aux_sym_basic_string_content_token1,
+      sym_escape_sequence,
+  [2926] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(383), 1,
+      anon_sym_SQUOTE2,
+    ACTIONS(385), 1,
+      aux_sym_literal_string_content_token1,
+    STATE(126), 1,
+      sym_literal_string_content,
+  [2939] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(23), 1,
+      anon_sym_RBRACK,
+    ACTIONS(387), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [2952] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(367), 1,
+      anon_sym_COMMA,
+    ACTIONS(389), 1,
+      anon_sym_RBRACE,
+    STATE(101), 1,
+      aux_sym_inline_table_repeat1,
+  [2965] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(367), 1,
+      anon_sym_COMMA,
+    ACTIONS(391), 1,
+      anon_sym_RBRACE,
+    STATE(107), 1,
+      aux_sym_inline_table_repeat1,
+  [2978] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(393), 3,
+      anon_sym_RBRACK,
+      anon_sym_EQ,
+      anon_sym_DOT,
+  [2987] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(85), 1,
+      anon_sym_RBRACK,
+    ACTIONS(395), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [3000] = 4,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(79), 1,
+      anon_sym_RBRACK,
+    ACTIONS(303), 1,
+      anon_sym_COMMA,
+    STATE(100), 1,
+      aux_sym_array_repeat2,
+  [3013] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(385), 1,
+      aux_sym_literal_string_content_token1,
+    ACTIONS(397), 1,
+      anon_sym_SQUOTE2,
+    STATE(140), 1,
+      sym_literal_string_content,
+  [3026] = 4,
+    ACTIONS(194), 1,
+      sym_comment,
+    ACTIONS(385), 1,
+      aux_sym_literal_string_content_token1,
+    ACTIONS(399), 1,
+      anon_sym_SQUOTE2,
+    STATE(154), 1,
+      sym_literal_string_content,
+  [3039] = 3,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(401), 1,
+      anon_sym_EQ,
+    ACTIONS(403), 1,
+      anon_sym_DOT,
+  [3049] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(405), 2,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [3057] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(393), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3065] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(407), 2,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [3073] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(234), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3081] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(240), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3089] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(250), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3097] = 3,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(409), 1,
+      anon_sym_RBRACK_RBRACK,
+    ACTIONS(411), 1,
+      anon_sym_DOT,
+  [3107] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(365), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3115] = 3,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(403), 1,
+      anon_sym_DOT,
+    ACTIONS(413), 1,
+      anon_sym_RBRACK,
+  [3125] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(259), 2,
+      anon_sym_RBRACK_RBRACK,
+      anon_sym_DOT,
+  [3133] = 3,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(403), 1,
+      anon_sym_DOT,
+    ACTIONS(415), 1,
+      anon_sym_EQ,
+  [3143] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(417), 1,
+      anon_sym_SQUOTE2,
+  [3150] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(259), 1,
+      sym__line_ending_or_eof,
+  [3157] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(347), 1,
+      sym__line_ending_or_eof,
+  [3164] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(329), 1,
+      sym__line_ending_or_eof,
+  [3171] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(321), 1,
+      sym__line_ending_or_eof,
+  [3178] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(361), 1,
+      sym__line_ending_or_eof,
+  [3185] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(407), 1,
+      sym__line_ending_or_eof,
+  [3192] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(349), 1,
+      sym__line_ending_or_eof,
+  [3199] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(419), 1,
+      sym__line_ending_or_eof,
+  [3206] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(421), 1,
+      anon_sym_SQUOTE2,
+  [3213] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(423), 1,
+      sym__line_ending_or_eof,
+  [3220] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(363), 1,
+      sym__line_ending_or_eof,
+  [3227] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(331), 1,
+      sym__line_ending_or_eof,
+  [3234] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(355), 1,
+      sym__line_ending_or_eof,
+  [3241] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(425), 1,
+      anon_sym_SQUOTE2,
+  [3248] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(323), 1,
+      sym__line_ending_or_eof,
+  [3255] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(325), 1,
+      sym__line_ending_or_eof,
+  [3262] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(359), 1,
+      sym__line_ending_or_eof,
+  [3269] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(333), 1,
+      sym__line_ending_or_eof,
+  [3276] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(351), 1,
+      sym__line_ending_or_eof,
+  [3283] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(427), 1,
+      sym__line_ending_or_eof,
+  [3290] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(319), 1,
+      sym__line_ending_or_eof,
+  [3297] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(327), 1,
+      sym__line_ending_or_eof,
+  [3304] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(234), 1,
+      sym__line_ending_or_eof,
+  [3311] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(353), 1,
+      sym__line_ending_or_eof,
+  [3318] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(240), 1,
+      sym__line_ending_or_eof,
+  [3325] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(250), 1,
+      sym__line_ending_or_eof,
+  [3332] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(429), 1,
+      ts_builtin_sym_end,
+  [3339] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(431), 1,
+      anon_sym_SQUOTE2,
+  [3346] = 2,
+    ACTIONS(3), 1,
+      sym_comment,
+    ACTIONS(345), 1,
+      sym__line_ending_or_eof,
+};
+
+static const uint32_t ts_small_parse_table_map[] = {
+  [SMALL_STATE(2)] = 0,
+  [SMALL_STATE(3)] = 66,
+  [SMALL_STATE(4)] = 132,
+  [SMALL_STATE(5)] = 198,
+  [SMALL_STATE(6)] = 264,
+  [SMALL_STATE(7)] = 330,
+  [SMALL_STATE(8)] = 396,
+  [SMALL_STATE(9)] = 462,
+  [SMALL_STATE(10)] = 528,
+  [SMALL_STATE(11)] = 594,
+  [SMALL_STATE(12)] = 660,
+  [SMALL_STATE(13)] = 726,
+  [SMALL_STATE(14)] = 792,
+  [SMALL_STATE(15)] = 858,
+  [SMALL_STATE(16)] = 924,
+  [SMALL_STATE(17)] = 990,
+  [SMALL_STATE(18)] = 1056,
+  [SMALL_STATE(19)] = 1122,
+  [SMALL_STATE(20)] = 1188,
+  [SMALL_STATE(21)] = 1254,
+  [SMALL_STATE(22)] = 1320,
+  [SMALL_STATE(23)] = 1383,
+  [SMALL_STATE(24)] = 1446,
+  [SMALL_STATE(25)] = 1503,
+  [SMALL_STATE(26)] = 1560,
+  [SMALL_STATE(27)] = 1593,
+  [SMALL_STATE(28)] = 1639,
+  [SMALL_STATE(29)] = 1678,
+  [SMALL_STATE(30)] = 1717,
+  [SMALL_STATE(31)] = 1756,
+  [SMALL_STATE(32)] = 1795,
+  [SMALL_STATE(33)] = 1834,
+  [SMALL_STATE(34)] = 1862,
+  [SMALL_STATE(35)] = 1890,
+  [SMALL_STATE(36)] = 1915,
+  [SMALL_STATE(37)] = 1937,
+  [SMALL_STATE(38)] = 1957,
+  [SMALL_STATE(39)] = 1977,
+  [SMALL_STATE(40)] = 1999,
+  [SMALL_STATE(41)] = 2019,
+  [SMALL_STATE(42)] = 2039,
+  [SMALL_STATE(43)] = 2059,
+  [SMALL_STATE(44)] = 2080,
+  [SMALL_STATE(45)] = 2095,
+  [SMALL_STATE(46)] = 2116,
+  [SMALL_STATE(47)] = 2128,
+  [SMALL_STATE(48)] = 2144,
+  [SMALL_STATE(49)] = 2156,
+  [SMALL_STATE(50)] = 2174,
+  [SMALL_STATE(51)] = 2186,
+  [SMALL_STATE(52)] = 2202,
+  [SMALL_STATE(53)] = 2220,
+  [SMALL_STATE(54)] = 2238,
+  [SMALL_STATE(55)] = 2250,
+  [SMALL_STATE(56)] = 2262,
+  [SMALL_STATE(57)] = 2278,
+  [SMALL_STATE(58)] = 2294,
+  [SMALL_STATE(59)] = 2310,
+  [SMALL_STATE(60)] = 2329,
+  [SMALL_STATE(61)] = 2346,
+  [SMALL_STATE(62)] = 2365,
+  [SMALL_STATE(63)] = 2384,
+  [SMALL_STATE(64)] = 2401,
+  [SMALL_STATE(65)] = 2418,
+  [SMALL_STATE(66)] = 2435,
+  [SMALL_STATE(67)] = 2454,
+  [SMALL_STATE(68)] = 2471,
+  [SMALL_STATE(69)] = 2490,
+  [SMALL_STATE(70)] = 2509,
+  [SMALL_STATE(71)] = 2528,
+  [SMALL_STATE(72)] = 2547,
+  [SMALL_STATE(73)] = 2564,
+  [SMALL_STATE(74)] = 2581,
+  [SMALL_STATE(75)] = 2591,
+  [SMALL_STATE(76)] = 2601,
+  [SMALL_STATE(77)] = 2611,
+  [SMALL_STATE(78)] = 2621,
+  [SMALL_STATE(79)] = 2631,
+  [SMALL_STATE(80)] = 2641,
+  [SMALL_STATE(81)] = 2651,
+  [SMALL_STATE(82)] = 2661,
+  [SMALL_STATE(83)] = 2675,
+  [SMALL_STATE(84)] = 2689,
+  [SMALL_STATE(85)] = 2703,
+  [SMALL_STATE(86)] = 2717,
+  [SMALL_STATE(87)] = 2727,
+  [SMALL_STATE(88)] = 2737,
+  [SMALL_STATE(89)] = 2747,
+  [SMALL_STATE(90)] = 2757,
+  [SMALL_STATE(91)] = 2767,
+  [SMALL_STATE(92)] = 2777,
+  [SMALL_STATE(93)] = 2787,
+  [SMALL_STATE(94)] = 2797,
+  [SMALL_STATE(95)] = 2807,
+  [SMALL_STATE(96)] = 2817,
+  [SMALL_STATE(97)] = 2830,
+  [SMALL_STATE(98)] = 2839,
+  [SMALL_STATE(99)] = 2852,
+  [SMALL_STATE(100)] = 2865,
+  [SMALL_STATE(101)] = 2878,
+  [SMALL_STATE(102)] = 2891,
+  [SMALL_STATE(103)] = 2904,
+  [SMALL_STATE(104)] = 2917,
+  [SMALL_STATE(105)] = 2926,
+  [SMALL_STATE(106)] = 2939,
+  [SMALL_STATE(107)] = 2952,
+  [SMALL_STATE(108)] = 2965,
+  [SMALL_STATE(109)] = 2978,
+  [SMALL_STATE(110)] = 2987,
+  [SMALL_STATE(111)] = 3000,
+  [SMALL_STATE(112)] = 3013,
+  [SMALL_STATE(113)] = 3026,
+  [SMALL_STATE(114)] = 3039,
+  [SMALL_STATE(115)] = 3049,
+  [SMALL_STATE(116)] = 3057,
+  [SMALL_STATE(117)] = 3065,
+  [SMALL_STATE(118)] = 3073,
+  [SMALL_STATE(119)] = 3081,
+  [SMALL_STATE(120)] = 3089,
+  [SMALL_STATE(121)] = 3097,
+  [SMALL_STATE(122)] = 3107,
+  [SMALL_STATE(123)] = 3115,
+  [SMALL_STATE(124)] = 3125,
+  [SMALL_STATE(125)] = 3133,
+  [SMALL_STATE(126)] = 3143,
+  [SMALL_STATE(127)] = 3150,
+  [SMALL_STATE(128)] = 3157,
+  [SMALL_STATE(129)] = 3164,
+  [SMALL_STATE(130)] = 3171,
+  [SMALL_STATE(131)] = 3178,
+  [SMALL_STATE(132)] = 3185,
+  [SMALL_STATE(133)] = 3192,
+  [SMALL_STATE(134)] = 3199,
+  [SMALL_STATE(135)] = 3206,
+  [SMALL_STATE(136)] = 3213,
+  [SMALL_STATE(137)] = 3220,
+  [SMALL_STATE(138)] = 3227,
+  [SMALL_STATE(139)] = 3234,
+  [SMALL_STATE(140)] = 3241,
+  [SMALL_STATE(141)] = 3248,
+  [SMALL_STATE(142)] = 3255,
+  [SMALL_STATE(143)] = 3262,
+  [SMALL_STATE(144)] = 3269,
+  [SMALL_STATE(145)] = 3276,
+  [SMALL_STATE(146)] = 3283,
+  [SMALL_STATE(147)] = 3290,
+  [SMALL_STATE(148)] = 3297,
+  [SMALL_STATE(149)] = 3304,
+  [SMALL_STATE(150)] = 3311,
+  [SMALL_STATE(151)] = 3318,
+  [SMALL_STATE(152)] = 3325,
+  [SMALL_STATE(153)] = 3332,
+  [SMALL_STATE(154)] = 3339,
+  [SMALL_STATE(155)] = 3346,
+};
+
+static const TSParseActionEntry ts_parse_actions[] = {
+  [0] = {.entry = {.count = 0, .reusable = false}},
+  [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(),
+  [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(),
+  [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 0, 0, 0),
+  [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27),
+  [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36),
+  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39),
+  [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125),
+  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63),
+  [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112),
+  [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10),
+  [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15),
+  [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129),
+  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(63),
+  [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42),
+  [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112),
+  [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58),
+  [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(86),
+  [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86),
+  [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87),
+  [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83),
+  [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(83),
+  [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33),
+  [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26),
+  [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82),
+  [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(82),
+  [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148),
+  [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8),
+  [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145),
+  [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70),
+  [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70),
+  [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
+  [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141),
+  [65] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3),
+  [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143),
+  [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62),
+  [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(62),
+  [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81),
+  [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138),
+  [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14),
+  [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
+  [81] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13),
+  [83] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144),
+  [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79),
+  [87] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17),
+  [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89),
+  [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71),
+  [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71),
+  [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19),
+  [97] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76),
+  [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93),
+  [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68),
+  [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(68),
+  [105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20),
+  [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80),
+  [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9),
+  [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
+  [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5),
+  [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72),
+  [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41),
+  [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113),
+  [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56),
+  [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(155),
+  [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155),
+  [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128),
+  [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132),
+  [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132),
+  [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34),
+  [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117),
+  [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117),
+  [139] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), SHIFT_REPEAT(26),
+  [142] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0),
+  [144] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0),
+  [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 1, 0, 0),
+  [148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30),
+  [150] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 4, 0, 0),
+  [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31),
+  [154] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 4, 0, 0),
+  [156] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_array_element, 5, 0, 0),
+  [158] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_array_element, 5, 0, 0),
+  [160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0),
+  [162] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(30),
+  [165] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0),
+  [167] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(125),
+  [170] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(63),
+  [173] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat1, 2, 0, 0), SHIFT_REPEAT(112),
+  [176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 5, 0, 0),
+  [178] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 5, 0, 0),
+  [180] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table_array_element, 4, 0, 0),
+  [182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29),
+  [184] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table_array_element, 4, 0, 0),
+  [186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114),
+  [188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74),
+  [190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147),
+  [192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123),
+  [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(),
+  [196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55),
+  [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38),
+  [200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94),
+  [202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_multiline_basic_string_repeat1, 2, 0, 0), SHIFT_REPEAT(55),
+  [205] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_multiline_basic_string_repeat1, 2, 0, 0), SHIFT_REPEAT(38),
+  [208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_multiline_basic_string_repeat1, 2, 0, 0),
+  [210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121),
+  [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64),
+  [214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105),
+  [216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131),
+  [218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40),
+  [220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150),
+  [222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37),
+  [224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90),
+  [226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109),
+  [228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pair, 2, 0, 0),
+  [230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pair, 2, 0, 0),
+  [232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116),
+  [234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_basic_string, 2, 0, 0),
+  [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92),
+  [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137),
+  [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal_string, 2, 0, 0),
+  [242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_document_repeat2, 2, 0, 0),
+  [244] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_document_repeat2, 2, 0, 0), SHIFT_REPEAT(36),
+  [247] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_document_repeat2, 2, 0, 0), SHIFT_REPEAT(39),
+  [250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_basic_string, 3, 0, 0),
+  [252] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_multiline_literal_string_repeat1, 2, 0, 0), SHIFT_REPEAT(92),
+  [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_multiline_literal_string_repeat1, 2, 0, 0),
+  [257] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_document, 2, 0, 0),
+  [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal_string, 3, 0, 0),
+  [261] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_basic_string_content, 1, 0, 0),
+  [263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139),
+  [265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95),
+  [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91),
+  [269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7),
+  [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_basic_string_repeat1, 2, 0, 0),
+  [273] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_basic_string_repeat1, 2, 0, 0), SHIFT_REPEAT(104),
+  [276] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_basic_string_repeat1, 2, 0, 0), SHIFT_REPEAT(60),
+  [279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2),
+  [281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61),
+  [283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46),
+  [285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104),
+  [287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67),
+  [289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118),
+  [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65),
+  [293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120),
+  [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60),
+  [297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11),
+  [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50),
+  [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
+  [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18),
+  [305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59),
+  [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6),
+  [309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66),
+  [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16),
+  [313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149),
+  [315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73),
+  [317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152),
+  [319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inline_table, 2, 0, 0),
+  [321] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inline_table, 3, 0, 1),
+  [323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 4, 0, 0),
+  [325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inline_table, 4, 0, 1),
+  [327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 5, 0, 0),
+  [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 6, 0, 0),
+  [331] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 7, 0, 0),
+  [333] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 8, 0, 0),
+  [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84),
+  [337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat2, 3, 0, 0),
+  [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85),
+  [341] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat2, 2, 0, 0),
+  [343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat2, 4, 0, 0),
+  [345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer, 1, 0, 0),
+  [347] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_float, 1, 0, 0),
+  [349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string, 1, 0, 0),
+  [351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 2, 0, 0),
+  [353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_basic_string, 2, 0, 0),
+  [355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_literal_string, 2, 0, 0),
+  [357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_literal_string_content, 1, 0, 0),
+  [359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 3, 0, 0),
+  [361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_basic_string, 3, 0, 0),
+  [363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiline_literal_string, 3, 0, 0),
+  [365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_key, 1, 0, 0),
+  [367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35),
+  [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142),
+  [371] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat2, 2, 0, 0), SHIFT_REPEAT(22),
+  [374] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_inline_table_repeat1, 2, 0, 0), SHIFT_REPEAT(35),
+  [377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_inline_table_repeat1, 2, 0, 0),
+  [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130),
+  [381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_basic_string_content, 1, 0, 0),
+  [383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119),
+  [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135),
+  [387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12),
+  [389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77),
+  [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75),
+  [393] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_key, 3, 0, 0),
+  [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
+  [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48),
+  [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151),
+  [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
+  [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43),
+  [405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_inline_table_repeat1, 2, 0, 1),
+  [407] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__inline_pair, 3, 0, 0),
+  [409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146),
+  [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45),
+  [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136),
+  [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24),
+  [417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124),
+  [419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44),
+  [421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal_string_content, 1, 0, 0),
+  [423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28),
+  [425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54),
+  [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32),
+  [429] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
+  [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127),
+};
+
+enum ts_external_scanner_symbol_identifiers {
+  ts_external_token__line_ending_or_eof = 0,
+  ts_external_token__multiline_basic_string_content_internal = 1,
+  ts_external_token_multiline_basic_string_end = 2,
+  ts_external_token__multiline_literal_string_content_internal = 3,
+  ts_external_token_multiline_literal_string_end = 4,
+};
+
+static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = {
+  [ts_external_token__line_ending_or_eof] = sym__line_ending_or_eof,
+  [ts_external_token__multiline_basic_string_content_internal] = sym__multiline_basic_string_content_internal,
+  [ts_external_token_multiline_basic_string_end] = sym_multiline_basic_string_end,
+  [ts_external_token__multiline_literal_string_content_internal] = sym__multiline_literal_string_content_internal,
+  [ts_external_token_multiline_literal_string_end] = sym_multiline_literal_string_end,
+};
+
+static const bool ts_external_scanner_states[5][EXTERNAL_TOKEN_COUNT] = {
+  [1] = {
+    [ts_external_token__line_ending_or_eof] = true,
+    [ts_external_token__multiline_basic_string_content_internal] = true,
+    [ts_external_token_multiline_basic_string_end] = true,
+    [ts_external_token__multiline_literal_string_content_internal] = true,
+    [ts_external_token_multiline_literal_string_end] = true,
+  },
+  [2] = {
+    [ts_external_token__multiline_basic_string_content_internal] = true,
+    [ts_external_token_multiline_basic_string_end] = true,
+  },
+  [3] = {
+    [ts_external_token__multiline_literal_string_content_internal] = true,
+    [ts_external_token_multiline_literal_string_end] = true,
+  },
+  [4] = {
+    [ts_external_token__line_ending_or_eof] = true,
+  },
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void *tree_sitter_toml_external_scanner_create(void);
+void tree_sitter_toml_external_scanner_destroy(void *);
+bool tree_sitter_toml_external_scanner_scan(void *, TSLexer *, const bool *);
+unsigned tree_sitter_toml_external_scanner_serialize(void *, char *);
+void tree_sitter_toml_external_scanner_deserialize(void *, const char *, unsigned);
+
+#ifdef TREE_SITTER_HIDE_SYMBOLS
+#define TS_PUBLIC
+#elif defined(_WIN32)
+#define TS_PUBLIC __declspec(dllexport)
+#else
+#define TS_PUBLIC __attribute__((visibility("default")))
+#endif
+
+TS_PUBLIC const TSLanguage *tree_sitter_toml(void) {
+  static const TSLanguage language = {
+    .abi_version = LANGUAGE_VERSION,
+    .symbol_count = SYMBOL_COUNT,
+    .alias_count = ALIAS_COUNT,
+    .token_count = TOKEN_COUNT,
+    .external_token_count = EXTERNAL_TOKEN_COUNT,
+    .state_count = STATE_COUNT,
+    .large_state_count = LARGE_STATE_COUNT,
+    .production_id_count = PRODUCTION_ID_COUNT,
+    .supertype_count = SUPERTYPE_COUNT,
+    .field_count = FIELD_COUNT,
+    .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
+    .parse_table = &ts_parse_table[0][0],
+    .small_parse_table = ts_small_parse_table,
+    .small_parse_table_map = ts_small_parse_table_map,
+    .parse_actions = ts_parse_actions,
+    .symbol_names = ts_symbol_names,
+    .symbol_metadata = ts_symbol_metadata,
+    .public_symbol_map = ts_symbol_map,
+    .alias_map = ts_non_terminal_alias_map,
+    .alias_sequences = &ts_alias_sequences[0][0],
+    .lex_modes = (const void*)ts_lex_modes,
+    .lex_fn = ts_lex,
+    .external_scanner = {
+      &ts_external_scanner_states[0][0],
+      ts_external_scanner_symbol_map,
+      tree_sitter_toml_external_scanner_create,
+      tree_sitter_toml_external_scanner_destroy,
+      tree_sitter_toml_external_scanner_scan,
+      tree_sitter_toml_external_scanner_serialize,
+      tree_sitter_toml_external_scanner_deserialize,
+    },
+    .primary_state_ids = ts_primary_state_ids,
+    .name = "toml",
+    .max_reserved_word_set_size = 0,
+    .metadata = {
+      .major_version = 0,
+      .minor_version = 7,
+      .patch_version = 0,
+    },
+  };
+  return &language;
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/library/tstoml/src/tree-sitter/toml/scanner.c b/src/library/tstoml/src/tree-sitter/toml/scanner.c
new file mode 100644
index 0000000000..9640bfe183
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/scanner.c
@@ -0,0 +1,82 @@
+#include "tree_sitter/parser.h"
+
+typedef enum {
+    LINE_ENDING_OR_EOF,
+    MULTILINE_BASIC_STRING_CONTENT_INTERNAL,
+    MULTILINE_BASIC_STRING_END,
+    MULTILINE_LITERAL_STRING_CONTENT_INTERNAL,
+    MULTILINE_LITERAL_STRING_END,
+} TokenType;
+
+void *tree_sitter_toml_external_scanner_create() { return NULL; }
+
+void tree_sitter_toml_external_scanner_destroy(void *payload) {}
+
+unsigned tree_sitter_toml_external_scanner_serialize(void *payload, char *buffer) { return 0; }
+
+void tree_sitter_toml_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {}
+
+bool tree_sitter_toml_external_scanner_scan_multiline_string_end(TSLexer *lexer, const bool *valid_symbols,
+                                                                 int32_t delimiter, TokenType content_symbol,
+                                                                 TokenType end_symbol) {
+    if (!valid_symbols[end_symbol] || lexer->lookahead != delimiter) {
+        return false;
+    }
+
+    lexer->advance(lexer, false);
+    lexer->mark_end(lexer);
+
+    if (lexer->lookahead != delimiter) {
+        lexer->result_symbol = content_symbol;
+        return true;
+    }
+
+    lexer->advance(lexer, false);
+
+    if (lexer->lookahead != delimiter) {
+        lexer->mark_end(lexer);
+        lexer->result_symbol = content_symbol;
+        return true;
+    }
+
+    lexer->advance(lexer, false);
+
+    if (lexer->lookahead != delimiter) {
+        lexer->mark_end(lexer);
+        lexer->result_symbol = end_symbol;
+        return true;
+    }
+
+    lexer->result_symbol = content_symbol;
+    return true;
+}
+
+bool tree_sitter_toml_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
+    if (tree_sitter_toml_external_scanner_scan_multiline_string_end(
+            lexer, valid_symbols, '"', MULTILINE_BASIC_STRING_CONTENT_INTERNAL, MULTILINE_BASIC_STRING_END) ||
+        tree_sitter_toml_external_scanner_scan_multiline_string_end(
+            lexer, valid_symbols, '\'', MULTILINE_LITERAL_STRING_CONTENT_INTERNAL, MULTILINE_LITERAL_STRING_END)) {
+        return true;
+    }
+
+    if (valid_symbols[LINE_ENDING_OR_EOF]) {
+        lexer->result_symbol = LINE_ENDING_OR_EOF;
+
+        while (lexer->lookahead == ' ' || lexer->lookahead == '\t') {
+            lexer->advance(lexer, true);
+        }
+
+        if (lexer->lookahead == 0 || lexer->lookahead == '\n') {
+            return true;
+        }
+
+        if (lexer->lookahead == '\r') {
+            lexer->advance(lexer, true);
+            if (lexer->lookahead == '\n') {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
diff --git a/src/library/tstoml/src/tree-sitter/toml/tree_sitter/alloc.h b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/alloc.h
new file mode 100644
index 0000000000..1abdd12015
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/alloc.h
@@ -0,0 +1,54 @@
+#ifndef TREE_SITTER_ALLOC_H_
+#define TREE_SITTER_ALLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Allow clients to override allocation functions
+#ifdef TREE_SITTER_REUSE_ALLOCATOR
+
+extern void *(*ts_current_malloc)(size_t size);
+extern void *(*ts_current_calloc)(size_t count, size_t size);
+extern void *(*ts_current_realloc)(void *ptr, size_t size);
+extern void (*ts_current_free)(void *ptr);
+
+#ifndef ts_malloc
+#define ts_malloc  ts_current_malloc
+#endif
+#ifndef ts_calloc
+#define ts_calloc  ts_current_calloc
+#endif
+#ifndef ts_realloc
+#define ts_realloc ts_current_realloc
+#endif
+#ifndef ts_free
+#define ts_free    ts_current_free
+#endif
+
+#else
+
+#ifndef ts_malloc
+#define ts_malloc  malloc
+#endif
+#ifndef ts_calloc
+#define ts_calloc  calloc
+#endif
+#ifndef ts_realloc
+#define ts_realloc realloc
+#endif
+#ifndef ts_free
+#define ts_free    free
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_SITTER_ALLOC_H_
diff --git a/src/library/tstoml/src/tree-sitter/toml/tree_sitter/array.h b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/array.h
new file mode 100644
index 0000000000..85597d24c8
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/array.h
@@ -0,0 +1,291 @@
+#ifndef TREE_SITTER_ARRAY_H_
+#define TREE_SITTER_ARRAY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "./alloc.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4101)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#define Array(T)       \
+  struct {             \
+    T *contents;       \
+    uint32_t size;     \
+    uint32_t capacity; \
+  }
+
+/// Initialize an array.
+#define array_init(self) \
+  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
+
+/// Create an empty array.
+#define array_new() \
+  { NULL, 0, 0 }
+
+/// Get a pointer to the element at a given `index` in the array.
+#define array_get(self, _index) \
+  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
+
+/// Get a pointer to the first element in the array.
+#define array_front(self) array_get(self, 0)
+
+/// Get a pointer to the last element in the array.
+#define array_back(self) array_get(self, (self)->size - 1)
+
+/// Clear the array, setting its size to zero. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_clear(self) ((self)->size = 0)
+
+/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
+/// less than the array's current capacity, this function has no effect.
+#define array_reserve(self, new_capacity) \
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
+
+/// Free any memory allocated for this array. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_delete(self) _array__delete((Array *)(self))
+
+/// Push a new `element` onto the end of the array.
+#define array_push(self, element)                            \
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
+
+/// Increase the array's size by `count` elements.
+/// New elements are zero-initialized.
+#define array_grow_by(self, count) \
+  do { \
+    if ((count) == 0) break; \
+    _array__grow((Array *)(self), count, array_elem_size(self)); \
+    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
+    (self)->size += (count); \
+  } while (0)
+
+/// Append all elements from one array to the end of another.
+#define array_push_all(self, other)                                       \
+  array_extend((self), (other)->size, (other)->contents)
+
+/// Append `count` elements to the end of the array, reading their values from the
+/// `contents` pointer.
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
+  )
+
+/// Remove `old_count` elements from the array starting at the given `index`. At
+/// the same index, insert `new_count` new elements, reading their values from the
+/// `new_contents` pointer.
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
+  )
+
+/// Insert one `element` into the array at the given `index`.
+#define array_insert(self, _index, element) \
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
+
+/// Remove one element from the array at the given `index`.
+#define array_erase(self, _index) \
+  _array__erase((Array *)(self), array_elem_size(self), _index)
+
+/// Pop the last element off the array, returning the element by value.
+#define array_pop(self) ((self)->contents[--(self)->size])
+
+/// Assign the contents of one array to another, reallocating if necessary.
+#define array_assign(self, other) \
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
+
+/// Swap one array with another
+#define array_swap(self, other) \
+  _array__swap((Array *)(self), (Array *)(other))
+
+/// Get the size of the array contents
+#define array_elem_size(self) (sizeof *(self)->contents)
+
+/// Search a sorted array for a given `needle` value, using the given `compare`
+/// callback to determine the order.
+///
+/// If an existing element is found to be equal to `needle`, then the `index`
+/// out-parameter is set to the existing value's index, and the `exists`
+/// out-parameter is set to true. Otherwise, `index` is set to an index where
+/// `needle` should be inserted in order to preserve the sorting, and `exists`
+/// is set to false.
+#define array_search_sorted_with(self, compare, needle, _index, _exists) \
+  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
+
+/// Search a sorted array for a given `needle` value, using integer comparisons
+/// of a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_with`.
+#define array_search_sorted_by(self, field, needle, _index, _exists) \
+  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
+
+/// Insert a given `value` into a sorted array, using the given `compare`
+/// callback to determine the order.
+#define array_insert_sorted_with(self, compare, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+/// Insert a given `value` into a sorted array, using integer comparisons of
+/// a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_by`.
+#define array_insert_sorted_by(self, field, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+// Private
+
+typedef Array(void) Array;
+
+/// This is not what you're looking for, see `array_delete`.
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
+}
+
+/// This is not what you're looking for, see `array_erase`.
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  assert(index < self->size);
+  char *contents = (char *)self->contents;
+  memmove(contents + index * element_size, contents + (index + 1) * element_size,
+          (self->size - index - 1) * element_size);
+  self->size--;
+}
+
+/// This is not what you're looking for, see `array_reserve`.
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = ts_realloc(self->contents, new_capacity * element_size);
+    } else {
+      self->contents = ts_malloc(new_capacity * element_size);
+    }
+    self->capacity = new_capacity;
+  }
+}
+
+/// This is not what you're looking for, see `array_assign`.
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
+}
+
+/// This is not what you're looking for, see `array_swap`.
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
+}
+
+/// This is not what you're looking for, see `array_push` or `array_grow_by`.
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
+    if (new_capacity < 8) new_capacity = 8;
+    if (new_capacity < new_size) new_capacity = new_size;
+    _array__reserve(self, element_size, new_capacity);
+  }
+}
+
+/// This is not what you're looking for, see `array_splice`.
+static inline void _array__splice(Array *self, size_t element_size,
+                                 uint32_t index, uint32_t old_count,
+                                 uint32_t new_count, const void *elements) {
+  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t old_end = index + old_count;
+  uint32_t new_end = index + new_count;
+  assert(old_end <= self->size);
+
+  _array__reserve(self, element_size, new_size);
+
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
+    memmove(
+      contents + new_end * element_size,
+      contents + old_end * element_size,
+      (self->size - old_end) * element_size
+    );
+  }
+  if (new_count > 0) {
+    if (elements) {
+      memcpy(
+        (contents + index * element_size),
+        elements,
+        new_count * element_size
+      );
+    } else {
+      memset(
+        (contents + index * element_size),
+        0,
+        new_count * element_size
+      );
+    }
+  }
+  self->size += new_count - old_count;
+}
+
+/// A binary search routine, based on Rust's `std::slice::binary_search_by`.
+/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
+#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
+  do { \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
+    if (size == 0) break; \
+    int comparison; \
+    while (size > 1) { \
+      uint32_t half_size = size / 2; \
+      uint32_t mid_index = *(_index) + half_size; \
+      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
+      if (comparison <= 0) *(_index) = mid_index; \
+      size -= half_size; \
+    } \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
+  } while (0)
+
+/// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
+/// parameter by reference in order to work with the generic sorting function above.
+#define _compare_int(a, b) ((int)*(a) - (int)(b))
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#elif defined(__GNUC__) || defined(__clang__)
+# pragma GCC diagnostic pop
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_ARRAY_H_
diff --git a/src/library/tstoml/src/tree-sitter/toml/tree_sitter/parser.h b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/parser.h
new file mode 100644
index 0000000000..858107deb9
--- /dev/null
+++ b/src/library/tstoml/src/tree-sitter/toml/tree_sitter/parser.h
@@ -0,0 +1,286 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define ts_builtin_sym_error ((TSSymbol)-1)
+#define ts_builtin_sym_end 0
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t TSStateId;
+typedef uint16_t TSSymbol;
+typedef uint16_t TSFieldId;
+typedef struct TSLanguage TSLanguage;
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
+} TSLanguageMetadata;
+#endif
+
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
+} TSFieldMapEntry;
+
+// Used to index the field and supertype maps.
+typedef struct {
+  uint16_t index;
+  uint16_t length;
+} TSMapSlice;
+
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
+} TSSymbolMetadata;
+
+typedef struct TSLexer TSLexer;
+
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+  void (*log)(const TSLexer *, const char *, ...);
+};
+
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
+} TSParseActionType;
+
+typedef union {
+  struct {
+    uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
+} TSParseAction;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+} TSLexMode;
+
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+  uint16_t reserved_word_set_id;
+} TSLexerMode;
+
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
+} TSParseActionEntry;
+
+typedef struct {
+  int32_t start;
+  int32_t end;
+} TSCharacterRange;
+
+struct TSLanguage {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexerMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+  const char *name;
+  const TSSymbol *reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  const TSSymbol *supertype_symbols;
+  const TSMapSlice *supertype_map_slices;
+  const TSSymbol *supertype_map_entries;
+  TSLanguageMetadata metadata;
+};
+
+static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
+  uint32_t index = 0;
+  uint32_t size = len - index;
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = index + half_size;
+    const TSCharacterRange *range = &ranges[mid_index];
+    if (lookahead >= range->start && lookahead <= range->end) {
+      return true;
+    } else if (lookahead > range->end) {
+      index = mid_index;
+    }
+    size -= half_size;
+  }
+  const TSCharacterRange *range = &ranges[index];
+  return (lookahead >= range->start && lookahead <= range->end);
+}
+
+/*
+ *  Lexer Macros
+ */
+
+#ifdef _MSC_VER
+#define UNUSED __pragma(warning(suppress : 4101))
+#else
+#define UNUSED __attribute__((unused))
+#endif
+
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
+
+#define ADVANCE(state_value) \
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
+
+#define ADVANCE_MAP(...)                                              \
+  {                                                                   \
+    static const uint16_t map[] = { __VA_ARGS__ };                    \
+    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
+      if (map[i] == lookahead) {                                      \
+        state = map[i + 1];                                           \
+        goto next_state;                                              \
+      }                                                               \
+    }                                                                 \
+  }
+
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
+
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
+
+#define END_STATE() return result;
+
+/*
+ *  Parse Table Macros
+ */
+
+#define SMALL_STATE(id) ((id) - LARGE_STATE_COUNT)
+
+#define STATE(id) id
+
+#define ACTIONS(id) id
+
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
+
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
+
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
+
+#define REDUCE(symbol_name, children, precedence, prod_id) \
+  {{                                                       \
+    .reduce = {                                            \
+      .type = TSParseActionTypeReduce,                     \
+      .symbol = symbol_name,                               \
+      .child_count = children,                             \
+      .dynamic_precedence = precedence,                    \
+      .production_id = prod_id                             \
+    },                                                     \
+  }}
+
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
+
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_PARSER_H_
diff --git a/src/library/tstoml/tools/dynamic-help.R b/src/library/tstoml/tools/dynamic-help.R
new file mode 100644
index 0000000000..567c784a68
--- /dev/null
+++ b/src/library/tstoml/tools/dynamic-help.R
@@ -0,0 +1,5 @@
+cat(
+  sep = "\n",
+  "\\renewcommand{\\eval}{\\Sexpr[stage=render,results=rd]{#1}}",
+  file = "man/macros/eval2.Rd"
+)
diff --git a/src/library/tstoml/tools/man/quickstart.Rmd b/src/library/tstoml/tools/man/quickstart.Rmd
new file mode 100644
index 0000000000..188a53617f
--- /dev/null
+++ b/src/library/tstoml/tools/man/quickstart.Rmd
@@ -0,0 +1,138 @@
+```{asciicast}
+#| include: FALSE
+pkgload::load_all()
+```
+
+### Create a tstoml object
+
+Create a tstoml object from a string:
+
+```{asciicast}
+#| results: hide
+txt <- r"(
+# This is a TOML document
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+dob = 1979-05-27T07:32:00-08:00
+
+[database]
+enabled = true
+ports = [ 8000, 8001, 8002 ]
+data = [ ["delta", "phi"], [3.14] ]
+temp_targets = { cpu = 79.5, case = 72.0 }
+
+[servers]
+
+[servers.alpha]
+ip = "10.0.0.1"
+role = "frontend"
+
+[servers.beta]
+ip = "10.0.0.2"
+role = "backend"
+)"
+toml <- ts_parse_toml(text = txt)
+```
+
+Pretty print a tstoml object:
+
+```{asciicast}
+#| label: print-toml
+toml
+```
+
+### Select elements in a tstoml object
+
+```{asciicast}
+#| label: select-table
+ts_tree_select(toml, "owner")
+```
+
+Select element(s) inside elements:
+
+```{asciicast}
+#| label: select-select
+ts_tree_select(toml, "owner", "name")
+```
+
+Select element(s) of an array:
+
+```{asciicast}
+#| label: select-array
+ts_tree_select(toml, "database", "ports", 1:2)
+```
+
+Select multiple keys from a table:
+
+```{asciicast}
+#| label: select-multiple
+ts_tree_select(toml, "owner", c("name", "dob"))
+```
+
+### Delete elements
+
+Delete selected elements:
+
+```{asciicast}
+#| label: delete-elements
+ts_tree_select(toml, "owner", "name") |> ts_tree_delete()
+```
+
+### Insert elements
+
+Insert a key-value pair into the document:
+
+```{asciicast}
+#| label: insert-pair-document
+ts_tree_insert(toml, key = "new_key", "new_value")
+```
+
+Insert a key-value pair into a table:
+```{asciicast}
+#| label: insert-pair-table
+ts_tree_select(toml, "owner") |> ts_tree_insert(key = "dpt", "Engineering")
+```
+
+Insert an element into an array:
+```{asciicast}
+#| label: insert-element-array
+ts_tree_select(toml, "database", "ports") |>
+  ts_tree_insert(10000L) |>
+  print(n = 100)
+```
+
+Insert a new table into the document:
+```{asciicast}
+#| label: insert-table-document
+ts_tree_insert(toml, key = "new_table", list(a = 1, b = 2)) |>
+  print(n = 100)
+```
+
+Insert a new array of tables into the document:
+```{asciicast}
+#| label: insert-aot-document
+ts_tree_insert(toml, key = "new_aot",
+  list(list(x = 1), list(x = 2))) |>
+  print(n = 100)
+```
+
+### Update elements
+
+Update an existing element:
+
+```{asciicast}
+#| label: update-element
+ts_tree_select(toml, "title") |> ts_tree_update("A New TOML Example")
+```
+
+Update multiple elements at once:
+
+```{asciicast}
+#| label: update-multiple
+ts_tree_select(toml, "servers", c("alpha", "beta"), "ip") |>
+  ts_tree_update("192.168.1.23") |>
+  print(n = 100)
+```