@marko/tree-sitter 0.0.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JS Foundation and contributors
+
+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/README.md

@@ -0,0 +1,280 @@
+# @marko/tree-sitter
+
+A [tree-sitter](https://tree-sitter.github.io/) grammar for the
+[Marko](https://markojs.com/) templating language.
+
+It covers the full language: both authoring modes (HTML and
+concise/indentation-based), `${placeholders}`, tag variables, arguments and
+parameters, shorthand `#id`/`.class` and method attributes, attribute
+groups, statement tags, raw-text tags, `--` content blocks, and `$`
+scriptlets, all with the exact source ranges the Marko compiler sees, so the
+tree is reliable for highlighting, folding, structural editing, and tooling.
+
+## Usage
+
+With the node bindings:
+
+```js
+const Parser = require("tree-sitter");
+const Marko = require("@marko/tree-sitter");
+
+const parser = new Parser();
+parser.setLanguage(Marko);
+
+const tree = parser.parse("<button onClick() { count++ }>${count}</button>");
+console.log(tree.rootNode.toString());
+```
+
+In the browser (or anywhere native bindings are unwanted), use the wasm
+build with [web-tree-sitter](https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web):
+
+```js
+import { Language, Parser } from "web-tree-sitter";
+
+await Parser.init();
+const Marko = await Language.load("tree-sitter-marko.wasm");
+const parser = new Parser();
+parser.setLanguage(Marko);
+```
+
+Building from a checkout:
+
+```sh
+npm install
+npm run build        # tree-sitter generate && node-gyp rebuild
+npm run build:wasm   # tree-sitter-marko.wasm (the CLI fetches wasi-sdk itself)
+```
+
+For editors, the grammar ships ready-to-use queries: `queries/highlights.scm`
+for syntax highlighting captures and `queries/injections.scm` for
+embedded-language injections (described below).
+
+## Editors and tools
+
+Every integration consumes the same artifacts: the generated parser
+(`src/parser.c` + `src/scanner.c`), the queries in `queries/`, and, for
+embedded highlighting, the `typescript`, `css`, and `scss` grammars installed
+in the host tool like any other language.
+
+### tree-sitter CLI
+
+From this directory:
+
+```sh
+npx tree-sitter playground            # interactive tree in the browser
+npx tree-sitter parse file.marko      # print the syntax tree
+npx tree-sitter highlight file.marko  # ANSI highlighting (--html for a page)
+```
+
+`highlight` resolves the injected languages through the CLI config: run
+`tree-sitter init-config`, then make sure one of the `parser-directories`
+in `~/.config/tree-sitter/config.json` holds clones of
+`tree-sitter-typescript` (run `npm install --ignore-scripts` inside it, as
+its queries reference its `tree-sitter-javascript` dependency),
+`tree-sitter-css`, and `tree-sitter-scss`. Note the loader only discovers
+grammars that have a `tree-sitter.json`.
+
+### Neovim
+
+Neovim (0.10+) needs no plugins. Compile the parser onto the runtime path
+and start treesitter for the filetype:
+
+```sh
+# from this directory
+mkdir -p ~/.local/share/nvim/site/parser ~/.local/share/nvim/site/queries
+npx tree-sitter build -o ~/.local/share/nvim/site/parser/marko.so
+cp -R queries ~/.local/share/nvim/site/queries/marko
+```
+
+```lua
+-- init.lua
+vim.filetype.add({ extension = { marko = "marko" } })
+vim.api.nvim_create_autocmd("FileType", {
+  pattern = "marko",
+  callback = function()
+    vim.treesitter.start()
+  end,
+})
+```
+
+Embedded highlighting uses whatever parsers are installed; with
+nvim-treesitter that's `:TSInstall typescript css scss`.
+
+### Helix
+
+Register the grammar and language in `~/.config/helix/languages.toml`:
+
+```toml
+[[language]]
+name = "marko"
+scope = "source.marko"
+file-types = ["marko"]
+comment-token = "//"
+block-comment-tokens = { start = "<!--", end = "-->" }
+injection-regex = "^marko$"
+
+[[grammar]]
+name = "marko"
+source = { git = "https://github.com/marko-js/tree-sitter", rev = "<commit>" }
+```
+
+(or `source = { path = "/path/to/tree-sitter" }` for a local
+checkout), then:
+
+```sh
+hx --grammar fetch && hx --grammar build
+```
+
+and copy the queries to `~/.config/helix/runtime/queries/marko/`.
+
+### Zed
+
+Marko support in Zed is provided by the
+[marko-js/zed](https://github.com/marko-js/zed) extension, which bundles this
+grammar (via its `[grammars.marko]` entry pointing here), the language config,
+the editor queries, and the
+[Marko language server](https://github.com/marko-js/language-server). Install
+it from Zed's extension registry, or run `zed: install dev extension` on a
+local checkout of that repo. Its `highlights.scm`/`injections.scm` are copies
+of the `queries/` here, used as-is: Zed evaluates the
+`#eq?`/`#any-of?`/`#not-any-of?` predicates, `injection.combined`, and the
+dynamic `@injection.language` dialects. The Zed-specific `brackets.scm` and
+`outline.scm` are maintained in that extension repo.
+
+### VS Code
+
+VS Code does not consume tree-sitter grammars. Marko support there remains
+the tmLanguage-based
+[Marko VS Code extension](https://github.com/marko-js/language-server),
+which this grammar's queries are designed to match visually.
+
+## The tree
+
+```marko
+div.panel
+  <button onClick() { count++ }>${count}</button>
+```
+
+```
+(document
+  (element
+    (tag_name (tag_name_fragment))
+    (shorthand_class (tag_name_fragment))
+    (concise_open_tag_end)
+    (element
+      (open_tag_start)
+      (tag_name (tag_name_fragment))
+      (attr_name)
+      (args)
+      (method_body (method_body_expr))
+      (open_tag_end)
+      (placeholder (placeholder_start) (placeholder_expr))
+      (close_tag (close_tag_start) (close_tag_name) (close_tag_end))
+      (element_end))
+    (element_end)))
+```
+
+Commonly queried nodes:
+
+| node                                                                                       | meaning                                                      |
+| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
+| `element`                                                                                  | a tag in either mode, including its body and close           |
+| `tag_name`, `tag_name_fragment`                                                            | tag names; interpolated names contain `placeholder` children |
+| `shorthand_id`, `shorthand_class`                                                          | `#id` / `.class` shorthands                                  |
+| `attr_name`, `attr_value`, `attr_bound_value`, `attr_spread`                               | attributes (`x=…`, `x:=…`, `...spread`)                      |
+| `args`, `method_body`                                                                      | `(…)` arguments and `{ … }` shorthand-method bodies          |
+| `tag_var` → `var_pattern`, `var_type`                                                      | tag variables: `/pattern` with an optional `: type`          |
+| `params` → `param` → `param_pattern`, `param_type`, `param_default`                        | `\|a: T = 1, b\|` tag parameters                             |
+| `type_args`, `type_params` → `type_expr`                                                   | `<T>` type arguments/parameters                              |
+| `placeholder`, `placeholder_expr`                                                          | `${…}` and `$!{…}`                                           |
+| `scriptlet`, `scriptlet_expr`, `scriptlet_block_expr`                                      | `$ statement` / `$ { block }`                                |
+| `statement_expr`                                                                           | the body of statement tags (`import`, `static`, `server`, …) |
+| `text`, `html_comment`, `line_comment`, `block_comment`, `cdata`, `doctype`, `declaration` | content                                                      |
+| `html_block`                                                                               | `--` delimited / single-line content blocks in concise mode  |
+
+A few structural notes:
+
+- `element_end` is a zero-width node marking where an element closes
+  implicitly (concise dedent, void tags, self-closing, end of input).
+  `concise_open_tag_end` is similarly zero-width (or covers a trailing `;`).
+- Delimiters are visible named tokens (`args_open`/`args_close`,
+  `params_open`/`params_close`, `type_open`/`type_close`,
+  `attr_group_open`/`attr_group_close`, `method_body_open`/
+  `method_body_close`, `scriptlet_block_open`/`scriptlet_block_close`,
+  `placeholder_start`/`placeholder_end`), so bracket-matching and
+  punctuation queries can target them.
+- Whitespace is significant in Marko, so the grammar has no `extras`; text
+  nodes contain their exact whitespace.
+- Invalid input produces an `ERROR` node from the first error onward,
+  matching how Marko itself reports a single error per template rather than
+  guessing at recovery.
+
+## Tag types
+
+Tag parsing in Marko depends on the tag. This grammar follows the
+[tags API](https://markojs.com/docs/reference/core-tag)'s `parseOptions` (and
+the vscode tmLanguage grammar it replaces), which sorts tags into three
+groups.
+
+Void tags take no children and no closing tag: the html void elements plus
+`const`, `debug`, `id`, `let`, `lifecycle`, `log`, and `return`.
+
+Raw-text tags (`script`, `style`, `html-script`, `html-style`,
+`html-comment`) have bodies of text and placeholders only.
+
+Statement tags (`import`, `export`, `static`, `server`, `client`, plus
+`class` for class-API compatibility) treat the rest of the line, and any
+indented continuation, as a single embedded statement.
+
+## Embedded languages
+
+Marko templates embed TypeScript and CSS throughout, and
+`queries/injections.scm` maps it all. TypeScript is injected into every
+expression position: placeholders, attribute values/spreads, arguments,
+shorthand-method bodies, scriptlets, statement-tag bodies, and the
+pattern/default parts of tag variables and parameters.
+
+Statement tags split into two groups, mirroring how the compiler consumes
+them. `import`, `export`, and `class` are pass-through TypeScript, where the
+keyword is part of the statement, so the whole element (keyword included) is
+injected and the keyword takes its color from the TS grammar. For `static`,
+`server`, and `client` the keyword is Marko syntax that the compiler strips,
+so only the body is injected and `highlights.scm` captures the keyword as
+`@keyword` (the tmLanguage grammar makes the same split). `<script>`/
+`<html-script>` bodies inject TypeScript and `<style>`/`<html-style>` bodies
+inject CSS, including their concise `script --` / `style --` block forms,
+with `injection.combined` merging chunks split by placeholders. `style`
+dialect shorthands are honored the way the compiler resolves them: the last
+shorthand segment names the injected language, so `<style.scss>` and
+`style.module.scss --` inject `scss` while plain `<style>` falls back to
+`css`. `html-style` is exempt, since its shorthand is a real class attribute,
+not a dialect.
+
+Type annotations (tag var/param types, `<T>` type args/params) are captured
+as `@type` instead of injected: a bare type is not a valid TypeScript
+program, so flat coloring is the accurate option (the tmLanguage grammar
+makes the same approximation). One residual case: the parameters of a
+shorthand method (`onClick(event) { … }`) inject as a whole TS program,
+which renders typed parameters slightly off, since that position cannot be
+split without lookahead the scanner doesn't have.
+
+## Fidelity and development
+
+Marko's parser is [htmljs-parser](https://github.com/marko-js/htmljs-parser);
+this grammar's external scanner reimplements its state machine, and the test
+suite (`npm test`, Node 22) asserts the tree reproduces the parser's event
+stream with byte-precise ranges across the parser's full fixture suite, plus
+thousands of templates from the Marko ecosystem during development.
+
+The reference parser and its fixtures are always the same htmljs-parser
+revision: they are fetched together into `.cache/` with degit, so the suite
+compares the grammar against the exact parser the fixtures came from (set
+`HTMLJS_FIXTURES` to point at a local checkout's fixtures instead, and the
+adjacent sources are used as the parser; if this directory is dropped inside
+an htmljs-parser checkout, the local parser sources are used automatically).
+The published `htmljs-parser` package is only a last-resort fallback. The
+grammar tracks the parser, so the suite is only expected to be green against
+the htmljs-parser revision the grammar was synced with.
+
+See `__tests__/` and `tools/` to work on the grammar itself; the scanner
+internals are documented at the top of `src/scanner.c`.

package/binding.gyp

@@ -0,0 +1,19 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_marko_binding",
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except"
+      ],
+      "include_dirs": ["src"],
+      "sources": ["bindings/node/binding.cc", "src/parser.c", "src/scanner.c"],
+      "conditions": [
+        ["OS!='win'", {
+          "cflags_c": ["-std=c11"]
+        }, {
+          "cflags_c": ["/std:c11", "/utf-8"]
+        }]
+      ]
+    }
+  ]
+}

package/bindings/node/binding.cc

@@ -0,0 +1,22 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_marko();
+
+namespace {
+
+// "tree-sitter", "language" hashed with BLAKE2
+const napi_type_tag LANGUAGE_TYPE_TAG = {0x8AF2E5212AD58ABF, 0xD5006CAD83ABBA16};
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports["name"] = Napi::String::New(env, "marko");
+  auto language = Napi::External<TSLanguage>::New(env, tree_sitter_marko());
+  language.TypeTag(&LANGUAGE_TYPE_TAG);
+  exports["language"] = language;
+  return exports;
+}
+
+NODE_API_MODULE(tree_sitter_marko_binding, Init)
+
+}  // namespace

package/bindings/node/index.d.ts

@@ -0,0 +1,28 @@
+type BaseNode = {
+  type: string;
+  named: boolean;
+};
+
+type ChildNode = {
+  multiple: boolean;
+  required: boolean;
+  types: BaseNode[];
+};
+
+type NodeInfo =
+  | (BaseNode & {
+      subtypes: BaseNode[];
+    })
+  | (BaseNode & {
+      fields: { [name: string]: ChildNode };
+      children: ChildNode[];
+    });
+
+type Language = {
+  name: string;
+  language: unknown;
+  nodeTypeInfo: NodeInfo[];
+};
+
+declare const language: Language;
+export = language;

package/bindings/node/index.js

@@ -0,0 +1,13 @@
+const root = require("path").join(__dirname, "..", "..");
+
+module.exports =
+  typeof process.versions.bun === "string"
+    ? // Support `bun build --compile` by being statically analyzable enough to find the .node binding during build-time
+      require(
+        `../../prebuilds/${process.platform}-${process.arch}/@marko+tree-sitter.node`,
+      )
+    : require("node-gyp-build")(root);
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

package/grammar.js

@@ -0,0 +1,248 @@
+/**
+ * Tree-sitter grammar for Marko templates.
+ *
+ * This grammar is a faithful port of htmljs-parser (../src). Because nearly
+ * all of Marko's syntax is context sensitive (concise mode indentation,
+ * expression terminators that depend on the surrounding construct, operator
+ * continuation across whitespace, parsed-text tags like <script>, etc.) every
+ * terminal is produced by the external scanner in src/scanner.c, which ports
+ * the parser's state machine. The rules below only describe how those tokens
+ * compose, mirroring the event stream emitted by createParser().
+ */
+
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+module.exports = grammar({
+  name: "marko",
+
+  // Whitespace is significant almost everywhere (text content, expression
+  // termination, concise indentation), so there are no extras; the external
+  // scanner skips insignificant trivia (whitespace/commas/comments inside
+  // open tags) itself, exactly where htmljs-parser does.
+  extras: () => [],
+
+  externals: ($) => [
+    $.text,
+    $.placeholder_start, // "${" (escape=true placeholders)
+    $.placeholder_start_raw, // "$!{"
+    $._interp_start, // "${" within tag names / shorthands
+    $.placeholder_expr,
+    $._placeholder_end, // "}"
+    $.html_comment, // "<!--" ... "->"
+    $.line_comment, // "//" ...
+    $.block_comment, // "/*" ... "*/"
+    $.cdata, // "<![CDATA[" ... "]]>"
+    $.doctype, // "<!" ... ">"
+    $.declaration, // "<?" ... ">" | "?>"
+    $.scriptlet_start, // "$" at the start of a line in html mode
+    $.scriptlet_start_concise, // "$" at the start of a concise line
+    $._scriptlet_block_open, // "{"
+    $.scriptlet_block_expr,
+    $._scriptlet_block_close, // "}" plus an optional trailing ";"
+    $.scriptlet_expr, // statement after "$ "
+    $._block_open, // "--", "---", ... starting a delimited html block
+    $._block_close, // matching delimiter line, or zero-width
+    $.open_tag_start, // "<"
+    $.tag_name_fragment, // run of tag name characters between placeholders
+    $._tag_name_empty, // zero-width: shorthand-only tags like <.foo>
+    $._shorthand_id_start, // "#"
+    $._shorthand_class_start, // "."
+    $.statement_expr, // body of statement tags (import/export/static/class)
+    $._tag_var_start, // "/"
+    $.var_pattern, // tag variable binding pattern (before any ": type")
+    $._var_colon, // ":" between a tag var pattern and its type
+    $.var_type, // tag variable type annotation
+    $._args_open, // "("
+    $.args_expr,
+    $._args_close, // ")"
+    $._params_open, // "|"
+    $.param_pattern, // parameter binding pattern
+    $._param_colon, // ":" before a parameter type
+    $.param_type, // parameter type annotation
+    $._param_eq, // "=" before a parameter default
+    $.param_default, // parameter default value expression
+    $._param_comma, // "," between parameters
+    $._params_close, // "|"
+    $._type_args_open, // "<" directly after the tag name
+    $._type_params_open, // "<" before tag params or a method shorthand
+    $.type_expr,
+    $._types_close, // ">"
+    $._attr_group_open, // "[" (concise mode)
+    $._attr_group_close, // "]"
+    $.attr_name,
+    $.attr_eq, // "="
+    $.attr_bound_eq, // ":="
+    $._attr_spread_start, // "..."
+    $.attr_value_expr,
+    $._method_body_open, // "{"
+    $.method_body_expr,
+    $._method_body_close, // "}"
+    $.open_tag_end, // ">"
+    $.open_tag_end_self, // "/>"
+    $.concise_open_tag_end, // zero-width (EOL/EOF/"--") or ";"
+    $.close_tag_start, // "</"
+    $.close_tag_name, // may be zero-width for "</>"
+    $.close_tag_end, // ">"
+    $.element_end, // zero-width: dedent, void, self-closed, EOF, after </x>
+    $._tag_comment, // "//..." or "/*...*/" inside an open tag (no events)
+    $.escape, // backslash run before an escaped/double-escaped "${"
+    $._error_sentinel, // never emitted; detects error recovery
+  ],
+
+  rules: {
+    document: ($) => repeat($._child),
+
+    _child: ($) =>
+      choice(
+        $.element,
+        $.text,
+        $.placeholder,
+        $.html_comment,
+        $.line_comment,
+        $.block_comment,
+        $.cdata,
+        $.doctype,
+        $.declaration,
+        $.scriptlet,
+        $.html_block,
+        $.escape,
+      ),
+
+    // Covers html mode (<a>...</a>, <br>, <input/>), concise mode (indent
+    // based, ended by a zero-width element_end at the dedent), statement tags
+    // (import/export/static/class) and parsed-text tags (script/style/
+    // textarea/html-comment whose bodies only contain text & placeholders).
+    element: ($) =>
+      seq(
+        optional($.open_tag_start),
+        $.tag_name,
+        repeat(choice($.shorthand_id, $.shorthand_class)),
+        optional($.statement_expr),
+        repeat($._tag_part),
+        choice($.open_tag_end, $.open_tag_end_self, $.concise_open_tag_end),
+        repeat($._child),
+        optional($.close_tag),
+        $.element_end,
+      ),
+
+    tag_name: ($) => choice(repeat1($._tag_name_part), $._tag_name_empty),
+
+    shorthand_id: ($) => seq($._shorthand_id_start, repeat($._tag_name_part)),
+
+    shorthand_class: ($) =>
+      seq($._shorthand_class_start, repeat($._tag_name_part)),
+
+    _tag_name_part: ($) =>
+      choice($.tag_name_fragment, alias($.tag_name_placeholder, $.placeholder)),
+
+    tag_name_placeholder: ($) =>
+      seq(
+        alias($._interp_start, $.placeholder_start),
+        $.placeholder_expr,
+        alias($._placeholder_end, $.placeholder_end),
+      ),
+
+    _tag_part: ($) =>
+      choice(
+        $.tag_var,
+        $.args,
+        $.params,
+        $.type_args,
+        $.type_params,
+        $.attr_group,
+        $.attr_name,
+        $.attr_value,
+        $.attr_bound_value,
+        $.attr_spread,
+        $.method_body,
+        $._tag_comment,
+      ),
+
+    tag_var: ($) => seq($._tag_var_start, $.tag_var_expr),
+
+    // The pattern/type split happens exactly where the parser's expression
+    // scanner enters type mode (a top-level ":" outside a ternary), so the
+    // node's extent always equals the parser's tagVar value range.
+    tag_var_expr: ($) =>
+      seq($.var_pattern, optional(seq($._var_colon, $.var_type))),
+
+    // Delimiter tokens are visible named nodes (aliased from the hidden
+    // externals) so editors can pair them in bracket-matching queries and
+    // capture them as punctuation; they map to no parser events.
+    args: ($) =>
+      seq(
+        alias($._args_open, $.args_open),
+        optional($.args_expr),
+        alias($._args_close, $.args_close),
+      ),
+    params: ($) =>
+      seq(
+        alias($._params_open, $.params_open),
+        optional($.params_expr),
+        alias($._params_close, $.params_close),
+      ),
+
+    // Parameters split at depth-0 commas/colons/equals; the scanner keeps
+    // the parser's exact "|" termination so the extent is unchanged.
+    params_expr: ($) => seq($.param, repeat(seq($._param_comma, $.param))),
+
+    param: ($) =>
+      seq(
+        $.param_pattern,
+        optional(seq($._param_colon, $.param_type)),
+        optional(seq($._param_eq, $.param_default)),
+      ),
+    type_args: ($) =>
+      seq(
+        alias($._type_args_open, $.type_open),
+        optional($.type_expr),
+        alias($._types_close, $.type_close),
+      ),
+    type_params: ($) =>
+      seq(
+        alias($._type_params_open, $.type_open),
+        optional($.type_expr),
+        alias($._types_close, $.type_close),
+      ),
+    attr_group: ($) =>
+      seq(
+        alias($._attr_group_open, $.attr_group_open),
+        repeat($._tag_part),
+        alias($._attr_group_close, $.attr_group_close),
+      ),
+    attr_value: ($) => seq($.attr_eq, $.attr_value_expr),
+    attr_bound_value: ($) => seq($.attr_bound_eq, $.attr_value_expr),
+    attr_spread: ($) => seq($._attr_spread_start, $.attr_value_expr),
+    method_body: ($) =>
+      seq(
+        alias($._method_body_open, $.method_body_open),
+        optional($.method_body_expr),
+        alias($._method_body_close, $.method_body_close),
+      ),
+
+    placeholder: ($) =>
+      seq(
+        choice($.placeholder_start, $.placeholder_start_raw),
+        $.placeholder_expr,
+        alias($._placeholder_end, $.placeholder_end),
+      ),
+
+    scriptlet: ($) =>
+      seq(
+        choice($.scriptlet_start, $.scriptlet_start_concise),
+        choice($.scriptlet_block, $.scriptlet_expr),
+      ),
+
+    scriptlet_block: ($) =>
+      seq(
+        alias($._scriptlet_block_open, $.scriptlet_block_open),
+        optional($.scriptlet_block_expr),
+        alias($._scriptlet_block_close, $.scriptlet_block_close),
+      ),
+
+    html_block: ($) => seq($._block_open, repeat($._child), $._block_close),
+
+    close_tag: ($) => seq($.close_tag_start, $.close_tag_name, $.close_tag_end),
+  },
+});