@marko/tree-sitter 0.0.0 → 0.2.0

package/package.json

@@ -1 +1,86 @@
-{"name":"@marko/tree-sitter","version":"0.0.0","private":false}
+{
+  "name": "@marko/tree-sitter",
+  "version": "0.2.0",
+  "description": "Tree-sitter grammar for the Marko templating language",
+  "keywords": [
+    "incremental",
+    "marko",
+    "parser",
+    "tree-sitter"
+  ],
+  "homepage": "https://github.com/marko-js/tree-sitter",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marko-js/tree-sitter.git"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "bindings/node",
+  "types": "bindings/node",
+  "files": [
+    "*.wasm",
+    "LICENSE",
+    "binding.gyp",
+    "bindings/node",
+    "grammar.js",
+    "prebuilds/**",
+    "queries",
+    "src/**",
+    "tree-sitter.json"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.3.0",
+    "node-gyp-build": "^4.8.4"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.7.0",
+    "@changesets/cli": "^2.31.0",
+    "@types/degit": "^2.8.6",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.11.16",
+    "degit": "^2.8.4",
+    "htmljs-parser": "^5.10.2",
+    "mocha": "^10.2.0",
+    "node-gyp": "^11.0.0",
+    "prebuildify": "^6.0.1",
+    "tree-sitter": "^0.25.0",
+    "tree-sitter-cli": "^0.26.9",
+    "tsx": "^4.19.2",
+    "web-tree-sitter": "^0.26.9"
+  },
+  "peerDependencies": {
+    "tree-sitter": "^0.25.0"
+  },
+  "peerDependenciesMeta": {
+    "tree-sitter": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tree-sitter generate && node-gyp rebuild",
+    "change": "changeset add",
+    "generate": "tree-sitter generate",
+    "install": "node-gyp-build",
+    "release:publish": "changeset publish",
+    "release:tag": "changeset tag",
+    "test": "mocha \"./__tests__/*.test.mts\"",
+    "prebuild": "prebuildify --napi --strip",
+    "build:wasm": "tree-sitter build --wasm -o tree-sitter-marko.wasm",
+    "test:wasm": "tsx tools/check-wasm.mts",
+    "version": "changeset version && node tools/sync-tree-sitter-version.mjs && npm install --package-lock-only"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.marko",
+      "file-types": [
+        "marko"
+      ],
+      "injection-regex": "^marko$"
+    }
+  ]
+}

package/queries/highlights.scm

@@ -0,0 +1,61 @@
+; Basic syntax highlighting for Marko templates.
+
+; Statement-tag names are not tags visually: static/server/client are
+; Marko keywords (the compiler strips them before parsing the body as TS),
+; while import/export/class are part of the injected TS statement itself
+; and take their color from that injection (see injections.scm).
+((tag_name (tag_name_fragment) @tag)
+ (#not-any-of? @tag "import" "export" "class" "static" "server" "client"))
+((tag_name (tag_name_fragment) @keyword)
+ (#any-of? @keyword "static" "server" "client"))
+(close_tag_name) @tag
+(shorthand_id) @constant
+(shorthand_class) @property
+
+(attr_name) @attribute
+
+; Binding positions: patterns get the TS injection; types are captured
+; flatly because a bare type is not a valid TS program (matching the
+; tmLanguage grammar's source.ts#type approximation).
+(var_pattern) @variable
+(var_type) @type
+(param_pattern) @variable.parameter
+(param_type) @type
+(param_default) @none
+(type_expr) @type
+
+(open_tag_start) @punctuation.bracket
+(open_tag_end) @punctuation.bracket
+(open_tag_end_self) @punctuation.bracket
+(close_tag_start) @punctuation.bracket
+(close_tag_end) @punctuation.bracket
+
+(args_open) @punctuation.bracket
+(args_close) @punctuation.bracket
+(params_open) @punctuation.bracket
+(params_close) @punctuation.bracket
+(type_open) @punctuation.bracket
+(type_close) @punctuation.bracket
+(attr_group_open) @punctuation.bracket
+(attr_group_close) @punctuation.bracket
+(method_body_open) @punctuation.bracket
+(method_body_close) @punctuation.bracket
+(scriptlet_block_open) @punctuation.bracket
+(scriptlet_block_close) @punctuation.bracket
+
+(placeholder_start) @punctuation.special
+(placeholder_start_raw) @punctuation.special
+(placeholder_end) @punctuation.special
+
+(html_comment) @comment
+(line_comment) @comment
+(block_comment) @comment
+
+(doctype) @keyword
+(declaration) @keyword
+(cdata) @string
+
+(scriptlet_start) @punctuation.special
+(scriptlet_start_concise) @punctuation.special
+
+(text) @none

package/queries/injections.scm

@@ -0,0 +1,123 @@
+; Embedded-language injections for Marko templates.
+;
+; All expression positions in Marko hold TypeScript expressions/statements
+; (TypeScript is a superset of JavaScript, so it always applies), and
+; style/script tag bodies hold CSS/TS. These queries let editors parse that
+; embedded content with the right grammar.
+
+; ${...} / $!{...} placeholders (content + tag name interpolations)
+((placeholder_expr) @injection.content
+ (#set! injection.language "typescript"))
+
+; $ scriptlets: `$ statement` and `$ { block }`
+((scriptlet_expr) @injection.content
+ (#set! injection.language "typescript"))
+((scriptlet_block_expr) @injection.content
+ (#set! injection.language "typescript"))
+
+; Statement tags come in two groups, mirroring how the compiler's core tag
+; parsers consume them. import/export/class are pass-through TypeScript:
+; the keyword itself is part of the statement the compiler parses, so the
+; injection covers the whole element (its trailing tokens are zero-width,
+; making its extent exactly the statement text, semicolon included).
+; include-children is required: child node ranges are otherwise excluded
+; from an injection, and the element's children span its entire text.
+((element
+   (tag_name) @_name
+   (#any-of? @_name "import" "export" "class")
+   (statement_expr)) @injection.content
+ (#set! injection.language "typescript")
+ (#set! injection.include-children))
+
+; static/server/client strip their keyword before the body is parsed as
+; TS, so only the body is injected (the keyword is highlighted as a Marko
+; keyword in highlights.scm).
+(element
+  (tag_name) @_name
+  (#any-of? @_name "static" "server" "client")
+  (statement_expr) @injection.content
+  (#set! injection.language "typescript"))
+
+; attribute values, spreads and bound values
+((attr_value_expr) @injection.content
+ (#set! injection.language "typescript"))
+
+; tag variables and parameters are binding positions: their patterns and
+; defaults parse cleanly as bare programs, while type annotations are
+; captured flatly in highlights.scm (a bare type is not a valid TS program).
+((var_pattern) @injection.content
+ (#set! injection.language "typescript"))
+((param_pattern) @injection.content
+ (#set! injection.language "typescript"))
+((param_default) @injection.content
+ (#set! injection.language "typescript"))
+
+; tag/attr arguments and shorthand-method bodies are expression/statement
+; positions.
+((args_expr) @injection.content
+ (#set! injection.language "typescript"))
+((method_body_expr) @injection.content
+ (#set! injection.language "typescript"))
+
+; <script> bodies: injection.combined merges the raw text chunks split by
+; ${...} placeholders.
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "script")
+  (text) @injection.content
+  (#set! injection.language "typescript")
+  (#set! injection.combined))
+
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "html-script")
+  (text) @injection.content
+  (#set! injection.language "typescript")
+  (#set! injection.combined))
+
+; <style> bodies are CSS by default, but shorthand "extension" segments
+; pick the stylesheet dialect, last segment winning (<style.scss>,
+; <style.module.scss> -> scss), mirroring the compiler's STYLE_EXT_REG.
+; The @injection.language capture overrides the #set! fallback, and with
+; several captured segments the last capture wins.
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "style")
+  (shorthand_class (tag_name_fragment) @injection.language)*
+  (text) @injection.content
+  (#set! injection.language "css")
+  (#set! injection.combined))
+
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "html-style")
+  (text) @injection.content
+  (#set! injection.language "css")
+  (#set! injection.combined))
+
+; style -- css blocks / script -- js blocks in concise mode (the style
+; form supports the same dialect shorthands: style.scss -- ...).
+;
+; Unlike the <script>/<style> forms above, these omit injection.combined: the
+; concise body is a nested html_block whose lines are separate text nodes, and
+; Zed desyncs combined injections nested under an html_block on incremental
+; edits (highlighting blanks out while typing). Per-chunk injection highlights
+; each line independently, which is fine for these short blocks.
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "style")
+  (shorthand_class (tag_name_fragment) @injection.language)*
+  (html_block
+    (text) @injection.content)
+  (#set! injection.language "css"))
+
+(element
+  (tag_name) @_tag
+  (#eq? @_tag "script")
+  (html_block
+    (text) @injection.content)
+  (#set! injection.language "typescript"))
+
+; html comments
+((html_comment) @injection.content
+ (#set! injection.language "html"))