@yorun-ai/skel-highlight 0.9.1 → 0.9.2

package/README.md

@@ -1,6 +1,8 @@
 # Skel Highlight
 
-Syntax highlighting definitions for the Skel contract language. The package currently provides the canonical TextMate grammar and a custom language registration for [Shiki](https://shiki.style/).
+Frontend syntax-highlighting definitions for the Skel contract language. The package supports Shiki, PrismJS, Highlight.js, Monaco Editor, Starry Night, and CodeMirror 6. Its TextMate grammar is the canonical lexical definition shared with the VS Code extension.
+
+Install the package with only the highlighter used by your application. All highlighter peer dependencies are optional.
 
 ## Shiki
 
@@ -8,21 +10,91 @@ Syntax highlighting definitions for the Skel contract language. The package curr
 npm install shiki @yorun-ai/skel-highlight
 ```
 
-Register Skel when creating a highlighter:
-
 ```js
 import { createHighlighter } from "shiki";
 import skel from "@yorun-ai/skel-highlight/shiki";
 
-const highlighter = await createHighlighter({
-  langs: [skel],
-  themes: ["github-dark"]
-});
+const highlighter = await createHighlighter({ langs: [skel], themes: ["github-dark"] });
+const html = highlighter.codeToHtml("domain demo.user", { lang: "skel", theme: "github-dark" });
+```
+
+## PrismJS
+
+```sh
+npm install prismjs @yorun-ai/skel-highlight
+```
+
+```js
+import Prism from "prismjs";
+import skel, { registerSkelPrism } from "@yorun-ai/skel-highlight/prism";
+
+registerSkelPrism(Prism);
+const html = Prism.highlight("domain demo.user", skel, "skel");
+```
+
+`registerSkelPrism` also carries the metadata expected by Refractor, so it can be passed to `refractor.register`.
+
+## Highlight.js
+
+```sh
+npm install highlight.js @yorun-ai/skel-highlight
+```
+
+```js
+import hljs from "highlight.js/lib/core";
+import skel from "@yorun-ai/skel-highlight/highlightjs";
+
+hljs.registerLanguage("skel", skel);
+const html = hljs.highlight("domain demo.user", { language: "skel" }).value;
+```
+
+The same language function can be registered with Lowlight.
+
+## Monaco Editor
+
+```sh
+npm install monaco-editor @yorun-ai/skel-highlight
+```
+
+```js
+import * as monaco from "monaco-editor";
+import { registerSkelMonaco } from "@yorun-ai/skel-highlight/monaco";
+
+registerSkelMonaco(monaco);
+monaco.editor.create(element, { language: "skel", value: "domain demo.user" });
+```
 
-const html = highlighter.codeToHtml("domain demo.user", {
-  lang: "skel",
-  theme: "github-dark"
-});
+The Monaco entrypoint also exports `skelMonarch` and `skelLanguageConfiguration` for applications that manage language registration themselves.
+
+## Starry Night
+
+```sh
+npm install @wooorm/starry-night @yorun-ai/skel-highlight
 ```
 
-The raw TextMate grammar is also exported as `@yorun-ai/skel-highlight/textmate`.
+```js
+import { createStarryNight } from "@wooorm/starry-night";
+import skel from "@yorun-ai/skel-highlight/starry-night";
+
+const highlighter = await createStarryNight([skel]);
+const tree = highlighter.highlight("domain demo.user", "source.skel");
+```
+
+## CodeMirror 6
+
+```sh
+npm install @codemirror/language @codemirror/view @yorun-ai/skel-highlight
+```
+
+```js
+import { EditorView } from "@codemirror/view";
+import { skel } from "@yorun-ai/skel-highlight/codemirror";
+
+new EditorView({ parent: element, doc: "domain demo.user", extensions: [skel()] });
+```
+
+The CodeMirror entrypoint provides stream-based syntax highlighting. Semantic completion, diagnostics, navigation, and rename remain the responsibility of `skelc lsp` integrations.
+
+## TextMate
+
+The raw grammar is available as `@yorun-ai/skel-highlight/textmate` for TextMate-compatible consumers.

package/dist/codemirror.js

@@ -0,0 +1,122 @@
+// src/codemirror.js
+import { LanguageSupport, StreamLanguage } from "@codemirror/language";
+
+// src/language.js
+var entryKeywords = Object.freeze([
+  "enum",
+  "data",
+  "config",
+  "actor",
+  "resource",
+  "service",
+  "web",
+  "event",
+  "task"
+]);
+var declarationKeywords = Object.freeze(["domain", "import", ...entryKeywords]);
+var controlKeywords = Object.freeze([
+  "pub",
+  "as",
+  "via",
+  "for",
+  "auth",
+  "noauth",
+  "permission",
+  "credential",
+  "info",
+  "method",
+  "require",
+  "trigger",
+  "input",
+  "output",
+  "payload",
+  "action",
+  "check",
+  "all",
+  "any",
+  "client",
+  "agent",
+  "openapi",
+  "eternal",
+  "instant"
+]);
+var builtinTypes = Object.freeze([
+  "int",
+  "float",
+  "bool",
+  "string",
+  "decimal",
+  "binary",
+  "timestamp",
+  "duration",
+  "localdate",
+  "localtime",
+  "localdatetime",
+  "uuid",
+  "json",
+  "PermissionCode",
+  "list",
+  "map"
+]);
+var keywords = Object.freeze([...declarationKeywords, ...controlKeywords]);
+var keywordSet = new Set(keywords);
+var builtinTypeSet = new Set(builtinTypes);
+
+// src/codemirror.js
+function readDelimited(stream, state, delimiter, stateField, tokenType) {
+  if (stream.skipTo(delimiter)) {
+    stream.match(delimiter);
+    state[stateField] = false;
+  } else {
+    stream.skipToEnd();
+  }
+  return tokenType;
+}
+var skelStreamParser = {
+  name: "skel",
+  startState() {
+    return { blockComment: false, tripleString: false };
+  },
+  token(stream, state) {
+    if (state.blockComment) return readDelimited(stream, state, "*/", "blockComment", "comment");
+    if (state.tripleString) return readDelimited(stream, state, '"""', "tripleString", "string");
+    if (stream.eatSpace()) return null;
+    if (stream.match("//")) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match("/*")) {
+      state.blockComment = true;
+      return readDelimited(stream, state, "*/", "blockComment", "comment");
+    }
+    if (stream.match('"""')) {
+      state.tripleString = true;
+      return readDelimited(stream, state, '"""', "tripleString", "string");
+    }
+    if (stream.match(/"(?:\\.|[^"\\])*(?:"|$)/)) return "string";
+    if (stream.match(/@[A-Za-z_][A-Za-z0-9_]*/)) return "meta";
+    if (stream.match(/\d+(?:\.\d+)?/)) return "number";
+    if (stream.match(/[A-Za-z_][A-Za-z0-9_]*/)) {
+      const word = stream.current();
+      if (keywordSet.has(word)) return "keyword";
+      if (builtinTypeSet.has(word)) return "typeName";
+      if (/^[A-Z]/.test(word)) return "className";
+      return "variableName";
+    }
+    if (stream.match(/[?=*]/)) return "operator";
+    if (stream.match(/[{}()[\]<>.,:;]/)) return "punctuation";
+    stream.next();
+    return null;
+  }
+};
+var skelLanguage = StreamLanguage.define(skelStreamParser);
+function skel() {
+  return new LanguageSupport(skelLanguage);
+}
+var codemirror_default = skel;
+export {
+  codemirror_default as default,
+  skel,
+  skelLanguage,
+  skelStreamParser
+};

package/dist/highlightjs.js

@@ -0,0 +1,86 @@
+// src/language.js
+var entryKeywords = Object.freeze([
+  "enum",
+  "data",
+  "config",
+  "actor",
+  "resource",
+  "service",
+  "web",
+  "event",
+  "task"
+]);
+var declarationKeywords = Object.freeze(["domain", "import", ...entryKeywords]);
+var controlKeywords = Object.freeze([
+  "pub",
+  "as",
+  "via",
+  "for",
+  "auth",
+  "noauth",
+  "permission",
+  "credential",
+  "info",
+  "method",
+  "require",
+  "trigger",
+  "input",
+  "output",
+  "payload",
+  "action",
+  "check",
+  "all",
+  "any",
+  "client",
+  "agent",
+  "openapi",
+  "eternal",
+  "instant"
+]);
+var builtinTypes = Object.freeze([
+  "int",
+  "float",
+  "bool",
+  "string",
+  "decimal",
+  "binary",
+  "timestamp",
+  "duration",
+  "localdate",
+  "localtime",
+  "localdatetime",
+  "uuid",
+  "json",
+  "PermissionCode",
+  "list",
+  "map"
+]);
+var keywords = Object.freeze([...declarationKeywords, ...controlKeywords]);
+var keywordSet = new Set(keywords);
+var builtinTypeSet = new Set(builtinTypes);
+
+// src/highlightjs.js
+function skelHighlightJs(hljs) {
+  return {
+    name: "Skel",
+    aliases: ["skel"],
+    keywords: {
+      keyword: keywords.join(" "),
+      type: builtinTypes.join(" ")
+    },
+    contains: [
+      hljs.COMMENT("//", "$"),
+      hljs.COMMENT("/\\*", "\\*/"),
+      { scope: "string", begin: /"""/, end: /"""/ },
+      { scope: "string", begin: /"/, end: /"/, contains: [hljs.BACKSLASH_ESCAPE] },
+      { scope: "meta", begin: /@[A-Za-z_][A-Za-z0-9_]*/ },
+      hljs.C_NUMBER_MODE,
+      { scope: "title.class", begin: /\b[A-Z][A-Za-z0-9_]*\b/ }
+    ]
+  };
+}
+var highlightjs_default = skelHighlightJs;
+export {
+  highlightjs_default as default,
+  skelHighlightJs
+};

package/dist/index.js

@@ -186,7 +186,7 @@ var skel_tmLanguage_default = {
               name: "keyword.declaration.via.skel"
             },
             "2": {
-              name: "entity.name.function.skel"
+              name: "constant.language.actor-via.skel"
             }
           }
         }
@@ -307,7 +307,7 @@ var skel_tmLanguage_default = {
       patterns: [
         {
           name: "keyword.control.skel",
-          match: "\\b(pub|domain|import|as|via|for|auth|noauth|permission|credential|info|method|require|trigger|input|output|payload|resource|action|check|all|any)\\b"
+          match: "\\b(pub|domain|import|as|via|for|auth|noauth|permission|credential|info|method|require|trigger|input|output|payload|resource|action|check|all|any|client|agent|openapi|eternal|instant)\\b"
         }
       ]
     },

package/dist/monaco.js

@@ -0,0 +1,116 @@
+// src/language.js
+var entryKeywords = Object.freeze([
+  "enum",
+  "data",
+  "config",
+  "actor",
+  "resource",
+  "service",
+  "web",
+  "event",
+  "task"
+]);
+var declarationKeywords = Object.freeze(["domain", "import", ...entryKeywords]);
+var controlKeywords = Object.freeze([
+  "pub",
+  "as",
+  "via",
+  "for",
+  "auth",
+  "noauth",
+  "permission",
+  "credential",
+  "info",
+  "method",
+  "require",
+  "trigger",
+  "input",
+  "output",
+  "payload",
+  "action",
+  "check",
+  "all",
+  "any",
+  "client",
+  "agent",
+  "openapi",
+  "eternal",
+  "instant"
+]);
+var builtinTypes = Object.freeze([
+  "int",
+  "float",
+  "bool",
+  "string",
+  "decimal",
+  "binary",
+  "timestamp",
+  "duration",
+  "localdate",
+  "localtime",
+  "localdatetime",
+  "uuid",
+  "json",
+  "PermissionCode",
+  "list",
+  "map"
+]);
+var keywords = Object.freeze([...declarationKeywords, ...controlKeywords]);
+var keywordSet = new Set(keywords);
+var builtinTypeSet = new Set(builtinTypes);
+
+// src/monaco.js
+var skelLanguageConfiguration = Object.freeze({
+  comments: { lineComment: "//", blockComment: ["/*", "*/"] },
+  brackets: [["{", "}"], ["[", "]"], ["(", ")"], ["<", ">"]],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: '"', close: '"' }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: '"', close: '"' }
+  ]
+});
+var skelMonarch = {
+  defaultToken: "",
+  tokenPostfix: ".skel",
+  keywords,
+  builtinTypes,
+  tokenizer: {
+    root: [
+      [/\s+/, "white"],
+      [/\/\//, "comment", "@lineComment"],
+      [/\/\*/, "comment", "@blockComment"],
+      [/"""/, "string", "@tripleString"],
+      [/"(?:\\.|[^"\\])*"/, "string"],
+      [/@[A-Za-z_][A-Za-z0-9_]*/, "annotation"],
+      [/[A-Za-z_][A-Za-z0-9_]*/, { cases: { "@keywords": "keyword", "@builtinTypes": "type", "@default": "identifier" } }],
+      [/\d+(?:\.\d+)?/, "number"],
+      [/[?=*]/, "operator"],
+      [/[{}()[\]<>]/, "@brackets"],
+      [/[.,:;]/, "delimiter"]
+    ],
+    lineComment: [[/.*$/, "comment", "@pop"]],
+    blockComment: [[/[^*]+/, "comment"], [/\*\//, "comment", "@pop"], [/\*/, "comment"]],
+    tripleString: [[/[^\"]+/, "string"], [/"""/, "string", "@pop"], [/\"/, "string"]]
+  }
+};
+function registerSkelMonaco(monaco) {
+  monaco.languages.register({ id: "skel", extensions: [".skel"], aliases: ["Skel", "skel"] });
+  monaco.languages.setLanguageConfiguration("skel", skelLanguageConfiguration);
+  monaco.languages.setMonarchTokensProvider("skel", skelMonarch);
+}
+var monaco_default = skelMonarch;
+export {
+  monaco_default as default,
+  registerSkelMonaco,
+  skelLanguageConfiguration,
+  skelMonarch
+};

package/dist/prism.js

@@ -0,0 +1,110 @@
+// src/language.js
+var entryKeywords = Object.freeze([
+  "enum",
+  "data",
+  "config",
+  "actor",
+  "resource",
+  "service",
+  "web",
+  "event",
+  "task"
+]);
+var declarationKeywords = Object.freeze(["domain", "import", ...entryKeywords]);
+var controlKeywords = Object.freeze([
+  "pub",
+  "as",
+  "via",
+  "for",
+  "auth",
+  "noauth",
+  "permission",
+  "credential",
+  "info",
+  "method",
+  "require",
+  "trigger",
+  "input",
+  "output",
+  "payload",
+  "action",
+  "check",
+  "all",
+  "any",
+  "client",
+  "agent",
+  "openapi",
+  "eternal",
+  "instant"
+]);
+var builtinTypes = Object.freeze([
+  "int",
+  "float",
+  "bool",
+  "string",
+  "decimal",
+  "binary",
+  "timestamp",
+  "duration",
+  "localdate",
+  "localtime",
+  "localdatetime",
+  "uuid",
+  "json",
+  "PermissionCode",
+  "list",
+  "map"
+]);
+var keywords = Object.freeze([...declarationKeywords, ...controlKeywords]);
+var keywordSet = new Set(keywords);
+var builtinTypeSet = new Set(builtinTypes);
+var identifierPattern = "[A-Za-z_][A-Za-z0-9_]*";
+
+// src/prism.js
+var keywordPattern = new RegExp(`\\b(?:${keywords.join("|")})\\b`);
+var builtinPattern = new RegExp(`\\b(?:${builtinTypes.join("|")})\\b`);
+var declarationNamePattern = new RegExp(`(\\b(?:${entryKeywords.join("|")})\\s+)${identifierPattern}`);
+var functionNamePattern = new RegExp(`(\\b(?:method|action|check)\\s+)${identifierPattern}`);
+var skelPrism = Object.freeze({
+  comment: [
+    { pattern: /\/\*(?:[\s\S]*?\*\/|[\s\S]*)/, greedy: true },
+    { pattern: /\/\/.*$/m, greedy: true }
+  ],
+  string: [
+    { pattern: /"""(?:[\s\S]*?"""|[\s\S]*)/, greedy: true },
+    { pattern: /"(?:\\.|[^"\\])*(?:"|$)/m, greedy: true }
+  ],
+  decorator: {
+    pattern: /@[A-Za-z_][A-Za-z0-9_]*/,
+    alias: "annotation"
+  },
+  "class-name": {
+    pattern: declarationNamePattern,
+    lookbehind: true
+  },
+  function: {
+    pattern: functionNamePattern,
+    lookbehind: true
+  },
+  keyword: keywordPattern,
+  builtin: builtinPattern,
+  number: /\b\d+(?:\.\d+)?\b/,
+  "type-reference": {
+    pattern: /\b[A-Z][A-Za-z0-9_]*\b/,
+    alias: "class-name"
+  },
+  operator: /[?=*]/,
+  punctuation: /[{}()[\]<>.,:;]/
+});
+function registerSkelPrism(Prism) {
+  Prism.languages.skel = skelPrism;
+  return skelPrism;
+}
+registerSkelPrism.displayName = "skel";
+registerSkelPrism.aliases = [];
+var prism_default = skelPrism;
+export {
+  prism_default as default,
+  registerSkelPrism,
+  skelPrism
+};

package/dist/starry-night.js

@@ -0,0 +1,351 @@
+// src/skel.tmLanguage.json
+var skel_tmLanguage_default = {
+  name: "Skel",
+  scopeName: "source.skel",
+  patterns: [
+    {
+      include: "#comments"
+    },
+    {
+      include: "#strings"
+    },
+    {
+      include: "#decorators"
+    },
+    {
+      include: "#domain"
+    },
+    {
+      include: "#imports"
+    },
+    {
+      include: "#entries"
+    },
+    {
+      include: "#members"
+    },
+    {
+      include: "#method-output"
+    },
+    {
+      include: "#methods"
+    },
+    {
+      include: "#keywords"
+    },
+    {
+      include: "#scalars"
+    },
+    {
+      include: "#type-references"
+    },
+    {
+      include: "#operators"
+    }
+  ],
+  repository: {
+    comments: {
+      patterns: [
+        {
+          name: "comment.line.double-slash.skel",
+          match: "//.*$"
+        },
+        {
+          name: "comment.block.skel",
+          begin: "/\\*",
+          end: "\\*/"
+        }
+      ]
+    },
+    strings: {
+      patterns: [
+        {
+          name: "string.quoted.triple.skel",
+          begin: '"""',
+          end: '"""',
+          patterns: [
+            {
+              name: "constant.character.escape.skel",
+              match: "\\\\."
+            }
+          ]
+        },
+        {
+          name: "string.quoted.double.skel",
+          begin: '"',
+          end: '"',
+          patterns: [
+            {
+              name: "constant.character.escape.skel",
+              match: "\\\\."
+            }
+          ]
+        }
+      ]
+    },
+    decorators: {
+      patterns: [
+        {
+          name: "meta.annotation.skel",
+          match: "(@)([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "punctuation.definition.annotation.skel"
+            },
+            "2": {
+              name: "entity.name.function.decorator.skel"
+            }
+          }
+        }
+      ]
+    },
+    domain: {
+      patterns: [
+        {
+          name: "meta.domain.skel",
+          match: "^\\s*(domain)\\s+([A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.domain.skel"
+            },
+            "2": {
+              name: "entity.name.namespace.skel"
+            }
+          }
+        }
+      ]
+    },
+    imports: {
+      patterns: [
+        {
+          name: "meta.import.skel",
+          match: "^\\s*(import)\\s+([A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*)(?:\\s+(as)\\s+([A-Za-z_][A-Za-z0-9_]*))?",
+          captures: {
+            "1": {
+              name: "keyword.control.import.skel"
+            },
+            "2": {
+              name: "entity.name.namespace.skel"
+            },
+            "3": {
+              name: "keyword.control.as.skel"
+            },
+            "4": {
+              name: "variable.other.alias.skel"
+            }
+          }
+        }
+      ]
+    },
+    entries: {
+      patterns: [
+        {
+          name: "meta.definition.skel",
+          match: "^\\s*(?:(pub)\\s+)?(enum|data|config|actor|resource|service|web|event|task)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "storage.modifier.public.skel"
+            },
+            "2": {
+              name: "keyword.declaration.skel"
+            },
+            "3": {
+              name: "entity.name.type.skel"
+            }
+          }
+        },
+        {
+          name: "meta.resource-check.skel",
+          match: "^\\s*(check)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.check.skel"
+            },
+            "2": {
+              name: "entity.name.function.check.skel"
+            }
+          }
+        },
+        {
+          name: "meta.resource-action.skel",
+          match: "^\\s*(action)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.action.skel"
+            },
+            "2": {
+              name: "entity.name.function.action.skel"
+            }
+          }
+        },
+        {
+          name: "meta.actor-access.skel",
+          match: "\\b(via)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.via.skel"
+            },
+            "2": {
+              name: "constant.language.actor-via.skel"
+            }
+          }
+        }
+      ]
+    },
+    members: {
+      patterns: [
+        {
+          name: "meta.member.skel",
+          match: "^\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*(:)\\s*([A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)?)",
+          captures: {
+            "1": {
+              name: "variable.other.member.skel"
+            },
+            "2": {
+              name: "punctuation.separator.key-value.skel"
+            },
+            "3": {
+              name: "support.type.skel"
+            }
+          }
+        },
+        {
+          name: "meta.method-output.skel",
+          match: "\\b(output)\\s*([A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)?)",
+          captures: {
+            "1": {
+              name: "keyword.control.output.skel"
+            },
+            "2": {
+              name: "support.type.skel"
+            }
+          }
+        }
+      ]
+    },
+    "method-output": {
+      patterns: [
+        {
+          name: "meta.method-auth.skel",
+          match: "\\b(auth|noauth)\\b",
+          captures: {
+            "1": {
+              name: "keyword.control.auth.skel"
+            }
+          }
+        },
+        {
+          name: "meta.method-require.skel",
+          match: "\\b(require)\\s+",
+          captures: {
+            "1": {
+              name: "keyword.control.require.skel"
+            }
+          }
+        },
+        {
+          name: "keyword.control.require-mode.skel",
+          match: "\\b(all|any)\\b(?=\\s*\\()"
+        },
+        {
+          name: "meta.permission-target.skel",
+          match: "\\b([A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)?)(:)([A-Za-z_][A-Za-z0-9_]*)(?:(:)([A-Za-z_][A-Za-z0-9_]*))?",
+          captures: {
+            "1": {
+              name: "entity.name.type.resource.skel"
+            },
+            "2": {
+              name: "punctuation.separator.permission.skel"
+            },
+            "3": {
+              name: "entity.name.function.action.skel"
+            },
+            "4": {
+              name: "punctuation.separator.permission.skel"
+            },
+            "5": {
+              name: "entity.name.function.check.skel"
+            }
+          }
+        },
+        {
+          name: "meta.method-output.skel",
+          match: "\\b(output)(\\s*)",
+          captures: {
+            "1": {
+              name: "keyword.control.output.skel"
+            }
+          }
+        }
+      ]
+    },
+    methods: {
+      patterns: [
+        {
+          name: "meta.method.skel",
+          match: "^\\s*(method)\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*(?=\\{)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.method.skel"
+            },
+            "2": {
+              name: "entity.name.function.method.skel"
+            }
+          }
+        }
+      ]
+    },
+    "type-references": {
+      patterns: [
+        {
+          name: "entity.name.type.reference.skel",
+          match: "\\b[A-Z][A-Za-z0-9_]*\\b"
+        }
+      ]
+    },
+    keywords: {
+      patterns: [
+        {
+          name: "keyword.control.skel",
+          match: "\\b(pub|domain|import|as|via|for|auth|noauth|permission|credential|info|method|require|trigger|input|output|payload|resource|action|check|all|any|client|agent|openapi|eternal|instant)\\b"
+        }
+      ]
+    },
+    scalars: {
+      patterns: [
+        {
+          name: "support.type.builtin.skel",
+          match: "\\b(int|float|bool|string|decimal|binary|timestamp|duration|localdate|localtime|localdatetime|uuid|json|PermissionCode|list|map)\\b"
+        }
+      ]
+    },
+    operators: {
+      patterns: [
+        {
+          name: "keyword.operator.nullable.skel",
+          match: "\\?"
+        },
+        {
+          name: "punctuation.separator.skel",
+          match: "[,.:;]"
+        },
+        {
+          name: "punctuation.bracket.skel",
+          match: "[{}()<>\\[\\]]"
+        }
+      ]
+    }
+  }
+};
+
+// src/starry-night.js
+var skelStarryNight = Object.freeze({
+  ...skel_tmLanguage_default,
+  names: ["skel"],
+  extensions: [".skel"]
+});
+var starry_night_default = skelStarryNight;
+export {
+  starry_night_default as default,
+  skelStarryNight
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yorun-ai/skel-highlight",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Syntax highlighting definitions for the Skel contract language.",
   "type": "module",
   "license": "Apache-2.0",
@@ -9,19 +9,28 @@
     "url": "https://github.com/yorun-ai/skel-editor-support.git",
     "directory": "packages/highlight"
   },
-  "homepage": "https://github.com/yorun-ai/skel-editor-support#shiki",
+  "homepage": "https://github.com/yorun-ai/skel-editor-support#syntax-highlighting",
   "bugs": {
     "url": "https://github.com/yorun-ai/skel-editor-support/issues"
   },
   "keywords": [
     "skel",
     "shiki",
+    "prismjs",
+    "highlight.js",
+    "monaco-editor",
+    "codemirror",
     "syntax-highlighting",
     "textmate"
   ],
   "files": [
     "dist",
     "src/index.d.ts",
+    "src/prism.d.ts",
+    "src/highlightjs.d.ts",
+    "src/monaco.d.ts",
+    "src/starry-night.d.ts",
+    "src/codemirror.d.ts",
     "src/skel.tmLanguage.json",
     "LICENSE",
     "README.md"
@@ -35,6 +44,26 @@
       "types": "./src/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./prism": {
+      "types": "./src/prism.d.ts",
+      "default": "./dist/prism.js"
+    },
+    "./highlightjs": {
+      "types": "./src/highlightjs.d.ts",
+      "default": "./dist/highlightjs.js"
+    },
+    "./monaco": {
+      "types": "./src/monaco.d.ts",
+      "default": "./dist/monaco.js"
+    },
+    "./starry-night": {
+      "types": "./src/starry-night.d.ts",
+      "default": "./dist/starry-night.js"
+    },
+    "./codemirror": {
+      "types": "./src/codemirror.d.ts",
+      "default": "./dist/codemirror.js"
+    },
     "./textmate": "./src/skel.tmLanguage.json"
   },
   "types": "./src/index.d.ts",
@@ -44,20 +73,54 @@
     "node": ">=20"
   },
   "peerDependencies": {
+    "@codemirror/language": "^6.12.4",
+    "@wooorm/starry-night": "^3.10.0",
+    "highlight.js": "^11.11.1",
+    "monaco-editor": "^0.56.0",
+    "prismjs": "^1.30.0",
     "shiki": "^4.3.1"
   },
+  "peerDependenciesMeta": {
+    "@codemirror/language": {
+      "optional": true
+    },
+    "@wooorm/starry-night": {
+      "optional": true
+    },
+    "highlight.js": {
+      "optional": true
+    },
+    "monaco-editor": {
+      "optional": true
+    },
+    "prismjs": {
+      "optional": true
+    },
+    "shiki": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "node ../../scripts/prepare-assets.js && esbuild ./src/index.js --bundle --format=esm --platform=neutral --outfile=./dist/index.js",
+    "build": "node ../../scripts/prepare-assets.js && esbuild ./src/index.js ./src/prism.js ./src/highlightjs.js ./src/monaco.js ./src/starry-night.js ./src/codemirror.js --bundle --format=esm --platform=neutral --packages=external --outdir=./dist",
     "check": "npm run build && npm test && npm run typecheck",
     "prepack": "npm run build",
     "test": "node --test ./test/*.test.js ./test/*.test.cjs",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
+    "@codemirror/language": "6.12.4",
+    "@lezer/highlight": "1.2.3",
+    "@types/prismjs": "1.26.6",
+    "@wooorm/starry-night": "3.10.0",
     "esbuild": "^0.28.1",
+    "highlight.js": "11.11.1",
+    "lowlight": "3.3.0",
+    "monaco-editor": "0.56.0",
+    "prismjs": "1.30.0",
+    "refractor": "5.0.0",
     "shiki": "4.3.1",
     "typescript": "^7.0.2",
     "vscode-oniguruma": "^2.0.1",

package/src/codemirror.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageSupport, StreamLanguage, StreamParser } from "@codemirror/language";
+
+type SkelState = {
+  blockComment: boolean;
+  tripleString: boolean;
+};
+
+export declare const skelStreamParser: StreamParser<SkelState>;
+export declare const skelLanguage: StreamLanguage<SkelState>;
+export declare function skel(): LanguageSupport;
+export default skel;

package/src/highlightjs.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageFn } from "highlight.js";
+
+export declare const skelHighlightJs: LanguageFn;
+export default skelHighlightJs;

package/src/monaco.d.ts

@@ -0,0 +1,6 @@
+import type * as Monaco from "monaco-editor";
+
+export declare const skelLanguageConfiguration: Monaco.languages.LanguageConfiguration;
+export declare const skelMonarch: Monaco.languages.IMonarchLanguage;
+export declare function registerSkelMonaco(monaco: typeof Monaco): void;
+export default skelMonarch;

package/src/prism.d.ts

@@ -0,0 +1,8 @@
+import type Prism from "prismjs";
+
+export declare const skelPrism: Prism.Grammar;
+export declare const registerSkelPrism: ((prism: typeof Prism) => Prism.Grammar) & {
+  displayName: "skel";
+  aliases: string[];
+};
+export default skelPrism;

package/src/skel.tmLanguage.json

@@ -185,7 +185,7 @@
               "name": "keyword.declaration.via.skel"
             },
             "2": {
-              "name": "entity.name.function.skel"
+              "name": "constant.language.actor-via.skel"
             }
           }
         }
@@ -306,7 +306,7 @@
       "patterns": [
         {
           "name": "keyword.control.skel",
-          "match": "\\b(pub|domain|import|as|via|for|auth|noauth|permission|credential|info|method|require|trigger|input|output|payload|resource|action|check|all|any)\\b"
+          "match": "\\b(pub|domain|import|as|via|for|auth|noauth|permission|credential|info|method|require|trigger|input|output|payload|resource|action|check|all|any|client|agent|openapi|eternal|instant)\\b"
         }
       ]
     },

package/src/starry-night.d.ts

@@ -0,0 +1,4 @@
+import type { Grammar } from "@wooorm/starry-night";
+
+export declare const skelStarryNight: Grammar;
+export default skelStarryNight;