tree-sitter-aspx 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 M. Reifschneider
+
+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/NOTICE

@@ -0,0 +1,7 @@
+tree-sitter-aspx is an original grammar.
+
+An existing ASPX grammar was evaluated before this one was written.
+Its rules were not copied. No third-party grammar source is included
+in this repository.
+
+See LICENSE for the MIT license text.

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# tree-sitter-aspx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Verify](https://github.com/alfpricot/tree-sitter-aspx/actions/workflows/verify.yml/badge.svg?branch=dev)](https://github.com/alfpricot/tree-sitter-aspx/actions/workflows/verify.yml)
+[![Crates.io](https://img.shields.io/crates/v/tree-sitter-aspx)](https://crates.io/crates/tree-sitter-aspx)
+
+A [tree-sitter](https://tree-sitter.github.io/tree-sitter/) grammar for ASP.NET Web Forms markup: `.aspx` pages, `.ascx` user controls, `.master` master pages, and the directive headers of `.asax`, `.asmx`, and `.ashx` files, with Node and Rust bindings. Classic ASP (`.asp` with VBScript) and Razor (`.cshtml`, `.vbhtml`) are different languages and are out of scope, and code-behind files (`.aspx.cs`, `.aspx.vb`) are ordinary C# or VB.NET that this grammar does not parse.
+
+## Installation
+
+```sh
+npm install tree-sitter-aspx   # Node
+cargo add tree-sitter-aspx     # Rust
+```
+
+### Requirements
+
+- **Node:** the `tree-sitter` package, version `^0.25.0`, is an optional peer dependency. The binding is a Node-API addon with prebuilt copies for Linux and Windows; on any other platform the install compiles it from source and needs a C/C++ toolchain that `node-gyp` can use.
+- **Rust:** 1.85 or newer. The crate depends only on `tree-sitter-language`, so the `tree-sitter` version your own crate uses is the one that parses.
+
+## Usage
+
+The grammar parses directives, server comments, HTML comments, code nuggets, `<script>` and `<style>` elements, and tags with attributes. It does not validate HTML. Void tags (`br`, `img`, `meta`, and the other HTML void elements) do not swallow the following markup. End tags that HTML lets a page leave out are implied, as a browser would: an open `li`, `p`, `td`, `tr`, `option`, `dt`, `dd`, or other element with an optional end tag ends at the start tag that closes it (a sibling `li`, a block element after a `p`, and so on), at an ancestor's end tag, or at the end of the file. An end tag that names an element further out closes the elements inside it, and an end tag whose name matches no open element closes nothing and stays in the tree as an `end_tag`, as a browser ignores it. The scanner keeps the names of the innermost 64 open elements; deeper than that, end tags pair with start tags by position. A `<` followed by whitespace starts no tag, so `if a < b` is text, as browsers and ASP.NET read it. `<script>` and `<style>` bodies are raw text, so `<` inside JavaScript or CSS is not a tag, but a nugget or server comment inside a body is still parsed as one. Nuggets and server comments may also stand in for attributes in a tag, as in `<option <%= selected %>>`. `<![CDATA[ ]]>` sections and `<?xml ?>` declarations parse as `cdata_section` and `processing_instruction` nodes whose nuggets are still parsed, and self-closing `<script ... />` and `<style />` tags are `self_closing_element` nodes.
+
+The C# and VB.NET inside a page are exposed as `c_sharp_code` and `vb_code` nodes, with injection queries for editors. See [docs/EMBEDDED_CODE.md](docs/EMBEDDED_CODE.md).
+
+### Node
+
+The default export exposes `name`, `language`, and `nodeTypeInfo` (the entries from `src/node-types.json`) on every platform, plus the `HIGHLIGHTS_QUERY` and `INJECTIONS_QUERY` strings.
+
+```js
+import Parser from 'tree-sitter';
+import Aspx from 'tree-sitter-aspx';
+
+const parser = new Parser();
+parser.setLanguage(Aspx);
+const tree = parser.parse('<%@ Page Language="C#" %>');
+console.log(tree.rootNode.toString());
+```
+
+### Rust
+
+```rust
+let mut parser = tree_sitter::Parser::new();
+parser
+    .set_language(&tree_sitter_aspx::LANGUAGE.into())
+    .expect("Error loading ASPX parser");
+```
+
+`LANGUAGE` is a `tree_sitter_language::LanguageFn`. The crate also exports `NODE_TYPES`, `HIGHLIGHTS_QUERY`, and `INJECTIONS_QUERY`.
+
+## How to contribute
+
+Branch from `dev` and open pull requests against it. [CONTRIBUTING.md](CONTRIBUTING.md) covers building the parser, running the checks CI runs, and the pull request rules; [ARCHITECTURE.md](ARCHITECTURE.md) explains how the pieces fit together.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/binding.gyp

@@ -0,0 +1,30 @@
+{
+    "targets": [
+        {
+            "target_name": "tree_sitter_aspx_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,20 @@
+#include <napi.h>
+
+typedef struct TSLanguage TSLanguage;
+
+extern "C" TSLanguage *tree_sitter_aspx();
+
+// "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, "aspx");
+    auto language = Napi::External<TSLanguage>::New(env, tree_sitter_aspx());
+    language.TypeTag(&LANGUAGE_TYPE_TAG);
+    exports["language"] = language;
+    return exports;
+}
+
+NODE_API_MODULE(tree_sitter_aspx_binding, Init)

package/bindings/node/binding_test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert';
+import { test } from 'node:test';
+import Parser from 'tree-sitter';
+
+test('can load grammar', async () => {
+  const parser = new Parser();
+  await assert.doesNotReject(async () => {
+    const { default: language } = await import('./index.js');
+    parser.setLanguage(language);
+  });
+});
+
+test('exports node type metadata', async () => {
+  const { default: language } = await import('./index.js');
+  assert(Array.isArray(language.nodeTypeInfo));
+  assert(language.nodeTypeInfo.some((node) => node.type === 'document'));
+});
+
+test('exports the aspx language name', async () => {
+  const { default: language } = await import('./index.js');
+  assert.equal(language.name, 'aspx');
+});
+
+test('parses a page directive without error', async () => {
+  const { default: language } = await import('./index.js');
+  const parser = new Parser();
+  parser.setLanguage(language);
+  const tree = parser.parse('<%@ Page Language="C#" Inherits="Example.Page" %>');
+  assert.equal(tree.rootNode.hasError, false);
+  assert.equal(tree.rootNode.type, 'source_file');
+});

package/bindings/node/index.d.ts

@@ -0,0 +1,57 @@
+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;
+    });
+
+/**
+ * The tree-sitter language object for this grammar.
+ *
+ * @see {@linkcode https://tree-sitter.github.io/node-tree-sitter/interfaces/Parser.Language.html Parser.Language}
+ *
+ * @example
+ * import Parser from "tree-sitter";
+ * import Aspx from "tree-sitter-aspx";
+ *
+ * const parser = new Parser();
+ * parser.setLanguage(Aspx);
+ */
+declare const binding: {
+  /** The language name. */
+  name: "aspx";
+
+  /**
+   * The inner language object.
+   * @private
+   */
+  language: unknown;
+
+  /**
+   * The content of the `node-types.json` file for this grammar.
+   *
+   * @see {@linkplain https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types Static Node Types}
+   */
+  nodeTypeInfo: NodeInfo[];
+
+  /** The syntax highlighting query for this grammar. */
+  HIGHLIGHTS_QUERY?: string;
+
+  /** The language injection query for this grammar. */
+  INJECTIONS_QUERY?: string;
+};
+
+export default binding;

package/bindings/node/index.js

@@ -0,0 +1,41 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('../..', import.meta.url));
+
+const binding =
+  typeof process.versions.bun === 'string'
+    ? // Support `bun build --compile` by being statically analyzable enough to find the .node file at build-time
+      await import(`${root}/prebuilds/${process.platform}-${process.arch}/tree-sitter-aspx.node`)
+    : (await import('node-gyp-build')).default(root);
+
+try {
+  binding.nodeTypeInfo = JSON.parse(
+    readFileSync(new URL('../../src/node-types.json', import.meta.url), 'utf8'),
+  );
+} catch {
+  // node-types.json is optional metadata; the binding still works without it.
+}
+
+const queries = [
+  ['HIGHLIGHTS_QUERY', `${root}/queries/highlights.scm`],
+  ['INJECTIONS_QUERY', `${root}/queries/injections.scm`],
+];
+
+for (const [prop, path] of queries) {
+  Object.defineProperty(binding, prop, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      delete binding[prop];
+      try {
+        binding[prop] = readFileSync(path, 'utf8');
+      } catch {
+        // A missing query file leaves the property undefined.
+      }
+      return binding[prop];
+    },
+  });
+}
+
+export default binding;

package/grammar.js

@@ -0,0 +1,409 @@
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+// Lexical precedence above the general tag/attribute names, so `script`,
+// `br`, and `Language` win when they are the same length as the general
+// pattern. Longer names (`scriptmanager`, `break`) still take the general
+// pattern because the lexer prefers the longest match.
+const RESERVED = 1;
+
+/**
+ * @param {string} word
+ */
+function reserved(word) {
+  return token(
+    prec(
+      RESERVED,
+      new RegExp(
+        word
+          .split('')
+          .map((ch) => {
+            const lower = ch.toLowerCase();
+            const upper = ch.toUpperCase();
+            return lower === upper
+              ? ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+              : `[${upper}${lower}]`;
+          })
+          .join(''),
+      ),
+    ),
+  );
+}
+
+const VOID_TAGS = [
+  'area',
+  'base',
+  'br',
+  'col',
+  'embed',
+  'hr',
+  'img',
+  'input',
+  'link',
+  'meta',
+  'param',
+  'source',
+  'track',
+  'wbr',
+];
+
+export default grammar({
+  name: 'aspx',
+
+  // A UTF-8 BOM is whitespace as far as the page parser is concerned. UTF-16
+  // files are decoded to UTF-8 before parsing; see tools/corpus-check.mjs.
+  extras: (_) => [/\s/, /\uFEFF/],
+
+  // Reserved names (`col`, `script`, `Language`, `WebHandler`) must not match
+  // a prefix of a longer name (`Columns`, `asp:ScriptManager`). Keywords are
+  // recognized only against this word token, which directive names use. Other
+  // tag names come from the scanner, which reads the whole name and leaves
+  // the reserved ones to the grammar.
+  word: ($) => $._name,
+
+  externals: ($) => [
+    $._lang_csharp,
+    $._lang_vb,
+    $._lang_other,
+    $._code_csharp,
+    $._code_vb,
+    $.server_comment_text,
+    $._script_csharp,
+    $._script_vb,
+    $.style_text,
+    $.expression_text,
+    $._handler_csharp,
+    $._handler_vb,
+    $._start_tag_name,
+    $._end_tag_name,
+    $._implicit_end_tag,
+    $._self_closing_delimiter,
+    $._stray_end_tag_name,
+    $._script_tag_probe,
+  ],
+
+  rules: {
+    // WebHandler / WebService files are a directive plus code, not markup.
+    // The reserved directive name is what selects that alternative. An empty
+    // file is the start rule matching nothing; `document` itself cannot be
+    // empty because tree-sitter rejects a non-start rule that matches "".
+    source_file: ($) => optional(choice($.handler_file, $.document)),
+
+    document: ($) => repeat1($._top),
+
+    handler_file: ($) =>
+      seq(
+        $.handler_directive,
+        repeat(choice($.directive, $.server_comment, $.script_element, $.handler_code)),
+      ),
+
+    // The code of a handler file, labeled with the directive's language like
+    // nugget code so consumers count and inject it the same way.
+    handler_code: ($) =>
+      choice(alias($._handler_csharp, $.c_sharp_code), alias($._handler_vb, $.vb_code)),
+
+    _top: ($) => choice($._content, $.end_tag),
+
+    _content: ($) =>
+      choice(
+        $.directive,
+        $.server_comment,
+        $.html_comment,
+        $._nugget,
+        $.script_element,
+        $.style_element,
+        $.void_element,
+        $.self_closing_element,
+        $.element,
+        $.doctype,
+        $.cdata_section,
+        $.processing_instruction,
+        alias($.stray_end_tag, $.end_tag),
+        $.text,
+      ),
+
+    directive: ($) =>
+      seq('<%@', field('name', $.directive_name), repeat($._directive_attribute), '%>'),
+
+    handler_directive: ($) =>
+      seq(
+        '<%@',
+        field('name', alias(choice($.web_handler_name, $.web_service_name), $.directive_name)),
+        repeat($._directive_attribute),
+        '%>',
+      ),
+
+    _name: (_) => /[A-Za-z_][A-Za-z0-9_.:-]*/,
+    directive_name: ($) => $._name,
+    web_handler_name: (_) => reserved('WebHandler'),
+    web_service_name: (_) => reserved('WebService'),
+
+    // `Language` is its own attribute so the value is a language_value node
+    // and the scanner can record C# vs VB for later code tokens. On an
+    // element it is an ordinary attribute; the scanner reads a server
+    // script's `language` itself, before the attributes are parsed.
+    language_attribute: ($) =>
+      seq(
+        field('name', alias($.language_name, $.attribute_name)),
+        '=',
+        choice(
+          seq('"', optional(field('value', $._language_value)), '"'),
+          seq("'", optional(field('value', $._language_value)), "'"),
+          field('value', $._language_value),
+        ),
+      ),
+
+    language_name: (_) => reserved('Language'),
+
+    _language_value: ($) =>
+      alias(choice($._lang_csharp, $._lang_vb, $._lang_other), $.language_value),
+
+    _directive_attribute: ($) => choice($.language_attribute, $.attribute),
+
+    attribute: ($) =>
+      seq(
+        field('name', $.attribute_name),
+        optional(
+          seq(
+            '=',
+            field(
+              'value',
+              choice(
+                $.quoted_attribute_value,
+                alias($.unquoted_attribute_value, $.attribute_value),
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    attribute_name: (_) => /[A-Za-z_:][A-Za-z0-9_.:-]*/,
+
+    quoted_attribute_value: ($) =>
+      choice(
+        seq('"', repeat($._double_quoted_chunk), '"'),
+        seq("'", repeat($._single_quoted_chunk), "'"),
+      ),
+
+    _double_quoted_chunk: ($) =>
+      choice(
+        $._nugget,
+        $.server_comment,
+        alias(/[^"<%]+/, $.attribute_value),
+        alias('%', $.attribute_value),
+        alias('<', $.attribute_value),
+      ),
+
+    _single_quoted_chunk: ($) =>
+      choice(
+        $._nugget,
+        $.server_comment,
+        alias(/[^'<%]+/, $.attribute_value),
+        alias('%', $.attribute_value),
+        alias('<', $.attribute_value),
+      ),
+
+    unquoted_attribute_value: (_) => /[^"'=<>\s`]+/,
+
+    // Any run of two or more dashes before `%>` closes the comment, as in
+    // `<%-- note ---%>`; the scanner stops the text before that run.
+    server_comment: ($) =>
+      seq('<%--', optional($.server_comment_text), alias(token(/-*--%>/), '--%>')),
+
+    // Nuggets inside an HTML comment still execute, so they stay real nodes.
+    html_comment: ($) =>
+      seq(
+        '<!--',
+        repeat(
+          choice(
+            $._nugget,
+            $.server_comment,
+            $.directive,
+            alias(/[^-<>]+/, $.comment_text),
+            alias('-', $.comment_text),
+            alias('<', $.comment_text),
+            alias('>', $.comment_text),
+          ),
+        ),
+        '-->',
+      ),
+
+    _nugget: ($) =>
+      choice(
+        $.encoded_expression,
+        $.output_expression,
+        $.binding_expression,
+        $.expression_builder,
+        $.statement_block,
+      ),
+
+    _embedded_code: ($) =>
+      choice(alias($._code_csharp, $.c_sharp_code), alias($._code_vb, $.vb_code)),
+
+    encoded_expression: ($) => seq('<%:', optional($._embedded_code), '%>'),
+    output_expression: ($) => seq('<%=', optional($._embedded_code), '%>'),
+    binding_expression: ($) => seq('<%#', optional($._embedded_code), '%>'),
+    statement_block: ($) => seq('<%', optional($._embedded_code), '%>'),
+
+    // Expression builders (`<%$ AppSettings:Key %>`) are not C# or VB.
+    expression_builder: ($) =>
+      seq('<%$', optional(alias($.expression_text, $.expression_value)), '%>'),
+
+    // Script and style bodies are raw text up to their end tag, except that
+    // nuggets, server comments, and directives inside them are still parsed. A body
+    // split by a nugget is several code or style_text chunks; the injection
+    // query combines them.
+    script_element: ($) =>
+      seq(
+        alias($.script_start_tag, $.start_tag),
+        repeat(
+          choice(
+            alias($._script_csharp, $.c_sharp_code),
+            alias($._script_vb, $.vb_code),
+            $._nugget,
+            $.server_comment,
+            $.directive,
+          ),
+        ),
+        alias($.script_end_tag, $.end_tag),
+      ),
+
+    // The probe is a zero-width scanner token that reads the tag's `runat`
+    // and `language` ahead of the grammar, so a server script's body is
+    // labeled with its own language.
+    script_start_tag: ($) =>
+      seq(
+        '<',
+        field('name', alias($.script_tag_name, $.tag_name)),
+        $._script_tag_probe,
+        repeat($._tag_item),
+        '>',
+      ),
+
+    script_end_tag: ($) => seq('</', field('name', alias($.script_tag_name, $.tag_name)), '>'),
+
+    script_tag_name: (_) => reserved('script'),
+
+    style_element: ($) =>
+      seq(
+        alias($.style_start_tag, $.start_tag),
+        repeat(choice($.style_text, $._nugget, $.server_comment, $.directive)),
+        alias($.style_end_tag, $.end_tag),
+      ),
+
+    style_start_tag: ($) =>
+      seq('<', field('name', alias($.style_tag_name, $.tag_name)), repeat($._tag_item), '>'),
+
+    style_end_tag: ($) => seq('</', field('name', alias($.style_tag_name, $.tag_name)), '>'),
+
+    style_tag_name: (_) => reserved('style'),
+
+    void_element: ($) =>
+      seq(
+        '<',
+        field('name', alias($.void_tag_name, $.tag_name)),
+        repeat($._tag_item),
+        choice('/>', '>'),
+      ),
+
+    void_tag_name: (_) => choice(...VOID_TAGS.map((name) => reserved(name))),
+
+    // `<script src="..." />` and `<style />` close themselves in XHTML-era
+    // pages instead of opening a raw-text body. Other names go through the
+    // scanner's open-element stack, so their `/>` is the scanner's token.
+    self_closing_element: ($) =>
+      choice(
+        seq(
+          '<',
+          field('name', $._tag_name),
+          repeat($._tag_item),
+          alias($._self_closing_delimiter, '/>'),
+        ),
+        seq(
+          '<',
+          field('name', alias($.script_tag_name, $.tag_name)),
+          $._script_tag_probe,
+          repeat($._tag_item),
+          '/>',
+        ),
+        seq('<', field('name', alias($.style_tag_name, $.tag_name)), repeat($._tag_item), '/>'),
+      ),
+
+    // An element ends at its end tag or, for HTML's optional end tags (`li`,
+    // `p`, `td`, `option`, and the rest), where the scanner finds it implied:
+    // at a sibling or other start tag that closes it, at an ancestor's end
+    // tag, or at the end of the file.
+    element: ($) => seq($.start_tag, repeat($._content), choice($.end_tag, $._implicit_end_tag)),
+
+    start_tag: ($) => seq('<', field('name', $._tag_name), repeat($._tag_item), '>'),
+
+    // A nugget or server comment can stand in for an attribute, as in
+    // `<option value="1" <%= selected ? "selected" : "" %>>`.
+    _tag_item: ($) => choice($.attribute, $._nugget, $.server_comment),
+
+    // Start and end tag names come from the scanner, which keeps the stack of
+    // open elements that implied end tags are decided from.
+    _tag_name: ($) => alias($._start_tag_name, $.tag_name),
+
+    end_tag: ($) =>
+      seq(
+        '</',
+        field(
+          'name',
+          choice(
+            alias($.script_tag_name, $.tag_name),
+            alias($.style_tag_name, $.tag_name),
+            alias($.void_tag_name, $.tag_name),
+            alias($._end_tag_name, $.tag_name),
+          ),
+        ),
+        '>',
+      ),
+
+    // An end tag that names no open element closes nothing, as a browser
+    // treats it, so `<p><table></table></p>` keeps its parent open.
+    stray_end_tag: ($) => seq('</', field('name', alias($._stray_end_tag_name, $.tag_name)), '>'),
+
+    doctype: ($) => seq($.doctype_token, optional(alias(/[^>]+/, $.doctype_declaration)), '>'),
+
+    doctype_token: (_) => token(prec(RESERVED, /<![Dd][Oo][Cc][Tt][Yy][Pp][Ee]/)),
+
+    // `<![CDATA[ ... ]]>` and `<?xml ... ?>` appear in XHTML-era pages and
+    // .asmx files. ASP.NET still runs nuggets inside them, as in an RSS feed's
+    // `<![CDATA[<%# Eval("Body") %>]]>`, so nuggets stay real nodes and the
+    // rest is text.
+    cdata_section: ($) =>
+      seq(
+        '<![CDATA[',
+        repeat(
+          choice(
+            $._nugget,
+            $.server_comment,
+            alias(/[^\]<]+/, $.text),
+            alias(']', $.text),
+            alias('<', $.text),
+          ),
+        ),
+        ']]>',
+      ),
+
+    processing_instruction: ($) =>
+      seq(
+        '<?',
+        repeat(
+          choice(
+            $._nugget,
+            $.server_comment,
+            alias(/[^?<]+/, $.text),
+            alias('?', $.text),
+            alias('<', $.text),
+          ),
+        ),
+        '?>',
+      ),
+
+    // A `<` followed by whitespace starts no tag, as browsers and ASP.NET's
+    // own tag pattern read it, so `a < b` is text rather than an element.
+    text: (_) => token(choice(/[^<\s][^<]*/, /<\s[^<]*/)),
+  },
+});