Merge branch 'claude/jovial-snyder-3d4f82'

Author: johnsoncodehk

html.tmLanguage.json

@@ -1040,7 +1040,7 @@
     "attribute": {
       "patterns": [
         {
-          "begin": "(on\\w+)(?![\\w:.-])",
+          "begin": "(on[A-Za-z0-9_]+)(?![\\w:.-])",
           "beginCaptures": {
             "1": {
               "name": "entity.other.attribute-name.html"

html.ts

@@ -9,10 +9,12 @@
 // tags). It does not implement the WHATWG error-recovery tree-construction
 // algorithm (that is not a context-free grammar); conformance is measured against
 // `parse5` on well-formed input. See memory: html-vue-markup.
-import { token, rule, defineGrammar, many, opt, alt, seq, oneOf, noneOf, range, anyChar, star, plus, notFollowedBy } from './src/api.ts';
+import { token, rule, defineGrammar, many, opt, alt, lit, seq, oneOf, noneOf, range, anyChar, star, plus, notFollowedBy } from './src/api.ts';
 import type { MarkupConfig } from './src/types.ts';
 
 // ── Tokens ──
+// ASCII word chars [A-Za-z0-9_] — NOT `\w` (Oniguruma treats `\w` as Unicode-aware); tag/attr
+// names and the `on*` embed selector are intentionally ASCII, so the IR enumerates the set.
 const word = oneOf(range('A', 'Z'), range('a', 'z'), range('0', '9'), '_');
 const whitespace = oneOf('\t', '\n', '\f', '\r', ' ');
 
@@ -120,8 +122,8 @@ export const markup: MarkupConfig = {
   // VS Code's own HTML grammar (a flat source.css blob there) and matching the hand-written Vue
   // grammar's `#vue-directives-style-attr` (its "Copy from source.css#rule-list-innards").
   attributeEmbed: [
-    { namePattern: 'on\\w+', embed: 'source.js' },
-    { namePattern: 'style', embed: 'source.css', include: 'source.css#rule-list-innards' },
+    { namePattern: seq(lit('on'), plus(word)), embed: 'source.js' },
+    { namePattern: lit('style'), embed: 'source.css', include: 'source.css#rule-list-innards' },
   ],
   // Raw-text element bodies are scanned verbatim by the parser, but the HIGHLIGHTER
   // delegates `<script>`/`<style>` to the platform's real JS/CSS grammars (exactly as

src/gen-tm.ts

@@ -16,6 +16,7 @@ import {
   tokenPatternSource,
   tokenPatternStartsWithDecimal,
   tokenPatternStringDelimiters,
+  tokenPatternToRegex,
   tokenPatternTrailingCharClass,
 } from './token-pattern.ts';
 
@@ -3863,7 +3864,7 @@ function generateMarkupTm(grammar: CstGrammar, grammarName: string, scopeName: s
   // name/value tie on a real `on*`; leftmost-match still prefers the generic name rule for
   // `data-on…` (it matches at the earlier, true attribute start). `(?![\w:.-])` completes the name.
   const attrEmbed: TmPattern[] = (m.attributeEmbed ?? []).map(spec => ({
-    begin: `(${spec.namePattern})(?![\\w:.-])`,
+    begin: `(${tokenPatternToRegex(spec.namePattern)})(?![\\w:.-])`,
     beginCaptures: { '1': { name: sAttr } },
     end: `(?=[\\s${escapeForCharClass(m.tagClose)}${escapeForCharClass(m.closeMarker ?? '/')}])`,
     patterns: embedValuePatterns(spec.embed, spec.include ?? spec.embed, sEq, assign, attrQuotes, quoteCc, { begin: sStrPunctB, end: sStrPunctE }, spec.valuePatterns),
@@ -3986,7 +3987,7 @@ function buildMarkupInjectParts(grammar: CstGrammar, mainScopeName: string): { r
     const dir: TmPattern[] = [];
     for (const c of d.control) {         // v-for / v-if … — distinct scope, value embedded
       dir.push({
-        begin: `${beforeAttr}(${c.match})(?=[${assignCc}\\s${ccSlash}${ccClose}]|$)`,
+        begin: `${beforeAttr}(${tokenPatternToRegex(c.match)})(?=[${assignCc}\\s${ccSlash}${ccClose}]|$)`,
         beginCaptures: { '1': { name: c.scope } },
         end: endAttr, patterns: values,
       });

src/token-pattern.ts

@@ -263,6 +263,9 @@ function quantifier(min: number, max: number | undefined): string {
   return `{${min},${max}}`;
 }
 
+// A char class serializes to an explicit `[…]`, never a `\w`/`\d`/`\s` shorthand: Oniguruma's
+// shorthands are Unicode-aware (`\d` matches U+FF10, `\w` matches `é`/`你`), so condensing an
+// enumerated ASCII set to a shorthand would silently widen the meaning the IR declares.
 function emitCharClass(pattern: Extract<TokenPattern, { type: 'charClass' }>): string {
   return `[${pattern.negate ? '^' : ''}${pattern.items.map(emitClassItem).join('')}]`;
 }

src/types.ts

@@ -141,7 +141,7 @@ export interface MarkupConfig {
   // {name,match}); when present it REPLACES `include` inside the value span (the quote bounding is
   // unchanged). Lets an embed mirror a hand-written grammar's value rule verbatim (e.g. Volar's
   // `vue-directives-generic-attr`) using the host's PUBLIC repository keys.
-  attributeEmbed?: { namePattern: string; embed: string; include?: string; valuePatterns?: RepoAlias[] }[];
+  attributeEmbed?: { namePattern: TokenPattern; embed: string; include?: string; valuePatterns?: RepoAlias[] }[];
   // Elements whose content is raw (CDATA-like): after the start tag's `tagClose`,
   // everything up to the matching `tagOpen+closeMarker+name` is one `token`. `embed`
   // optionally maps a tag → the grammar scope to embed in its body (e.g. Vue SFC blocks:
@@ -236,7 +236,7 @@ export interface MarkupInject {
     scopeName: string;        // emitted file's scopeName, e.g. vue.directives
     repoKey: string;          // main-grammar repository key the stub includes, e.g. vue-directives
     selector: InjectClause[]; // host scopes (e.g. meta.tag / meta.element)
-    control: { match: string; scope: string }[];  // e.g. [{match:'v-for', scope:'keyword.control.loop.vue'}, …]
+    control: { match: TokenPattern; scope: string }[];  // e.g. [{match:lit('v-for'), scope:'keyword.control.loop.vue'}, …]
     shorthand: { char: string; scope: string }[];  // e.g. [{char:':', scope:'punctuation.attribute-shorthand.bind.html.vue'}, …]
     prefix: string;        // long-form directive prefix, e.g. 'v-'
     nameScope: string;     // scope for a directive name / argument (entity.other.attribute-name.html.vue)

vue.tmLanguage.json

@@ -3286,7 +3286,7 @@
     "attribute": {
       "patterns": [
         {
-          "begin": "(on\\w+)(?![\\w:.-])",
+          "begin": "(on[A-Za-z0-9_]+)(?![\\w:.-])",
           "beginCaptures": {
             "1": {
               "name": "entity.other.attribute-name.vue"

vue.ts

@@ -14,7 +14,7 @@
 // is HTML's raw-text mechanism with a per-block embed map) and only swaps the markup config
 // + scope name. We import those reusable pieces and build through `defineGrammar` — the same
 // API every other grammar uses — instead of spreading html's already-built grammar object.
-import { defineGrammar } from './src/api.ts';
+import { defineGrammar, lit, alt } from './src/api.ts';
 import { tokens, rules, scopes, markup as htmlMarkup } from './html.ts';
 
 export default defineGrammar({
@@ -52,7 +52,7 @@ export default defineGrammar({
     // SAME vue grammar runs on either host (proven by test/vue-dropin.ts). Vue-only, so it extends
     // html.ts's `on*`/`style` embeds rather than polluting the HTML grammar.
     attributeEmbed: [...(htmlMarkup.attributeEmbed ?? []), {
-      namePattern: 'generic', embed: 'source.ts',
+      namePattern: lit('generic'), embed: 'source.ts',
       valuePatterns: [
         { include: 'source.ts#comment' },
         { name: 'storage.modifier.ts', match: '(?<![_$[:alnum:]])(?:(?<=\\.\\.\\.)|(?<!\\.))(extends|in|out)(?![_$[:alnum:]])(?:(?=\\.\\.\\.)|(?!\\.))' },
@@ -127,8 +127,8 @@ export default defineGrammar({
           { scope: 'meta.element', excludes: ['meta.attribute'] },
         ],
         control: [
-          { match: 'v-for', scope: 'keyword.control.loop.vue' },
-          { match: 'v-if|v-else-if|v-else', scope: 'keyword.control.conditional.vue' },
+          { match: lit('v-for'), scope: 'keyword.control.loop.vue' },
+          { match: alt(lit('v-if'), lit('v-else-if'), lit('v-else')), scope: 'keyword.control.conditional.vue' },
         ],
         shorthand: [
           { char: ':', scope: 'punctuation.attribute-shorthand.bind.html.vue' },