@gershy/clearing 0.0.6 → 0.0.7

package/cmp/mjs/main.js

@@ -1,149 +1,113 @@
 const applyClearing = (() => {
     const global = globalThis;
     // Prevent multiple installations...
-    const memSym = Symbol.for('clearing:mem');
+    const pfx = '@gershy/clearing';
+    const memSym = Symbol.for(`${pfx}:mem`);
     if (global[memSym])
         return;
     global[memSym] = true;
-    const symNames = ['add', 'at', 'apart', 'assert', 'bind', 'bits', 'built', 'char', 'code', 'count', 'cut', 'dive', 'empty', 'fire', 'group', 'has', 'hasHead', 'hasTail', 'indent', 'isInt', 'limn', 'lower', 'mod', 'map', 'mapk', 'merge', 'padHead', 'padTail', 'rem', 'find', 'slash', 'slice', 'suppress', 'toArr', 'toNum', 'toObj', 'toStr', 'upper'];
-    const syms = Object.fromEntries(symNames.map(term => [term, Symbol(`clearing:${term}`)]));
-    const sovereign = v => v;
-    Object.assign(global, {
-        // Reference native constructors
-        AsyncFunction: (async () => { }).constructor,
-        GeneratorFunction: (function* () { })().constructor,
-        AsyncGeneratorFunction: (async function* () { })().constructor,
-        // Symbols
-        ...syms,
-        // Forms
-        getFormName: f => {
-            if (f === null)
-                return 'Null';
-            if (f === undefined)
-                return 'Undef';
-            if (f !== f)
-                return 'UndefNum';
-            return Object.getPrototypeOf(f)?.constructor.name ?? 'Prototypeless'; // e.g. `getFormName(Object.plain()) === 'Prototypeless'`
-        },
-        getForm: f => Object.getPrototypeOf(f)?.constructor ?? null,
-        isForm: (fact, Form) => {
-            // NaN only matches against the NaN primitive (not the Number Form)
-            if (fact !== fact)
-                return Form !== Form;
-            if (fact == null)
-                return false;
-            return Object.getPrototypeOf(fact).constructor === Form;
-        },
-        hasForm: (fact, Form) => fact instanceof Form,
-        // Utility
-        skip: undefined,
-        sovereign,
-        then: (val, rsv = Function.stub, rjc) => {
-            // Act on `val` regardless of whether it's a Promise or an immediate
-            // value; return `rsv(val)` either immediately or as a Promise;
-            // Promises are returned with `then`/`fail` handling
-            if (hasForm(val, Promise))
-                return val.then(rsv).catch(rjc);
-            // No `rjc` means no `try`/`catch` handling
-            if (!rjc)
-                return rsv(val);
-            try {
-                return rsv(val);
-            }
-            catch (err) {
-                return rjc(err);
-            }
-        },
-        safe: (val, acc = Function.stub, rjc) => {
-            try {
-                return then(val(), acc, rjc);
+    const symNames = [
+        // <SYMBOLS>
+        'add',
+        'allArr',
+        'allObj',
+        'at',
+        'assert',
+        'base32',
+        'base36',
+        'base62',
+        'base64Std',
+        'base64Url',
+        'baseline',
+        'bind',
+        'bits',
+        'char',
+        'charset',
+        'code',
+        'count',
+        'cut',
+        'dive',
+        'empty',
+        'find',
+        'fire',
+        'group',
+        'has',
+        'hasHead',
+        'hasTail',
+        'indent',
+        'int32',
+        'int64',
+        'isInt',
+        'later',
+        'limn',
+        'lower',
+        'map',
+        'mapk',
+        'merge',
+        'mod',
+        'padHead',
+        'padTail',
+        'rem',
+        'slash',
+        'slice',
+        'suppress',
+        'toArr',
+        'toNum',
+        'toObj',
+        'toStr',
+        'upper'
+        // </SYMBOLS>
+    ];
+    const syms = Object.fromEntries(symNames.map(term => [term, Symbol(`${pfx}:${term}`)]));
+    const getClsName = i => {
+        if (i === null)
+            return 'Null';
+        if (i === undefined)
+            return 'Undef';
+        if (i !== i)
+            return 'Nan';
+        return Object.getPrototypeOf(i)?.constructor.name ?? 'Prototypeless';
+    };
+    const getCls = i => Object.getPrototypeOf(i)?.constructor ?? null;
+    const isCls = (i, C) => {
+        // NaN only matches against the NaN primitive (not the Number Form)
+        if (i !== i)
+            return C !== C;
+        // `null` and `undefined` only match to themselves
+        if (i == null)
+            return i === C;
+        // Otherwise strictly check the constructor
+        return Object.getPrototypeOf(i).constructor === C;
+    };
+    const inCls = (i, C) => i instanceof C;
+    const skip = undefined;
+    Object.assign(global, { ...syms, clearing: { getClsName, getCls, isCls, inCls } });
+    const protoDefs = (Cls, def) => {
+        let protoVals = [];
+        let classVals = [];
+        for (const key of Reflect.ownKeys(def)) {
+            if (key !== '$' && !isCls(key, Symbol))
+                throw Object.assign(Error('invalid proto key'), { Cls, keyClsName: getClsName(key), key });
+            if (key !== '$') {
+                protoVals.push([key, def[key]]);
             }
-            catch (err) {
-                if (!rjc)
-                    throw err;
-                return rjc(err);
+            else {
+                for (const k of Reflect.ownKeys(def[key])) {
+                    if (!isCls(k, Symbol))
+                        throw Object.assign(Error('invalid class key'), { Cls, keyClsName: getClsName(k), key: k });
+                    classVals.push([k, def[key][k]]);
+                }
             }
-        },
-        // Jsfn
-        jsfn: {
-            encode: sovereign((dec /* `val` is still not allowed to have cycles! */, opts) => {
-                const encodeFn = opts?.encodeFn ?? (fn => fn.toString());
-                const hoists = [];
-                const serializeObjKey = (key) => {
-                    if (/^[$_a-zA-Z][$_a-zA-Z]+$/.test(key))
-                        return key;
-                    return `'${key.replaceAll(`'`, `\\'`)}'`;
-                };
-                const serialize = (val) => {
-                    if (isForm(val, Object) && Object.keys(val).sort().join(',') === 'args,form,hoist' && hasForm(val.form, Function)) {
-                        const { args, form, hoist } = val;
-                        hoists.push(hoist);
-                        return `new ${hoist.split('::').at(-1)}(${args.map(a => serialize(a)).join(', ')})`;
-                    }
-                    if (isForm(val, Array))
-                        return '[' + val.map((v) => serialize(v)).join(',') + ']';
-                    if (isForm(val, Object))
-                        return '{' + val[toArr]((v, k) => `${serializeObjKey(k)}:${serialize(v)}`).join(',') + '}';
-                    if (hasForm(val, Function))
-                        return encodeFn(val);
-                    return JSON.stringify(val);
-                };
-                return {
-                    // Note `str` is stringified, but it isn't json - it's js, in string representation!!
-                    // This representation is actually very simple - in order to run the js represented by
-                    // `str`, all hoists need to be imported in the context
-                    hoists,
-                    str: serialize(dec)
-                };
-            })
-        },
-    });
-    const protoDefs = (Cls, def) => {
-        const protoVals = [];
-        const classVals = [];
-        for (const key of Reflect.ownKeys(def) /* includes symbols!! */) {
-            if (!isForm(key, String))
-                protoVals.push({ key, val: def[key] });
-            else if (key.startsWith('$'))
-                classVals.push({ key: key.slice(1), val: def[key] });
-            else if (key.endsWith('->'))
-                protoVals.push({ key: def[key], val: Cls.prototype[key.slice(0, -2)] });
         }
         // Assign class properties
-        Object.assign(Cls, Object.fromEntries(classVals.map(({ key, val }) => [key, val])));
-        // Avoid making more properties available on `global` - if a typo winds up referring to a
-        // global property, the bug which results can be highly unexpected!
-        // TODO: Note, we don't want to populate the global namespace, *but* we still populate all the
-        // symbols keyed by string name on `global` (note the *symbol* is keyed by its *string name* on
-        // `global` - i.e., `global['toArr']` results in `Symbol('clearing.toArr')`! This results in
-        // many dozens of keys being populated in global namespace... should probably move these
-        // symbols to a module import instead :(
-        if (Cls === global.constructor)
-            for (const entry of protoVals)
-                if (isForm(entry.key, String))
-                    global[entry.key] = skip;
-        // Assign proto properties
-        Object.defineProperties(Cls.prototype, Object.fromEntries(protoVals
-            .map(({ key, val }) => [key, { enumerable: false, writable: true, value: val }])));
+        for (const [target, props] of [[Cls, classVals], [Cls.prototype, protoVals]])
+            for (const [sym, value] of props)
+                Object.defineProperty(target, sym, { enumerable: false, value });
     };
     protoDefs(Object, {
-        $stub: Object.freeze({}),
-        $plain: obj => obj ? Object.assign(Object.create(null), obj) : Object.create(null),
-        'hasOwnProperty->': has,
-        *[apart](dive = []) {
-            // Breaks apart a "structured" object into a flat list of dive keys paired with values; every
-            // value in the original object appears alongside the "dive" (chain of keys to recursively
-            // apply) required to dereference it
-            for (const [k, val] of this) {
-                if (isForm(val, Object))
-                    yield* val[apart]([...dive, k]);
-                else
-                    yield { dive: [...dive, k], val };
-            }
-        },
         [at](cmps, def = skip) {
             let ptr = this;
-            if (!isForm(cmps, Array))
+            if (!isCls(cmps, Array))
                 cmps = [cmps];
             for (const c of cmps) {
                 if (ptr[has](c))
@@ -153,23 +117,29 @@ const applyClearing = (() => {
             }
             return ptr;
         },
-        [built](diveFromKey = (key) => key.split('.')) {
-            // The reverse operation of `apart` - takes a flat list of (dive, value) pairs and produces a
-            // structured object
-            const result = {};
+        [count]() { let c = 0; for (const k in this)
+            c++; return c; },
+        [empty]() { for (const k in this)
+            return false; return true; },
+        [group](fn) {
+            //  { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10 }.group(n => {
+            //    if (n < 4) return 'small';
+            //    if (n < 8) return 'medium';
+            //    return 'big';
+            //  });
+            //  >> { small: { a: 1, b: 2, c: 3 }, medium: { d: 4, e: 5, f: 6, g: 7 }, big: { h: 8, i: 9, j: 10 } }
+            const ret = {};
             for (const [k, v] of this) {
-                const dive = diveFromKey(k);
-                const last = dive.pop();
-                let ptr = result;
-                for (const cmp of dive)
-                    ptr = ptr[at](cmp) ?? (ptr[cmp] = {});
-                ptr[last] = isForm(v, Object) ? v[built]() : v;
+                const g = fn(v, k);
+                if (g === skip)
+                    continue;
+                if (!ret[has](g))
+                    ret[g] = {};
+                ret[g][k] = v;
             }
-            return result;
+            return ret;
         },
-        [count]() { let c = 0; for (const k in this)
-            c++; return c; },
-        [dive](cmps, def = skip) { return this[at](cmps, def); },
+        [has]: Object.prototype.hasOwnProperty,
         [map](fn) {
             const ret = Object.assign({}, this);
             for (const k in ret) {
@@ -190,44 +160,6 @@ const applyClearing = (() => {
             }
             return Object.fromEntries(arr);
         },
-        [toArr](fn) {
-            const ret = [];
-            for (const k in this) {
-                const r = fn(this[k], k);
-                if (r !== skip)
-                    ret.push(r);
-            }
-            return ret;
-        },
-        [slash](p) {
-            const obj = { ...this };
-            for (const k of p)
-                delete obj[k];
-            return obj;
-        },
-        [slice](p) {
-            // >> { a: 1, b: 2, c: 3, d: 4 }.slice([ 'b', 'd' ]);
-            // { b: 2, d: 4 }
-            return p[toObj](p => this[has](p) ? [p, this[p]] : skip);
-        },
-        [empty]() { for (const k in this)
-            return false; return true; },
-        [group](fn) {
-            //  { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10 }.group(n => {
-            //    if (n < 4) return 'small';
-            //    if (n < 8) return 'medium';
-            //    return 'big';
-            //  });
-            //  >> { small: { a: 1, b: 2, c: 3 }, medium: { d: 4, e: 5, f: 6, g: 7 }, big: { h: 8, i: 9, j: 10 } }
-            const ret = {};
-            for (const [k, v] of this) {
-                const t = fn(v, k);
-                if (!ret[has](t))
-                    ret[t] = {};
-                ret[t][k] = v;
-            }
-            return ret;
-        },
         [merge](o) {
             for (const [k, v] of o) {
                 // `skip` can be passed to remove properties
@@ -236,46 +168,45 @@ const applyClearing = (() => {
                     continue;
                 }
                 // Incoming non-Object properties are simple
-                if (!isForm(v, Object)) {
+                if (!isCls(v, Object)) {
                     this[k] = v;
                     continue;
                 }
                 // `v` is an Object; existing non-Object replaced with `{}`
-                if (!this[has](k) || !isForm(this[k], Object))
+                if (!this[has](k) || !isCls(this[k], Object))
                     this[k] = {};
                 // And simply recurse!
                 this[k][merge](v);
             }
             return this;
         },
-        *[Symbol.iterator]() { for (const k in this)
-            yield [k, this[k]]; }
-    });
-    protoDefs(Array, {
-        $stub: Object.freeze([]),
-        'includes->': has,
-        [has](v) { return this.includes(v); },
-        [map](it) {
-            const ret = [];
-            const len = this.length;
-            for (let i = 0; i < len; i++) {
-                const r = it(this[i], i);
-                if (r !== skip)
-                    ret.push(r);
-            }
-            return ret;
+        [slash](p) {
+            const obj = { ...this };
+            for (const k of p)
+                delete obj[k];
+            return obj;
         },
-        [toArr](it) { return this[map](it); },
-        [toObj](it) {
+        [slice](p) {
+            // >> { a: 1, b: 2, c: 3, d: 4 }.slice([ 'b', 'd' ]);
+            // { b: 2, d: 4 }
+            return p[toObj](p => this[has](p) ? [p, this[p]] : skip);
+        },
+        [toArr](fn) {
             const ret = [];
-            const len = this.length;
-            for (let i = 0; i < len; i++) {
-                const r = it(this[i], i);
+            for (const k in this) {
+                const r = fn(this[k], k);
                 if (r !== skip)
                     ret.push(r);
             }
-            return Object.fromEntries(ret);
+            return ret;
         },
+        *[Symbol.iterator]() { for (const k in this)
+            yield [k, this[k]]; }
+    });
+    protoDefs(Array, {
+        [add](...args) { this.push(...args); return args[0]; },
+        [count]() { return this.length; },
+        [empty]() { return !this.length; },
         [find](f) {
             const n = this.length;
             for (let i = 0; i < n; i++)
@@ -283,11 +214,6 @@ const applyClearing = (() => {
                     return { found: true, val: this[i], ind: i };
             return { found: false, val: null, ind: null };
         },
-        [empty]() { return !this.length; },
-        [add](...args) { this.push(...args); return args[0]; },
-        [rem](val) { const ind = this.indexOf(val); if (ind > -1)
-            this.splice(ind, 1); },
-        [count]() { return this.length; },
         [group](fn) {
             //  [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ].group(n => {
             //    if (n < 4) return 'small';
@@ -297,56 +223,78 @@ const applyClearing = (() => {
             //  >> { small: [ 1, 2, 3 ], medium: [ 4, 5, 6, 7 ], big: [ 8, 9, 10 ] }
             const ret = {};
             for (const elem of this) {
-                const t = fn(elem);
-                if (!ret[has](t))
-                    ret[t] = [];
-                ret[t].push(elem);
+                const g = fn(elem);
+                if (g === skip)
+                    continue;
+                if (!ret[has](g))
+                    ret[g] = [];
+                ret[g].push(elem);
+            }
+            return ret;
+        },
+        [has]: Array.prototype.includes,
+        [map](it) {
+            const ret = [];
+            const len = this.length;
+            for (let i = 0; i < len; i++) {
+                const r = it(this[i], i);
+                if (r !== skip)
+                    ret.push(r);
             }
             return ret;
+        },
+        [rem](val) { const ind = this.indexOf(val); if (ind > -1)
+            this.splice(ind, 1); },
+        [toObj](it) {
+            const ret = [];
+            const len = this.length;
+            for (let i = 0; i < len; i++) {
+                const r = it(this[i], i);
+                if (r !== skip)
+                    ret.push(r);
+            }
+            return Object.fromEntries(ret);
         }
     });
     protoDefs(String, {
-        $baseline: (str, seq = '| ') => {
-            return str.split('\n')[map](ln => {
-                const ind = ln.indexOf(seq);
-                if (ind === -1)
-                    return skip;
-                return ln.slice(ind + seq.length);
-            }).join('\n');
-        },
-        $charset: str => {
-            const cache = new Map();
-            return {
-                str,
-                size: BigInt(str.length),
-                charVal: (c) => {
-                    if (!cache.has(c)) {
-                        const ind = str.indexOf(c);
-                        if (ind < 0)
-                            throw Error('char outside charset')[mod]({ char: c });
-                        cache.set(c, BigInt(ind));
+        $: {
+            [baseline]: (str, seq = '| ') => {
+                return str.split('\n')[map](ln => {
+                    const ind = ln.indexOf(seq);
+                    if (ind === -1)
+                        return skip;
+                    return ln.slice(ind + seq.length);
+                }).join('\n');
+            },
+            [base32]: '0123456789abcdefghijklmnopqrstuv',
+            [base36]: '0123456789abcdefghijklmnopqrstuvwxyz',
+            [base62]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+            [base64Url]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_',
+            [base64Std]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/',
+            [charset]: str => {
+                const cache = new Map();
+                return {
+                    str,
+                    size: BigInt(str.length),
+                    charVal: (c) => {
+                        if (!cache.has(c)) {
+                            const ind = str.indexOf(c);
+                            if (ind < 0)
+                                throw Error('char outside charset')[mod]({ char: c });
+                            cache.set(c, BigInt(ind));
+                        }
+                        return cache.get(c);
+                    },
+                    valChar: (n) => {
+                        if (n < 0 || n >= str.length)
+                            throw Error('val outside charset');
+                        return str[n];
                     }
-                    return cache.get(c);
-                },
-                valChar: (n) => {
-                    if (n < 0 || n >= str.length)
-                        throw Error('val outside charset');
-                    return str[n];
-                }
-            };
+                };
+            },
         },
-        $base32: '0123456789abcdefghijklmnopqrstuv',
-        $base36: '0123456789abcdefghijklmnopqrstuvwxyz',
-        $base62: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
-        $base64: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_',
-        $base64Std: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/',
-        'includes->': has,
-        'startsWith->': hasHead,
-        'endsWith->': hasTail,
-        'padStart->': padHead,
-        'padEnd->': padTail,
-        'toUpperCase->': upper,
-        'toLowerCase->': lower,
+        [code](ind = 0) { return this.charCodeAt(ind); },
+        [count]() { return this.length; },
         [cut](delim, cuts = 1) {
             // `cuts` defines # of cuts (resulting array length is `num + 1`)
             const split = this.split(delim, cuts < Infinity ? cuts : skip);
@@ -358,13 +306,14 @@ const applyClearing = (() => {
                 ? [...split, this.slice(lenConsumed + delim.length)]
                 : split;
         },
-        [code](ind = 0) { return this.charCodeAt(ind); },
-        [count]() { return this.length; },
+        [has]: String.prototype.includes,
+        [hasHead]: String.prototype.startsWith,
+        [hasTail]: String.prototype.endsWith,
         [indent](...args /* amt=2, char=' ' | indentStr=' '.repeat(2) */) {
             if (!this)
                 return this; // No-op on empty String (otherwise it would transform a 0-line string to a 1-line string)
             let indentStr;
-            if (isForm(args[0], String)) {
+            if (isCls(args[0], String)) {
                 indentStr = args[0];
             }
             else {
@@ -373,10 +322,13 @@ const applyClearing = (() => {
             }
             return this.split('\n')[map](ln => `${indentStr}${ln}`).join('\n');
         },
-        [toNum](charset = String.base62) {
-            if (isForm(charset, String))
-                charset = String.charset(charset);
-            const base = charset.size;
+        [lower]: String.prototype.toLowerCase,
+        [padHead]: String.prototype.padStart,
+        [padTail]: String.prototype.padEnd,
+        [toNum](cs = String[base62]) {
+            if (isCls(cs, String))
+                cs = String[charset](cs);
+            const base = cs.size;
             if (base === 1n)
                 return this.count();
             let sum = 0n;
@@ -385,14 +337,15 @@ const applyClearing = (() => {
                 // Earlier values of `i` represent higher places same as with written numbers further left
                 // digits are more significant
                 // The value of the place `i` is `ind - 1`
-                sum += (base ** BigInt(n - ind - 1)) * charset.charVal(this[ind]);
+                sum += (base ** BigInt(n - ind - 1)) * cs.charVal(this[ind]);
             return sum;
-        }
+        },
+        [upper]: String.prototype.toUpperCase,
     });
     protoDefs(Number, {
-        $int32: Math.pow(2, 32),
-        $int64: Math.pow(2, 64),
+        $: { [int32]: 2 ** 32, [int64]: 2 ** 64 },
         [char]() { return String.fromCharCode(this); },
+        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it disrupts Infinity
         [toArr](fn) { const arr = new Array(this || 0); for (let i = 0; i < this; i++)
             arr[i] = fn(i); return arr; },
         [toObj](fn) {
@@ -404,55 +357,67 @@ const applyClearing = (() => {
             }
             return Object.fromEntries(ret);
         },
-        [toStr](charset, padLen = 0) {
+        [toStr](cs, padLen = 0) {
             // Note that base-1 requires 0 to map to the empty string. This also
             // means that, for `n >= 1`:
             //      |       (n).encodeStr(singleChr)
             // is always equivalent to
             //      |       singleChr.repeat(n - 1)
-            if (isForm(charset, String))
-                charset = String.charset(charset);
-            const base = charset.size;
+            if (isCls(cs, String))
+                cs = String[charset](cs);
+            const base = cs.size;
             if (base === 1n && padLen)
                 throw Error(`pad with base-1 encoding`);
             if (this !== this)
-                return (base === 1n) ? '' : charset[0].repeat(Math.max(padLen, 1));
+                return (base === 1n) ? '' : cs[0].repeat(Math.max(padLen, 1));
             let num = this.constructor === BigInt ? this : BigInt(Math.floor(this));
             const digits = [];
             while (num) {
-                digits.push(charset.valChar(num % base));
+                digits.push(cs.valChar(num % base));
                 num /= base;
             }
-            return digits.reverse().join('')[padHead](padLen, charset.str[0]);
+            return digits.reverse().join('')[padHead](padLen, cs.str[0]);
         },
-        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it disrupts Infinity
-        *[Symbol.iterator]() { Error.assert({ n: this }, args => args.n.isInteger()); for (let i = 0; i < this; i++)
+        *[Symbol.iterator]() { for (let i = 0; i < this; i++)
             yield i; },
         *[bits]() { let n = this >= 0 ? this : -this; while (n) {
             yield n & 1;
             n = n >> 1;
-        } },
-        [map]: undefined // Prevent `Number(...).map`
+        } }
     });
     protoDefs(BigInt, { [toStr]: Number.prototype[toStr] });
     protoDefs(Function, {
-        $stub: v => v,
         [bind](...args) { return this.bind(null, ...args); }
     });
     protoDefs(Error, {
-        $stackTraceLimit: 150,
-        $assert: (args, fn) => {
-            if (fn(args))
-                return;
-            throw Error('assert failed')[mod]({
-                fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
-                args
-            });
+        $: {
+            [assert]: (args, fn) => {
+                if (fn(args))
+                    return;
+                throw Error('assert failed')[mod]({
+                    fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
+                    args
+                });
+            },
+        },
+        [fire](props /* { cause, msg, message, ...more } */) { throw this[mod](props); },
+        [limn](seen = new Map()) {
+            if (seen.has(this))
+                return seen.get(this);
+            seen.set(this, 'cycle(Error)');
+            const { message, stack, cause, ...props } = this;
+            return {
+                form: getClsName(this),
+                msg: message,
+                trace: stack?.split('\n').slice(1)[map](v => v.trim() ?? skip) ?? [],
+                ...props,
+                cause: !cause ? null : cause[limn](seen)
+            };
         },
         [mod](props = {} /* { cause, msg, message, ...more } */) {
-            if (isForm(props, Function))
+            if (isCls(props, Function))
                 props = props(this.message, this);
-            if (isForm(props, String))
+            if (isCls(props, String))
                 props = { message: props };
             const { cause = null, msg = null, message = msg ?? this.message, ...moreProps } = props;
             // - Assign `cause` to transfer props like fs "code" props, etc. - watch out, `cause` may be
@@ -460,56 +425,47 @@ const applyClearing = (() => {
             // - Assign `moreProps` to transfer any other properties
             // - Add `message` prop
             // - Only add `cause` prop if `cause` is non-null
-            return Object.assign(this, hasForm(cause, Error) ? cause : {}, moreProps, cause ? { message, cause } : { message });
+            return Object.assign(this, inCls(cause, Error) ? cause : {}, moreProps, cause ? { message, cause } : { message });
         },
-        [fire](props /* { cause, msg, message, ...more } */) { throw this[mod](props); },
         [suppress]() {
             this[Symbol.for('clearing.err.suppressed')] = true;
             if (this.cause) {
-                const causes = hasForm(this.cause, Error) ? [this.cause] : this.cause;
+                const causes = inCls(this.cause, Error) ? [this.cause] : this.cause;
                 for (const err of causes)
                     err[suppress]();
             }
             return this;
-        },
-        [limn](seen = new Map()) {
-            if (seen.has(this))
-                return seen.get(this);
-            seen.set(this, 'cycle(Error)');
-            const { message, stack, cause, ...props } = this;
-            return {
-                form: getFormName(this),
-                msg: message,
-                trace: stack?.split('\n').slice(1)[map](v => v.trim() ?? skip) ?? [],
-                ...props,
-                cause: !cause ? null : cause[limn](seen)
-            };
         }
     });
     protoDefs(Promise, {
-        $resolve: Promise.resolve,
-        $reject: Promise.reject,
-        $all: Promise.all,
-        $allArr: Promise.all,
-        $later: (resolve, reject) => {
-            const p = new Promise((...a) => [resolve, reject] = a);
-            return Object.assign(p, { resolve, reject });
-        },
-        $allObj: (obj) => {
-            // Need to get `keys` here in case `obj` mutates before resolution
-            const keys = Object.keys(obj);
-            return Promise.allArr(Object.values(obj)).then(vals => {
-                const ret = {};
-                for (const [i, k] of keys.entries())
-                    if (vals[i] !== skip)
-                        ret[k] = vals[i];
-                return ret;
-            });
+        $: {
+            [allArr]: Promise.all,
+            [allObj]: (obj) => {
+                // Need to get `keys` immediately, in case `obj` mutates before resolution
+                const keys = Object.keys(obj);
+                return Promise.all(Object.values(obj)).then(vals => {
+                    const ret = {};
+                    for (const [i, k] of keys.entries())
+                        if (vals[i] !== skip)
+                            ret[k] = vals[i];
+                    return ret;
+                });
+            },
+            [later]: (resolve, reject) => {
+                const p = new Promise((...a) => [resolve, reject] = a);
+                return Object.assign(p, { resolve, reject });
+            }
         }
     });
     protoDefs(Set, {
-        $stub: { count: () => 0, add: Function.stub, rem: Function.stub, has: () => false, values: () => Array.stub },
-        'delete->': rem,
+        [count]() { return this.size; },
+        [empty]() { return !this.size; },
+        [find](fn) {
+            for (const val of this)
+                if (fn(val))
+                    return { found: true, val };
+            return { found: false, val: null };
+        },
         [map](fn) {
             const ret = [];
             let ind = 0;
@@ -520,14 +476,7 @@ const applyClearing = (() => {
             }
             return ret;
         },
-        [find](fn) {
-            for (const val of this)
-                if (fn(val))
-                    return { found: true, val };
-            return { found: false, val: null };
-        },
-        [count]() { return this.size; },
-        [empty]() { return !this.size; },
+        [rem]: Set.prototype.delete,
         [toArr](fn) {
             const ret = [];
             let ind = 0;
@@ -549,27 +498,16 @@ const applyClearing = (() => {
         }
     });
     protoDefs(Map, {
-        $stub: { count: () => 0, set: Function.stub, rem: Function.stub, has: () => false, values: () => Array.stub },
-        'set->': add,
-        'delete->': rem,
-        [map](fn) {
-            const ret = [];
-            for (const [k, v] of this) {
-                const r = fn(v, k);
-                if (r !== skip)
-                    ret.push(r);
-            }
-            return Object.fromEntries(ret);
-        },
+        [add]: Map.prototype.set,
+        [count]() { return this.size; },
+        [empty]() { return !this.size; },
         [find](fn) {
             for (const [k, v] of this)
                 if (fn(v, k))
                     return { found: true, val: v, key: k };
             return { found: false, val: null, key: null };
         },
-        [count]() { return this.size; },
-        [empty]() { return !this.size; },
-        [toObj](fn) {
+        [map](fn) {
             const ret = [];
             for (const [k, v] of this) {
                 const r = fn(v, k);
@@ -578,6 +516,7 @@ const applyClearing = (() => {
             }
             return Object.fromEntries(ret);
         },
+        [rem]: Map.prototype.delete,
         [toArr](fn) {
             const ret = [];
             for (const [k, v] of this) {
@@ -586,18 +525,15 @@ const applyClearing = (() => {
                     ret.push(r);
             }
             return ret;
-        }
-    });
-    protoDefs(GeneratorFunction, {
-        [toArr](fn) { return [...this][map](fn); },
+        },
         [toObj](fn) {
-            const ret = {};
-            for (const v of this) {
-                const r = fn(v);
+            const ret = [];
+            for (const [k, v] of this) {
+                const r = fn(v, k);
                 if (r !== skip)
-                    ret[r[0]] = r[1];
+                    ret.push(r);
             }
-            return ret;
+            return Object.fromEntries(ret);
         }
     });
 });