jsmdcui 0.3.0

package/runtime/jsplugins/linter/linter.js

@@ -0,0 +1,281 @@
+// linter.js — JS port of linter.lua
+// Runs linters on save, adds gutter messages via bp.Buf.AddMessage.
+// micro global is available as globalThis.micro.
+
+import { basename, dirname } from "node:path";
+
+const GOOS = process.platform === "win32" ? "windows" : process.platform;
+const devnull = GOOS === "windows" ? "NUL" : "/dev/null";
+
+// ── Linter registry ───────────────────────────────────────────────────────────
+
+const linters = new Map();
+
+function makeLinter(name, filetype, cmd, args, errorformat, {
+  os: osList = [], whitelist = false, domatch = false, loffset = 0, coffset = 0,
+} = {}) {
+  linters.set(name, { filetype, cmd, args, errorformat, osList, whitelist, domatch, loffset, coffset });
+}
+
+function removeLinter(name) { linters.delete(name); }
+
+// ── Registrations (mirrors linter.lua preinit) ────────────────────────────────
+
+makeLinter("gcc",         "c",           "gcc",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("g++",         "c++",         "g++",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("dmd",         "d",           "dmd",        ["-color=off", "-o-", "-w", "-wi", "-c", "%f"],                 "%f%(%l%):.+: %m");
+makeLinter("ldc2",        "d",           "ldc2",       ["--o-", "--vcolumns", "-w", "-c", "%f"],                       "%f%(%l,%c%):[^:]+: %m");
+makeLinter("gdc",         "d",           "gdc",        ["-fsyntax-only", "-Wall", "-Wextra", "%f"],                    "%f:%l:%c:.+: %m");
+makeLinter("eslint",      "javascript",  "eslint",     ["-f", "json", "--no-ignore", "%f"],                            null);  // JSON parsing
+makeLinter("gobuild",     "go",          "go",         ["build", "-o", devnull, "%d"],                                 "%f:%l:%c:? %m");
+makeLinter("govet",       "go",          "go",         ["vet"],                                                        "%f:%l:%c: %m");
+makeLinter("clippy",      "rust",        "cargo",      ["clippy", "--message-format", "short"],                        "%f:%l:%c: %m");
+makeLinter("hlint",       "haskell",     "hlint",      ["%f"],                                                         "%f:%(?%l[,:]%c%)?.-: %m");
+makeLinter("javac",       "java",        "javac",      ["-d", "%d", "%f"],                                             "%f:%l: error: %m");
+makeLinter("jshint",      "javascript",  "jshint",     ["%f"],                                                         "%f: line %l,.+, %m");
+makeLinter("literate",    "literate",    "lit",        ["-c", "%f"],                                                   "%f:%l:%m",   { domatch: true });
+makeLinter("luacheck",    "lua",         "luacheck",   ["--no-color", "%f"],                                           "%f:%l:%c: %m");
+makeLinter("nim",         "nim",         "nim",        ["check", "--listFullPaths", "--stdout", "--hints:off", "%f"],   "%f.%l, %c. %m");
+makeLinter("clang",       "objective-c", "xcrun",      ["clang", "-fsyntax-only", "-Wall", "-Wextra", "%f"],           "%f:%l:%c:.+: %m");
+makeLinter("pyflakes",    "python",      "pyflakes",   ["%f"],                                                         "%f:%l:.-:? %m");
+makeLinter("mypy",        "python",      "mypy",       ["%f"],                                                         "%f:%l: %m");
+makeLinter("pylint",      "python",      "pylint",     ["--output-format=parseable", "--reports=no", "%f"],            "%f:%l: %m");
+makeLinter("ruff",        "python",      "ruff",       ["check", "--output-format=concise", "%f"],                     "%f:%l:%c: %m");
+makeLinter("flake8",      "python",      "flake8",     ["%f"],                                                         "%f:%l:%c: %m");
+makeLinter("shfmt",       "shell",       "shfmt",      ["%f"],                                                         "%f:%l:%c: %m");
+makeLinter("shellcheck",  "shell",       "shellcheck", ["-f", "gcc", "%f"],                                            "%f:%l:%c:.+: %m");
+makeLinter("swiftc",      "swift",       "xcrun",      ["swiftc", "%f"],                                               "%f:%l:%c:.+: %m", { os: ["darwin"], whitelist: true });
+makeLinter("swiftc-linux","swift",       "swiftc",     ["%f"],                                                         "%f:%l:%c:.+: %m", { os: ["linux"],  whitelist: true });
+makeLinter("yaml",        "yaml",        "yamllint",   ["--format", "parsable", "%f"],                                 "%f:%l:%c:.+ %m");
+makeLinter("nix-linter",  "nix",         "nix-linter", ["%f"],                                                        "%m at %f:%l:%c",   { os: ["linux"],  whitelist: true });
+
+// ── Errorformat → JS regex ────────────────────────────────────────────────────
+
+function parseErrorformat(ef) {
+  const captures = [];
+  let out = "";
+  let i = 0;
+
+  while (i < ef.length) {
+    if (ef[i] === "%") {
+      const next = ef[i + 1] ?? "";
+      i += 2;
+      switch (next) {
+        case "f": captures.push("f"); out += "(.+?)"; break;
+        case "l": captures.push("l"); out += "(\\d+)"; break;
+        case "c": captures.push("c"); out += "(\\d+)"; break;
+        case "m": captures.push("m"); out += "(.+)";  break;
+        case "%": out += "%"; break;
+        case "d": out += "\\d"; break;
+        case "D": out += "\\D"; break;
+        case "s": out += "\\s"; break;
+        case "S": out += "\\S"; break;
+        case "w": out += "\\w"; break;
+        case "W": out += "\\W"; break;
+        case "a": out += "[a-zA-Z]"; break;
+        default:
+          // Lua punctuation escape → literal, JS-escaped
+          out += next.replace(/[.+*?^${}()|[\]\\]/g, "\\$&");
+          break;
+      }
+      continue;
+    }
+
+    if (ef[i] === "[") {
+      let cls = "[";
+      i++;
+      while (i < ef.length && ef[i] !== "]") {
+        if (ef[i] === "%") {
+          const nc = ef[i + 1] ?? "";
+          i += 2;
+          if (nc === "s") cls += "\\s";
+          else if (nc === "S") cls += "\\S";
+          else if (nc === "d") cls += "\\d";
+          else if (nc === "w") cls += "\\w";
+          else if (nc === "%") cls += "%";
+          else cls += nc;
+        } else {
+          cls += ef[i++];
+        }
+      }
+      cls += "]";
+      if (ef[i] === "]") i++;
+      out += cls;
+      continue;
+    }
+
+    // Lua `.-` (lazy any) → JS `.*?`
+    if (ef[i] === "." && ef[i + 1] === "-") {
+      out += ".*?";
+      i += 2;
+      continue;
+    }
+
+    // `|` is literal in Lua patterns but special in JS regex
+    if (ef[i] === "|" || ef[i] === "{" || ef[i] === "}") {
+      out += "\\" + ef[i++];
+      continue;
+    }
+
+    out += ef[i++];
+  }
+
+  return { regex: new RegExp(out), captures };
+}
+
+const _parsedCache = new Map();
+function getParsed(ef) {
+  if (!_parsedCache.has(ef)) _parsedCache.set(ef, parseErrorformat(ef));
+  return _parsedCache.get(ef);
+}
+
+// ── eslint JSON output parsing ────────────────────────────────────────────────
+
+function parseEslintJson(output, bufPath) {
+  let results;
+  try { results = JSON.parse(output); } catch { return null; }
+  if (!Array.isArray(results)) return null;
+
+  const msgs = [];
+  const bufBase = basename(bufPath);
+  for (const file of results) {
+    if (!file?.messages || basename(file.filePath ?? "") !== bufBase) continue;
+    for (const m of file.messages) {
+      msgs.push({
+        line: m.line ?? 1,
+        col: m.column ?? 1,
+        msg: m.message ?? "",
+        severity: (m.severity ?? 2) >= 2 ? micro.buffer.MTError : micro.buffer.MTWarning,
+      });
+    }
+  }
+  return msgs;
+}
+
+// ── OS filter ─────────────────────────────────────────────────────────────────
+
+function checkFtMatch(ft, v) {
+  let ftmatch = v.domatch ? new RegExp(v.filetype).test(ft) : ft === v.filetype;
+  if (!ftmatch) return false;
+  const hasOS = v.osList.includes(GOOS);
+  if (!hasOS && v.whitelist) return false;
+  if (hasOS && !v.whitelist) return false;
+  return true;
+}
+
+// ── Spawn + parse ─────────────────────────────────────────────────────────────
+
+async function spawnAndCollect(argv) {
+  let proc;
+  try {
+    proc = Bun.spawn(argv, { stdout: "pipe", stderr: "pipe", stdin: "ignore" });
+  } catch (err) {
+    micro.pushLintLog(`[linter:${argv[0]}] spawn failed: ${err.message}`);
+    return null;
+  }
+  const dec = new TextDecoder();
+  const readAll = async (stream) => {
+    const chunks = [];
+    if (!stream) return "";
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(dec.decode(value, { stream: true }));
+    }
+    return chunks.join("");
+  };
+  try {
+    const [out, err] = await Promise.all([readAll(proc.stdout), readAll(proc.stderr)]);
+    await proc.exited;
+    return out + err;
+  } catch (err) {
+    micro.pushLintLog(`[linter:${argv[0]}] read failed: ${err.message}`);
+    return null;
+  }
+}
+
+async function lint(bufAdapter, linterName, v) {
+  const file = bufAdapter.Path ?? bufAdapter.path ?? "";
+  const dir = dirname(file) || ".";
+
+  const argv = [v.cmd, ...v.args.map(a => a.replace(/%f/g, file).replace(/%d/g, dir))];
+  const output = await spawnAndCollect(argv);
+  if (output == null) return;
+
+  bufAdapter.ClearMessages(linterName);
+
+  // eslint: JSON path
+  if (v.errorformat === null) {
+    const msgs = parseEslintJson(output, file);
+    if (!msgs) {
+      if (output.trim()) micro.pushLintLog(`[linter:${linterName}]\n${output.trim()}`);
+      return;
+    }
+    for (const { line, col, msg, severity } of msgs) {
+      const start = micro.buffer.Loc(col - 1 + v.coffset, line - 1 + v.loffset);
+      const end   = micro.buffer.Loc(col     + v.coffset, line - 1 + v.loffset);
+      bufAdapter.AddMessage(micro.buffer.newMessage(linterName, msg, start, end, severity));
+    }
+    micro.render();
+    return;
+  }
+
+  // Generic errorformat path
+  const { regex, captures } = getParsed(v.errorformat);
+  const hasCol = captures.includes("c");
+  const bufBase = basename(file);
+
+  for (let rawLine of output.split("\n")) {
+    rawLine = rawLine.replace(/^\s+|\s+$/g, "");
+    if (!rawLine) continue;
+    const m = regex.exec(rawLine);
+    if (!m) continue;
+
+    const capMap = {};
+    captures.forEach((k, idx) => { capMap[k] = m[idx + 1]; });
+
+    if (!capMap.f || basename(capMap.f) !== bufBase) continue;
+
+    const lineNum = Number(capMap.l ?? 1);
+    const colNum  = Number(capMap.c ?? 1);
+    const msg     = capMap.m ?? "";
+
+    let bmsg;
+    if (hasCol && capMap.c != null) {
+      const start = micro.buffer.Loc(colNum - 1 + v.coffset, lineNum - 1 + v.loffset);
+      const end   = micro.buffer.Loc(colNum     + v.coffset, lineNum - 1 + v.loffset);
+      bmsg = micro.buffer.newMessage(linterName, msg, start, end, micro.buffer.MTError);
+    } else {
+      bmsg = micro.buffer.newMessageAtLine(linterName, msg, lineNum + v.loffset, micro.buffer.MTError);
+    }
+    bufAdapter.AddMessage(bmsg);
+  }
+  micro.render();
+}
+
+async function runLinter(bp) {
+  const ft   = bp.Buf.FileType();
+  const buf  = bp.Buf;
+
+  for (const [name, v] of linters) {
+    if (!checkFtMatch(ft, v)) continue;
+    lint(buf, name, v).catch(e => micro.pushLintLog(`[linter:${name}] ${e.message}`));
+  }
+}
+
+// ── Hook registration ─────────────────────────────────────────────────────────
+
+micro.on("init", () => {
+  micro.MakeCommand("lint", async (bp) => {
+    await bp.Save();
+    await runLinter(bp);
+  });
+});
+
+micro.on("onSave", (bp) => {
+  runLinter(bp).catch(e => micro.pushLintLog(`[linter:onSave] ${e.message}`));
+});
+
+// Expose API for user init.js to override linter definitions
+globalThis.linter = { makeLinter, removeLinter, linters };

package/runtime/plugins/autoclose/autoclose.lua

@@ -0,0 +1,75 @@
+VERSION = "1.0.0"
+
+local uutil = import("micro/util")
+local utf8 = import("utf8")
+local autoclosePairs = {"\"\"", "''", "``", "()", "{}", "[]"}
+local autoNewlinePairs = {"()", "{}", "[]"}
+
+function charAt(str, i)
+    -- lua indexing is one off from go
+    return uutil.RuneAt(str, i-1)
+end
+
+function onRune(bp, r)
+    for i = 1, #autoclosePairs do
+        if r == charAt(autoclosePairs[i], 2) then
+            local curLine = bp.Buf:Line(bp.Cursor.Y)
+
+            if charAt(curLine, bp.Cursor.X+1) == charAt(autoclosePairs[i], 2) then
+                bp:Backspace()
+                bp:CursorRight()
+                break
+            end
+
+            if bp.Cursor.X > 1 and (uutil.IsWordChar(charAt(curLine, bp.Cursor.X-1)) or charAt(curLine, bp.Cursor.X-1) == charAt(autoclosePairs[i], 1)) then
+                break
+            end
+        end
+        if r == charAt(autoclosePairs[i], 1) then
+            local curLine = bp.Buf:Line(bp.Cursor.Y)
+
+            if bp.Cursor.X == uutil.CharacterCountInString(curLine) or not uutil.IsWordChar(charAt(curLine, bp.Cursor.X+1)) then
+                -- the '-' here is to derefence the pointer to bp.Cursor.Loc which is automatically made
+                -- when converting go structs to lua
+                -- It needs to be dereferenced because the function expects a non pointer struct
+                bp.Buf:Insert(-bp.Cursor.Loc, charAt(autoclosePairs[i], 2))
+                bp:CursorLeft()
+                break
+            end
+        end
+    end
+    return true
+end
+
+function preInsertNewline(bp)
+    local curLine = bp.Buf:Line(bp.Cursor.Y)
+    local curRune = charAt(curLine, bp.Cursor.X)
+    local nextRune = charAt(curLine, bp.Cursor.X+1)
+    local ws = uutil.GetLeadingWhitespace(curLine)
+
+    for i = 1, #autoNewlinePairs do
+        if curRune == charAt(autoNewlinePairs[i], 1) then
+            if nextRune == charAt(autoNewlinePairs[i], 2) then
+                bp.Buf:Insert(-bp.Cursor.Loc, "\n" .. ws)
+                bp:StartOfLine()
+                bp:CursorLeft()
+                bp:InsertNewline()
+                bp:InsertTab()
+                return false
+            end
+        end
+    end
+
+    return true
+end
+
+function preBackspace(bp)
+    for i = 1, #autoclosePairs do
+        local curLine = bp.Buf:Line(bp.Cursor.Y)
+        if charAt(curLine, bp.Cursor.X+1) == charAt(autoclosePairs[i], 2) and charAt(curLine, bp.Cursor.X) == charAt(autoclosePairs[i], 1) then
+            bp:Delete()
+        end
+    end
+
+    return true
+end

package/runtime/plugins/ftoptions/ftoptions.lua

@@ -0,0 +1,17 @@
+VERSION = "1.0.0"
+
+function onBufferOpen(b)
+    local ft = b:FileType()
+
+    if ft == "go" or
+    ft == "makefile" then
+        b:SetOption("tabstospaces", "off")
+    elseif ft == "fish" or
+           ft == "python" or
+           ft == "python2" or
+           ft == "python3" or
+           ft == "yaml" or
+           ft == "nim" then
+        b:SetOption("tabstospaces", "on")
+    end
+end

package/runtime/plugins/literate/README.md

@@ -0,0 +1,5 @@
+# Literate Micro
+
+Support for reading `.lit` files from [zyedidia/Literate](https://github.com/zyedidia/Literate).
+
+This plugin will automatically detect the filetype and highlight the correct language inside the code blocks.

package/runtime/plugins/literate/literate.lua

@@ -0,0 +1,55 @@
+VERSION = "1.0.0"
+
+local config = import("micro/config")
+
+function startswith(str, start)
+   return string.sub(str,1,string.len(start))==start
+end
+
+function endswith(str, endStr)
+   return endStr=='' or string.sub(str,-string.len(endStr))==endStr
+end
+
+function split(string, sep)
+    local sep, fields = sep or ":", {}
+    local pattern = string.format("([^%s]+)", sep)
+    string:gsub(pattern, function(c) fields[#fields+1] = c end)
+    return fields
+end
+
+function onBufferOpen(buf)
+    if not endswith(buf.Path, ".lit") then
+        return
+    end
+
+    local codetype = "unknown"
+    for i=1,buf:LinesNum() do
+        local line = buf:Line(i-1)
+        if startswith(line, "@code_type") then
+            codetype = split(line, " ")[2]
+            break
+        end
+    end
+
+    local syntaxFile = ""
+    syntaxFile = syntaxFile .. "filetype: literate-" .. codetype .. "\n"
+    syntaxFile = syntaxFile .. "detect:\n"
+    syntaxFile = syntaxFile .. "    filename: \"\\\\.lit$\"\n"
+    syntaxFile = syntaxFile .. "rules:\n"
+    syntaxFile = syntaxFile .. "    - include: \"markdown\"\n"
+    syntaxFile = syntaxFile .. "    - special: \"^(@s|@title|@code_type|@comment_type|@include|@change|@change_end)\"\n"
+    syntaxFile = syntaxFile .. "    - special: \"(@add_css|@overwrite_css|@colorscheme|@compiler|@error_format|@book)\"\n"
+    syntaxFile = syntaxFile .. "    - default:\n"
+    syntaxFile = syntaxFile .. "        start: \"---.*$\"\n"
+    syntaxFile = syntaxFile .. "        end: \"---$\"\n"
+    syntaxFile = syntaxFile .. "        limit-group: \"identifier\"\n"
+    syntaxFile = syntaxFile .. "        rules:\n"
+    syntaxFile = syntaxFile .. "            - special:\n"
+    syntaxFile = syntaxFile .. "                start: \"@\\\\{\"\n"
+    syntaxFile = syntaxFile .. "                end: \"\\\\}\"\n"
+    syntaxFile = syntaxFile .. "            - include: " .. codetype .. "\n"
+
+    config.AddRuntimeFileFromMemory(config.RTSyntax, "literate.yaml", syntaxFile)
+    config.Reload()
+    buf:UpdateRules()
+end

package/runtime/plugins/status/help/status.md

@@ -0,0 +1,21 @@
+# Status
+
+The status plugin provides some functions for modifying the status line.
+
+Using the `statusformatl` and `statusformatr` options, the exact contents
+of the status line can be modified. Please see the documentation for
+those options (`> help options`) for more information.
+
+This plugin provides functions that can be used in the status line format:
+
+* `status.branch`: returns the name of the current git branch in the repository
+   where the file is located.
+* `status.hash`: returns the hash of the current git commit in the repository
+   where the file is located.
+* `status.paste`: returns "" if the paste option is disabled and "PASTE"
+   if it is enabled.
+* `status.lines`: returns the number of lines in the buffer.
+* `status.vcol`: returns the visual column number of the cursor.
+* `status.bytes`: returns the number of bytes in the current buffer.
+* `status.size`: returns the size of the current buffer in a human-readable
+   format.

package/runtime/plugins/status/status.lua

@@ -0,0 +1,62 @@
+VERSION = "1.0.0"
+
+local micro = import("micro")
+local buffer = import("micro/buffer")
+local config = import("micro/config")
+local shell = import("micro/shell")
+local filepath = import("filepath")
+local humanize = import("humanize")
+local strings = import("strings")
+
+function init()
+    micro.SetStatusInfoFn("status.branch")
+    micro.SetStatusInfoFn("status.hash")
+    micro.SetStatusInfoFn("status.paste")
+    micro.SetStatusInfoFn("status.vcol")
+    micro.SetStatusInfoFn("status.lines")
+    micro.SetStatusInfoFn("status.bytes")
+    micro.SetStatusInfoFn("status.size")
+    config.AddRuntimeFile("status", config.RTHelp, "help/status.md")
+end
+
+function lines(b)
+    return tostring(b:LinesNum())
+end
+
+function vcol(b)
+    return tostring(b:GetActiveCursor():GetVisualX(false))
+end
+
+function bytes(b)
+    return tostring(b:Size())
+end
+
+function size(b)
+    return humanize.Bytes(b:Size())
+end
+
+local function parseRevision(b, opt)
+    if b.Type.Kind ~= buffer.BTInfo then
+        local dir = filepath.Dir(b.Path)
+        local str, err = shell.ExecCommand("git", "-C", dir, "rev-parse", opt, "HEAD")
+        if err == nil then
+            return strings.TrimSpace(str)
+        end
+    end
+    return ""
+end
+
+function branch(b)
+    return parseRevision(b, "--abbrev-ref")
+end
+
+function hash(b)
+    return parseRevision(b, "--short")
+end
+
+function paste(b)
+    if config.GetGlobalOption("paste") then
+        return "PASTE "
+    end
+    return ""
+end

package/runtime/syntax/LICENSE

@@ -0,0 +1,22 @@
+Micro's syntax files are licensed under the MIT "Expat" License:
+
+Copyright (c) 2020: Zachary Yedidia, et al.
+
+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/runtime/syntax/PowerShell.yaml

@@ -0,0 +1,128 @@
+# PowerShell syntax highlighting file for micro - https://micro-editor.github.io/
+# PowerShell syntax taken from: https://github.com/PowerShell/EditorSyntax
+
+filetype: powershell
+
+detect:
+    filename: "\\.ps(1|m1|d1)$"
+
+rules:
+    # - comment.block:           # Block Comment
+    # - comment.doc:             # Doc Comment
+    # - comment.line:            # Line Comment
+    # - comment.shebang:         # Shebang Line
+
+    # - constant:                # Constant
+    # - constant.bool:           # Constant (true, false)
+    # - constant.interpolation:
+    # - constant.number:         # Constant (null)
+    # - constant.specialChar:
+    # - constant.string:         # String
+    # - constant.string.char:
+    # - constant.string.url:     # Uri
+    # - constant.unicode:
+
+    # - identifier:              # Also used for functions
+    # - identifier.class:        # Also used for functions
+    # - identifier.macro:
+    # - identifier.var:
+
+    # - preproc:                 # Preprocessor
+    # - preproc.DebugIdentifier: # Preprocessor
+    # - preproc.shebang:         # The #! at the beginning of a file that tells the os what script interpreter to use
+
+    # - special:                 # Special (global|local|private|script|using|workflow)
+
+    # - statement:               # Statements Keywords
+    # - statement.built_in:
+    # - statement.declaration:   # Declaration Keywords
+    # - statement.meta:          # Meta
+    # - statement.reserved:      # Reserved Keywords
+
+    # - symbol
+    # - symbol.brackets:         # {}()[] and sometimes <>
+    # - symbol.operator:         # Operators
+    # - symbol.tag:              # For html tags, among other things
+
+    # - type
+    # - type.collections:        # Collections (array, hashtable)
+    # - type.ctypes:             # CTypes (CBool, CChar, etc.)
+    # - type.keyword:            # If you want a special highlight for keywords like 'private'
+    # - type.storage:            # Storage Types (int, uint, string, etc.)
+
+    # Class
+    - identifier.class: "class +[A-Za-z0-9]+ *((:) +[A-Za-z0-9.]+)?"
+    - identifier.class: "(function)(?:([[:space:]][A-Za-z0-9]+[[:space:]]*))"
+
+    # Verbs taken from PwSh 6.0.2
+    - identifier: "(Add|Approve|Assert|Backup|Block|Build|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy)[-][A-Za-z0-9]+"
+    - identifier: "(Debug|Deny|Deploy|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|Format|Get|Grant|Group|Hide)[-][A-Za-z0-9]+"
+    - identifier: "(Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Mount|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push)[-][A-Za-z0-9]+"
+    - identifier: "(Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke)[-][A-Za-z0-9]+"
+    - identifier: "(Save|Search|Select|Send|Set|Show|Skip|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Test|Trace)[-][A-Za-z0-9]+"
+    - identifier: "(Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Write)[-][A-Za-z0-9]+"
+    - identifier.var: "\\$(?i)((Global|Local|Private|Script|Using|Workflow)[:])?[A-Za-z0-9]*"
+
+
+    # Expression and types
+    - type: "\\[\\b([A-Za-z]+|[A-Za-z]+[0-9]+)\\b\\]"
+
+    # Keywords
+    - statement: "\\b(alias|as|begin|break|catch|continue|data|default|define|do|dynamicparam)\\b"
+    - statement: "\\b(else|elseif|end|exit|finally|for|foreach|foreach-object|from|if|in|inlinescript)\\b"
+    - statement: "\\b(parallel|param|process|return|switch|throw|trap|try|until|using|var|where|where-object|while)\\b"
+
+    # Special Keywords
+    - special: "\\b(break|continue|exit)\\b"
+
+    - symbol.brackets: "(\\{|\\})"
+    - symbol.brackets: "(\\(|\\))"
+    - symbol.brackets: "(\\[|\\])"
+    - symbol.operator: "[\\-+/*=<>?:!~%&|]"
+    - symbol.operator: "[[:space:]][-](ne|eq|gt|ge|lt|le|like|notlike|match|notmatch|contains|notcontains|in|notin|replace|is|isnot)[[:space:]]"
+
+    # Constants
+    - constant.bool: "\\b\\$(true|false|null)\\b"
+    - constant.number: "\\b([0-9._]+|0x[A-Fa-f0-9_]+|0b[0-1_]+)[FL]?\\b"
+
+    # Expression Mode String
+    - constant.string:
+        start: "\""
+        end: "\""
+        #skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    # Argument Mode String
+    - constant.string:
+        start: "'"
+        end: "'"
+        #skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\([btnfr]|'|\\\"|\\\\)"
+            - constant.specialChar: "\\\\u[A-Fa-f0-9]{4}"
+
+    # Line Comment
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME|BUG):?"
+
+    # Block Comment
+    - comment:
+        start: "<#"
+        end: "#>"
+        rules:
+            - todo: "(TODO|XXX|FIXME|BUG):?"
+
+    # Embedded C#
+    - default:
+        start: "@\""
+        end: "\"@"
+        rules:
+            - include: "csharp"
+
+    # Todo
+    - todo: "(TODO|XXX|FIXME|BUG):?"