@mirascript/textmate 0.1.83 → 0.1.84

package/.c8rc.json

@@ -0,0 +1,6 @@
+{
+  "all": true,
+  "reporter": ["text", "lcov"],
+  "src": ["src"],
+  "skip-full": true
+}

package/ava.config.js

@@ -0,0 +1,4 @@
+export default {
+    files: ['tests/**/*'],
+    extensions: ['js', 'ts'],
+};

package/dist/grammar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AA2mB3D;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAW9D;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,oBAAoB,CAUtE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,oBAAoB,CA2XjE"}
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAknB3D;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAW9D;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,oBAAoB,CAUtE;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,oBAAoB,CAgfjE"}

package/dist/grammar.js

@@ -2,6 +2,7 @@ import { CONSTANT_KEYWORDS, CONTROL_KEYWORDS, KEYWORDS, NUMERIC_KEYWORDS, REG_ID
 import { mirascriptDocLanguage, mirascriptLanguage, mirascriptTemplateLanguage } from "./language.js";
 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 = [
@@ -9,6 +10,8 @@ const BUILT_IN_TYPES = [
     'unknown',
     'never',
     'boolean',
+    'true',
+    'false',
     'number',
     'string',
     'record',
@@ -18,6 +21,10 @@ const BUILT_IN_TYPES = [
     '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.
  */
@@ -33,17 +40,6 @@ function alternatives(values) {
         .map(escapeRegex)
         .join('|');
 }
-/**
- * Create a boundary-aware TextMate keyword rule.
- */
-function keywordRule(values, name) {
-    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(NUMERIC_KEYWORDS);
 const constantKeywords = CONSTANT_KEYWORDS.filter((keyword) => !numericKeywordSet.has(keyword));
 const languageVariables = ['_', 'global'];
@@ -61,7 +57,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*$)|(?=\*/)`;
@@ -279,6 +275,13 @@ function documentationRepository(sourceInclude = '#source') {
  * Build the shared repository used by source and template grammars.
  */
 function sourceRepository() {
+    /**
+     * Create a boundary-aware TextMate keyword rule.
+     */
+    const keywordRule = (values, name) => ({
+        name: `${name}.${SCOPE_SUFFIX}`,
+        match: `${IDENTIFIER_START}(?:${alternatives(values)})${IDENTIFIER_END}`,
+    });
     const keywordPatterns = [
         keywordRule(NUMERIC_KEYWORDS, 'constant.numeric.language'),
         keywordRule(constantKeywords, 'constant.language'),
@@ -289,7 +292,7 @@ function sourceRepository() {
         keywordRule(RESERVED_KEYWORDS, 'keyword.reserved'),
         keywordRule(languageVariables, 'variable.language'),
         keywordRule(otherKeywords, 'keyword.other'),
-    ].filter((p) => p != null);
+    ];
     return {
         source: {
             patterns: [
@@ -343,7 +346,7 @@ function sourceRepository() {
             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}` },
@@ -355,7 +358,7 @@ function sourceRepository() {
                 },
                 {
                     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}` },
@@ -363,7 +366,7 @@ function sourceRepository() {
                 },
                 {
                     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}` },
@@ -377,7 +380,7 @@ function sourceRepository() {
         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}` },
@@ -385,7 +388,7 @@ function sourceRepository() {
                 },
                 {
                     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 },
@@ -406,7 +409,7 @@ function sourceRepository() {
         '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}` },
@@ -417,7 +420,7 @@ function sourceRepository() {
         '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}` },
@@ -426,7 +429,7 @@ function sourceRepository() {
                     },
                 },
                 {
-                    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}` },
@@ -487,7 +490,7 @@ function sourceRepository() {
             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})`,
                 },
             ],
         },
@@ -639,27 +642,43 @@ export function createMiraScriptDocGrammar() {
             ...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: '$',
@@ -714,7 +733,7 @@ export function createMiraScriptDocGrammar() {
             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' },
@@ -722,7 +741,7 @@ export function createMiraScriptDocGrammar() {
                         },
                     },
                     {
-                        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' },
@@ -730,10 +749,35 @@ export function createMiraScriptDocGrammar() {
                     },
                 ],
             },
+            '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' },
@@ -745,22 +789,65 @@ export function createMiraScriptDocGrammar() {
             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: {
-                            1: { name: 'variable.other.property.mira' },
-                            3: { name: 'punctuation.separator.type.mira' },
+                            2: { name: 'entity.name.label.mira' },
+                            4: { name: 'entity.name.function.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*)(\??:)(?=[ \t]*/\*[ \t]*<extern[ \t]+class(?:[ \t]+${DOC_TAG_NAME})?>[ \t]*\*/)`,
+                        beginCaptures: {
+                            2: { name: 'entity.name.label.mira' },
+                            4: { name: 'entity.name.type.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*)(\??:)`,
+                        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' },
                 ],
             },
@@ -775,21 +862,28 @@ export function createMiraScriptDocGrammar() {
                     },
                 ],
             },
-            'extern-function-properties': {
+            'doc-array-value': {
                 patterns: [
                     {
-                        match: String.raw `(${IDENTIFIER})(\s*)(:)(?=\s*/\*\s*<\s*extern\s+(?:(?:async\s+)?function\*?)(?:\s+${IDENTIFIER})?\s*>\s*\*/)`,
+                        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 `(${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' },
@@ -797,54 +891,84 @@ export function createMiraScriptDocGrammar() {
                     },
                 ],
             },
-            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' },
@@ -865,7 +989,7 @@ export function createMiraScriptDocGrammar() {
             '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: [
@@ -988,11 +1112,7 @@ export function createMiraScriptDocGrammar() {
                     { 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 `\.\.` },