MKRhere

@-moz-document domain("developer.mozilla.org") {
main {
  background: #000;
}

html {
  color: #fff;
}

.titlebar-container {

MKRhere

const betterArray = xs => new Proxy(xs, {
	get (xs, key) {
		if (xs[key] || !xs.length) return xs[key];
		const idx = Number(key);
		if (!idx || idx > 0) return xs[key];
		return xs[xs.length + idx];
	},
});

const arr = betterArray([ 1, 2, 3, 4, 5 ]);

MKRhere

1. Create all attached files below as-is. Directory structure:

etc
├── nginx
│   ├── sites-enabled
│   │   └── domain.tld.port.conf (several)
│   └── ssl
│       ├── .conf # file attached as ssl.conf
│ ├── well-known.conf # file attached

MKRhere

"use strict";
const htmlparser = window.htmlparser2;

const html2hyperscript = (input, stream) => {
	const elements = new Set();
	let indentLevel = 0;
	let attrOpen = false;
	let textWritten = false;
	let justClosed = false;
	let size = 0;

MKRhere

const state = {
	watch: false,
	range: {
		src: {
			start: 0,
			end: 0
		},
		dest: {
			start: 0,
			end: 0

MKRhere

#!/bin/env node

const child = require("child_process");
const readline = require("readline");
const { promisify } = require("util");

const getLines = () =>
	String(
		child.execSync("neofetch --config ~/.mkr/config/neofetch.conf --off"),
	)

MKRhere

1) Create the following directory structure

/etc
├── nginx
│   ├── sites-enabled
│   │   └── domain.tld.port.conf # template attached
│   └── ssl
│       ├── .conf # file attached as `ssl.conf`
│       ├── dhparam.pem # generated

MKRhere

const compose = (...fns) => fns.reduce((f, g) => (...args) => f(g(...args)));

const listeners = {};

const on = (ev, ...handlers) => {
	if (!listeners[ev]) listeners[ev] = [];
	listeners[ev].push(compose(...handlers)(x => x));
};

const emit = (ev, ctx) => {

MKRhere

class FoldBreak <T> {
  constructor(public value: T) {};
};

const foldBreak = <T>(value: T) => new FoldBreak(value);

export const fold = Object.assign(<X, Acc>(
    reducer: (acc: Acc, x: X) => Acc | FoldBreak<Acc>,
    init: Acc,
    xs: X[],

MKRhere

function* map<T, U>(iter: Iterable<T>, f: (t: T) => U): Iterable<U> {
	for (const i of iter) {
		yield f(i);
	}
}

export async function* merge<T>(iterables: AsyncIterable<T>[]) {
	const racers = new Map<AsyncIterator<T>, Promise<IteratorResult<T>>>(
		map(
			map(iterables, (iter) => iter[Symbol.asyncIterator]()),