Chris Baker bakerface

## example.ts
import * as Maybe from "./maybe";
import { caseOf } from "./one-of";

const square = (n: number) => n * n;

// serializable as plain js arrays
console.log(Maybe.of(42)); // [ 'Just', 42 ]

// supports exhaustive pattern matching
caseOf(Maybe.map(Maybe.of(3), square), {

## index.html
<html>
<head>
<style>
body { width: 100%; }
table { margin: auto; border-spacing: 1rem; }
button { padding: 1rem; }
</style>
</head>
<body>
  <table>

## mocha.h
/**
 * Copyright (c) 2022 Chris Baker
 *
 * 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:
 *

## co.h
/**
 * Copyright (c) 2022 Chris Baker
 *
 * 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:
 *

## crc16.h
/**
 * Copyright (c) 2022 Chris Baker
 *
 * 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:
 *

## fluent-example.ts
import type { Fluent } from "./fluent";

export class User {
  public id: string;
  public username: string;

  private constructor() {
    this.id = "";
    this.username = "";
  }

## match.ts
export type KeysOfParams<S extends string> =
  S extends `${infer Before} :${infer Name} ${infer After}`
    ? KeysOfParams<Before> | Name | KeysOfParams<After>
    : S extends `:${infer Name} ${infer After}`
    ? Name | KeysOfParams<After>
    : S extends `${infer Before} :${infer Name}`
    ? KeysOfParams<Before> | Name
    : S extends `:${infer Name}`
    ? Name
    : never;

## statistics.ts
export class Statistics {
  private static ensureNotEmpty(arr: readonly number[]): void {
    if (arr.length === 0) {
      throw new Error("The array must not be empty.");
    }
  }

  static asc(a: number, b: number): number {
    return a - b;
  }

## job-queue-example.ts
import { JobQueue } from "./job-queue";

export interface Device {
  send(command: string): Promise<void>;
}

const sleep = (ms: number) => new Promise<void>((fn) => setTimeout(fn, ms));

export class AsyncDevice implements Device {
  async send(command: string): Promise<void> {

## mixin.ts
export type Constructor<T> = new (...args: any[]) => T;

export interface Mixin<Features, Requirements = any> {
  <T extends Constructor<Requirements>>(Base: T): T & Constructor<Features>;
}
	import * as Maybe from "./maybe";
	import { caseOf } from "./one-of";

	const square = (n: number) => n * n;

	// serializable as plain js arrays
	console.log(Maybe.of(42)); // [ 'Just', 42 ]

	// supports exhaustive pattern matching
	caseOf(Maybe.map(Maybe.of(3), square), {
	<html>
	<head>
	<style>
	body { width: 100%; }
	table { margin: auto; border-spacing: 1rem; }
	button { padding: 1rem; }
	</style>
	</head>
	<body>
	<table>
	/**
	* Copyright (c) 2022 Chris Baker
	*
	* 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:
	*
	import type { Fluent } from "./fluent";

	export class User {
	public id: string;
	public username: string;

	private constructor() {
	this.id = "";
	this.username = "";
	}
	export type KeysOfParams<S extends string> =
	S extends `${infer Before} :${infer Name} ${infer After}`
	? KeysOfParams<Before> \| Name \| KeysOfParams<After>
	: S extends `:${infer Name} ${infer After}`
	? Name \| KeysOfParams<After>
	: S extends `${infer Before} :${infer Name}`
	? KeysOfParams<Before> \| Name
	: S extends `:${infer Name}`
	? Name
	: never;
	export class Statistics {
	private static ensureNotEmpty(arr: readonly number[]): void {
	if (arr.length === 0) {
	throw new Error("The array must not be empty.");
	}
	}

	static asc(a: number, b: number): number {
	return a - b;
	}
	import { JobQueue } from "./job-queue";

	export interface Device {
	send(command: string): Promise<void>;
	}

	const sleep = (ms: number) => new Promise<void>((fn) => setTimeout(fn, ms));

	export class AsyncDevice implements Device {
	async send(command: string): Promise<void> {
	export type Constructor<T> = new (...args: any[]) => T;

	export interface Mixin<Features, Requirements = any> {
	<T extends Constructor<Requirements>>(Base: T): T & Constructor<Features>;
	}