@backbencher/brain 0.0.0-stage → 0.1.1

package/grammars/tree-sitter-graphql/README.md

@@ -0,0 +1,106 @@
+# tree-sitter-graphql — vendored, patched, and pinned
+
+This directory is the **source of the wasm the product loads**:
+`wasm/tree-sitter-graphql.wasm`. It is not a mirror of upstream; it is
+upstream plus a measured patch, and the patch is a reviewable diff because
+`grammar.js` is **generated** from `grammar.upstream.js` by `port.py`.
+
+## Why the tree is shaped this way
+
+| file | role |
+|---|---|
+| `grammar.upstream.js` | `github.com/bkegley/tree-sitter-graphql` @ `ee5ce96`, verbatim. The port always reads this, so `python3 port.py` is idempotent. |
+| `port.py` | the patch, as code: the PascalCase rename and four FIX hunks, each anchored to upstream's exact text and each refusing to write a half-ported grammar. |
+| `grammar.js` | the generated, patched grammar. **This is what `tree-sitter generate` reads.** |
+| `src/node-types.json`, `src/grammar.json` | generated, and tracked ON PURPOSE: `script/m14/verify-grammar-pins.ts` uses the pair for its offline source↔wasm proof. |
+| `src/parser.c` | generated, 283 KB, **not** tracked. `tree-sitter generate` rebuilds it. |
+| `tree-sitter.json`, `package.json` | ABI 15 build config and npm metadata. `package.json` deliberately has no `"type"` field: the repository root is `"type": "module"`, and `grammar.js` is CommonJS `module.exports`, so without a local `package.json` the CLI cannot load it. |
+
+## Divergence 1 — the rule names are PascalCase, and that is a contract
+
+Upstream names its rules `snake_case` (`object_type_definition`). This
+repository's rules are `PascalCase` (`ObjectTypeDefinition`), because:
+
+- `src/ast/real-graphql-analyzer.ts` dispatches on `node.type === "ObjectTypeDefinition"`.
+  Under upstream's spelling **every construct falls through the analyzer's
+  default arm** and the file yields nothing.
+- `script/m12/graphql-node-types-compare.ts`, the m12 shape-safety artifact, the
+  m14/m60 language lanes and every stored symbol row assume the PascalCase
+  spelling.
+- The wasm this repository vendored **before** this work already exposed
+  PascalCase names (built with an older tree-sitter CLI, which PascalCases rule
+  names on the analyzer's behalf). The rename preserves that surface rather than
+  breaking it.
+
+The rename is a mechanical `snake_case → PascalCase` map over 71 rules, pinned
+to the vendored wasm's own `language.nodeTypeForId` table, with `source_file`,
+`comment` and `comma` held lower-case because that is what the previous wasm
+exposed for them.
+
+**Upstream's `main` is not a drop-in.** The A/B is in
+`bb_tests/graphql/out/extraction-ab.json`; the measured result of a
+PascalCase-only port is that the analyzer's whole string-literal contract
+becomes dead. That is why this is a *patched port* and not an upgrade.
+
+## Divergence 2 — four specification constructs upstream rejects
+
+Each FIX in `port.py` is anchored to a row in the 113-construct battery
+(`bb_tests/graphql/probe/grammar-gaps.mts`) and each was measured, not reasoned.
+
+| # | construct | specification | what upstream's rule does | the patch |
+|---|---|---|---|---|
+| FIX 1 | `extend schema { query: Q mutation: M }`, and `extend schema @link(…)` with no body | §3.18 | one `root_operation_type_definition`, and the body is mandatory | `repeat1(...)` inside an optional body, with `prec.right` to resolve the `{` ambiguity (the same resolution every other `*_type_extension` in this grammar already uses) |
+| FIX 2 | `extend scalar S` with no directive | §3.17 | `$.directives` is `repeat1`, so a directive is **mandatory** | `optional($.directives)` |
+| FIX 3 | `{ f @a @b }` — two directives on one field selection | §3.3 | `optional($.directive)`, singular | `optional($.directives)` |
+| FIX 4 | `\"` and `\\` in a `"…"` string; `\"""` in a `"""…"""` block string | §2.9.4 | the short string's regex forbids every backslash, and the block string has no accepting path for `\"""` | short string: `[^"\\\n]` or `\\` + any non-newline; block string: a quote is consumable only when it is not the closing delimiter, and a backslash always consumes the next character |
+
+FIX 4 was measured twice. The first attempt wrote the short string's escape as
+`\\[^\\\n]`, whose character class excludes the backslash **itself**, so `\"`,
+`\/` and `\n` all parsed and `\\` did not — 4 of 7 escape probes green. The
+second attempt uses `\\[^\n]`.
+
+**Still a gap, deliberately not fixed:** the block-string rule accepts
+`"""a\""""` as the block string `a"` followed by a stray quote. graphql-js agrees
+(`BlockStringValue` is greedy to the last `"""`), so tightening it would make
+this grammar disagree with the reference implementation. Recorded, not hidden.
+
+## Regenerating the wasm
+
+```sh
+cd grammars/tree-sitter-graphql
+python3 port.py                                   # upstream + the patch -> grammar.js
+tree-sitter generate                              # -> src/{parser.c,grammar.json,node-types.json}
+tree-sitter build --wasm -o ../../wasm/tree-sitter-graphql.wasm
+```
+
+`tree-sitter build --wasm` needs emscripten; with only docker present it uses
+`emscripten/emsdk` through docker automatically. The CLI must be ≥ 0.25 for the
+`tree-sitter.json`/ABI-15 path; the bb_tests copy at
+`/home/ishaq2321/bb_tests/node_modules/tree-sitter-cli` is 0.25.1.
+
+**After regenerating, re-run every gate** — the wasm hash is pinned and the
+extraction changes:
+
+```sh
+/home/ishaq2321/bb_tests/graphql/run-all.sh --corpus
+cd /home/ishaq2321/backbencher-brain && bun script/m14/verify-grammar-pins.ts --write
+```
+
+## What the patch bought, measured
+
+47 real `.graphql` files across four repositories, the same analyzer under both
+grammars (`bb_tests/graphql/out/extraction-ab.json`):
+
+| | previous wasm | wired wasm | delta |
+|---|---|---|---|
+| files with a grammar error | **12 / 47** | **4 / 47** | **−8** |
+| grammar error nodes | **20** | **7** | **−13** |
+| symbols | 8,743 | **8,747** | +4 |
+| relationships | 16,861 | **16,937** | +76 |
+
+Every delta is enumerated and adjudicated in `REVIEW.md` §E. The direction is
+uniform, and the previous wasm's losses include a class of **phantom facts**: on
+`neo4j-graphql/.../apollo-federation-subgraph-compatibility/schema.graphql` a
+described `extend type User` degraded to ERROR, and the analyzer then published
+`anonymous_operation_1566 → Int`, `→ ID`, `→ @external` and `→ @requires` —
+four invented references — while losing five real `User` field symbols.

package/grammars/tree-sitter-groovy/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Amaan Qureshi <amaanq12@gmail.com>
+
+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.

package/grammars/tree-sitter-groovy/README.md

@@ -0,0 +1,4 @@
+## tree-sitter-groovy
+
+> [!Note]
+> this is a WIP and is not super polished, I cobbled this together in an hour to test something, eventually I'd like to clean it up but it works for me for now.

package/grammars/tree-sitter-haskell/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 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.

package/grammars/tree-sitter-haskell/README.md

@@ -0,0 +1,394 @@
+# tree-sitter-haskell
+
+[![CI][ci]](https://github.com/tree-sitter/tree-sitter-haskell/actions/workflows/ci.yml)
+[![discord][discord]](https://discord.gg/w7nTvsVJhm)
+[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
+[![crates][crates]](https://crates.io/crates/tree-sitter-haskell)
+[![npm][npm]](https://www.npmjs.com/package/tree-sitter-haskell)
+[![pypi][pypi]](https://pypi.org/project/tree-sitter-haskell)
+
+Haskell grammar for [tree-sitter].
+
+# References
+
+- [Haskell 2010 Language Report – Syntax References][ref]
+- [GHC Language Extensions][ext]
+
+# Supported Language Extensions
+
+These extensions are supported ✅, unsupported ❌ or not applicable because they don't involve parsing ➖️:
+
+- AllowAmbiguousTypes ➖️
+- ApplicativeDo ➖️
+- Arrows ❌
+- BangPatterns ✅
+- BinaryLiterals ✅
+- BlockArguments ✅
+- CApiFFI ✅
+- ConstrainedClassMethods ✅
+- ConstraintKinds ✅
+- CPP ✅
+- CUSKs ✅
+- DataKinds ✅
+- DatatypeContexts ✅
+- DefaultSignatures ✅
+- DeriveAnyClass ➖️
+- DeriveDataTypeable ➖️
+- DeriveFoldable ➖️
+- DeriveFunctor ➖️
+- DeriveGeneric ➖️
+- DeriveLift ➖️
+- DeriveTraversable ➖️
+- DerivingStrategies ✅
+- DerivingVia ✅
+- DisambiguateRecordFields ➖️
+- DuplicateRecordFields ➖️
+- EmptyCase ✅
+- EmptyDataDecls ✅
+- EmptyDataDeriving ✅
+- ExistentialQuantification ✅
+- ExplicitForAll ✅
+- ExplicitNamespaces ✅
+- ExtendedDefaultRules ➖️
+- FlexibleContexts ✅
+- FlexibleInstances ✅
+- ForeignFunctionInterface ✅
+- FunctionalDependencies ✅
+- GADTs ✅
+- GADTSyntax ✅
+- GeneralisedNewtypeDeriving ➖️
+- GHCForeignImportPrim ✅
+- Haskell2010 ➖️
+- Haskell98 ➖️
+- HexFloatLiterals ✅
+- ImplicitParams ✅
+- ImplicitPrelude ➖️
+- ImportQualifiedPost ✅
+- ImpredicativeTypes ➖️
+- IncoherentInstances ➖️
+- InstanceSigs ✅
+- InterruptibleFFI ✅
+- KindSignatures ✅
+- LambdaCase ✅
+- LexicalNegation ❌
+- LiberalTypeSynonyms ✅
+- LinearTypes ✅
+- ListTuplePuns ✅
+- MagicHash ✅
+- Modifiers ❌
+- MonadComprehensions ➖️
+- MonadFailDesugaring ➖️
+- MonoLocalBinds ➖️
+- MonomorphismRestriction ➖️
+- MultiParamTypeClasses ✅
+- MultiWayIf ✅
+- NamedFieldPuns ✅
+- NamedWildCards ✅
+- NegativeLiterals ➖️
+- NondecreasingIndentation ✅
+- NPlusKPatterns ➖️
+- NullaryTypeClasses ✅
+- NumDecimals ➖️
+- NumericUnderscores ✅
+- OverlappingInstances ➖️
+- OverloadedLabels ✅
+- OverloadedLists ➖️
+- OverloadedRecordDot ✅
+- OverloadedRecordUpdate ✅
+- OverloadedStrings ➖️
+- PackageImports ✅
+- ParallelListComp ✅
+- PartialTypeSignatures ✅
+- PatternGuards ✅
+- PatternSynonyms ✅
+- PolyKinds ➖️
+- PostfixOperators ➖️
+- QualifiedDo ✅
+- QuantifiedConstraints ✅
+- QuasiQuotes ✅
+- Rank2Types ✅
+- RankNTypes ✅
+- RebindableSyntax ➖️
+- RecordWildCards ➖️
+- RecursiveDo ✅
+- RequiredTypeArguments ✅
+- RoleAnnotations ✅
+- Safe ➖️
+- ScopedTypeVariables ✅
+- StandaloneDeriving ✅
+- StandaloneKindSignatures ✅
+- StarIsType ✅
+- StaticPointers ❌
+- Strict ➖️
+- StrictData ✅
+- TemplateHaskell ✅
+- TemplateHaskellQuotes ✅
+- TraditionalRecordSyntax ➖️
+- TransformListComp ✅
+- Trustworthy ➖️
+- TupleSections ✅
+- TypeAbstractions ✅
+- TypeApplications ✅
+- TypeData ✅
+- TypeFamilies ✅
+- TypeFamilyDependencies ✅
+- TypeInType ✅
+- TypeOperators ✅
+- TypeSynonymInstances ➖️
+- UnboxedSums ✅
+- UnboxedTuples ✅
+- UndecidableInstances ➖️
+- UndecidableSuperClasses ➖️
+- UnicodeSyntax ✅
+- UnliftedFFITypes ➖️
+- UnliftedNewtypes ✅
+- Unsafe ➖️
+- ViewPatterns ✅
+
+# Bugs
+
+## CPP
+
+Preprocessor `#elif` and `#else` directives cannot be handled correctly, since the parser state would have to be
+manually reset to what it was at the `#if`.
+As a workaround, the code blocks in the alternative branches are parsed as part of the directives.
+
+# Querying
+
+The grammar contains several [supertypes](https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types),
+which group multiple other node types under a single name.
+
+Supertype names do not occur as extra nodes in parse trees, but they can be used in queries in special ways:
+
+- As an alias, matching any of their subtypes
+- As prefix for one of their subtypes, matching its symbol only when it occurs as a production of the supertype
+
+For example, the query `(expression)` matches the nodes `infix`, `record`, `projection`, `constructor`, and the second
+and third `variable` in this tree for `cats <> Cat {mood = moods.sleepy}`:
+
+```
+(infix
+  (variable)
+  (operator)
+  (record
+    (constructor)
+    (field_update
+      (field_name (variable))
+      (projection (variable) (field_name (variable)))))))))
+```
+
+The two occurrences of `variable` in `field_name` (`mood` and `sleepy`) are not expressions, but record field names part
+of a composite `record` expression.
+
+Matching `variable` nodes specifically that are expressions is possible with the second special form.
+A query for `(expression/variable)` will match only the other two, `cats` and `moods`.
+
+The grammar's supertypes consist of the following sets:
+
+- [`expression`](./grammar/exp.js)
+
+  Rules that are valid in any expression position, excluding type applications, explicit types and expression
+  signatures.
+
+- [`pattern`](./grammar/pat.js)
+
+  Rules that are valid in any pattern position, excluding type binders, explicit types and pattern signatures.
+
+- [`type`](./grammar/type.js)
+
+  Types that are either atomic (have no ambiguous associativity, like bracketed constructs, variables and type
+  constructors), applied types or infix types.
+
+- [`quantified_type`](./grammar/type.js)
+
+  Types prefixed with a `forall`, context or function parameter.
+
+- [`constraint`](./grammar/constraint.js)
+
+  Almost the same rules as `type`, but mirrored for use in contexts.
+
+- [`constraints`](./grammar/constraints.js)
+
+  Analog of `quantified_type`, for constraints with `forall` or context.
+
+- [`type_param`](./grammar/type.js)
+
+  Atomic nodes in type and class heads, like the three nodes following `A` in `data A @k a (b :: k)`.
+
+- [`declaration`](./grammar/module.js)
+
+  All top-level declarations, like functions and data types.
+
+- [`decl`](./grammar/decl.js)
+
+  Shorthand for declarations that are also valid in local bindings (`let` and `where`) and in class and instance bodies,
+  except for fixity declarations.
+  Consists of `signature`, `function` and `bind`.
+
+- [`class_decl` and `instance_decl`](./grammar/class.js)
+
+  All declarations that are valid in classes and instances, which includes associated type and data families.
+
+- [`statement`](./grammar/exp.js)
+
+  Different forms of `do`-notation statements.
+
+- [`qualifier`](./grammar/exp.js)
+
+  Different forms of list comprehension qualifiers.
+
+- [`guard`](./grammar/exp.js)
+
+  Different forms of guards in function equations and case alternatives.
+
+# Development
+
+The main driver for generating and testing the parser for this grammar is the [tree-sitter CLI][cli].
+Other components of the project require additional tools, described below.
+
+Some are made available through `npm` – for example, `npx tree-sitter` runs the CLI.
+If you don't have `tree-sitter` available otherwise, prefix all the commands in the following sections with `npx`.
+
+## Output path
+
+The CLI writes the shared library containing the parser to the directory denoted by `$TREE_SITTER_LIBDIR`.
+If that variable is unset, it defaults to `$HOME/.cache/tree-sitter/lib`.
+
+In order to avoid clobbering this global directory with development versions, you can set the env var to a local path:
+
+```
+export TREE_SITTER_LIBDIR=$PWD/.lib
+```
+
+## The grammar
+
+The javascript file `grammar.js` contains the entry point into the grammar's production rules.
+Please consult the [tree-sitter documentation][grammar-docs] for a comprehensive introduction to the syntax and
+semantics.
+
+Parsing starts with the first item in the `rules` field:
+
+```javascript
+{
+  rules: {
+    haskell: $ => seq(
+      optional($.header),
+      optional($._body),
+    ),
+  }
+}
+```
+
+## Generating the parser
+
+The first step in the development workflow converts the javascript rule definitions to C code in `src/parser.c`:
+
+```
+$ tree-sitter generate
+```
+
+Two byproducts of this process are written to `src/grammar.json` and `src/node-types.json`.
+
+## Compiling the parser
+
+The C code is automatically compiled by most of the test tools mentioned below, but you can instruct tree-sitter to do
+it in one go:
+
+```
+$ tree-sitter generate --build
+```
+
+If you've set `$TREE_SITTER_LIBDIR` as mentioned above, the shared object will be written to `$PWD/.lib/haskell.so`.
+
+Aside from the generated `src/parser.c`, tree-sitter will also compile and link `src/scanner.c` into this object.
+This file contains the _external scanner_, which is a custom extension of the built-in lexer whose purpose is to handle
+language constructs that cannot be expressed (efficiently) in the javascript grammar, like Haskell layouts.
+
+### WebAssembly
+
+The parser can be compiled to WebAssembly as well, which requires `emscripten`:
+
+```
+$ tree-sitter build --wasm
+```
+
+The resulting binary is written to `$PWD/tree-sitter-haskell.wasm`.
+
+## Testing the parser
+
+The most fundamental test infrastructure for tree-sitter grammars consists of a set of code snippets with associated
+reference ASTs stored in `./test/corpus/*.txt`.
+
+```
+$ tree-sitter test
+```
+
+Individual tests can be run by specifying (a substring of) their description with `-f`:
+
+```
+$ tree-sitter test -f 'module: exports empty'
+```
+
+The project contains several other types of tests:
+
+- `test/parse/run.bash [update] [test names ...]` parses the files in `test/parse/*.hs` and compares the output with
+  `test/parse/*.target`.
+  If `update` is specified as the first argument, it will update the `.target` file for the first failing test.
+
+- `test/query/run.bash [update] [test names ...]` parses the files in `test/query/*.hs`, applies the queries in
+  `test/query/*.query` and compares the output with `test/query/*.target`, similar to `test/parse`.
+
+- `test/rust/parse-test.rs` contains a few tests that use tree-sitter's Rust API to extract the test ranges for
+  terminals in a slightly more convenient way.
+  This requires `cargo` to be installed, and can be executed with `cargo test` (which also runs the tests in
+  `bindings/rust`).
+
+- `test/parse-libs [wasm]` clones a set of Haskell libraries to `test/libs` and parses the entire codebase.
+  When invoked as `test/parse-libs wasm`, it will use the WebAssembly parser.
+  This requires `bc` to be installed.
+
+- `test/parse-lib name [wasm]` parses only the library `name` in that directory (without cloning the repository).
+
+### Debugging
+
+The shared library built by `tree-sitter test` includes debug symbols, so if the scanner segfaults you can just run
+`coredumpctl debug` to inspect the backtrace and memory:
+
+```
+newline_lookahead () at src/scanner.c:2583
+2583                ((Newline *) 0)->indent = 5;
+(gdb) bt
+#0  newline_lookahead () at src/scanner.c:2583
+#1  0x00007ffff7a0740e in newline_start () at src/scanner.c:2604
+#2  scan () at src/scanner.c:2646
+#3  eval () at src/scanner.c:2684
+#4  tree_sitter_haskell_external_scanner_scan (payload=<optimized out>, lexer=<optimized out>,
+    valid_symbols=<optimized out>) at src/scanner.c:2724
+#5  0x0000555555772488 in ts_parser.lex ()
+```
+
+For more control, launch `gdb tree-sitter` and start the process with `run test -f 'some test'`, and set a breakpoint
+with `break tree_sitter_haskell_external_scanner_scan`.
+
+To disable optimizations, run `tree-sitter test --debug-build`.
+
+#### Tracing
+
+The `test` and `parse` commands offer two modes for obtaining detailed information about the parsing process.
+
+With `tree-sitter test --debug`, every lexer step and shift/reduce action is printed to stderr.
+
+With `tree-sitter test --debug-graph`, the CLI will generate an HTML file showing a graph representation of every step.
+This requires `graphviz` to be installed.
+
+[tree-sitter]: https://github.com/tree-sitter/tree-sitter
+[ref]: https://www.haskell.org/onlinereport/haskell2010/haskellch10.html
+[ext]: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/exts/table.html
+[cli]: https://github.com/tree-sitter/tree-sitter/tree/master/cli
+[grammar-docs]: https://tree-sitter.github.io/tree-sitter/creating-parsers#writing-the-grammar
+[ci]: https://img.shields.io/github/actions/workflow/status/tree-sitter/tree-sitter-haskell/ci.yml?logo=github&label=CI
+[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
+[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
+[npm]: https://img.shields.io/npm/v/tree-sitter-haskell?logo=npm
+[crates]: https://img.shields.io/crates/v/tree-sitter-haskell?logo=rust
+[pypi]: https://img.shields.io/pypi/v/tree-sitter-haskell?logo=pypi&logoColor=ffd242

package/grammars/tree-sitter-hcl/CHANGELOG.md

@@ -0,0 +1,102 @@
+# Changelog
+
+## 1.2.0 - 2025-06-15
+
+feat:
+* namespaced identitifers
+
+fix:
+* precedence of unary operators and expressions
+
+housekeeping:
+* regenerate with tree-sitter-cli 0.25.6
+* add bindings
+
+## 1.1.0 - 2023-07-25
+
+feature
+* add dialects so we can have different queries in `nvim-treesitter`
+
+fix:
+* fix ci acceptance workflow
+
+housekeeping:
+* reformat using LSPs, ditch editorconfig
+
+## 1.0.0 - 2022-12-02
+
+breaking:
+* remove `template_if_branch` and `template_else_branch`
+
+fix:
+* fix precedence in template expressions
+
+## 0.7.0 - 2022-06-02
+
+housekeeping:
+* bump tree-sitter dependency to 0.20.6
+* regenerate parser
+* fix clang+windows CI job
+
+fix:
+* allow empty string literals
+
+## 0.6.0 - 2021-09-20
+
+feature:
+* add template for expressions
+* add template if expressions
+
+cleanup:
+* move fuzzing instrumentation to different repository
+
+## 0.5.0 - 2021-09-15
+
+feature:
+* unhide `(block|object|tuple)_(start|end)` tokens
+
+fix:
+* remove empty `template_directive` block because it causes issues for semgrep
+
+## 0.4.0 - 2021-07-02
+
+feature:
+* add named "key" and "val" fields to left and right side of object elements
+* unhide the `template_interpolation_(start|end)` and `quoted_template_(start|end)` tokens
+
+## 0.3.2 - 2021-07-01
+
+fix:
+* add a build step to CI to make sure the scanner is compilable
+* add fuzzing instrumentation
+
+## 0.3.1 - 2021-06-30
+
+fix:
+* dont use c struct initializer syntax in src/scanner.cc
+
+## 0.3.0 - 2021-06-28
+
+fix:
+* correct expression for identifiers
+* allow empty template interpolations
+* allow empty templates
+* fix crash when `context_stack.size()` exceeds `CHAR_MAX`
+* fix crash when `heredoc_identifier.size()` exceeds `CHAR_MAX`
+
+quality:
+* add fuzzing
+
+## 0.2.0 - 2021-06-26
+
+feature:
+* add quoted templates and heredoc templates
+* still missing template directives though
+
+quality:
+* collect corpus of real world hcl files from github
+* add github actions
+
+## 0.1.0 - 2021-06-13
+
+* initial version