moonbit-syntax-highlighter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nanaloveyuki
+
+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/LICENSE.upstream

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

@@ -0,0 +1,73 @@
+# moonbit-syntax-highlighter
+
+Reusable MoonBit syntax grammar package for front-end documentation tooling.
+
+This package vendors a MoonBit TextMate-style syntax definition and exposes stable Node-side entry points that documentation tools can consume.
+
+It is framework-agnostic by design: the package ships raw grammar access, metadata, and a small registration helper instead of binding itself to a single docs stack.
+
+## What This Package Exports
+
+- `moonbitGrammarPath`: absolute local path to the vendored `moonbit.sublime-syntax`
+- `moonbitGrammar`: raw grammar file contents as a string
+- `readMoonbitGrammar()`: reads the packaged grammar from disk
+- `moonbitLanguage`: language metadata for consumers that accept a custom language registration object
+- `createMoonbitLanguageRegistration()`: returns metadata plus inline grammar content for tools that prefer in-memory registration
+- `moonbitAliases`: common aliases such as `moonbit`, `mbt`, and `mbti`
+
+## Install
+
+```bash
+pnpm add moonbit-syntax-highlighter
+```
+
+## Basic Usage
+
+```js
+import {
+  createMoonbitLanguageRegistration,
+  moonbitGrammarPath,
+} from 'moonbit-syntax-highlighter'
+
+const language = createMoonbitLanguageRegistration()
+
+console.log(language.scopeName)
+console.log(moonbitGrammarPath)
+```
+
+```js
+import { moonbitGrammar } from 'moonbit-syntax-highlighter/content'
+
+console.log(moonbitGrammar.slice(0, 40))
+```
+
+## Intended Consumers
+
+- Shiki-based documentation sites such as VitePress or Astro
+- Markdown pipelines that can register external TextMate-style grammars
+- Internal tooling that needs a stable MoonBit language metadata entry point
+
+## Source and Attribution
+
+The vendored syntax source in `syntaxes/moonbit.sublime-syntax` is based on the MIT-licensed MoonBit Sublime syntax project by `hyrious`:
+
+- upstream repo: `https://github.com/hyrious/moonbit-syntax-highlight`
+- upstream file: `MoonBit.sublime-syntax`
+
+This package preserves upstream attribution in `LICENSE.upstream` and is intended to make the grammar easier to consume from documentation tooling.
+
+## Current Scope
+
+This first version focuses on packaging and reuse. It does not yet add framework-specific adapters, snapshot tests, or MoonBit-specific semantic highlighting.
+
+## Local Development
+
+```bash
+pnpm run check
+pnpm run dev
+pnpm run pack:check
+```
+
+`pnpm run dev` uses Node watch mode to rerun the package self-check whenever files change.
+
+`pnpm run pack:check` builds the tarball locally so you can inspect the exact files that would be published.

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "moonbit-syntax-highlighter",
+  "version": "0.1.0",
+  "description": "Reusable MoonBit syntax grammar package for documentation tooling and front-end highlighters.",
+  "author": "Nanaloveyuki",
+  "license": "MIT",
+  "type": "module",
+  "packageManager": "pnpm@11.5.3",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nanaloveyuki/moonbit-syntax-highlighter-npm.git"
+  },
+  "homepage": "https://github.com/Nanaloveyuki/moonbit-syntax-highlighter-npm#readme",
+  "bugs": {
+    "url": "https://github.com/Nanaloveyuki/moonbit-syntax-highlighter-npm/issues"
+  },
+  "keywords": [
+    "moonbit",
+    "syntax",
+    "highlight",
+    "shiki",
+    "textmate",
+    "grammar",
+    "vitepress"
+  ],
+  "files": [
+    "src",
+    "syntaxes",
+    "README.md",
+    "LICENSE",
+    "LICENSE.upstream"
+  ],
+  "scripts": {
+    "dev": "node --watch scripts/check.js",
+    "check": "node scripts/check.js",
+    "pack:check": "pnpm pack --pack-destination .pack"
+  },
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./grammar": {
+      "types": "./src/grammar.d.ts",
+      "default": "./src/grammar.js"
+    },
+    "./content": {
+      "types": "./src/content.d.ts",
+      "default": "./src/content.js"
+    },
+    "./shiki": {
+      "types": "./src/shiki.d.ts",
+      "default": "./src/shiki.js"
+    },
+    "./syntaxes/moonbit.sublime-syntax": "./syntaxes/moonbit.sublime-syntax",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/content.d.ts

@@ -0,0 +1,3 @@
+export declare function readMoonbitGrammar(): string
+
+export declare const moonbitGrammar: string

package/src/content.js

@@ -0,0 +1,9 @@
+import { readFileSync } from 'node:fs'
+
+import { moonbitGrammarPath } from './grammar.js'
+
+export function readMoonbitGrammar() {
+  return readFileSync(moonbitGrammarPath, 'utf8')
+}
+
+export const moonbitGrammar = readMoonbitGrammar()

package/src/grammar.d.ts

@@ -0,0 +1,5 @@
+export declare const moonbitScopeName: 'source.moonbit'
+
+export declare const moonbitAliases: readonly ['moonbit', 'mbt', 'mbti']
+
+export declare const moonbitGrammarPath: string

package/src/grammar.js

@@ -0,0 +1,10 @@
+import { fileURLToPath } from 'node:url'
+
+export const moonbitScopeName = 'source.moonbit'
+
+export const moonbitAliases = ['moonbit', 'mbt', 'mbti']
+
+export const moonbitGrammarPath = fileURLToPath(
+  new URL('../syntaxes/moonbit.sublime-syntax', import.meta.url),
+)
+

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export { moonbitAliases, moonbitGrammarPath, moonbitScopeName } from './grammar.js'
+export { moonbitGrammar, readMoonbitGrammar } from './content.js'
+export {
+  createMoonbitLanguageRegistration,
+  moonbitLanguage,
+} from './shiki.js'
+export type { MoonbitLanguageRegistration } from './shiki.js'

package/src/index.js

@@ -0,0 +1,3 @@
+export { moonbitAliases, moonbitGrammarPath, moonbitScopeName } from './grammar.js'
+export { moonbitGrammar, readMoonbitGrammar } from './content.js'
+export { moonbitLanguage, createMoonbitLanguageRegistration } from './shiki.js'

package/src/shiki.d.ts

@@ -0,0 +1,14 @@
+import type { moonbitAliases, moonbitGrammarPath, moonbitScopeName } from './grammar.js'
+
+export interface MoonbitLanguageRegistration {
+  id: 'moonbit'
+  name: 'MoonBit'
+  scopeName: typeof moonbitScopeName
+  aliases: typeof moonbitAliases
+  path: typeof moonbitGrammarPath
+  grammar: string
+}
+
+export declare const moonbitLanguage: Omit<MoonbitLanguageRegistration, 'grammar'>
+
+export declare function createMoonbitLanguageRegistration(): MoonbitLanguageRegistration

package/src/shiki.js

@@ -0,0 +1,17 @@
+import { moonbitGrammarPath, moonbitScopeName, moonbitAliases } from './grammar.js'
+import { moonbitGrammar } from './content.js'
+
+export const moonbitLanguage = {
+  id: 'moonbit',
+  name: 'MoonBit',
+  scopeName: moonbitScopeName,
+  aliases: moonbitAliases,
+  path: moonbitGrammarPath,
+}
+
+export function createMoonbitLanguageRegistration() {
+  return {
+    ...moonbitLanguage,
+    grammar: moonbitGrammar,
+  }
+}

package/syntaxes/moonbit.sublime-syntax

@@ -0,0 +1,550 @@
+%YAML 1.2
+---
+# - https://www.sublimetext.com/docs/syntax.html
+# - https://docs.moonbitlang.com/en/latest/language/introduction.html
+# - https://github.com/moonbitlang/moonbit-docs/blob/main/next/_ext/lexer.py
+
+file_extensions:
+  - mbt
+  - mbti
+
+first_line_match: |-
+  (?xi:
+    ^ \s* // .*? -\*- .*? \bmoonbit\b .*? -\*-  # editorconfig
+  )
+
+name: MoonBit
+scope: source.moonbit
+version: 2
+
+variables:
+  # https://docs.moonbitlang.com/en/latest/language/introduction.html#naming-conventions
+  ident_lower: '[a-z][\w_]*'
+  ident_upper: '[A-Z][\w_]*'
+  ident_path: '[a-z][\w_/]*'
+  builtin_types: '(?:Eq|Compare|Hash|Show|Logger|Default|ToJson|FromJson|None|Some|ArrayView|Array|FixedArray|Int16|Int64|Int|UInt16|UInt64|UInt|BigInt|Option|Result|BytesView|Bytes?|Bool|Unit|Char|String|Float|Double|Error|Tuple|Hasher|Iter2?|IterResult|Json|Map|Set|StringBuilder|UninitializedArray)'
+  op_functions: '(?:not|land|lnot|lor|lxor|op_add|op_sub|op_div|op_mul|op_mod|op_equal|op_shl|op_shr)'
+  escaped_char: '\\(?:[nrtb\"''\\]|x\h{2}|o[0-3][0-7]{2}|u\{(?:\h_*){1,6}\})'
+  int_suffixes: '[uUlL]+'
+  dec_literal: '\d[\d_]*'
+  hex_literal: '\h[\h_]*'
+  float_exponent: '[eE][+-]?{{dec_literal}}'
+  float_power: '[pP][+-]?{{dec_literal}}'
+
+contexts:
+  prototype:
+    - include: comments
+
+  main:
+    - include: statements
+
+  comments:
+    - include: line-comments
+
+  line-comments:
+    - match: ///\s*(@[_\.\w]+)?
+      scope: punctuation.definition.comment.moonbit
+      captures:
+        1: entity.other.attribute-name.documentation.moonbit
+      push: doc-comment-body
+    - match: //
+      scope: punctuation.definition.comment.moonbit
+      push: line-comment-body
+    - match: '#deprecated\b'
+      scope: punctuation.definition.comment.moonbit entity.other.attribute-name.documentation.moonbit
+
+  # https://docs.moonbitlang.com/en/latest/language/docs.html
+  doc-comment-body:
+    - meta_include_prototype: false
+    - meta_scope: comment.block.documentation.moonbit
+    - match: $\n?
+      pop: true
+
+  line-comment-body:
+    - meta_include_prototype: false
+    - meta_scope: comment.line.double-slash.moonbit
+    - match: $\n?
+      pop: true
+
+  statements:
+    - include: type-declarations
+    - include: function-definitions
+    - include: expressions
+
+  type-declarations:
+    - match: \b(type!?)\s+({{ident_upper}})(\[)
+      captures:
+        1: keyword.declaration.type.moonbit
+        2: entity.name.type.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(type!?)\s+({{ident_upper}})
+      captures:
+        1: keyword.declaration.type.moonbit
+        2: entity.name.type.moonbit
+    - match: \b(impl)\s*(\[)
+      captures:
+        1: keyword.declaration.trait.moonbit
+        2: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(impl)\b
+      scope: keyword.declaration.trait.moonbit
+    - match: \b(trait)\s+({{ident_upper}})
+      captures:
+        1: keyword.declaration.trait.moonbit
+        2: entity.name.trait.moonbit
+    - match: \b(enum)\s+({{ident_upper}})\s*(\[)
+      captures:
+        1: keyword.declaration.enum.moonbit
+        2: entity.name.enum.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(enum)\s+({{ident_upper}})
+      captures:
+        1: keyword.declaration.enum.moonbit
+        2: entity.name.enum.moonbit
+    - match: \b(struct)\s+({{ident_upper}})\s*(\[)
+      captures:
+        1: keyword.declaration.struct.moonbit
+        2: entity.name.struct.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(struct)\s+({{ident_upper}})
+      captures:
+        1: keyword.declaration.struct.moonbit
+        2: entity.name.struct.moonbit
+
+  function-definitions:
+    - match: (\#)({{ident_lower}})\s*(\()
+      captures:
+        1: punctuation.definition.annotation.moonbit
+        2: variable.annotation.moonbit
+        3: punctuation.section.group.begin.moonbit
+      push: parameters
+    - match: (\#)({{ident_lower}})\s*
+      captures:
+        1: punctuation.definition.annotation.moonbit
+        2: variable.annotation.moonbit
+    - match: \b(fn)\s+(?:({{ident_upper}})(\:\:))*({{ident_lower}})(!?)\s*(\[)
+      captures:
+        1: keyword.declaration.function.moonbit
+        2: support.type.moonbit
+        3: punctuation.accessor.double-colon.moonbit
+        4: entity.name.function.moonbit
+        5: keyword.declaration.error.moonbit
+        6: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(fn)\s+(?:({{ident_upper}})(\:\:))*({{ident_lower}})(!?)\s*(\()
+      captures:
+        1: keyword.declaration.function.moonbit
+        2: support.type.moonbit
+        3: punctuation.accessor.double-colon.moonbit
+        4: entity.name.function.moonbit
+        5: keyword.declaration.error.moonbit
+        6: punctuation.section.group.begin.moonbit
+      push: parameters
+    - match: \b(fn)\s+(main)\s*(\{)
+      captures:
+        1: keyword.declaration.function.moonbit
+        2: keyword.other.moonbit
+        3: punctuation.section.block.begin.moonbit
+    - match: \b(fn)(!?)\s*(\[)
+      captures:
+        1: keyword.declaration.function.moonbit
+        2: keyword.declaration.interface.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b(with)\s+({{ident_lower}})\s*(\()
+      captures:
+        1: keyword.declaration.impl.moonbit
+        2: entity.name.function.moonbit
+        3: punctuation.section.group.begin.moonbit
+      push: parameters
+
+  type-parameters:
+    - match: '(\])\s*(?:({{ident_upper}})(\:\:))*({{ident_lower}})(!?)\s*(\()'
+      captures:
+        1: punctuation.definition.generic.end.moonbit
+        2: support.type.moonbit
+        3: punctuation.accessor.double-colon.moonbit
+        4: entity.name.function.moonbit
+        5: keyword.declaration.error.moonbit
+        6: punctuation.section.group.begin.moonbit
+      set: parameters
+    - match: '(\])\s*(\()'
+      captures:
+        1: punctuation.definition.generic.end.moonbit
+        2: punctuation.section.group.begin.moonbit
+      set: parameters
+    - match: \(
+      scope: punctuation.section.group.begin.moonbit
+      push: parameters
+    - match: \[
+      scope: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \]
+      scope: punctuation.definition.generic.end.moonbit
+      pop: true
+    - match: '{{ident_upper}}'
+      scope: variable.parameter.generic.moonbit
+    - include: variables
+    - include: operators
+
+  parameters:
+    - match: (\))\s*(->)
+      captures:
+        1: punctuation.section.group.end.moonbit
+        2: storage.type.function.arrow.moonbit
+      set: return-type
+    - match: \)
+      scope: punctuation.section.group.end.moonbit
+      pop: true
+    - include: expressions
+    - match: '\b{{ident_lower}}\b'
+      scope: variable.parameter.moonbit
+    - match: '\b{{ident_upper}}\b(!?)'
+      scope: support.type.moonbit
+      captures:
+        1: keyword.declaration.error.moonbit
+    - match: ':'
+      scope: punctuation.separator.type.moonbit
+    - match: \(
+      scope: punctuation.section.group.begin.moonbit
+      push: brace-body
+    - match: \[
+      scope: punctuation.definition.generic.begin.moonbit
+      push: bracket-body
+
+  return-type:
+    - match: $\n?
+      pop: true
+    - match: \b(raise)\b
+      scope: keyword.control.moonbit
+    - match: \{
+      scope: punctuation.section.block.begin.moonbit
+      pop: true
+    - match: '='
+      scope: keyword.operator.assignment.moonbit
+      pop: true
+    - match: \!\!
+      scope: keyword.declaration.async.moonbit
+    - match: \!
+      scope: keyword.declaration.error.moonbit
+    - match: \?
+      scope: keyword.operator.none.moonbit
+    - match: '(@)({{ident_path}})'
+      captures:
+        1: punctuation.definition.variable.moonbit
+        2: variable.other.constant.moonbit
+    - match: '({{ident_upper}})(\[)'
+      captures:
+        1: support.type.moonbit
+        2: punctuation.definition.generic.begin.moonbit
+      push: bracket-body
+    - include: types
+
+  brace-body:
+    - match: \)
+      scope: punctuation.section.group.end.moonbit
+      pop: true
+    - include: expressions
+
+  bracket-body:
+    - match: \]
+      scope: punctuation.definition.generic.end.moonbit
+      pop: true
+    - include: type-parameters
+
+  expressions:
+    - include: variables
+    - include: strings
+    - include: keywords
+    - include: function-calls
+    - include: braces
+    - include: numbers
+    - include: operators
+
+  braces:
+    - match: '\)'
+      scope: punctuation.section.group.end.moonbit
+      pop: true
+    - match: '\('
+      scope: punctuation.section.group.begin.moonbit
+      push: expressions
+
+  function-calls:
+    - match: '\b(not)(\()'
+      captures:
+        1: keyword.operator.logical.moonbit
+        2: punctuation.section.group.begin.moonbit
+      push: function-arguments
+    - match: '\b({{ident_lower}}!{,2}\??)\s*(\()'
+      captures:
+        1: variable.function.moonbit
+        2: punctuation.section.group.begin.moonbit
+      push: function-arguments
+
+  function-arguments:
+    - match: '\)'
+      scope: punctuation.section.group.end.moonbit
+      pop: true
+    - include: expressions
+
+  variables:
+    - match: \b({{ident_upper}})(\:\:)
+      captures:
+        1: support.type.moonbit
+        2: punctuation.accessor.double-colon.moonbit
+    - match: '(@)({{ident_path}})'
+      captures:
+        1: punctuation.definition.variable.moonbit
+        2: variable.other.constant.moonbit
+    - match: '({{ident_lower}})(~)'
+      captures:
+        1: entity.name.label.moonbit variable.parameter.moonbit
+        2: punctuation.definition.label.moonbit
+    - match: '({{ident_lower}})(=)'
+      captures:
+        1: variable.parameter.moonbit
+        2: keyword.operator.assignment.moonbit
+
+  types:
+    - match: \b({{builtin_types}})(!?)\s*(\[)
+      captures:
+        1: support.type.builtin.moonbit
+        2: keyword.declaration.error.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b({{builtin_types}})\b(!?)(\??)
+      scope: support.type.builtin.moonbit
+      captures:
+        2: keyword.declaration.error.moonbit
+        3: keyword.declaration.optional.moonbit
+    - match: \b({{ident_upper}})(!?)\s*(\[)
+      captures:
+        1: storage.type.moonbit
+        2: keyword.declaration.error.moonbit
+        3: punctuation.definition.generic.begin.moonbit
+      push: type-parameters
+    - match: \b({{ident_upper}})\b(!?)(\??)
+      scope: storage.type.moonbit
+      captures:
+        2: keyword.declaration.error.moonbit
+        3: keyword.declaration.optional.moonbit
+
+  keywords:
+    - match: \b(package)\b
+      scope: keyword.declaration.moonbit
+    - match: \b(import)\b
+      scope: keyword.import.moonbit
+    - include: bool
+    - match: \b(pub)\((all|open|readonly)\)
+      captures:
+        1: storage.modifier.moonbit
+        2: keyword.other.moonbit
+    - match: \b(pub|priv)\b
+      scope: storage.modifier.moonbit
+    - match: \b(extern|test|init|async|as)\b
+      scope: keyword.other.moonbit
+    - include: types
+    - match: \b(self)\b
+      scope: keyword.other.moonbit
+    - match: \b(Self)\b
+      scope: storage.type.moonbit
+    - match: \b(letrec|let|and)\b
+      scope: keyword.declaration.variable.moonbit
+    - match: \b(const|mut)\b
+      scope: storage.modifier.moonbit
+    - match: \b(fnalias|fn)\b(!?)
+      scope: keyword.declaration.function.moonbit
+      captures:
+        2: keyword.declaration.error.moonbit
+    - match: \b(impl|with|derive)\b
+      scope: keyword.declaration.impl.moonbit
+    - match: \b(type!?|enum|struct|traitalias|trait|typealias)\b
+      scope: keyword.declaration.type.moonbit
+    - match: \b(guard|else|for|if|loop|match|while|in)\b
+      scope: keyword.control.moonbit
+    - match: \b(catch!)
+      scope: keyword.control.moonbit
+    - match: \b(try|catch|raise)\b
+      scope: keyword.control.moonbit
+    - match: \b(break|continue)\b
+      scope: keyword.control.moonbit
+    - match: \b(return)\b
+      scope: keyword.control.moonbit
+    - match: \b(is)\b
+      scope: keyword.other.moonbit
+    - match: \b(_)\b
+      scope: variable.language.underscore.moonbit
+
+  # https://docs.moonbitlang.com/en/latest/language/fundamentals.html#boolean
+  bool:
+    - match: \b(false)\b
+      scope: constant.language.boolean.false.moonbit
+    - match: \b(true)\b
+      scope: constant.language.boolean.true.moonbit
+
+  # https://docs.moonbitlang.com/en/latest/language/fundamentals.html#number
+  numbers:
+    - include: floats
+    - include: bigints
+    - include: integers
+
+  floats:
+    - match: '\b0x({{hex_literal}})\.(?:{{hex_literal}})?(?:{{float_exponent}})?({{float_power}})'
+      scope: constant.numeric.float.moonbit
+    - match: '\b0x({{hex_literal}})\.({{hex_literal}})(?:{{float_exponent}})?'
+      scope: constant.numeric.float.moonbit
+    - match: '\b0x({{hex_literal}})({{float_exponent}})\b'
+      scope: constant.numeric.float.moonbit
+    - match: '\b0x({{hex_literal}})\.(?![A-Za-z._''])'
+      scope: constant.numeric.float.moonbit
+    - match: '\b({{dec_literal}})\.(?:{{dec_literal}})?(?:{{float_exponent}})?({{float_power}})'
+      scope: constant.numeric.float.moonbit
+    - match: '\b({{dec_literal}})\.({{dec_literal}})(?:{{float_exponent}})?'
+      scope: constant.numeric.float.moonbit
+    - match: '\b({{dec_literal}})({{float_exponent}})\b'
+      scope: constant.numeric.float.moonbit
+    - match: '\b({{dec_literal}})\.(?![A-Za-z._''])'
+      scope: constant.numeric.float.moonbit
+
+  integers:
+    - match: '\b({{dec_literal}})({{int_suffixes}})?\b'
+      captures:
+        1: constant.numeric.integer.decimal.moonbit
+        2: constant.numeric.suffix.moonbit
+    - match: '\b(0x{{hex_literal}})({{int_suffixes}})?\b'
+      captures:
+        1: constant.numeric.integer.hexadecimal.moonbit
+        2: constant.numeric.suffix.moonbit
+    - match: '\b(0o[0-7][0-7_]*)({{int_suffixes}})?\b'
+      captures:
+        1: constant.numeric.integer.octal.moonbit
+        2: constant.numeric.suffix.moonbit
+    - match: '\b(0b[0-1][0-1_]*)({{int_suffixes}})?\b'
+      captures:
+        1: constant.numeric.integer.binary.moonbit
+        2: constant.numeric.suffix.moonbit
+
+  bigints:
+    - match: '\b({{dec_literal}})([nN])\b'
+      captures:
+        1: constant.numeric.integer.decimal.moonbit
+        2: constant.numeric.suffix.moonbit
+    - match: '\b(0x{{hex_literal}})([nN])\b'
+      captures:
+        1: constant.numeric.integer.decimal.moonbit
+        2: constant.numeric.suffix.moonbit
+
+  # https://docs.moonbitlang.com/en/latest/language/fundamentals.html#string
+  strings:
+    - match: '(#\|)?b"'
+      scope: punctuation.definition.string.begin.moonbit
+      push: binary-string-content
+    - match: '"'
+      scope: punctuation.definition.string.begin.moonbit
+      push: string-content
+    - match: '#\|'
+      scope: punctuation.definition.string.begin.moonbit
+      push: raw-string-content
+    - match: '\$\|'
+      scope: punctuation.definition.string.begin.moonbit
+      push: escape-string-content
+    - match: "'"
+      scope: punctuation.definition.string.begin.moonbit
+      push: char-content
+
+  raw-string-content:
+    - meta_include_prototype: false
+    - meta_scope: string.unquoted.moonbit
+    - match: $\n?
+      pop: true
+
+  escape-string-content:
+    - meta_include_prototype: false
+    - meta_scope: string.unquoted.moonbit
+    - match: $\n?
+      pop: true
+    - include: string-interpolations
+    - include: escaped-chars
+
+  string-content:
+    - meta_include_prototype: false
+    - meta_scope: string.quoted.double.moonbit
+    - match: '"'
+      scope: punctuation.definition.string.end.moonbit
+      pop: true
+    - include: string-interpolations
+    - include: escaped-chars
+    - include: internal-functions
+
+  internal-functions:
+    - match: '%[_\.\w]+'
+      scope: keyword.other.moonbit
+
+  binary-string-content:
+    - meta_include_prototype: false
+    - meta_scope: string.unquoted.moonbit
+    - match: '"'
+      scope: punctuation.definition.string.end.moonbit
+      pop: true
+    - include: escaped-chars
+
+  char-content:
+    - meta_include_prototype: false
+    - meta_scope: string.quoted.single.moonbit
+    - match: "'"
+      scope: punctuation.definition.string.end.moonbit
+      pop: true
+    - include: escaped-chars
+
+  string-interpolations:
+    - match: '\\{'
+      scope: punctuation.section.interpolation.begin.moonbit
+      push: string-interpolation-content
+
+  string-interpolation-content:
+    - clear_scopes: true
+    - meta_scope: meta.interpolation.moonbit
+    - meta_content_scope: source.moonbit.embedded
+    - match: '}'
+      scope: punctuation.section.interpolation.end.moonbit
+      pop: true
+    - include: expressions
+
+  escaped-chars:
+    - match: '{{escaped_char}}'
+      scope: constant.character.escape.moonbit
+
+  operators:
+    - match: \.\.\.
+      scope: keyword.operator.word.moonbit
+    - match: '=>'
+      scope: keyword.operator.arrow.moonbit
+    - match: '->'
+      scope: storage.type.function.arrow.moonbit
+    - match: ':(?!:)'
+      scope: punctuation.separator.moonbit
+    - match: '=(?!=)'
+      scope: keyword.operator.assignment.moonbit
+    - match: '\.\.<|\.\.=|\.\.(?!\.)'
+      scope: keyword.operator.range.moonbit
+    - match: '~'
+      scope: punctuation.definition.label.moonbit
+    - match: ','
+      scope: punctuation.separator.moonbit
+    - match: ';'
+      scope: punctuation.terminator.moonbit
+    - match: '\.'
+      scope: punctuation.accessor.dot.moonbit
+    - match: '{'
+      scope: punctuation.section.block.begin.moonbit
+    - match: '}'
+      scope: punctuation.section.block.end.moonbit
+    - match: '\?'
+      scope: keyword.operator.none.moonbit
+    - match: '\+|-|\*|\/|%|\|>|>>|<<|&&|\|\||\&|\||<=?|>=?|==|!='
+      scope: keyword.operator.moonbit
+    - match: \b{{op_functions}}\b
+      scope: keyword.operator.word.moonbit