rooklang 0.0.0-stage → 0.3.0

package/LICENSE

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

@@ -1,3 +1,178 @@
-# Temporary Holding Version
+# Rook
 
-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.
+**English** · [Русский](README.ru.md)
+
+A language with the semantics of JavaScript, Go-style syntax, goroutines on real threads and static
+types. It compiles to readable JavaScript without a runtime (WebAssembly is planned).
+
+```go
+async func square(jobs <-chan number, results chan<- number) {
+    for n in jobs {
+        results <- n * n
+    }
+}
+
+const jobs = chan<number>(10)
+const results = chan<number>()
+go square(jobs, results)            // another thread, at once with the rest
+go square(jobs, results)
+
+for let n = 1; n <= 4; n++ {
+    jobs <- n
+}
+close(jobs)
+for let i = 0; i < 4; i++ {
+    console.log(<-results)
+}
+```
+
+- **Goroutines and channels.** `go f(x)` runs a function as a goroutine, on another processor, and
+  channels, `select`, `after`, `tick` and `cancel` work as in Go; `go for i, v in pixels { ... }`
+  splits an array among the processors. The compiler checks that what goes to another thread can be
+  copied there.
+- **Go syntax.** `func`, the type after the name, several results, errors as a second value,
+  `defer`, a single `for` loop:
+
+  ```go
+  func divide(a, b number) (number, error) {
+      if b == 0 {
+          return 0, error("division by zero")
+      }
+      return a / b, null
+  }
+  ```
+
+- **Static types with null safety.** A `?User` cannot be used without a check.
+- **JavaScript inside.** The same values, classes and modules, any JS library; markup creates real
+  DOM elements, and components are compiled away.
+
+The guide with examples and a playground: <https://qwern-9876r.github.io/RookLang/>.
+Specification: [docs/spec.md](docs/spec.md), design of components:
+[docs/components.md](docs/components.md), an example: [examples/hello.rk](examples/hello.rk).
+
+## Installation
+
+Rook needs Node.js ≥ 24.
+
+```sh
+npm install --save-dev rooklang
+npx rook build app.rk                # app.js next to the source
+npx rook build src --out-dir dist       # every module of a folder
+npx rook run app.rk                  # compile and run
+```
+
+From code, the compiler is `import { compile } from 'rooklang'`. The package also has the
+[Vite](#vite) plugin, `rooklang/vite`, and `rooklang/browser`, the compiler without the
+TypeScript compiler for running in a browser, as in the site's playground: there imports are not
+type checked.
+
+## Development
+
+Node.js ≥ 24 (`nvm use`). The compiler is written in TypeScript, and Node runs the `.ts` files
+directly, so development needs no build step: the commands below run the compiler from `src/`.
+`dist/` is built only for the npm package.
+
+`npm install` also installs a pre-commit hook that formats the staged files: ESLint adds the blank
+lines between statements that Prettier keeps but never adds, then Prettier formats. Only the
+staged version is formatted, so edits that are not staged stay out of the commit.
+
+## Commands
+
+| Command                           | What it does                                            |
+| --------------------------------- | ------------------------------------------------------- |
+| `npm run rook -- build file.rk`   | Compile to `file.js`, with the `.rk` modules it imports |
+| `npm run rook -- run file.rk`     | Compile and run                                         |
+| `npm run rook -- tokens file.rk`  | Show the lexer's tokens                                 |
+| `npm run rook -- ast file.rk`     | Show the syntax tree                                    |
+| `npm test` / `npm run test:watch` | Tests (Vitest)                                          |
+| `npm run typecheck`               | Type check                                              |
+| `npm run lint` / `npm run format` | ESLint / Prettier with the blank lines from ESLint      |
+| `npm run check`                   | All at once: types, lint, format, tests                 |
+| `npm run build`                   | Build the npm package to `dist/`                        |
+| `npm run vscode:install`          | Build and install the VS Code extension                 |
+
+Options of `build`: `--out-dir dir` writes the `.js` files to a separate folder, `--stdout` prints
+the JS of one file, `--no-check` skips type checking. `--markup` and `--no-markup` turn markup and
+components on or off for all files (with `run` too); by default they are off, and a package turns
+them on in its `package.json`: `"rook": { "markup": true }`.
+
+## Releases
+
+A release is a new version in `package.json` on `main`: `npm version minor --no-git-tag-version`
+(or `patch`) changes it, and the push to `main` releases it. The workflow
+[.github/workflows/publish.yml](.github/workflows/publish.yml) sees that npm does not have this
+version yet, runs `npm run check`, builds `dist/`, publishes the package to npm and tags the commit
+`v0.2.0`. A push that keeps the version publishes nothing.
+
+## VS Code
+
+[editors/vscode/](editors/vscode/) has an extension for `.rk` files: highlighting of code, types
+and markup, errors as you type and completion of names, members, types, tags and attributes, from a
+language server with the compiler. `npm run vscode:install` builds it and installs it with `code`;
+see [editors/vscode/README.md](editors/vscode/README.md).
+
+## Documentation site
+
+[site/](site/) holds the site of Rook in English and Russian (in `ru/`), three pages in each: the
+home page (`index.html`), the guide (`docs/`) and the playground (`playground/`). The pages and
+their server are written in Rook, and the compiler runs right in the browser: every example of
+the guide has a tab with the JavaScript it compiles to and a run button, and the playground is a
+small IDE.
+
+- [site/src/en/](site/src/en/) and [site/src/ru/](site/src/ru/): the entry module of each page
+  (`home.rk`, `docs.rk`, `playground.rk`), the texts (`strings.rk`, `home-strings.rk`) and the
+  sections of the guide, listed in `guide.rk`;
+- [site/src/home/](site/src/home/), [site/src/docs/](site/src/docs/) and
+  [site/src/playground/](site/src/playground/): the three pages; the guide shows one section at a
+  time, chosen by the hash of the address, and has a search; [site/src/layout/](site/src/layout/):
+  the bar at the top and the footer;
+- [site/ui/](site/ui/): RookUI, the kit of components and the dark theme that the pages use;
+- [site/examples/](site/examples/) and [site/examples/ru/](site/examples/ru/): the examples; tests
+  check that they all compile and that each has a translation;
+- [site/src/i18n.rk](site/src/i18n.rk): the language of the page and the texts around the
+  guide;
+- [site/src/example.rk](site/src/example.rk) and [site/src/sandbox.rk](site/src/sandbox.rk): the
+  example with tabs, and compiling and running code in the page;
+- [site/src/highlight.rk](site/src/highlight.rk): code highlighting with the compiler's lexer;
+- [site/src/editor/](site/src/editor/): the editor of the playground, the one of VS Code (Monaco)
+  with the grammar of the VS Code extension, the compiler's errors under the code and its
+  completion; TypeScript for the browser, checked with [site/tsconfig.json](site/tsconfig.json);
+- [site/server.rk](site/server.rk): a static server on `node:http` with a log through `defer`.
+
+Vite builds the site ([vite.config.ts](vite.config.ts)): the plugin [src/vite.ts](src/vite.ts)
+compiles `.rk` modules with type checking, the playground's compiler comes straight from
+[src/browser.ts](src/browser.ts), and the code of the examples gets into the bundle from the
+`virtual:examples/en` and `virtual:examples/ru` modules. The compiler is a chunk of its own,
+loaded by [site/src/compiler.ts](site/src/compiler.ts) on the first run, when a JavaScript tab is
+opened and in the playground: the pages themselves need only the lexer, for highlighting. The
+editor of the playground, some 3.5 MB, is loaded by the playground only; until it is, and on touch
+screens, the playground has a text area of its own. The fonts, Geist and Geist Mono, come with the
+site from npm ([site/src/fonts.css](site/src/fonts.css)).
+
+```sh
+npm run site:dev    # the Vite dev server: changes show up right away
+npm run site        # builds the site to site/dist and runs site/server.rk at http://localhost:3000
+```
+
+## Vite
+
+The plugin `rooklang/vite` ([src/vite.ts](src/vite.ts)) adds Rook to any Vite project:
+
+```ts
+import { defineConfig } from 'vite';
+import { rook } from 'rooklang/vite';
+
+export default defineConfig({ plugins: [rook()] });
+```
+
+Then `.rk` files can be imported from JS, TS and other `.rk` modules. Type errors stop the
+build, and in development they show up over the page. Markup and components are off by default,
+so `.rk` modules fit a React, Svelte or Vue app as they are; turn them on with
+`"rook": { "markup": true }` in `package.json`, or `rook({ markup: true })`.
+
+## Conventions
+
+- Imports are written with the `.ts` extension (`import { x } from './lexer.ts'`).
+- Only erasable TS syntax: instead of `enum`, unions of strings or `as const` objects.
+- Text for people is written in English first (README, docs, the site, examples, comments); the
+  Russian versions are next to it: `README.ru.md`, `docs/*.ru.md`, `site/examples/ru/`.

package/README.ru.md

@@ -0,0 +1,178 @@
+# Rook
+
+[English](README.md) · **Русский**
+
+Язык с семантикой JavaScript, синтаксисом в духе Go, горутинами на настоящих потоках и статической
+типизацией. Компилируется в читаемый JavaScript без рантайма (в планах — WebAssembly).
+
+```go
+async func square(jobs <-chan number, results chan<- number) {
+    for n in jobs {
+        results <- n * n
+    }
+}
+
+const jobs = chan<number>(10)
+const results = chan<number>()
+go square(jobs, results)            // другой поток, одновременно с остальной программой
+go square(jobs, results)
+
+for let n = 1; n <= 4; n++ {
+    jobs <- n
+}
+close(jobs)
+for let i = 0; i < 4; i++ {
+    console.log(<-results)
+}
+```
+
+- **Горутины и каналы.** `go f(x)` запускает функцию горутиной, на другом процессоре, а каналы,
+  `select`, `after`, `tick` и `cancel` работают как в Go; `go for i, v in pixels { ... }` делит
+  массив между процессорами. Компилятор проверяет, что уходящее в другой поток можно туда
+  скопировать.
+- **Синтаксис Go.** `func`, тип после имени, несколько результатов, ошибки вторым значением,
+  `defer`, один цикл `for`:
+
+  ```go
+  func divide(a, b number) (number, error) {
+      if b == 0 {
+          return 0, error("division by zero")
+      }
+      return a / b, null
+  }
+  ```
+
+- **Статическая типизация с null-safety.** Значение типа `?User` нельзя использовать без проверки.
+- **Внутри — JavaScript.** Те же значения, классы и модули, любые JS-библиотеки; разметка создаёт
+  настоящие DOM-элементы, а компоненты исчезают при компиляции.
+
+Руководство с примерами и песочницей: <https://qwern-9876r.github.io/RookLang/ru/>.
+Спецификация: [docs/spec.ru.md](docs/spec.ru.md), концепция компонентов:
+[docs/components.ru.md](docs/components.ru.md), пример: [examples/hello.rk](examples/hello.rk).
+
+## Установка
+
+Нужен Node.js ≥ 24.
+
+```sh
+npm install --save-dev rooklang
+npx rook build app.rk                # app.js рядом с исходником
+npx rook build src --out-dir dist       # все модули папки
+npx rook run app.rk                  # скомпилировать и запустить
+```
+
+Из кода компилятор подключается как `import { compile } from 'rooklang'`. Ещё в пакете есть
+плагин для [Vite](#vite) — `rooklang/vite` — и `rooklang/browser`: компилятор без
+компилятора TypeScript, для работы в браузере, как в песочнице сайта; импорты там не проверяются
+по типам.
+
+## Разработка
+
+Node.js ≥ 24 (`nvm use`). Компилятор написан на TypeScript, Node запускает `.ts`-файлы напрямую,
+поэтому отдельная сборка для разработки не нужна: команды ниже запускают компилятор из `src/`.
+`dist/` собирается только для npm-пакета.
+
+`npm install` ставит и pre-commit хук, который форматирует застейдженные файлы: ESLint добавляет
+пустые строки между операторами, которые Prettier сохраняет, но сам не добавляет, затем
+форматирует Prettier. Форматируется только застейдженная версия, так что незастейдженные правки
+в коммит не попадают.
+
+## Команды
+
+| Команда                           | Что делает                                               |
+| --------------------------------- | -------------------------------------------------------- |
+| `npm run rook -- build file.rk`   | Скомпилировать в `file.js` вместе с импортируемыми `.rk` |
+| `npm run rook -- run file.rk`     | Скомпилировать и запустить                               |
+| `npm run rook -- tokens file.rk`  | Показать токены лексера                                  |
+| `npm run rook -- ast file.rk`     | Показать синтаксическое дерево                           |
+| `npm test` / `npm run test:watch` | Тесты (Vitest)                                           |
+| `npm run typecheck`               | Проверка типов                                           |
+| `npm run lint` / `npm run format` | ESLint / Prettier с пустыми строками от ESLint           |
+| `npm run check`                   | Всё сразу — типы, линт, формат, тесты                    |
+| `npm run build`                   | Собрать npm-пакет в `dist/`                              |
+| `npm run vscode:install`          | Собрать и установить расширение для VS Code              |
+
+Опции `build`: `--out-dir dir` — писать `.js` в отдельную папку, `--stdout` — вывести JS одного
+файла в консоль, `--no-check` — без проверки типов. `--markup` и `--no-markup` включают или
+выключают разметку и компоненты для всех файлов (и в `run`); по умолчанию они выключены, а пакет
+включает их в своём `package.json`: `"rook": { "markup": true }`.
+
+## Релизы
+
+Релиз — это новая версия в `package.json` в `main`: `npm version minor --no-git-tag-version` (или
+`patch`) меняет её, а пуш в `main` выпускает релиз. Workflow
+[.github/workflows/publish.yml](.github/workflows/publish.yml) видит, что такой версии в npm ещё
+нет, запускает `npm run check`, собирает `dist/`, публикует пакет в npm и ставит на коммит тег
+`v0.2.0`. Пуш без новой версии ничего не публикует.
+
+## VS Code
+
+В [editors/vscode/](editors/vscode/) лежит расширение для файлов `.rk`: подсветка кода, типов и
+разметки, ошибки прямо при наборе и автодополнение имён, членов, типов, тегов и атрибутов — от
+языкового сервера с компилятором. `npm run vscode:install` собирает его и устанавливает через
+`code`; подробности — в [editors/vscode/README.ru.md](editors/vscode/README.ru.md).
+
+## Сайт с документацией
+
+В [site/](site/) лежит сайт Rook на английском и русском (в `ru/`), в каждом по три страницы:
+главная (`index.html`), руководство (`docs/`) и песочница (`playground/`). И страницы, и сервер
+написаны на Rook, а компилятор работает прямо в браузере: у каждого примера руководства есть
+вкладка с JavaScript, который из него получается, и кнопка запуска, а песочница — маленькая IDE.
+
+- [site/src/en/](site/src/en/) и [site/src/ru/](site/src/ru/) — входной модуль каждой страницы
+  (`home.rk`, `docs.rk`, `playground.rk`), тексты (`strings.rk`, `home-strings.rk`) и разделы
+  руководства, перечисленные в `guide.rk`;
+- [site/src/home/](site/src/home/), [site/src/docs/](site/src/docs/) и
+  [site/src/playground/](site/src/playground/) — три страницы; руководство показывает по одному
+  разделу, выбранному хешем адреса, и умеет искать; [site/src/layout/](site/src/layout/) — шапка
+  и подвал;
+- [site/ui/](site/ui/) — RookUI, набор компонентов и тёмная тема, на которых построены страницы;
+- [site/examples/](site/examples/) и [site/examples/ru/](site/examples/ru/) — примеры кода; тесты
+  проверяют, что все они компилируются и что у каждого есть перевод;
+- [site/src/i18n.rk](site/src/i18n.rk) — язык страницы и тексты вокруг руководства;
+- [site/src/example.rk](site/src/example.rk) и [site/src/sandbox.rk](site/src/sandbox.rk) — пример
+  с вкладками, компиляция и запуск кода на странице;
+- [site/src/highlight.rk](site/src/highlight.rk) — подсветка кода лексером компилятора;
+- [site/src/editor/](site/src/editor/) — редактор песочницы, тот же, что в VS Code (Monaco), с
+  грамматикой расширения VS Code, ошибками компилятора прямо в коде и его автодополнением;
+  TypeScript для браузера, проверяется по [site/tsconfig.json](site/tsconfig.json);
+- [site/server.rk](site/server.rk) — статический сервер на `node:http` с логом через `defer`.
+
+Сайт собирает Vite ([vite.config.ts](vite.config.ts)): `.rk`-модули компилирует плагин
+[src/vite.ts](src/vite.ts) с проверкой типов, компилятор для песочницы берётся прямо из
+[src/browser.ts](src/browser.ts), а код примеров попадает в бандл из модулей
+`virtual:examples/en` и `virtual:examples/ru`. Компилятор вынесен в отдельный чанк, его загружает
+[site/src/compiler.ts](site/src/compiler.ts) при первом запуске, при открытии вкладки JavaScript и
+в песочнице: самим страницам нужен только лексер для подсветки. Редактор песочницы, около 3,5 МБ,
+загружает только песочница; до этого и на сенсорных экранах у неё свой textarea. Шрифты Geist и
+Geist Mono идут вместе с сайтом из npm ([site/src/fonts.css](site/src/fonts.css)).
+
+```sh
+npm run site:dev    # сервер разработки Vite: изменения видны сразу
+npm run site        # собирает сайт в site/dist и запускает site/server.rk на http://localhost:3000
+```
+
+## Vite
+
+Плагин `rooklang/vite` ([src/vite.ts](src/vite.ts)) подключает Rook к любому проекту на
+Vite:
+
+```ts
+import { defineConfig } from 'vite';
+import { rook } from 'rooklang/vite';
+
+export default defineConfig({ plugins: [rook()] });
+```
+
+После этого `.rk`-файлы можно импортировать из JS, TS и других `.rk`-модулей. Ошибки типов
+останавливают сборку, а в режиме разработки показываются поверх страницы. Разметка и компоненты по
+умолчанию выключены, поэтому `.rk`-модули подходят приложению на React, Svelte или Vue как
+есть; включить их можно через `"rook": { "markup": true }` в `package.json` или
+`rook({ markup: true })`.
+
+## Соглашения
+
+- Импорты пишутся с расширением `.ts` (`import { x } from './lexer.ts'`).
+- Только «стираемый» синтаксис TS: вместо `enum` — union-типы строк или `as const`-объекты.
+- Тексты для людей — сначала на английском (README, документация, сайт, примеры, комментарии);
+  русские версии лежат рядом: `README.ru.md`, `docs/*.ru.md`, `site/examples/ru/`.

package/dist/ast/declarations.d.ts

@@ -0,0 +1,185 @@
+import type { Expression, Identifier, StringLiteral } from './expressions.ts';
+import type { TypeMember, TypeNode, TypeReference } from './markup.ts';
+import type { BlockStatement, Statement } from './statements.ts';
+export interface NodeBase {
+    start: number;
+    end: number;
+}
+export interface Program extends NodeBase {
+    kind: 'Program';
+    body: Statement[];
+}
+/**
+ * `import x from "mod"`, `import * as ns from "mod"`, `import { a, b as c } from "mod"`,
+ * `import x, { a } from "mod"` and `import "mod"`.
+ */
+export interface ImportDeclaration extends NodeBase {
+    kind: 'ImportDeclaration';
+    defaultImport: Identifier | null;
+    namespaceImport: Identifier | null;
+    namedImports: ImportSpecifier[];
+    source: StringLiteral;
+}
+/** `a` or `a as b` inside `import { ... }`. Without `as`, `imported` and `local` are the same node. */
+export interface ImportSpecifier extends NodeBase {
+    kind: 'ImportSpecifier';
+    imported: Identifier;
+    local: Identifier;
+}
+/** `func divide(a, b number) (number, error) { ... }` */
+export interface FuncDeclaration extends NodeBase {
+    kind: 'FuncDeclaration';
+    exported: boolean;
+    /** `public func` in a decorator: the component calls it as `@name.f()`. */
+    isPublic: boolean;
+    /**
+     * `async func load() User`: the results are those of the Promise it returns, so its type is
+     * `func() Promise<User>`.
+     */
+    async?: true;
+    name: Identifier;
+    /** `[T any, U Shape]` after the name; empty for ordinary functions. */
+    typeParams: TypeParameter[];
+    params: Parameter[];
+    /** Result types: `[]` for no result, `[T]` for one, `[T1, T2]` for `(T1, T2)`. */
+    results: TypeNode[];
+    body: BlockStatement;
+}
+/** `name number`. The type is `null` only for arrow function parameters inferred from context. */
+export interface Parameter extends NodeBase {
+    kind: 'Parameter';
+    name: Identifier;
+    type: TypeNode | null;
+    /** `kind string = "info"`: only properties of components and decorators have default values. */
+    defaultValue: Expression | null;
+    /**
+     * `...attrs`, the last property of a component: the attributes of a use that are not its
+     * properties, which `{...attrs}` puts on one of its elements.
+     */
+    rest?: true;
+}
+/**
+ * `comp Card(title string, children Content) { ...; return <section>...</section> }`. Components
+ * exist only at compile time: each use is replaced by the component's code.
+ */
+export interface ComponentDeclaration extends NodeBase {
+    kind: 'ComponentDeclaration';
+    exported: boolean;
+    name: Identifier;
+    params: Parameter[];
+    body: BlockStatement;
+    /** `@html-tag` before `comp`: the component is also a web component. */
+    htmlTag: HtmlTag | null;
+    /** `@visible("300px")` before `comp`, in the order they are written. */
+    decorators: DecoratorUse[];
+}
+/** `@html-tag` or `@html-tag("app-page")`; without a name the tag comes from the component's name. */
+export interface HtmlTag extends NodeBase {
+    kind: 'HtmlTag';
+    name: StringLiteral | null;
+}
+/**
+ * `dec visible(margin string = "0px") { ... }`: logic added to the components it is applied to.
+ * Like a component, it exists only at compile time: its code is inlined into each of them.
+ */
+export interface DecoratorDeclaration extends NodeBase {
+    kind: 'DecoratorDeclaration';
+    exported: boolean;
+    name: Identifier;
+    params: Parameter[];
+    /** `needs cart, auth`: the decorators whose public members it uses; they are applied above it. */
+    needs: Identifier[];
+    body: BlockStatement;
+}
+/** `@visible("300px")` or `@visible` before `comp`; the arguments are positional. */
+export interface DecoratorUse extends NodeBase {
+    kind: 'DecoratorUse';
+    name: Identifier;
+    arguments: Expression[];
+}
+/**
+ * `let x number`, `const PI = 3.14`, `let a, b = 1, 2`, `const q, err = divide(10, 2)`; inside a
+ * component also `state count = 0` and `ref input`, which has no value: the markup gives it with
+ * `<input ref={input} />`.
+ *
+ * `values` is empty (every name gets its zero value), has one value per name, or holds a single
+ * call that returns several values.
+ */
+export interface VariableDeclaration extends NodeBase {
+    kind: 'VariableDeclaration';
+    exported: boolean;
+    keyword: 'let' | 'const' | 'state' | 'derived' | 'ref';
+    /**
+     * `public state`, `public derived` or `public const` in a decorator: the component reads it with
+     * `get(@name.x)`.
+     */
+    isPublic: boolean;
+    /** `_` is an ordinary identifier here; the checker treats it as "skip this value". */
+    names: Identifier[];
+    type: TypeNode | null;
+    values: Expression[];
+}
+/** `class Admin extends User implements Shape { ... }` */
+export interface ClassDeclaration extends NodeBase {
+    kind: 'ClassDeclaration';
+    exported: boolean;
+    name: Identifier;
+    typeParams: TypeParameter[];
+    /** An expression, as in JS, so that classes from JS modules can be extended. */
+    superClass: Expression | null;
+    implements: TypeReference[];
+    members: ClassMember[];
+}
+export type ClassMember = FieldDeclaration | ConstructorDeclaration | MethodDeclaration;
+export type Visibility = 'public' | 'protected' | 'private';
+/** `private age number`, `static count = 0`, `name = "circle"`. */
+export interface FieldDeclaration extends NodeBase {
+    kind: 'FieldDeclaration';
+    /** `public` when no modifier is written. */
+    visibility: Visibility;
+    isStatic: boolean;
+    name: Identifier;
+    type: TypeNode | null;
+    value: Expression | null;
+}
+/** `constructor(name string, age number) { ... }` */
+export interface ConstructorDeclaration extends NodeBase {
+    kind: 'ConstructorDeclaration';
+    visibility: Visibility;
+    params: Parameter[];
+    body: BlockStatement;
+}
+/** `greet() string { ... }`. Methods are written without `func`, as in JS classes. */
+export interface MethodDeclaration extends NodeBase {
+    kind: 'MethodDeclaration';
+    visibility: Visibility;
+    isStatic: boolean;
+    /** `async load() User`, like `async func`. */
+    async?: true;
+    name: Identifier;
+    params: Parameter[];
+    results: TypeNode[];
+    body: BlockStatement;
+}
+/** `interface Shape { name string; area() number }` */
+export interface InterfaceDeclaration extends NodeBase {
+    kind: 'InterfaceDeclaration';
+    exported: boolean;
+    name: Identifier;
+    typeParams: TypeParameter[];
+    members: TypeMember[];
+}
+/** `type ID string`, `type Handler func(string) bool`, `type Pair<A, B any> { ... }`. */
+export interface TypeAliasDeclaration extends NodeBase {
+    kind: 'TypeAliasDeclaration';
+    exported: boolean;
+    name: Identifier;
+    typeParams: TypeParameter[];
+    type: TypeNode;
+}
+/** `T any` or `T Shape` in `[T any, U Shape]`; the constraint is `null` when it is left out. */
+export interface TypeParameter extends NodeBase {
+    kind: 'TypeParameter';
+    name: Identifier;
+    constraint: TypeNode | null;
+}

package/dist/ast/declarations.js

@@ -0,0 +1 @@
+export {};