I switched to a slower computer. Here's a faster program runner.

Benefits:
- Faster (~200ms overhead vs ~600ms from node->babel->vm)
- Shows correct lines on error codes

Author: pfgithub

2021/solutions/_defaults/_defaults.0.ts

@@ -1,3 +1,5 @@
+import {fhmain} from "../../../src/fheader";
+fhmain(__filename);
 /*
 input: string, lines: string[], dblines: string[][]
 copy(text: string) → clipboard
@@ -13,5 +15,7 @@ error(message: string) → thrown error
 export {};
 
 const practice = ``;
+// input = practice;
+input = input.trim();
 
-// input = practice;
+// input.

2021/solutions/day6/day6.3.ts

@@ -1,3 +1,5 @@
+import {fhmain} from "../../../src/fheader";
+fhmain(__filename);
 /*
 input: string, lines: string[], dblines: string[][]
 copy(text: string) → clipboard
@@ -12,6 +14,38 @@ error(message: string) → thrown error
 
 export {};
 
-const practice = ``;
+const practice = `3,4,3,1,2
+`;
+// input = practice;
 
-// input = practice;
+let fish = input.trim().split(",").map(w => +w);
+
+let counts = new Array(9).fill(0);
+
+for(const fsh of fish) {
+    counts[fsh]++;
+}
+
+function step() {
+    let nc: number[] = [...counts];
+    counts.forEach((c, i) => {
+        if(i == 0) {
+            nc[i] -= c;
+            nc[6] += c;
+            nc[8] += c;
+        }else{
+            nc[i] -= c;
+            nc[i - 1] += c;
+        }
+    });
+    counts = nc;
+}
+
+for(let i = 0; i < 256; i++) {
+    step();
+}
+
+
+counts.dwth(log);
+console.log(Array.dwth.bind(counts)(log));
+console.log(counts.reduce((t, c) => t + c, 0));

globals.d.ts

@@ -14,7 +14,6 @@ declare global{
 	interface Object {
 		dwth: <T>(this: T, cb: (v: T) => unknown) => T;
 		use: <T, U>(this: T, cb: (v: T) => U) => U;
-		log: <T>(this: T) => T;
 	}
 
 	type Vector<N extends number, T> = (

package.json

@@ -1,11 +1,12 @@
 {
 	"scripts": {
-		"watch": "onchange --kill */solutions/\\*\\*/\\*.{js,ts} -- node runner.js '{{changed}}'",
+		"watch": "onchange --kill */solutions/\\*\\*/\\*.{js,ts} -- ./node_modules/.bin/esno '{{changed}}'",
 		"prettierwatch": "onchange */solutions/\\*\\*/\\*.{js,ts,md,json} \\*.{js,md,json} -- prettier --write '{{changed}}'",
 		"go": "node setup.js"
 	},
 	"dependencies": {
-		"clipboardy": "^2.1.0"
+		"clipboardy": "^2.1.0",
+		"esno": "^0.12.1"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.7.5",

runner.js

@@ -0,0 +1 @@
+export function fhmain(fn: string): void;

src/fheader.d.ts

@@ -0,0 +1,90 @@
+import * as path from "path";
+import * as fs from "fs";
+
+process.stdout.write("\u001b[2J\u001b[0;0H");
+
+const sessionid = Math.random();
+
+export function fhmain(filename) {
+	console.log(`${sessionid} - ${new Date().getTime()}
+====================================
+${path.basename(filename).replace(/\.(?:js|ts)/, "")}
+====================================`);
+	let txt_name = path.dirname(filename) + "/" + path.basename(path.dirname(filename)) + ".txt";
+
+	global.input = fs.readFileSync(txt_name, "utf-8");
+	global.lines = global.input.split("\n");
+	global.dblines = global.input.split("\n\n");
+	global.output = undefined;
+	global.start_time = Date.now();
+}
+
+global.highlight = msg => "\x1b[31m"+msg+"\x1b(B\x1b[m";
+global.copy = text => {
+	require("clipboardy").writeSync(text);
+	return text;
+};
+global.print = (...a) => console.log(...a);
+global.error = (...a) => {throw new Error(highlight(a.join(" ")))},
+global.clearScreen = () => process.stdout.write("\u001b[2J\u001b[0;0H");
+
+process.on("exit", () => {
+	let total_ms = Date.now() - start_time;
+	console.log("\n\x1b[90mCompleted in "+total_ms+" ms. ("+sessionid+")\x1b(B\x1b[m\x1b[A\x1b[A")
+});
+process.on("uncaughtException", (e) => {
+	console.log();
+	console.log(e.stack.replace(e.message, highlight(e.message)));
+	process.exit(1);
+});
+
+function _defproto(thing, name, cb) {
+	Object.defineProperty(thing.prototype, name, {
+		enumerable: false,
+		value: function(...args) {
+			return cb(
+				this,
+				...args,
+			);
+		},
+	});
+}
+_defproto(Object, "defproto", _defproto);
+
+Number.defproto("mod", (m, n) => ((m%n)+n)%n);
+// Object.defproto("dwth", (me, cb) => (cb(me), me));
+_defproto(Object, "dwth", (me, cb) => (cb(me), me));
+Object.defproto("use", (me, cb) => cb(me));
+global.log = (...a) => {
+	console.log(...a.map(w => {
+		if(w instanceof Number) return +w;
+		if(w instanceof String) return ""+w;
+		return w;
+	}));
+};
+
+global.vec = (...a) => a.flat();
+global.dupe = (a) => [...a];
+Array.defproto("op", (a, b, cb) => a.map((v, i) => cb(v, b[i], i, a, b)));
+Array.defproto("add", (a, b) => a.op(b, (a, b) => a + b));
+Array.defproto("sub", (a, b) => a.op(b, (a, b) => a - b));
+Array.defproto("mul", (a, b) => a.op(b, (a, b) => a * b));
+Array.defproto("div", (a, b) => a.op(b, (a, b) => a / b));
+Array.defproto("mod", (a, b) => a.op(b, (a, b) => a.mod(b)));
+Array.prototype.mapt = Array.prototype.map;
+for(const [index, name] of ["x", "y", "z", "a"].entries()) {
+	Object.defineProperty(Array.prototype, name, {
+		enumerable: false,
+		get: function() {return this[index]},
+		set: function(v) {this[index] = v},
+	});
+}
+
+global.cardinals = [[1,0],[-1,0],[0,1],[0,-1]];
+global.diagonals = [[-1,-1],[-1,1],[1,-1],[1,1]];
+global.adjacents = [...cardinals, ...diagonals];
+
+global.range = (...a) => {
+	const [start, end, step] = (a.length === 1 ? [0, a[0], 1] : a.length === 2 ? [...a, 1] : a);
+	return Array.from({length: Math.ceil((end - start) / step)}, (_, i) => i * step + start);
+}