@xnoxs/flux-lang 3.4.3 → 3.4.5

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [3.4.4] — 2026-06-26
+
+### Added
+- **`flux upgrade`** — cek semua dependensi di `flux.json` dan update ke versi terbaru dari npm
+  - `flux upgrade` — update langsung, tulis ke `flux.json`
+  - `flux upgrade --check` — dry-run, hanya tampilkan update yang tersedia tanpa mengubah file
+  - Tampilkan `↑ nama@lama → baru` untuk deps yang bisa di-upgrade, `✓ nama@ver — up to date` untuk yang sudah terbaru
+  - Tandai `(dev)` untuk devDependencies
+- `flux upgrade` dan `flux upgrade --check` ditambahkan ke help text CLI
+- Semua perintah package manager (`add/remove/install/upgrade/search/info/list`) sekarang tampil di `flux help`
+
+---
+
 ## [3.4.3] — 2026-06-26
 
 ### Fixed

package/dist/flux-cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*!
- * flux-lang v3.4.3
+ * flux-lang v3.4.5
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -7216,7 +7216,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@xnoxs/flux-lang",
-      version: "3.4.3",
+      version: "3.4.5",
       description: "Flux \u2014 A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
       main: "dist/flux.cjs.js",
       module: "dist/flux.esm.js",
@@ -8571,9 +8571,8 @@ var require_pkg = __commonJS({
     var Os = require("os");
     var { readPackage, writeConfig, loadConfig: loadConfig2 } = require_config2();
     var REGISTRY_URL = "https://registry.npmjs.org";
-    var FLUX_PKG_DIR = "flux_modules";
     var PKG_FILE = "flux.json";
-    var C2 = { reset: "\\x1b[0m", bold: "\\x1b[1m", dim: "\\x1b[2m", red: "\\x1b[31m", green: "\\x1b[32m", yellow: "\\x1b[33m", blue: "\\x1b[34m", cyan: "\\x1b[36m", gray: "\\x1b[90m" };
+    var C2 = { reset: "\x1B[0m", bold: "\x1B[1m", dim: "\x1B[2m", red: "\x1B[31m", green: "\x1B[32m", yellow: "\x1B[33m", blue: "\x1B[34m", cyan: "\x1B[36m", gray: "\x1B[90m" };
     function clr2(c, s) {
       return c + s + C2.reset;
     }
@@ -8691,6 +8690,7 @@ var require_pkg = __commonJS({
     }
     module2.exports.cmdRemove = cmdRemove;
     async function cmdInstall(opts) {
+      const { execSync } = require("child_process");
       const cwd = process.cwd();
       const pkg = ensureFluxJson(cwd);
       const deps = pkg.dependencies ?? {};
@@ -8702,18 +8702,39 @@ var require_pkg = __commonJS({
         return;
       }
       console.log(clr2(C2.cyan, "\n  Installing ") + names.length + " package(s)...\n");
-      const modDir = Path.join(cwd, FLUX_PKG_DIR);
-      if (!Fs.existsSync(modDir)) {
-        Fs.mkdirSync(modDir, { recursive: true });
-      }
       for (const name of names) {
         const spec = all[name];
-        const version = spec.replace(/[\^~>=<]/g, "").split(" ")[0];
-        console.log(clr2(C2.gray, "  \u25CB ") + name + clr2(C2.gray, "@" + version));
+        console.log(clr2(C2.gray, "  \u25CB ") + name + clr2(C2.gray, "@" + spec));
       }
       console.log();
-      ok("flux.json dependencies registered");
-      info("Note: Use npm/pnpm to install Node.js compatible packages");
+      let pm = "npm";
+      try {
+        execSync("pnpm --version", { stdio: "pipe" });
+        pm = "pnpm";
+      } catch (_) {
+      }
+      const prodNames = Object.keys(deps);
+      const devNames = Object.keys(devDeps);
+      try {
+        if (prodNames.length > 0) {
+          const prodPkgs = prodNames.map((n) => n + "@" + (deps[n] ?? "latest")).join(" ");
+          const installCmd = pm + " install " + prodPkgs;
+          info("Running: " + installCmd);
+          execSync(installCmd, { cwd, stdio: "inherit" });
+        }
+        if (devNames.length > 0) {
+          const devPkgs = devNames.map((n) => n + "@" + (devDeps[n] ?? "latest")).join(" ");
+          const devCmd = pm + " install --save-dev " + devPkgs;
+          info("Running: " + devCmd);
+          execSync(devCmd, { cwd, stdio: "inherit" });
+        }
+        console.log();
+        ok(names.length + " package(s) installed successfully");
+      } catch (e) {
+        console.log();
+        err("Install failed: " + e.message);
+        info("Try running manually: " + pm + " install");
+      }
       console.log();
     }
     module2.exports.cmdInstall = cmdInstall;
@@ -8836,6 +8857,80 @@ var require_pkg = __commonJS({
       console.log();
     }
     module2.exports.cmdPublish = cmdPublish2;
+    async function cmdUpgrade(opts) {
+      const check = opts && opts.check || false;
+      const cwd = process.cwd();
+      const pkg = readPackage(cwd);
+      if (!pkg) {
+        err("No flux.json found. Run: flux init");
+        return;
+      }
+      const allDeps = Object.assign({}, pkg.dependencies || {}, pkg.devDependencies || {});
+      const names = Object.keys(allDeps);
+      if (names.length === 0) {
+        info("No dependencies in flux.json");
+        return;
+      }
+      console.log();
+      console.log(clr2(C2.cyan, "  Checking " + names.length + " package(s) for updates...\n"));
+      let updated = 0;
+      let upToDate = 0;
+      let failed = 0;
+      for (const name of names) {
+        const current = allDeps[name].replace(/^[\^~>=<\s]+/, "");
+        try {
+          const data = await fetchJson(REGISTRY_URL + "/" + name);
+          const latest = data["dist-tags"] && data["dist-tags"].latest;
+          if (!latest) {
+            err(name + " \u2014 could not resolve latest");
+            failed++;
+            continue;
+          }
+          const isDev = !!(pkg.devDependencies && pkg.devDependencies[name]);
+          const tag = isDev ? clr2(C2.blue, " (dev)") : "";
+          if (current === latest) {
+            console.log("  " + clr2(C2.gray, "\u2713") + " " + clr2(C2.bold, name) + clr2(C2.gray, "@" + current + " \u2014 up to date") + tag);
+            upToDate++;
+          } else {
+            console.log("  " + clr2(C2.yellow, "\u2191") + " " + clr2(C2.bold, name) + clr2(C2.gray, "@" + current) + " \u2192 " + clr2(C2.green, latest) + tag);
+            if (!check) {
+              if (isDev) {
+                if (!pkg.devDependencies) pkg.devDependencies = {};
+                pkg.devDependencies[name] = "^" + latest;
+              } else {
+                if (!pkg.dependencies) pkg.dependencies = {};
+                pkg.dependencies[name] = "^" + latest;
+              }
+            }
+            updated++;
+          }
+        } catch (e) {
+          err(name + " \u2014 " + e.message);
+          failed++;
+        }
+      }
+      console.log();
+      if (check) {
+        console.log(clr2(C2.cyan, "  Check mode: no changes written."));
+        if (updated > 0) {
+          console.log(clr2(C2.yellow, "  " + updated + " update(s) available. Run: flux upgrade"));
+        } else {
+          console.log(clr2(C2.green, "  All packages are up to date."));
+        }
+      } else {
+        if (updated > 0) {
+          const pkgPath = Path.join(cwd, "flux.json");
+          Fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+          ok(updated + " package(s) updated in flux.json");
+          info("Run: flux install  to apply changes");
+        } else {
+          console.log(clr2(C2.green, "  \u2713 All packages are already up to date."));
+        }
+        if (failed > 0) info(failed + " package(s) could not be checked");
+      }
+      console.log();
+    }
+    module2.exports.cmdUpgrade = cmdUpgrade;
   }
 });
 
@@ -8914,6 +9009,13 @@ function showHelp() {
     ["fmt <file.flux>", "Format source code in-place"],
     ["test [dir]", "Discover and run *.test.flux files"],
     ["publish [--patch|minor|major]", "Bump version, update CHANGELOG, tag & release"],
+    ["add <package>[@ver] [--dev]", "Add a dependency to flux.json"],
+    ["remove <package>", "Remove a dependency from flux.json"],
+    ["install", "Install all dependencies from flux.json"],
+    ["upgrade [--check]", "Upgrade all dependencies to latest versions"],
+    ["search <query>", "Search the npm registry for packages"],
+    ["info <package>", "Show package details from npm registry"],
+    ["list", "List installed dependencies from flux.json"],
     ["tokens <file.flux>", "Show lexer token list"],
     ["ast <file.flux>", "Show Abstract Syntax Tree (JSON)"],
     ["repl", "Interactive REPL mode"],
@@ -10326,6 +10428,12 @@ function main() {
       cmdList({});
       break;
     }
+    case "upgrade": {
+      const { cmdUpgrade } = require_pkg();
+      const isCheck = process.argv.includes("--check");
+      cmdUpgrade({ check: isCheck });
+      break;
+    }
     case "repl":
     case void 0:
       if (!cmd) {

package/dist/flux.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.4.3
+ * flux-lang v3.4.5
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License

package/dist/flux.esm.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.4.3
+ * flux-lang v3.4.5
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License

package/dist/flux.min.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.4.3
+ * flux-lang v3.4.5
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xnoxs/flux-lang",
-  "version": "3.4.3",
+  "version": "3.4.5",
   "description": "Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
   "main": "dist/flux.cjs.js",
   "module": "dist/flux.esm.js",

package/src/self/cli.flux

@@ -27,17 +27,17 @@ val STAGE   = FLUX_STAGE   ?? "self-hosted"
 
 // ── ANSI Colors ───────────────────────────────────────────────
 val C = {
-  reset:   "\x1b[0m",
-  bold:    "\x1b[1m",
-  dim:     "\x1b[2m",
-  red:     "\x1b[31m",
-  green:   "\x1b[32m",
-  yellow:  "\x1b[33m",
-  blue:    "\x1b[34m",
-  cyan:    "\x1b[36m",
-  white:   "\x1b[37m",
-  gray:    "\x1b[90m",
-  magenta: "\x1b[35m",
+  reset:   "\u001b[0m",
+  bold:    "\u001b[1m",
+  dim:     "\u001b[2m",
+  red:     "\u001b[31m",
+  green:   "\u001b[32m",
+  yellow:  "\u001b[33m",
+  blue:    "\u001b[34m",
+  cyan:    "\u001b[36m",
+  white:   "\u001b[37m",
+  gray:    "\u001b[90m",
+  magenta: "\u001b[35m",
 }
 
 val noColor = process.env.NO_COLOR or not process.stdout.isTTY

package/src/self/cli.js

@@ -57,7 +57,7 @@ const { loadConfig } = require("./config");
 const { cmdAdd, cmdRemove, cmdInstall, cmdList, cmdSearch, cmdInfo, cmdPublish } = require("./pkg");
 const VERSION = (FLUX_VERSION ?? "3.0.0");
 const STAGE = (FLUX_STAGE ?? "self-hosted");
-const C = { reset: "\\x1b[0m", bold: "\\x1b[1m", dim: "\\x1b[2m", red: "\\x1b[31m", green: "\\x1b[32m", yellow: "\\x1b[33m", blue: "\\x1b[34m", cyan: "\\x1b[36m", white: "\\x1b[37m", gray: "\\x1b[90m", magenta: "\\x1b[35m" };
+const C = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m", cyan: "\x1b[36m", white: "\x1b[37m", gray: "\x1b[90m", magenta: "\x1b[35m" };
 const noColor = (process.env.NO_COLOR || !process.stdout.isTTY);
 function clr(c, s) {
   return (noColor ? s : ((c + s) + C.reset));

package/src/self/pkg.flux

@@ -25,15 +25,15 @@ val PKG_FILE     = "flux.json"
 
 // ── ANSI colors ───────────────────────────────────────────────
 val C = {
-  reset:  "\x1b[0m",
-  bold:   "\x1b[1m",
-  dim:    "\x1b[2m",
-  red:    "\x1b[31m",
-  green:  "\x1b[32m",
-  yellow: "\x1b[33m",
-  blue:   "\x1b[34m",
-  cyan:   "\x1b[36m",
-  gray:   "\x1b[90m",
+  reset:  "\u001b[0m",
+  bold:   "\u001b[1m",
+  dim:    "\u001b[2m",
+  red:    "\u001b[31m",
+  green:  "\u001b[32m",
+  yellow: "\u001b[33m",
+  blue:   "\u001b[34m",
+  cyan:   "\u001b[36m",
+  gray:   "\u001b[90m",
 }
 
 fn clr(c, s): return c + s + C.reset
@@ -157,6 +157,8 @@ export fn cmdRemove(names, opts):
 
 // ── flux install ──────────────────────────────────────────────
 export async fn cmdInstall(opts):
+  import { execSync } from "child_process"
+
   val cwd = process.cwd()
   val pkg = ensureFluxJson(cwd)
 
@@ -171,17 +173,45 @@ export async fn cmdInstall(opts):
 
   console.log(clr(C.cyan, "\n  Installing ") + names.length + " package(s)...\n")
 
-  val modDir = Path.join(cwd, FLUX_PKG_DIR)
-  if not Fs.existsSync(modDir): Fs.mkdirSync(modDir, { recursive: true })
-
   for name in names:
     val spec    = all[name]
     val version = spec.replace(/[\^~>=<]/g, "").split(" ")[0]
-    console.log(clr(C.gray, "  ○ ") + name + clr(C.gray, "@" + version))
+    console.log(clr(C.gray, "  ○ ") + name + clr(C.gray, "@" + spec))
 
   console.log()
-  ok("flux.json dependencies registered")
-  info("Note: Use npm/pnpm to install Node.js compatible packages")
+
+  // Detect available package manager: prefer pnpm, fall back to npm
+  var pm = "npm"
+  try:
+    execSync("pnpm --version", { stdio: "pipe" })
+    pm = "pnpm"
+  catch(e):
+    pass
+
+  val prodNames = Object.keys(deps)
+  val devNames  = Object.keys(devDeps)
+
+  try:
+    if prodNames.length > 0:
+      val prodPkgs = prodNames.map(n -> n + "@" + (deps[n] ?? "latest")).join(" ")
+      val installCmd = pm + " install " + prodPkgs
+      info("Running: " + installCmd)
+      execSync(installCmd, { cwd: cwd, stdio: "inherit" })
+
+    if devNames.length > 0:
+      val devPkgs = devNames.map(n -> n + "@" + (devDeps[n] ?? "latest")).join(" ")
+      val devFlag = pm == "pnpm" ? " --save-dev" : " --save-dev"
+      val devCmd  = pm + " install" + devFlag + " " + devPkgs
+      info("Running: " + devCmd)
+      execSync(devCmd, { cwd: cwd, stdio: "inherit" })
+
+    console.log()
+    ok(names.length + " package(s) installed successfully")
+  catch(e):
+    console.log()
+    err("Install failed: " + e.message)
+    info("Try running manually: " + pm + " install")
+
   console.log()
 
 // ── flux list ─────────────────────────────────────────────────

package/src/self/pkg.js

@@ -19,7 +19,7 @@ const { readPackage, writeConfig, loadConfig } = require("./config");
 const REGISTRY_URL = "https://registry.npmjs.org";
 const FLUX_PKG_DIR = "flux_modules";
 const PKG_FILE = "flux.json";
-const C = { reset: "\\x1b[0m", bold: "\\x1b[1m", dim: "\\x1b[2m", red: "\\x1b[31m", green: "\\x1b[32m", yellow: "\\x1b[33m", blue: "\\x1b[34m", cyan: "\\x1b[36m", gray: "\\x1b[90m" };
+const C = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m", cyan: "\x1b[36m", gray: "\x1b[90m" };
 function clr(c, s) {
   return ((c + s) + C.reset);
 }
@@ -139,10 +139,11 @@ function cmdRemove(names, opts) {
 }
 module.exports.cmdRemove = cmdRemove;
 async function cmdInstall(opts) {
+  const { execSync } = require("child_process");
   const cwd = process.cwd();
   const pkg = ensureFluxJson(cwd);
-  const deps = (pkg.dependencies ?? {  });
-  const devDeps = (pkg.devDependencies ?? {  });
+  const deps = (pkg.dependencies ?? {});
+  const devDeps = (pkg.devDependencies ?? {});
   const all = { ...deps, ...devDeps };
   const names = Object.keys(all);
   if ((names.length == 0)) {
@@ -150,18 +151,42 @@ async function cmdInstall(opts) {
     return;
   }
   console.log(((clr(C.cyan, "\n  Installing ") + names.length) + " package(s)...\n"));
-  const modDir = Path.join(cwd, FLUX_PKG_DIR);
-  if (!Fs.existsSync(modDir)) {
-    Fs.mkdirSync(modDir, { recursive: true });
-  }
   for (const name of names) {
     const spec = all[name];
-    const version = spec.replace(/[\^~>=<]/g, "").split(" ")[0];
-    console.log(((clr(C.gray, "  ○ ") + name) + clr(C.gray, ("@" + version))));
+    console.log(((clr(C.gray, "  ○ ") + name) + clr(C.gray, ("@" + spec))));
   }
   console.log();
-  ok("flux.json dependencies registered");
-  info("Note: Use npm/pnpm to install Node.js compatible packages");
+
+  // Detect available package manager: prefer pnpm, fall back to npm
+  let pm = "npm";
+  try {
+    execSync("pnpm --version", { stdio: "pipe" });
+    pm = "pnpm";
+  } catch (_) {}
+
+  const prodNames = Object.keys(deps);
+  const devNames  = Object.keys(devDeps);
+
+  try {
+    if (prodNames.length > 0) {
+      const prodPkgs   = prodNames.map(n => n + "@" + (deps[n] ?? "latest")).join(" ");
+      const installCmd = pm + " install " + prodPkgs;
+      info("Running: " + installCmd);
+      execSync(installCmd, { cwd: cwd, stdio: "inherit" });
+    }
+    if (devNames.length > 0) {
+      const devPkgs = devNames.map(n => n + "@" + (devDeps[n] ?? "latest")).join(" ");
+      const devCmd  = pm + " install --save-dev " + devPkgs;
+      info("Running: " + devCmd);
+      execSync(devCmd, { cwd: cwd, stdio: "inherit" });
+    }
+    console.log();
+    ok(names.length + " package(s) installed successfully");
+  } catch (e) {
+    console.log();
+    err("Install failed: " + e.message);
+    info("Try running manually: " + pm + " install");
+  }
   console.log();
 }
 module.exports.cmdInstall = cmdInstall;
@@ -283,4 +308,79 @@ function cmdPublish(opts) {
   info("Run: flux publish --registry <url>  for a custom registry");
   console.log();
 }
-module.exports.cmdPublish = cmdPublish;
+module.exports.cmdPublish = cmdPublish;
+
+// ── flux upgrade [--check] ─────────────────────────────────────────────────
+// Checks all dependencies in flux.json for newer versions and updates them.
+// --check : dry-run, only show what would change without writing
+async function cmdUpgrade(opts) {
+  const check = (opts && opts.check) || false;
+  const cwd   = process.cwd();
+  const pkg   = readPackage(cwd);
+  if (!pkg) { err('No flux.json found. Run: flux init'); return; }
+
+  const allDeps = Object.assign({}, pkg.dependencies || {}, pkg.devDependencies || {});
+  const names   = Object.keys(allDeps);
+  if (names.length === 0) { info('No dependencies in flux.json'); return; }
+
+  console.log();
+  console.log(clr(C.cyan, '  Checking ' + names.length + ' package(s) for updates...\n'));
+
+  let updated = 0;
+  let upToDate = 0;
+  let failed = 0;
+
+  for (const name of names) {
+    const current = allDeps[name].replace(/^[\^~>=<\s]+/, '');
+    try {
+      const data   = await fetchJson(REGISTRY_URL + '/' + name);
+      const latest = data['dist-tags'] && data['dist-tags'].latest;
+      if (!latest) { err(name + ' — could not resolve latest'); failed++; continue; }
+
+      const isDev  = !!(pkg.devDependencies && pkg.devDependencies[name]);
+      const tag    = isDev ? clr(C.blue, ' (dev)') : '';
+
+      if (current === latest) {
+        console.log('  ' + clr(C.gray, '✓') + ' ' + clr(C.bold, name) + clr(C.gray, '@' + current + ' — up to date') + tag);
+        upToDate++;
+      } else {
+        console.log('  ' + clr(C.yellow, '↑') + ' ' + clr(C.bold, name) + clr(C.gray, '@' + current) + ' → ' + clr(C.green, latest) + tag);
+        if (!check) {
+          if (isDev) {
+            if (!pkg.devDependencies) pkg.devDependencies = {};
+            pkg.devDependencies[name] = '^' + latest;
+          } else {
+            if (!pkg.dependencies) pkg.dependencies = {};
+            pkg.dependencies[name] = '^' + latest;
+          }
+        }
+        updated++;
+      }
+    } catch (e) {
+      err(name + ' — ' + e.message);
+      failed++;
+    }
+  }
+
+  console.log();
+  if (check) {
+    console.log(clr(C.cyan, '  Check mode: no changes written.'));
+    if (updated > 0) {
+      console.log(clr(C.yellow, '  ' + updated + ' update(s) available. Run: flux upgrade'));
+    } else {
+      console.log(clr(C.green, '  All packages are up to date.'));
+    }
+  } else {
+    if (updated > 0) {
+      const pkgPath = Path.join(cwd, 'flux.json');
+      Fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+      ok(updated + ' package(s) updated in flux.json');
+      info('Run: flux install  to apply changes');
+    } else {
+      console.log(clr(C.green, '  ✓ All packages are already up to date.'));
+    }
+    if (failed > 0) info(failed + ' package(s) could not be checked');
+  }
+  console.log();
+}
+module.exports.cmdUpgrade = cmdUpgrade;

package/src/self/test-runner.flux

@@ -13,14 +13,14 @@ import Path from "path"
 import Os   from "os"
 
 val C = {
-  reset:  '\x1b[0m',
-  bold:   '\x1b[1m',
-  red:    '\x1b[31m',
-  green:  '\x1b[32m',
-  yellow: '\x1b[33m',
-  cyan:   '\x1b[36m',
-  gray:   '\x1b[90m',
-  dim:    '\x1b[2m',
+  reset:  '\u001b[0m',
+  bold:   '\u001b[1m',
+  red:    '\u001b[31m',
+  green:  '\u001b[32m',
+  yellow: '\u001b[33m',
+  cyan:   '\u001b[36m',
+  gray:   '\u001b[90m',
+  dim:    '\u001b[2m',
 }
 
 fn clr(c, s):

package/src/self/test-runner.js

@@ -21,7 +21,7 @@ function repeat(s, n) { return String(s).repeat(n); }
 const Fs = require("fs");
 const Path = require("path");
 const Os = require("os");
-const C = { reset: "\\x1b[0m", bold: "\\x1b[1m", red: "\\x1b[31m", green: "\\x1b[32m", yellow: "\\x1b[33m", cyan: "\\x1b[36m", gray: "\\x1b[90m", dim: "\\x1b[2m" };
+const C = { reset: "\x1b[0m", bold: "\x1b[1m", red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", gray: "\x1b[90m", dim: "\x1b[2m" };
 function clr(c, s) {
   return (process.env.NO_COLOR ? s : ((c + s) + C.reset));
 }