bunmicro 0.8.0

package/runtime/syntax/vi.yaml

@@ -0,0 +1,31 @@
+filetype: vi
+
+detect:
+    filename: "(^|/|\\.)(ex|vim)rc$|\\.vim"
+
+rules:
+    - identifier: "[A-Za-z_][A-Za-z0-9_]*[(]+[A-Za-z0-9_:.,\\s]*[)]+"
+    - special: "[()]+"
+    - statement: "\\b([nvxsoilc]?(nore|un)?map|[nvlx]n|[ico]?no|[cilovx][um]|s?unm)\\b"
+    - statement: "\\b(snor|nun|nm|set|if|endif|let|unlet|source)\\b"
+    - statement: "[!&=?]"
+    - constant.number: "\\b[0-9]+\\b"
+
+    - comment:
+        start: "(^\"|[ \t]+\" |[ \t]+\"$)"
+        end: "$"
+        rules: []
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."

package/runtime/syntax/vue.yaml

@@ -0,0 +1,64 @@
+filetype: vue
+
+detect:
+    filename: "\\.vue$"
+
+rules:
+    - default:
+        start: "<template.*?>"
+        end: "</template.*?>"
+        limit-group: symbol.tag
+        rules:
+            - error: "<[^!].*?>"
+            - symbol.tag: "(?i)<[/]?(a|a(bbr|ddress|rea|rticle|side|udio)|b|b(ase|d(i|o)|lockquote|r|utton)|ca(nvas|ption)|center|cite|co(de|l|lgroup)|d(ata|atalist|d|el|etails|fn|ialog|l|t)|em|embed|fieldset|fig(caption|ure)|form|iframe|h[1-6]|hr|i|img|in(put|s)|kbd|keygen|label|legend|li|link|ma(in|p|rk)|menu|menuitem|met(a|er)|nav|noscript|o(bject|l|pt(group|ion)|utput)|p|param|picture|pre|progress|q|r(p|t|uby)|s|samp|se(ction|lect)|svg|small|source|span|strong|su(b|p|mmary)|textarea|time|track|u|ul|var|video|wbr)( .*)*?>"
+            - symbol.tag.extended: "(?i)<[/]?(body|div|html|head(er)?|footer|title|table|t(body|d|h(ead)?|r|foot))( .*)*?>"
+            - preproc: "(?i)<[/]?(script|style)( .*)*?>"
+            - special: "&[^;[[:space:]]]*;"
+
+            - identifier: "(alt|bgcolor|class|height|href|id|label|longdesc|name|on(click|focus|load|mouseover)|placeholder|size|span|src|style|target|type|value|width)="
+            - symbol: "[:=]"
+            - constant.string: "\"[^\"]*\""
+            - constant.number: "(?i)#[0-9a-fA-F]{6,6}"
+
+            - symbol.tag: "<|>"
+            - constant.string.url: "(ftp(s)?|http(s)?|git|chrome)://[^ 	]+"
+            - comment: "<!--.+?-->"
+            #- preproc: "<!DOCTYPE.+?>"
+            - comment.block:
+                start: "<!\\-\\-"
+                end: "\\-\\->"
+                rules: []
+
+            # Bootstrap
+            - symbol.tag.extended: "(?i)<[/]?(b-alert|b-aspect|b-avatar|b-badge|b-icon|b-breadcrumb|b-button-group|b-button-toolbar|b-button|b-calendar|b-card-text|b-card-input|b-card|b-carousel-slide|b-carousel|b-collapse|b-dropdown|b-dropdown-item|b-dropdown-divider|b-embed|b-form-checkbox-group|b-form-checkbox|b-form-datepicker|b-form-file|b-form-group|b-form-input|b-form-radio|b-form-rating|b-form-select|b-form-spinbutton|b-form-tags|b-form-textarea|b-form|b-form-timepicker|b-img-lazy|b-img|b-input-group|b-jumbotron|b-input|b-container|b-row|b-col|b-link|b-list-group|b-list-group-item|b-media|b-modal|b-nav|b-nav-item|b-nav-item-dropdown|b-nav-text|b-nav-form|b-navbar|b-navbar-brand|b-navbar-toggle|b-navbar-nav|b-overlay|b-pagination|b-pagination-nav|b-popover|b-progress|b-progress-bar|b-sidebar|b-skeleton-wrapper|b-skeleton|b-spinner|b-table|b-table-lite|b-table-simple|b-tabs|b-tab|b-time|b-toast|b-tooltip)\\b"
+            - identifier: "(variant|title|show|shadow|icon|align-h|align-v|label-for|@submit|tag|img-alt|img-src|data-toggle|data-target|aria-controls|aria-expanded|aria-label|aria-disabled|tabindex|:interval|background|img-width|img-height|@sliding-start|@sliding-end|cols|header|@reset)="
+            - symbol: "[:=]"
+            # Vue
+            - symbol.tag.extended: "(?i)<[/]?(component|transition|transition-group|keep-alive|slot)\\b"
+            - identifier: "(v-text|v-html|v-show|v-if|v-else|v-else-if|v-for|v-on|v-bind|v-model|v-slot|v-pre|v-cloak|v-once|key|ref|is|@click)="
+            - symbol: "[:=]"
+            # Vue-router
+            - symbol.tag.extended: "(?i)<[/]?(router-link|router-view)\\b"
+            - identifier: "(to|v-slot)="
+            - symbol: "[:=]"
+
+
+    - default:
+        start: "<script>"
+        end: "</script>"
+        limit-group: symbol.tag
+        rules:
+            - include: "javascript"
+
+    - default:
+        start: "<script[ ]+lang=(\"ts\"|'ts')>"
+        end: "</script>"
+        rules:
+            - include: "typescript"
+
+    - default:
+        start: "<style.*?>"
+        end: "</style.*?>"
+        limit-group: symbol.tag
+        rules:
+            - include: "css"

package/runtime/syntax/xml.yaml

@@ -0,0 +1,37 @@
+filetype: xml
+
+detect:
+    filename: "\\.(xml|sgml?|rng|svg|plist)$"
+    header: "<\\?xml.*\\?>"
+
+rules:
+    - preproc:
+        start: "<!DOCTYPE"
+        end: "[/]?>"
+        rules: []
+
+    - comment:
+        start: "<!--"
+        end: "-->"
+        rules: []
+
+    - symbol.tag:
+        start: "<\\??"
+        end: "\\??>"
+        rules:
+            - identifier:
+                start: " "
+                end: "="
+                rules: []
+            - constant.string:
+                start: "\""
+                end: "\""
+                skip: "\\\\."
+                rules:
+                    - constant.specialChar: "\\\\."
+            - constant.string:
+                start: "'"
+                end: "'"
+                skip: "\\\\."
+                rules:
+                    - constant.specialChar: "\\\\."

package/runtime/syntax/xresources.yaml

@@ -0,0 +1,14 @@
+filetype: xresources
+
+detect:
+    filename: "X(defaults|resources)$"
+
+rules:
+    - special: "^[[:alnum:]]+\\*"
+    - identifier.var: "\\*[[:alnum:]]+\\:"
+    - constant.number: "\\b[0-9]+\\b"
+    - symbol.operator: "[*:=]"
+    - constant.bool: "\\b(true|false)\\b"
+    - comment: "(^|[[:space:]])!([^{].*)?$"
+    - indent-char.whitespace: "[[:space:]]+$"
+    - indent-char: "	+ +| +	+"

package/runtime/syntax/yaml.yaml

@@ -0,0 +1,34 @@
+filetype: yaml
+
+detect:
+    filename: "\\.ya?ml$"
+    header: "%YAML"
+
+rules:
+    - type: "(^| )!!(binary|bool|float|int|map|null|omap|seq|set|str) "
+    - constant:  "\\b(YES|yes|Y|y|ON|on|TRUE|True|true|NO|no|N|n|OFF|off|FALSE|False|false)\\b"
+    - statement: "(:[[:space:]]|\\[|\\]|:[[:space:]]+[|>]|^[[:space:]]*- )"
+    - identifier: "[[:space:]][\\*&][A-Za-z0-9]+"
+    - type: "[-.\\w]+:"
+    - statement: ":"
+    - special:  "(^---|^\\.\\.\\.|^%YAML|^%TAG)"
+
+    - constant.string:
+        start: "(^| )\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "(^| )'"
+        end: "'"
+        skip: "(\\\\.)|('')"
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/yum.yaml

@@ -0,0 +1,12 @@
+filetype: yum
+
+detect:
+    filename: "\\.repo$|yum.*\\.conf$"
+
+rules:
+    - identifier: "^[[:space:]]*[^=]*="
+    - constant.specialChar: "^[[:space:]]*\\[.*\\]$"
+    - statement: "\\$(releasever|arch|basearch|uuid|YUM[0-9])"
+    - comment: "(^|[[:space:]])#([^{].*)?$"
+    - indent-char.whitespace: "[[:space:]]+$"
+    - indent-char: "	+ +| +	+"

package/runtime/syntax/zig.yaml

@@ -0,0 +1,52 @@
+filetype: zig
+
+detect:
+    filename: "\\.z(ig|on)$"
+
+rules:
+      # Reserved words
+    - statement: "\\b(addrspace|align|allowzero|and|asm|async|await|break|callconv|catch|comptime|const|continue|defer|else|errdefer|error|export|extern|fn|for|if|inline|noalias|noinline|nosuspend|or|orelse|packed|pub|resume|return|linksection|suspend|switch|test|threadlocal|try|unreachable|usingnamespace|var|volatile|while)\\b"
+      # builtin functions
+    - special: "@[a-zA-Z_]+"
+      # Primitive Types
+    - type: "\\b(anyframe|anytype|anyerror|anyopaque|bool|comptime_int|comptime_float|enum|f(16|32|64|80|128)|i(8|16|32|64|128)|isize|noreturn|opaque|struct|type|union|u(8|16|32|64|128)|usize|void)\\b"
+    - type: "\\b(c_u?(short|int|long(long)?)|c_longdouble|c_void)\\b"
+
+     # Operators
+    - symbol.operator: "[-!|=;%.+^*:&?<>~]"
+
+     # Parenthesis
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+     # Constants
+    - constant: "\\b(null|undefined)\\b"
+    - constant.number: "\\b(0b[01_]+|0o[0-7_]+|[0-9_]+|0x[a-fA-F0-9_]+)\\b"
+    - constant.bool: "\\b(true|false)\\b"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - error: "..+"
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - constant.string:
+        start: "\\\\\\\\"
+        end: "$"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([nrt\\\\'\"]|x[a-fA-F0-9]{2}|u{[a-fA-F0-9]+})"
+
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/zscript.yaml

@@ -0,0 +1,72 @@
+filetype: zscript
+# Loosely based on the csharp.yaml definition
+# (?i) on everything because ZScript isn't case sensitive
+
+detect:
+    filename: "(?i)\\.z(c|sc)$"
+
+rules:
+
+    # ZScript only has one preprocessor directive and a required engine version declaration
+    - preproc: "(?i)#include"
+    - preproc: "(?i)version"
+
+    # State labels ("goto" word overridden by state logic rule below)
+    - symbol.tag: "(?i)[a-z0-9.]+:"
+    - symbol.tag: "(?i)goto [a-z0-9]+[\\+0-9]*"
+
+    # Classes
+    - identifier.class: "(?i)class +[a-z0-9_]+ *((:) +[a-z0-9.]+)?"
+
+    # Functions (open paren overridden by symbol.brackets rule because perl regex apparently doesn't support postive lookahead)
+    - identifier: "(?i)[\\.]*[a-z0-9_]+[ ]*[(]+"
+
+    # Variable types
+    - type: "(?i)\\b(actor|object|vector2|vector3|name|string|color|sound|void|double|bool|int|float|float64|uint8|uint16|uint|int8|int16|TextureID|SpriteID|Array|voidptr|short|action|state|statelabel)\\b"
+
+    # Keywords
+    - statement: "(?i)\\b(class|default|private|static|native|return|if|else|for|while|do|deprecated|null|readonly|true|false|struct|extend|clearscope|vararg|ui|play|virtual|virtualscope|meta|Property|in|out|states|override|super|is|let|const|replaces|protected|self|abstract|enum|switch|case)\\b"
+
+    # State logic keywords
+    - special: "(?i)\\b(goto|loop|stop|break|continue|fail)\\b"
+
+    # Symbols
+    - symbol.operator: "[\\-+/*=<>?:!~%&|]"
+    - symbol.brackets: "[(){}]|\\[|\\]"
+
+    # Constants
+    - constant.bool: "(?i)(\\b(true|false)\\b|NULL)"
+    - constant.number: "(?i)\\b([0-9][.]*[0-9]*)+?\\b"
+    - constant.number: "(?i)\\b(0x[A-Fa-f0-9_]+)?\\b"
+    - constant.number: "(?i)\\b(0b[0-1_]+)[FL]?\\b"
+    #- constant.number: "(?i)\\b(([0-9][.]*[0-9]*)+|0x[A-Fa-f0-9_]+|0b[0-1_]+)[FL]?\\b"
+
+    # Strings
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    # Comments
+    - comment:
+        start: "//"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+
+    - comment:
+        start: "/\\*"
+        end: "\\*/"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"

package/runtime/syntax/zsh.yaml

@@ -0,0 +1,52 @@
+filetype: zsh
+
+detect:
+    filename: "(\\.zsh$|\\.?(zshenv|zprofile|zshrc|zlogin|zlogout)$)"
+    header: "^#!.*/(env +)?zsh( |$)"
+
+rules:
+    ## Numbers
+    - constant.number: "\\b[0-9]+\\b"
+
+      ## Conditionals and control flow
+    - statement: "\\b(always|break|bye|case|continue|disown|do|done|elif|else|esac|exit|fi|for|function|if|in|local|read|return|select|shift|then|time|until|while)\\b"
+
+    - statement: "(\\{|\\}|\\(|\\)|\\;|\\]|\\[|`|\\\\|\\$|<|>|!|=|&|\\|)"
+      ## Conditional flags
+    - special: "-[Ldefgruwx]\\b"
+    - special: "-(eq|ne|gt|lt|ge|le|s|n|z)\\b"
+
+      ## Bash-inherited
+    - statement: "\\b((un)?alias|bindkey|builtin|cd|declare|eval|exec|export|jobs|let|popd|pushd|set|source|typeset|umask|unset)\\b"
+      ## ZSH-specific
+    - type: "\\b(add-zsh-hook|autoload|chdir|compinit|dirs|(dis|en)able|echotc|emulate|print|prompt(init)?|(un)?setopt|zle|zmodload|zstyle|whence)\\b"
+
+      ## Common linux commands
+    - statement: "\\b((g|ig)?awk|find|\\w{0,4}grep|kill|killall|\\w{0,4}less|make|pkill|sed|tar)\\b"
+
+      ## Coreutils commands
+    - statement: "\\b(base64|basename|cat|chcon|chgrp|chmod|chown|chroot|cksum|comm|cp|csplit|cut|date|dd|df|dir|dircolors|dirname|du|echo|env|expand|expr|factor|false|fmt|fold|head|hostid|id|install|join|link|ln|logname|ls|md5sum|mkdir|mkfifo|mknod|mktemp|mv|nice|nl|nohup|nproc|numfmt|od|paste|pathchk|pinky|pr|printenv|printf|ptx|pwd|readlink|realpath|rm|rmdir|runcon|seq|(sha1|sha224|sha256|sha384|sha512)sum|shred|shuf|sleep|sort|split|stat|stdbuf|stty|sum|sync|tac|tail|tee|test|timeout|touch|tr|true|truncate|tsort|tty|uname|unexpand|uniq|unlink|users|vdir|wc|who|whoami|yes)\\b"
+
+      ## Function definition
+    - identifier: "^\\s+(function\\s+)[0-9A-Z_]+\\s+\\(\\)" # (i)
+
+      ## Variables
+    - identifier: "\\$\\{?[0-9A-Z_!@#$*?-]+\\}?" #(i)
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        rules: []
+
+    - comment:
+        start: "(^|\\s)#"
+        end: "$"
+        rules: []
+

package/src/buffer/buffer.js

@@ -0,0 +1,126 @@
+import { basename } from "node:path";
+import { Loc } from "./loc.js";
+
+export const BTDefault = { Kind: 0, Scratch: false, Readonly: false };
+export const BTHelp = { Kind: 1, Scratch: true, Readonly: true };
+export const BTLog = { Kind: 2, Scratch: true, Readonly: true };
+export const BTScratch = { Kind: 3, Scratch: true, Readonly: false };
+export const BTRaw = { Kind: 4, Scratch: true, Readonly: false };
+export const BTInfo = { Kind: 5, Scratch: true, Readonly: true };
+
+export class BufferCore {
+  constructor({ text = "", path = "", type = BTDefault, settings = {} } = {}) {
+    this.Path = path;
+    this.AbsPath = path;
+    this.Name = path ? basename(path) : "No name";
+    this.Type = type;
+    this.Settings = { filetype: "unknown", tabstospaces: false, tabsize: 4, ...settings };
+    this.lines = normalizeText(text).split("\n");
+    if (this.lines.length === 0) this.lines = [""];
+    this.Messages = [];
+    this.diffBase = "";
+    this.modified = false;
+  }
+
+  Line(n) {
+    return this.lines[n] ?? "";
+  }
+
+  LineBytes(n) {
+    return new TextEncoder().encode(this.Line(n));
+  }
+
+  LinesNum() {
+    return this.lines.length;
+  }
+
+  Size() {
+    return new TextEncoder().encode(this.Bytes()).byteLength;
+  }
+
+  Bytes() {
+    return this.lines.join("\n");
+  }
+
+  FileType() {
+    return this.Settings.filetype ?? "unknown";
+  }
+
+  SetOption(option, value) {
+    this.Settings[option] = parseOption(value);
+  }
+
+  DoSetOptionNative(option, value) {
+    this.Settings[option] = value;
+  }
+
+  Insert(loc, text) {
+    const pos = normalizeLoc(loc);
+    const line = this.Line(pos.Y);
+    const before = line.slice(0, pos.X);
+    const after = line.slice(pos.X);
+    const parts = normalizeText(text).split("\n");
+    if (parts.length === 1) {
+      this.lines[pos.Y] = before + parts[0] + after;
+    } else {
+      const replacement = [before + parts[0], ...parts.slice(1, -1), parts.at(-1) + after];
+      this.lines.splice(pos.Y, 1, ...replacement);
+    }
+    this.modified = true;
+  }
+
+  Replace(start, end, text) {
+    const s = normalizeLoc(start);
+    const e = normalizeLoc(end);
+    if (s.Y === e.Y) {
+      const line = this.Line(s.Y);
+      this.lines[s.Y] = line.slice(0, s.X) + text + line.slice(e.X);
+    } else {
+      const first = this.Line(s.Y).slice(0, s.X);
+      const last = this.Line(e.Y).slice(e.X);
+      const parts = normalizeText(text).split("\n");
+      const replacement = parts.length === 1 ? [first + parts[0] + last] : [first + parts[0], ...parts.slice(1, -1), parts.at(-1) + last];
+      this.lines.splice(s.Y, e.Y - s.Y + 1, ...replacement);
+    }
+    this.modified = true;
+  }
+
+  SetDiffBase(text) {
+    this.diffBase = String(text);
+  }
+
+  AddMessage(message) {
+    this.Messages.push(message);
+  }
+
+  ClearMessages(owner) {
+    this.Messages = this.Messages.filter((message) => message.Owner !== owner);
+  }
+
+  ClearAllMessages() {
+    this.Messages = [];
+  }
+}
+
+export function byteOffset(pos, buffer) {
+  const loc = normalizeLoc(pos);
+  let offset = 0;
+  for (let y = 0; y < loc.Y; y++) offset += buffer.Line(y).length + 1;
+  return offset + buffer.Line(loc.Y).slice(0, loc.X).length;
+}
+
+function normalizeLoc(value) {
+  if (value instanceof Loc) return value;
+  return new Loc(value?.X ?? value?.x ?? 0, value?.Y ?? value?.y ?? 0);
+}
+
+function normalizeText(text) {
+  return String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function parseOption(value) {
+  if (value === "on" || value === "true") return true;
+  if (value === "off" || value === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(String(value))) return Number(value);
+  return value;
+}

package/src/buffer/loc.js

@@ -0,0 +1,38 @@
+export class Loc {
+  constructor(x = 0, y = 0) {
+    this.X = x;
+    this.Y = y;
+    this.x = x;
+    this.y = y;
+  }
+
+  lessThan(other) {
+    return this.Y < other.Y || (this.Y === other.Y && this.X < other.X);
+  }
+
+  greaterThan(other) {
+    return this.Y > other.Y || (this.Y === other.Y && this.X > other.X);
+  }
+
+  greaterEqual(other) {
+    return this.greaterThan(other) || (this.X === other.X && this.Y === other.Y);
+  }
+
+  lessEqual(other) {
+    return this.lessThan(other) || (this.X === other.X && this.Y === other.Y);
+  }
+
+  clamp(start, end) {
+    if (this.greaterEqual(end)) return end;
+    if (this.lessThan(start)) return start;
+    return this;
+  }
+
+  toJSON() {
+    return { X: this.X, Y: this.Y };
+  }
+}
+
+export function loc(x = 0, y = 0) {
+  return new Loc(x, y);
+}

package/src/buffer/message.js

@@ -0,0 +1,29 @@
+import { Loc } from "./loc.js";
+
+export const MTInfo = 0;
+export const MTWarning = 1;
+export const MTError = 2;
+
+export class BufferMessage {
+  constructor(owner, msg, start, end, kind) {
+    this.Owner = owner;
+    this.Msg = msg;
+    this.Start = start;
+    this.End = end;
+    this.Kind = kind;
+  }
+}
+
+export function newMessage(owner, msg, start, end, kind) {
+  return new BufferMessage(owner, msg, normalizeLoc(start), normalizeLoc(end), kind);
+}
+
+export function newMessageAtLine(owner, msg, line, kind) {
+  const pos = new Loc(-1, Number(line) - 1);
+  return newMessage(owner, msg, pos, pos, kind);
+}
+
+function normalizeLoc(value) {
+  if (value instanceof Loc) return value;
+  return new Loc(value?.X ?? value?.x ?? 0, value?.Y ?? value?.y ?? 0);
+}

package/src/config/colorscheme.js

@@ -0,0 +1,109 @@
+export const DEFAULT_STYLE = {
+  fg: "default",
+  bg: "default",
+  bold: false,
+  italic: false,
+  reverse: false,
+  underline: false,
+};
+
+// Built-in fallback styles for color groups not defined in a colorscheme.
+// Matches Go micro's default group colours.
+const BUILTIN_GROUPS = {
+  "diff-added":    { ...DEFAULT_STYLE, fg: "green" },
+  "diff-modified": { ...DEFAULT_STYLE, fg: "yellow" },
+  "diff-deleted":  { ...DEFAULT_STYLE, fg: "red" },
+  "gutter-error":  { ...DEFAULT_STYLE, fg: "red" },
+  "gutter-warning":{ ...DEFAULT_STYLE, fg: "yellow" },
+  "gutter-info":   { ...DEFAULT_STYLE, fg: "brightblue" },
+};
+
+const COLOR_LINK = /color-link\s+(\S*)\s+"(.*)"/;
+const INCLUDE = /include\s+"(.*)"/;
+
+export class Colorscheme {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.styles = new Map();
+    this.defaultStyle = { ...DEFAULT_STYLE };
+  }
+
+  async load(name = "default", parsed = new Set()) {
+    const file = this.runtime.find(0, name);
+    if (!file) throw new Error(`${name} is not a valid colorscheme`);
+    parsed.add(name);
+    const parsedStyles = await this.parse(name, await file.text(), parsed);
+    this.styles = parsedStyles;
+    return this;
+  }
+
+  async parse(name, text, parsed = new Set()) {
+    const styles = new Map();
+    for (const rawLine of String(text).split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+
+      const include = line.match(INCLUDE);
+      if (include) {
+        const includeName = include[1];
+        if (!parsed.has(includeName)) {
+          const child = new Colorscheme(this.runtime);
+          await child.load(includeName, parsed);
+          for (const [key, value] of child.styles) styles.set(key, value);
+          if (child.styles.has("default")) this.defaultStyle = child.styles.get("default");
+        }
+        continue;
+      }
+
+      const match = line.match(COLOR_LINK);
+      if (!match) throw new Error(`Color-link statement is not valid: ${rawLine}`);
+      const style = stringToStyle(match[2], this.defaultStyle);
+      styles.set(match[1], style);
+      if (match[1] === "default") this.defaultStyle = style;
+    }
+    if (styles.has("default")) this.defaultStyle = styles.get("default");
+    return styles;
+  }
+
+  get(group) {
+    if (!group) return this.defaultStyle;
+    const parts = String(group).split(".");
+    let style = this.styles.get(group);
+    if (parts.length > 1) {
+      let cur = "";
+      for (const part of parts) {
+        cur = cur ? `${cur}.${part}` : part;
+        if (this.styles.has(cur)) style = this.styles.get(cur);
+      }
+    }
+    return style ?? BUILTIN_GROUPS[group] ?? stringToStyle(group, this.defaultStyle);
+  }
+}
+
+export function stringToStyle(input, base = DEFAULT_STYLE) {
+  const text = String(input);
+  const colorPart = text.split(/\s+/).at(-1) ?? "";
+  const [fgRaw = "default", bgRaw = "default"] = colorPart.split(",");
+  return {
+    fg: stringToColor(fgRaw.trim(), base.fg),
+    bg: stringToColor(bgRaw.trim(), base.bg),
+    bold: text.includes("bold"),
+    italic: text.includes("italic"),
+    reverse: text.includes("reverse"),
+    underline: text.includes("underline"),
+  };
+}
+
+export function stringToColor(value, fallback = "default") {
+  const color = String(value || "default").trim();
+  if (color === "default" || color === "") return fallback;
+  if (/^\d+$/.test(color)) return Number(color);
+  if (/^#[0-9a-fA-F]{6}$/.test(color)) return color;
+  const names = new Set([
+    "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+    "brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
+    "brightmagenta", "brightcyan", "brightwhite", "lightblack", "lightred",
+    "lightgreen", "lightyellow", "lightblue", "lightmagenta", "lightcyan", "lightwhite",
+  ]);
+  return names.has(color) ? color : fallback;
+}