@mirascript/textmate 0.1.83 → 0.1.84

package/src/grammar.ts

@@ -11,22 +11,33 @@ import { mirascriptDocLanguage, mirascriptLanguage, mirascriptTemplateLanguage }
 
 const SCOPE_SUFFIX = 'mira';
 const IDENTIFIER = REG_IDENTIFIER.source;
+const IDENTIFIER_START = String.raw`(?<!\p{XID_Continue})`;
 const IDENTIFIER_END = String.raw`(?!\p{XID_Continue})`;
 const MAX_VERBATIM_LENGTH = 16;
 const BUILT_IN_TYPES = [
     'any',
     'unknown',
     'never',
+
     'boolean',
+    'true',
+    'false',
+
     'number',
     'string',
+
     'record',
     'array',
     'extern',
     'module',
+
     'nil',
 ];
 const DOC_CONSTANT_IDENTIFIER = String.raw`(?:@+\p{XID_Continue}+|\p{Lu}[\p{XID_Continue}]*)`;
+const DOC_TAG_NAME = String.raw`[^>\r\n]*[^>\s]`;
+const DOC_TAG_CONTENT = String.raw`(?:module|function|extern)(?:[ \t]+${DOC_TAG_NAME})?`;
+const DOC_FIELD_NAME = String.raw`(?:${IDENTIFIER}|\d+|"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*')`;
+const DOC_TAG_NUMBER = String.raw`\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?[\d_]*\d)?`;
 
 /**
  * Escape a literal value for insertion into an Oniguruma regular expression.
@@ -45,17 +56,6 @@ function alternatives(values: Iterable<string>): string {
         .join('|');
 }
 
-/**
- * Create a boundary-aware TextMate keyword rule.
- */
-function keywordRule(values: readonly string[], name: string): { name: string; match: string } | null {
-    if (values.length === 0) return null;
-    return {
-        name: `${name}.${SCOPE_SUFFIX}`,
-        match: String.raw`(?<!\p{XID_Continue})(?:${alternatives(values)})${IDENTIFIER_END}`,
-    };
-}
-
 const numericKeywordSet = new Set<string>(NUMERIC_KEYWORDS);
 const constantKeywords = CONSTANT_KEYWORDS.filter((keyword) => !numericKeywordSet.has(keyword));
 const languageVariables = ['_', 'global'];
@@ -73,7 +73,7 @@ const classifiedKeywords = new Set([
     'type',
 ]);
 const otherKeywords = KEYWORDS.filter((keyword) => !classifiedKeywords.has(keyword));
-const mirascriptFenceTags = alternatives([mirascriptLanguage.name, ...(mirascriptLanguage.aliases ?? [])]);
+const mirascriptFenceTags = alternatives([mirascriptLanguage.name, ...mirascriptLanguage.aliases]);
 const documentationMiraFenceBegin = String.raw`^(\s*\*\s?)(\x60{3,})\s*((?i:${mirascriptFenceTags}))?\s*$`;
 const documentationOtherFenceBegin = String.raw`^(\s*\*\s?)(\x60{3,})\s*(\S+)(?:\s+.*)?\s*$`;
 const documentationFenceEnd = String.raw`^(?:(\s*\*\s?)(\2\x60*)\s*$)|(?=\*/)`;
@@ -300,6 +300,13 @@ function documentationRepository(sourceInclude = '#source') {
  * Build the shared repository used by source and template grammars.
  */
 function sourceRepository(): LanguageRegistration['repository'] {
+    /**
+     * Create a boundary-aware TextMate keyword rule.
+     */
+    const keywordRule = (values: readonly string[], name: string) => ({
+        name: `${name}.${SCOPE_SUFFIX}`,
+        match: `${IDENTIFIER_START}(?:${alternatives(values)})${IDENTIFIER_END}`,
+    });
     const keywordPatterns = [
         keywordRule(NUMERIC_KEYWORDS, 'constant.numeric.language'),
         keywordRule(constantKeywords, 'constant.language'),
@@ -310,7 +317,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
         keywordRule(RESERVED_KEYWORDS, 'keyword.reserved'),
         keywordRule(languageVariables, 'variable.language'),
         keywordRule(otherKeywords, 'keyword.other'),
-    ].filter((p) => p != null);
+    ];
 
     return {
         source: {
@@ -365,7 +372,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
             patterns: [
                 {
                     name: `meta.function.declaration.${SCOPE_SUFFIX}`,
-                    begin: String.raw`(?<!\p{XID_Continue})(fn)(\s+)(${IDENTIFIER})(\s*)(\()`,
+                    begin: String.raw`${IDENTIFIER_START}(fn)(\s+)(${IDENTIFIER})(\s*)(\()`,
                     beginCaptures: {
                         1: { name: `keyword.declaration.function.${SCOPE_SUFFIX}` },
                         3: { name: `entity.name.function.${SCOPE_SUFFIX}` },
@@ -377,7 +384,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
                 },
                 {
                     name: `meta.function.declaration.${SCOPE_SUFFIX}`,
-                    match: String.raw`(?<!\p{XID_Continue})(fn)(\s+)(${IDENTIFIER})`,
+                    match: String.raw`${IDENTIFIER_START}(fn)(\s+)(${IDENTIFIER})`,
                     captures: {
                         1: { name: `keyword.declaration.function.${SCOPE_SUFFIX}` },
                         3: { name: `entity.name.function.${SCOPE_SUFFIX}` },
@@ -385,7 +392,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
                 },
                 {
                     name: `meta.function.expression.parameters.${SCOPE_SUFFIX}`,
-                    begin: String.raw`(?<!\p{XID_Continue})(fn)(\s*)(\()`,
+                    begin: String.raw`${IDENTIFIER_START}(fn)(\s*)(\()`,
                     beginCaptures: {
                         1: { name: `keyword.declaration.function.${SCOPE_SUFFIX}` },
                         3: { name: `punctuation.section.parameters.begin.${SCOPE_SUFFIX}` },
@@ -399,7 +406,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
         parameters: {
             patterns: [
                 {
-                    match: String.raw`(?<!\p{XID_Continue})(mut)(\s+)(${IDENTIFIER})`,
+                    match: String.raw`${IDENTIFIER_START}(mut)(\s+)(${IDENTIFIER})`,
                     captures: {
                         1: { name: `keyword.declaration.mutable.${SCOPE_SUFFIX}` },
                         3: { name: `variable.emphasis.${SCOPE_SUFFIX}` },
@@ -407,7 +414,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
                 },
                 {
                     name: `keyword.declaration.mutable.${SCOPE_SUFFIX}`,
-                    match: String.raw`(?<!\p{XID_Continue})mut${IDENTIFIER_END}`,
+                    match: `${IDENTIFIER_START}mut${IDENTIFIER_END}`,
                 },
                 { name: `keyword.operator.spread.${SCOPE_SUFFIX}`, match: String.raw`\.\.` },
                 { name: `variable.other.constant.emphasis.${SCOPE_SUFFIX}`, match: IDENTIFIER },
@@ -428,7 +435,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
         'module-declarations': {
             patterns: [
                 {
-                    match: String.raw`(?<!\p{XID_Continue})(mod)(\s+)(${IDENTIFIER})`,
+                    match: String.raw`${IDENTIFIER_START}(mod)(\s+)(${IDENTIFIER})`,
                     captures: {
                         1: { name: `keyword.control.module.${SCOPE_SUFFIX}` },
                         3: { name: `entity.name.namespace.${SCOPE_SUFFIX}` },
@@ -439,7 +446,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
         'for-bindings': {
             patterns: [
                 {
-                    match: String.raw`(?<!\p{XID_Continue})(for)(\s+)(mut)(\s+)(${IDENTIFIER})(\s+)(in)${IDENTIFIER_END}`,
+                    match: String.raw`${IDENTIFIER_START}(for)(\s+)(mut)(\s+)(${IDENTIFIER})(\s+)(in)${IDENTIFIER_END}`,
                     captures: {
                         1: { name: `keyword.control.loop.${SCOPE_SUFFIX}` },
                         3: { name: `keyword.declaration.mutable.${SCOPE_SUFFIX}` },
@@ -448,7 +455,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
                     },
                 },
                 {
-                    match: String.raw`(?<!\p{XID_Continue})(for)(\s+)(${IDENTIFIER})(\s+)(in)${IDENTIFIER_END}`,
+                    match: String.raw`${IDENTIFIER_START}(for)(\s+)(${IDENTIFIER})(\s+)(in)${IDENTIFIER_END}`,
                     captures: {
                         1: { name: `keyword.control.loop.${SCOPE_SUFFIX}` },
                         3: { name: `variable.other.${SCOPE_SUFFIX}` },
@@ -509,7 +516,7 @@ function sourceRepository(): LanguageRegistration['repository'] {
             patterns: [
                 {
                     name: `keyword.operator.expression.${SCOPE_SUFFIX}`,
-                    match: String.raw`(?<!\p{XID_Continue})type${IDENTIFIER_END}(?=\s*\(|\s+${IDENTIFIER})`,
+                    match: String.raw`${IDENTIFIER_START}type${IDENTIFIER_END}(?=\s*\(|\s+${IDENTIFIER})`,
                 },
             ],
         },
@@ -664,27 +671,43 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
             ...documentationRepository('source.mira#source'),
             doc: {
                 patterns: [
+                    { include: '#tag' },
                     { include: '#global-value' },
                     { include: '#global-constants' },
                     { include: '#inline-parameter' },
+                    { include: '#properties' },
                     { include: '#inline-label' },
+                    { include: '#binding-value' },
                     { include: '#bindings' },
                     { include: '#function-signatures' },
-                    { include: '#properties' },
                     { include: '#generic-types' },
                     { include: '#parameters' },
                     { include: '#return-type' },
-                    { include: '#metadata' },
+                    { include: '#tag-comment' },
                     { include: 'source.mira' },
                 ],
             },
+            tag: {
+                patterns: [
+                    {
+                        name: 'meta.documentation.tag.mira',
+                        contentName: 'meta.documentation.tag.content.mira',
+                        begin: `(<)(?=${DOC_TAG_CONTENT}>)`,
+                        beginCaptures: { 1: { name: 'punctuation.definition.tag.begin.mira' } },
+                        end: '(>)',
+                        endCaptures: { 1: { name: 'punctuation.definition.tag.end.mira' } },
+                        patterns: [{ include: '#tag-content' }],
+                    },
+                ],
+            },
             'global-value': {
                 patterns: [
                     {
+                        name: 'meta.documentation.global-value.mira',
                         begin: String.raw`^(\x00)?(\(global\))(\s+)(${IDENTIFIER})(\s*)(=)`,
                         beginCaptures: {
                             2: { name: 'entity.name.label.mira' },
-                            4: { name: 'variable.other.constant.mira' },
+                            4: { name: 'variable.other.mira' },
                             6: { name: 'keyword.operator.assignment.mira' },
                         },
                         end: '$',
@@ -739,7 +762,7 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
             bindings: {
                 patterns: [
                     {
-                        match: String.raw`(?<!\p{XID_Continue})(let)(\s+)(mut)(\s+)(${IDENTIFIER})`,
+                        match: String.raw`${IDENTIFIER_START}(let)(\s+)(mut)(\s+)(${IDENTIFIER})`,
                         captures: {
                             1: { name: 'keyword.declaration.variable.mira' },
                             3: { name: 'keyword.declaration.mutable.mira' },
@@ -747,7 +770,7 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
                         },
                     },
                     {
-                        match: String.raw`(?<!\p{XID_Continue})(let|const)(\s+)(${IDENTIFIER})`,
+                        match: String.raw`${IDENTIFIER_START}(let|const)(\s+)(${IDENTIFIER})`,
                         captures: {
                             1: { name: 'keyword.declaration.variable.mira' },
                             3: { name: 'variable.other.constant.mira' },
@@ -755,10 +778,35 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
                     },
                 ],
             },
+            'binding-value': {
+                patterns: [
+                    {
+                        begin: String.raw`${IDENTIFIER_START}(let)(\s+)(mut)(\s+)(${IDENTIFIER})(\s*)(=)`,
+                        beginCaptures: {
+                            1: { name: 'keyword.declaration.variable.mira' },
+                            3: { name: 'keyword.declaration.mutable.mira' },
+                            5: { name: 'variable.other.readwrite.mira' },
+                            7: { name: 'keyword.operator.assignment.mira' },
+                        },
+                        end: '$',
+                        patterns: [{ include: '#doc-value' }],
+                    },
+                    {
+                        begin: String.raw`${IDENTIFIER_START}(let|const)(\s+)(${IDENTIFIER})(\s*)(=)`,
+                        beginCaptures: {
+                            1: { name: 'keyword.declaration.variable.mira' },
+                            3: { name: 'variable.other.constant.mira' },
+                            5: { name: 'keyword.operator.assignment.mira' },
+                        },
+                        end: '$',
+                        patterns: [{ include: '#doc-value' }],
+                    },
+                ],
+            },
             'function-signatures': {
                 patterns: [
                     {
-                        match: String.raw`(?<!\p{XID_Continue})(?:(pub)(\s+))?(fn)(\s+)(${IDENTIFIER})(?=\s*(?:<|\())`,
+                        match: String.raw`${IDENTIFIER_START}(?:(pub)(\s+))?(fn)(\s+)(${IDENTIFIER})(?=\s*(?:<|\())`,
                         captures: {
                             1: { name: 'keyword.control.module.mira' },
                             3: { name: 'keyword.declaration.function.mira' },
@@ -770,22 +818,65 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
             properties: {
                 patterns: [
                     {
-                        begin: String.raw`(${IDENTIFIER})(\s*)(\??:)`,
+                        name: 'meta.documentation.field.mira',
+                        begin: String.raw`^(\x00)?(?:(\(field\))(\s+))?(${DOC_FIELD_NAME})(\s*)(\??:)(?=[ \t]*/\*[ \t]*<extern[ \t]+(?:(?:async[ \t]+)?function\*?)(?:[ \t]+${DOC_TAG_NAME})?>[ \t]*\*/)`,
+                        beginCaptures: {
+                            2: { name: 'entity.name.label.mira' },
+                            4: { name: 'entity.name.function.mira' },
+                            6: { name: 'punctuation.separator.type.mira' },
+                        },
+                        end: '$',
+                        patterns: [
+                            { include: '#tag-comment' },
+                            { include: '#tag' },
+                            { include: '#doc-record-value' },
+                            { include: '#doc-array-value' },
+                            { include: '#type-context' },
+                        ],
+                    },
+                    {
+                        name: 'meta.documentation.field.mira',
+                        begin: String.raw`^(\x00)?(?:(\(field\))(\s+))?(${DOC_FIELD_NAME})(\s*)(\??:)(?=[ \t]*/\*[ \t]*<extern[ \t]+class(?:[ \t]+${DOC_TAG_NAME})?>[ \t]*\*/)`,
                         beginCaptures: {
-                            1: { name: 'variable.other.property.mira' },
-                            3: { name: 'punctuation.separator.type.mira' },
+                            2: { name: 'entity.name.label.mira' },
+                            4: { name: 'entity.name.type.mira' },
+                            6: { name: 'punctuation.separator.type.mira' },
                         },
                         end: '$',
-                        patterns: [{ include: '#metadata' }, { include: '#type-context' }],
+                        patterns: [
+                            { include: '#tag-comment' },
+                            { include: '#tag' },
+                            { include: '#doc-record-value' },
+                            { include: '#doc-array-value' },
+                            { include: '#type-context' },
+                        ],
+                    },
+                    {
+                        name: 'meta.documentation.field.mira',
+                        begin: String.raw`^(\x00)?(?:(\(field\))(\s+))?(${DOC_FIELD_NAME})(\s*)(\??:)`,
+                        beginCaptures: {
+                            2: { name: 'entity.name.label.mira' },
+                            4: { name: 'variable.other.property.mira' },
+                            6: { name: 'punctuation.separator.type.mira' },
+                        },
+                        end: '$',
+                        patterns: [
+                            { include: '#tag-comment' },
+                            { include: '#tag' },
+                            { include: '#doc-record-value' },
+                            { include: '#doc-array-value' },
+                            { include: '#type-context' },
+                        ],
                     },
                 ],
             },
             'doc-value': {
                 patterns: [
-                    { include: '#extern-function-properties' },
-                    { include: '#extern-class-properties' },
-                    { include: '#metadata' },
+                    { include: '#tag-properties' },
+                    { include: '#tag-comment' },
+                    { include: '#tag' },
                     { include: '#doc-record-value' },
+                    { include: '#doc-array-value' },
                     { include: 'source.mira' },
                 ],
             },
@@ -800,21 +891,28 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
                     },
                 ],
             },
-            'extern-function-properties': {
+            'doc-array-value': {
+                patterns: [
+                    {
+                        begin: String.raw`\[`,
+                        beginCaptures: { 0: { name: 'punctuation.section.brackets.begin.mira' } },
+                        end: String.raw`\]`,
+                        endCaptures: { 0: { name: 'punctuation.section.brackets.end.mira' } },
+                        patterns: [{ include: '#doc-value' }],
+                    },
+                ],
+            },
+            'tag-properties': {
                 patterns: [
                     {
-                        match: String.raw`(${IDENTIFIER})(\s*)(:)(?=\s*/\*\s*<\s*extern\s+(?:(?:async\s+)?function\*?)(?:\s+${IDENTIFIER})?\s*>\s*\*/)`,
+                        match: String.raw`(${DOC_FIELD_NAME})(\s*)(:)(?=[ \t]*/\*[ \t]*<extern[ \t]+(?:(?:async[ \t]+)?function\*?)(?:[ \t]+${DOC_TAG_NAME})?>[ \t]*\*/)`,
                         captures: {
                             1: { name: 'entity.name.function.mira' },
                             3: { name: 'punctuation.separator.key-value.mira' },
                         },
                     },
-                ],
-            },
-            'extern-class-properties': {
-                patterns: [
                     {
-                        match: String.raw`(${IDENTIFIER})(\s*)(:)(?=\s*/\*\s*<\s*extern\s+class(?:\s+${IDENTIFIER})?\s*>\s*\*/)`,
+                        match: String.raw`(${DOC_FIELD_NAME})(\s*)(:)(?=[ \t]*/\*[ \t]*<extern[ \t]+class(?:[ \t]+${DOC_TAG_NAME})?>[ \t]*\*/)`,
                         captures: {
                             1: { name: 'entity.name.type.mira' },
                             3: { name: 'punctuation.separator.key-value.mira' },
@@ -822,54 +920,84 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
                     },
                 ],
             },
-            metadata: {
+            'tag-comment': {
                 patterns: [
                     {
                         name: 'comment.block.mira',
-                        contentName: 'meta.documentation.type-hint.mira',
-                        begin: String.raw`/\*\s*<`,
-                        beginCaptures: { 0: { name: 'punctuation.definition.comment.begin.mira' } },
-                        end: String.raw`>\s*\*/`,
-                        endCaptures: { 0: { name: 'punctuation.definition.comment.end.mira' } },
-                        patterns: [
-                            {
-                                match: String.raw`(?<!\p{XID_Continue})(extern)(\s+)(?:(async)(\s+))?(function)(\*)?(?:\s+(${IDENTIFIER}))?`,
-                                captures: {
-                                    1: { name: 'storage.modifier.extern.mira' },
-                                    3: { name: 'storage.modifier.async.mira' },
-                                    5: { name: 'keyword.declaration.function.mira' },
-                                    6: { name: 'keyword.operator.generator.mira' },
-                                    7: { name: 'entity.name.function.mira' },
-                                },
-                            },
-                            {
-                                match: String.raw`(?<!\p{XID_Continue})(extern)(\s+)(class)(?:\s+(${IDENTIFIER}))?`,
-                                captures: {
-                                    1: { name: 'storage.modifier.extern.mira' },
-                                    3: { name: 'keyword.declaration.class.mira' },
-                                    4: { name: 'entity.name.type.mira' },
-                                },
-                            },
-                            {
-                                match: String.raw`(?<!\p{XID_Continue})(extern)(?:\s+(${IDENTIFIER}))?`,
-                                captures: {
-                                    1: { name: 'storage.modifier.extern.mira' },
-                                    2: { name: 'entity.name.type.mira' },
-                                },
-                            },
-                            { name: 'entity.name.type.mira', match: IDENTIFIER },
-                            { name: 'constant.numeric.mira', match: String.raw`\d+` },
-                            { name: 'punctuation.separator.type.mira', match: '[().,<>]' },
-                        ],
+                        contentName: 'meta.documentation.tag.mira',
+                        begin: String.raw`(/\*)([ \t]*)(<)(?=${DOC_TAG_CONTENT}>[ \t]*\*/)`,
+                        beginCaptures: {
+                            1: { name: 'punctuation.definition.comment.begin.mira' },
+                            3: { name: 'punctuation.definition.tag.begin.mira' },
+                        },
+                        end: String.raw`(>)([ \t]*)(\*/)`,
+                        endCaptures: {
+                            1: { name: 'punctuation.definition.tag.end.mira' },
+                            3: { name: 'punctuation.definition.comment.end.mira' },
+                        },
+                        patterns: [{ include: '#tag-content' }],
+                    },
+                ],
+            },
+            'tag-content': {
+                patterns: [
+                    {
+                        match: String.raw`(extern)([ \t]+)(?:(async)([ \t]+))?(function)(\*)?(?:([ \t]+)(${DOC_TAG_NAME}))?(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.extern.mira' },
+                            3: { name: 'keyword.js' },
+                            5: { name: 'keyword.js' },
+                            6: { name: 'keyword.operator.generator.js' },
+                            8: { name: 'entity.name.function.js' },
+                        },
+                    },
+                    {
+                        match: String.raw`(extern)([ \t]+)(class)(?:([ \t]+)(${DOC_TAG_NAME}))?(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.extern.mira' },
+                            3: { name: 'keyword.js' },
+                            5: { name: 'entity.name.type.js' },
+                        },
+                    },
+                    {
+                        match: String.raw`(extern)([ \t]+)(${DOC_TAG_NAME})(\()(${DOC_TAG_NUMBER})(\))(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.extern.mira' },
+                            3: { name: 'entity.name.type.js' },
+                            4: { name: 'punctuation.section.parens.begin.mira' },
+                            5: { name: 'constant.numeric.mira' },
+                            6: { name: 'punctuation.section.parens.end.mira' },
+                        },
+                    },
+                    {
+                        match: String.raw`(extern)(?:([ \t]+)(${DOC_TAG_NAME}))?(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.extern.mira' },
+                            3: { name: 'entity.name.type.js' },
+                        },
+                    },
+                    {
+                        match: String.raw`(module)(?:([ \t]+)(${DOC_TAG_NAME}))?(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.module.mira' },
+                            3: { name: 'entity.name.namespace.mira' },
+                        },
+                    },
+                    {
+                        match: String.raw`(function)(?:([ \t]+)(${DOC_TAG_NAME}))?(?=>)`,
+                        captures: {
+                            1: { name: 'keyword.declaration.function.mira' },
+                            3: { name: 'entity.name.function.mira' },
+                        },
                     },
                 ],
             },
             'reflection-type': {
                 patterns: [
                     {
-                        match: String.raw`(?<!\p{XID_Continue})(type)(\s*)(\()(\s*)(${IDENTIFIER})(\s*)(\))`,
+                        match: String.raw`${IDENTIFIER_START}(type)(\s*)(\()(\s*)(${IDENTIFIER})(\s*)(\))`,
                         captures: {
-                            1: { name: 'keyword.operator.expression.mira' },
+                            1: { name: 'support.type.type.mira' },
                             3: { name: 'punctuation.section.parens.begin.mira' },
                             5: { name: 'variable.other.mira' },
                             7: { name: 'punctuation.section.parens.end.mira' },
@@ -890,7 +1018,7 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
             'function-type': {
                 patterns: [
                     {
-                        begin: String.raw`(?<!\p{XID_Continue})(fn)${IDENTIFIER_END}(?=\s*(?:<|\())`,
+                        begin: String.raw`${IDENTIFIER_START}(fn)${IDENTIFIER_END}(?=\s*(?:<|\())`,
                         beginCaptures: { 1: { name: 'support.type.function.mira' } },
                         end: String.raw`(?=\s*(?:,|\)|$))`,
                         patterns: [
@@ -1013,11 +1141,7 @@ export function createMiraScriptDocGrammar(): LanguageRegistration {
                     { include: '#reflection-type' },
                     {
                         name: 'support.type.builtin.mira',
-                        match: String.raw`(?<!\p{XID_Continue})(?:${alternatives(BUILT_IN_TYPES)})${IDENTIFIER_END}`,
-                    },
-                    {
-                        name: 'constant.language.boolean.mira',
-                        match: String.raw`(?<!\p{XID_Continue})(?:true|false)${IDENTIFIER_END}`,
+                        match: `${IDENTIFIER_START}(?:${alternatives(BUILT_IN_TYPES)})${IDENTIFIER_END}`,
                     },
                     { name: 'keyword.operator.type.mira', match: '[&|]' },
                     { name: 'keyword.operator.spread.mira', match: String.raw`\.\.` },

package/src/index.ts

@@ -7,4 +7,4 @@ export const mirascriptDoc = createMiraScriptDocGrammar();
 
 export { mirascriptTemplate as 'mirascript-template', mirascriptDoc as 'mirascript-doc' };
 
-export const grammars: readonly LanguageRegistration[] = Object.freeze([mirascript, mirascriptTemplate, mirascriptDoc]);
+export const grammars: LanguageRegistration[] = [mirascript, mirascriptTemplate, mirascriptDoc];

package/tests/_engine.ts

@@ -0,0 +1,53 @@
+import { createHighlighter, type Highlighter } from 'shiki';
+import { INITIAL, type StateStack } from 'shiki/textmate';
+import test, { type ExecutionContext } from 'ava';
+import { grammars } from '../src/index.ts';
+
+let highlighter: Highlighter;
+
+test.before(async () => {
+    highlighter = await createHighlighter({
+        langs: grammars,
+        themes: [],
+    });
+});
+
+test.after.always(() => highlighter.dispose());
+
+/**
+ * Tokenize complete source while preserving TextMate state across lines.
+ */
+export function tokenize(
+    code: string,
+    language = 'mirascript',
+): Array<{ line: number; text: string; scopes: string[] }> {
+    const grammar = highlighter.getLanguage(language);
+    let state: StateStack = INITIAL;
+    return code.split('\n').flatMap((line, lineIndex) => {
+        const result = grammar.tokenizeLine(line, state);
+        state = result.ruleStack;
+        return result.tokens.map((token) => ({
+            line: lineIndex,
+            text: line.slice(token.startIndex, token.endIndex),
+            scopes: token.scopes,
+        }));
+    });
+}
+
+/**
+ * Assert that a selected textual token contains the expected scope.
+ */
+export function expectScope(
+    t: ExecutionContext,
+    tokens: Array<{ text: string; scopes: string[] }>,
+    text: string,
+    scope: string,
+    occurrence = 0,
+): void {
+    const matching = tokens.filter((token) => token.text === text);
+    t.true(matching.length > occurrence, `Missing token ${JSON.stringify(text)} #${occurrence}`);
+    t.true(
+        matching[occurrence].scopes.includes(scope),
+        `${JSON.stringify(text)} should include ${scope}; got ${matching[occurrence].scopes.join(', ')}`,
+    );
+}