Dmitry Iv. dy

Convert C file to wasm, example: https://github.com/jdh8/metallic

clang --target=wasm32 -pipe -O3 -Wall -flto  -I path/to/include -c ./pow.c -o ./pow.o 
llvm-lto ./pow.o -o ./pow.wasm --exported-symbol=pow
wasm2wat -f ./pow.wasm

Note: can use https://webassembly.github.io/wabt/demo/wasm2wat/ to convert back to text. Note: that for .h files you may want to create wrappers.

Params order

First taken from stack as block, then augmented with inline param.

(func $x (param i32 i32 i32))
...
(i32.const 0)(i32.const 1) (call $x (i32.const 3))

;; converts to

() => {} is not the same as () => void.
{a?: string | undefined} is tautology.
void | undefined | {} | never | null is tautology.
Native types Record, Partial etc are a bunch of internal jargon, meaningless from JS view.
Interfaces and types are same thing differently named, only creates confusion.
unknown vs any: little who cares about the difference.
JSX.Element, React.ReactNode, React.ReactFragment is tautology
const X = {abc:123} as const

If there is //@ts-ignore on the first line, prettier may split it to multiple lines and break ts this way.
Prettier expands inline constructs into ugly multiline vertical parts (myriads of examples)
Prettier breaks matrices formatting
It produces redundant diff logs, making it hard to analyze logic changes


	// based on https://github.com/WebReflection/not-so-weak/
	const refs = new WeakMap;

	const set = value => {
	const ref = new WeakRef(value);
	refs.set(value, ref);
	return ref;
	};


	// web codec API (one day, hopefully)
	const codecConfig = {
	codec: 'mp3',
	sampleRate: 48000,
	numberOfChannels: 2,
	description: new ArrayBuffer
	}
	let chunk = new EncodedAudioChunk({
	type: 'key',

	// what if we had simple method on elements, taking in VDOM pieces?
	// * it makes sure there's no internal content that messes up rendering
	// * it allows simple function as input - something prohibited by preact
	// * it enables element existence check

	element?.render(({props}) => <div></div>);
	element?.render(<div></div>);
	element?.render(<Element></Element>);
	function Element({props}) { ... }

	// extension of document fragment, keeps references to children
	// based on https://github.com/WebReflection/document-persistent-fragment/blob/master/esm/document-persistent-fragment.js

	class Bug extends DocumentFragment {}
	const shenanigans = !(new Bug instanceof Bug);

	export default class HyperFragment extends DocumentFragment {
	#nodes = []

	// DocumentFragment overrides

	;; test passing array to and back
	(module
	(import "js" "mem" (memory 1))
	(import "console" "log" (func $log (param i32 f32)))

	(global $blockSize (import "js" "blockSize") (mut i32))
	(global $len (mut i32) (i32.const 0))
	;; len = blockSize * 4
	(func (global.set $len (i32.mul (global.get $blockSize) (i32.const 4))))
	(start 1)

	<!DOCTYPE html>
	<a href="https://twitter.com/jviide/status/1257755526722662405">ref</a>
	<script type="module">
	import t from './libs/tst.js'

	// function μ(h,...d){for(var a=[],g=0,f=0,b=-1,c;c=h[g++];)c--?c--?c--?c--?c--?a[++b]=c--?c--?[d[f++],c?{}:null]:1<g\|\|[]:d[f++]:a[b]=this(...a[b]):Object.assign(a[b][1],d[f++]):a[b-1].push(a[b--]):a[b-2][1][a[b--]]=a[b--]:a[b-1]+=""+a[b--];return a[0]}

	function μ(hash, ...fields){
	// [root, tag, props, ...children]
	var stack=[], i=0, f=0, d=-1, c