@gershy/clearing 0.0.23 → 0.0.26

package/cmp/cjs/main.d.ts

@@ -3,7 +3,7 @@ type ClsCheck = {
     (i: unknown, num: BooleanConstructor): i is boolean;
     (i: unknown, num: NumberConstructor): i is number;
     (i: unknown, str: StringConstructor): i is string;
-    (i: unknown, buff: BufferConstructor): i is Buffer;
+    (i: unknown, buff: Buffer): i is Buffer;
     (i: unknown, arr: ArrayConstructor): i is any[];
     (i: unknown, obj: ObjectConstructor): i is Obj<unknown>;
     (i: unknown, fn: FunctionConstructor): i is Fn;

package/cmp/cjs/main.js

@@ -59,6 +59,7 @@ const applyClearing = (() => {
     if (global[memSym])
         return;
     global[memSym] = true;
+    const [enc, dec] = [new TextEncoder(), new TextDecoder()];
     const symNames = [
         // <SYMBOLS> :: definitions :: /[']([a-zA-Z0-9]+)[']/
         'add',
@@ -73,7 +74,6 @@ const applyClearing = (() => {
         'base64Url',
         'baseline',
         'bind',
-        'bits',
         'char',
         'charset',
         'code',
@@ -105,6 +105,7 @@ const applyClearing = (() => {
         'slice',
         'suppress',
         'toArr',
+        'toBin',
         'toNum',
         'toObj',
         'toStr',
@@ -113,29 +114,19 @@ const applyClearing = (() => {
     ];
     const syms = Object.fromEntries(symNames.map(term => [term, Symbol(`${pfx}:${term}`)]));
     Object.assign(global, { ...syms });
-    const protoDefs = (Cls, def) => {
-        let protoVals = [];
-        let classVals = [];
+    const assignSyms = (Cls, def) => {
+        const protoVals = [];
         for (const key of Reflect.ownKeys(def)) {
-            if (key !== '$' && !(0, exports.isCls)(key, Symbol))
+            if (!(0, exports.isCls)(key, Symbol))
                 throw Object.assign(Error('invalid proto key'), { Cls, keyClsName: (0, exports.getClsName)(key), key });
-            if (key !== '$') {
-                protoVals.push([key, def[key]]);
-            }
-            else {
-                for (const k of Reflect.ownKeys(def[key])) {
-                    if (!(0, exports.isCls)(k, Symbol))
-                        throw Object.assign(Error('invalid class key'), { Cls, keyClsName: (0, exports.getClsName)(k), key: k });
-                    classVals.push([k, def[key][k]]);
-                }
-            }
+            protoVals.push([key, def[key]]);
         }
         // Assign class properties
-        for (const [target, props] of [[Cls, classVals], [Cls.prototype, protoVals]])
-            for (const [sym, value] of props)
-                Object.defineProperty(target, sym, { enumerable: false, value });
+        for (const [sym, value] of protoVals)
+            Object.defineProperty(Cls, sym, { enumerable: false, value });
     };
-    protoDefs(Object, {
+    assignSyms(Object, {});
+    assignSyms(Object.prototype, {
         [at](cmps, def = exports.skip) {
             let ptr = this;
             if (!(0, exports.isCls)(cmps, Array))
@@ -234,7 +225,8 @@ const applyClearing = (() => {
         *[Symbol.iterator]() { for (const k in this)
             yield [k, this[k]]; }
     });
-    protoDefs(Array, {
+    assignSyms(Array, {});
+    assignSyms(Array.prototype, {
         [add](...args) { this.push(...args); return args[0]; },
         [count]() { return this.length; },
         [empty]() { return !this.length; },
@@ -287,43 +279,43 @@ const applyClearing = (() => {
             return Object.fromEntries(ret);
         }
     });
-    protoDefs(String, {
-        $: {
-            [baseline]: (str, seq = '| ') => {
-                return str.split('\n')[map](ln => {
-                    const ind = ln.indexOf(seq);
-                    if (ind === -1)
-                        return exports.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];
-                    }
-                };
-            },
+    assignSyms(String, {
+        [baseline]: (str, seq = '| ') => {
+            return str.split('\n')[map](ln => {
+                const ind = ln.indexOf(seq);
+                if (ind === -1)
+                    return exports.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];
+                }
+            };
+        }
+    });
+    assignSyms(String.prototype, {
         [code](ind = 0) { return this.charCodeAt(ind); },
         [count]() { return this.length; },
         [cut](delim, cuts = 1) {
@@ -356,6 +348,7 @@ const applyClearing = (() => {
         [lower]: String.prototype.toLowerCase,
         [padHead]: String.prototype.padStart,
         [padTail]: String.prototype.padEnd,
+        [toBin]() { return enc.encode(this); },
         [toNum](cs = String[base62]) {
             if ((0, exports.isCls)(cs, String))
                 cs = String[charset](cs);
@@ -365,18 +358,17 @@ const applyClearing = (() => {
             let sum = 0n;
             const n = this.length;
             for (let ind = 0; ind < n; ind++)
-                // Earlier values of `i` represent higher places same as with written numbers further left
+                // Earlier values of `i` are more valuable; same as how with written numbers leftmost
                 // digits are more significant
-                // The value of the place `i` is `ind - 1`
                 sum += (base ** BigInt(n - ind - 1)) * cs.charVal(this[ind]);
             return sum;
         },
         [upper]: String.prototype.toUpperCase,
     });
-    protoDefs(Number, {
-        $: { [int32]: 2 ** 32, [int64]: 2 ** 64 },
+    assignSyms(Number, { [int32]: 2 ** 32, [int64]: 2 ** 64 });
+    assignSyms(Number.prototype, {
         [char]() { return String.fromCharCode(this); },
-        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it disrupts Infinity
+        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it fails with +/- Infinity
         [toArr](fn) { const arr = new Array(this || 0); for (let i = 0; i < this; i++)
             arr[i] = fn(i); return arr; },
         [toObj](fn) {
@@ -394,13 +386,13 @@ const applyClearing = (() => {
             //      |       (n).encodeStr(singleChr)
             // is always equivalent to
             //      |       singleChr.repeat(n - 1)
+            if (this !== this)
+                throw Error('nan');
             if ((0, exports.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) ? '' : cs[0].repeat(Math.max(padLen, 1));
             let num = this.constructor === BigInt ? this : BigInt(Math.floor(this));
             const digits = [];
             while (num) {
@@ -409,28 +401,53 @@ const applyClearing = (() => {
             }
             return digits.reverse().join('')[padHead](padLen, cs.str[0]);
         },
+        [toBin]() {
+            if (this !== this)
+                throw Error('nan');
+            const base = 256n;
+            let num = this.constructor === BigInt ? this : BigInt(Math.floor(this));
+            const digits = [];
+            while (num) {
+                digits.push(Number(num % base));
+                num /= base;
+            }
+            return new Uint8Array(digits.reverse());
+        },
         *[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;
-        } }
     });
-    protoDefs(BigInt, { [toStr]: Number.prototype[toStr] });
-    protoDefs(Function, {
-        [bind](...args) { return this.bind(null, ...args); }
+    assignSyms(BigInt, {});
+    assignSyms(BigInt.prototype, { [toStr]: Number.prototype[toStr], [toBin]: Number.prototype[toBin] });
+    assignSyms(ArrayBuffer, {});
+    assignSyms(ArrayBuffer.prototype, {
+        [toStr]() { return dec.decode(this); },
+        [toNum]() { return (new Uint8Array(this))[toNum](); }
     });
-    protoDefs(Error, {
-        $: {
-            [assert]: (args, fn) => {
-                if (fn(args))
-                    return;
-                throw Error('assert failed')[mod]({
-                    fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
-                    args
-                });
-            },
-        },
+    assignSyms(Uint8Array, {});
+    assignSyms(Uint8Array.prototype, {
+        [toStr]() { return dec.decode(this); },
+        [toNum]() {
+            const base = 256n;
+            let sum = 0n;
+            const n = this.length;
+            for (let ind = 0; ind < n; ind++)
+                // Earlier values of `i` are more valuable; same as how with written numbers leftmost
+                // digits are more significant
+                sum += (base ** BigInt(n - ind - 1)) * BigInt(this[ind]);
+            return sum;
+        }
+    });
+    assignSyms(Error, {
+        [assert]: (args, fn) => {
+            if (fn(args))
+                return;
+            throw Error('assert failed')[mod]({
+                fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
+                args
+            });
+        }
+    });
+    assignSyms(Error.prototype, {
         [fire](props /* { cause, msg, message, ...more } */) { throw this[mod](props); },
         [limn](seen = new Map()) {
             if (seen.has(this))
@@ -468,27 +485,27 @@ const applyClearing = (() => {
             return this;
         }
     });
-    protoDefs(Promise, {
-        $: {
-            [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] !== exports.skip)
-                            ret[k] = vals[i];
-                    return ret;
-                });
-            },
-            [later]: (resolve, reject) => {
-                const p = new Promise((...a) => [resolve, reject] = a);
-                return Object.assign(p, { resolve, reject });
-            }
+    assignSyms(Promise, {
+        [allArr]: arr => Promise.all(arr).then(arr => arr.filter(v => v !== exports.skip)),
+        [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] !== exports.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, {
+    assignSyms(Promise.prototype, {});
+    assignSyms(Set, {});
+    assignSyms(Set.prototype, {
         [count]() { return this.size; },
         [empty]() { return !this.size; },
         [find](fn) {
@@ -528,7 +545,8 @@ const applyClearing = (() => {
             return Object.fromEntries(ret);
         }
     });
-    protoDefs(Map, {
+    assignSyms(Map, {});
+    assignSyms(Map.prototype, {
         [add]: Map.prototype.set,
         [count]() { return this.size; },
         [empty]() { return !this.size; },

package/cmp/mjs/main.d.ts

@@ -3,7 +3,7 @@ type ClsCheck = {
     (i: unknown, num: BooleanConstructor): i is boolean;
     (i: unknown, num: NumberConstructor): i is number;
     (i: unknown, str: StringConstructor): i is string;
-    (i: unknown, buff: BufferConstructor): i is Buffer;
+    (i: unknown, buff: Buffer): i is Buffer;
     (i: unknown, arr: ArrayConstructor): i is any[];
     (i: unknown, obj: ObjectConstructor): i is Obj<unknown>;
     (i: unknown, fn: FunctionConstructor): i is Fn;

package/cmp/mjs/main.js

@@ -50,6 +50,7 @@ const applyClearing = (() => {
     if (global[memSym])
         return;
     global[memSym] = true;
+    const [enc, dec] = [new TextEncoder(), new TextDecoder()];
     const symNames = [
         // <SYMBOLS> :: definitions :: /[']([a-zA-Z0-9]+)[']/
         'add',
@@ -64,7 +65,6 @@ const applyClearing = (() => {
         'base64Url',
         'baseline',
         'bind',
-        'bits',
         'char',
         'charset',
         'code',
@@ -96,6 +96,7 @@ const applyClearing = (() => {
         'slice',
         'suppress',
         'toArr',
+        'toBin',
         'toNum',
         'toObj',
         'toStr',
@@ -104,29 +105,19 @@ const applyClearing = (() => {
     ];
     const syms = Object.fromEntries(symNames.map(term => [term, Symbol(`${pfx}:${term}`)]));
     Object.assign(global, { ...syms });
-    const protoDefs = (Cls, def) => {
-        let protoVals = [];
-        let classVals = [];
+    const assignSyms = (Cls, def) => {
+        const protoVals = [];
         for (const key of Reflect.ownKeys(def)) {
-            if (key !== '$' && !isCls(key, Symbol))
+            if (!isCls(key, Symbol))
                 throw Object.assign(Error('invalid proto key'), { Cls, keyClsName: getClsName(key), key });
-            if (key !== '$') {
-                protoVals.push([key, def[key]]);
-            }
-            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]]);
-                }
-            }
+            protoVals.push([key, def[key]]);
         }
         // Assign class properties
-        for (const [target, props] of [[Cls, classVals], [Cls.prototype, protoVals]])
-            for (const [sym, value] of props)
-                Object.defineProperty(target, sym, { enumerable: false, value });
+        for (const [sym, value] of protoVals)
+            Object.defineProperty(Cls, sym, { enumerable: false, value });
     };
-    protoDefs(Object, {
+    assignSyms(Object, {});
+    assignSyms(Object.prototype, {
         [at](cmps, def = skip) {
             let ptr = this;
             if (!isCls(cmps, Array))
@@ -225,7 +216,8 @@ const applyClearing = (() => {
         *[Symbol.iterator]() { for (const k in this)
             yield [k, this[k]]; }
     });
-    protoDefs(Array, {
+    assignSyms(Array, {});
+    assignSyms(Array.prototype, {
         [add](...args) { this.push(...args); return args[0]; },
         [count]() { return this.length; },
         [empty]() { return !this.length; },
@@ -278,43 +270,43 @@ const applyClearing = (() => {
             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');
-            },
-            [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];
-                    }
-                };
-            },
+    assignSyms(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');
         },
+        [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];
+                }
+            };
+        }
+    });
+    assignSyms(String.prototype, {
         [code](ind = 0) { return this.charCodeAt(ind); },
         [count]() { return this.length; },
         [cut](delim, cuts = 1) {
@@ -347,6 +339,7 @@ const applyClearing = (() => {
         [lower]: String.prototype.toLowerCase,
         [padHead]: String.prototype.padStart,
         [padTail]: String.prototype.padEnd,
+        [toBin]() { return enc.encode(this); },
         [toNum](cs = String[base62]) {
             if (isCls(cs, String))
                 cs = String[charset](cs);
@@ -356,18 +349,17 @@ const applyClearing = (() => {
             let sum = 0n;
             const n = this.length;
             for (let ind = 0; ind < n; ind++)
-                // Earlier values of `i` represent higher places same as with written numbers further left
+                // Earlier values of `i` are more valuable; same as how with written numbers leftmost
                 // digits are more significant
-                // The value of the place `i` is `ind - 1`
                 sum += (base ** BigInt(n - ind - 1)) * cs.charVal(this[ind]);
             return sum;
         },
         [upper]: String.prototype.toUpperCase,
     });
-    protoDefs(Number, {
-        $: { [int32]: 2 ** 32, [int64]: 2 ** 64 },
+    assignSyms(Number, { [int32]: 2 ** 32, [int64]: 2 ** 64 });
+    assignSyms(Number.prototype, {
         [char]() { return String.fromCharCode(this); },
-        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it disrupts Infinity
+        [isInt]() { return this === Math.round(this); }, // No bitwise shortcut - it fails with +/- Infinity
         [toArr](fn) { const arr = new Array(this || 0); for (let i = 0; i < this; i++)
             arr[i] = fn(i); return arr; },
         [toObj](fn) {
@@ -385,13 +377,13 @@ const applyClearing = (() => {
             //      |       (n).encodeStr(singleChr)
             // is always equivalent to
             //      |       singleChr.repeat(n - 1)
+            if (this !== this)
+                throw Error('nan');
             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) ? '' : cs[0].repeat(Math.max(padLen, 1));
             let num = this.constructor === BigInt ? this : BigInt(Math.floor(this));
             const digits = [];
             while (num) {
@@ -400,28 +392,53 @@ const applyClearing = (() => {
             }
             return digits.reverse().join('')[padHead](padLen, cs.str[0]);
         },
+        [toBin]() {
+            if (this !== this)
+                throw Error('nan');
+            const base = 256n;
+            let num = this.constructor === BigInt ? this : BigInt(Math.floor(this));
+            const digits = [];
+            while (num) {
+                digits.push(Number(num % base));
+                num /= base;
+            }
+            return new Uint8Array(digits.reverse());
+        },
         *[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;
-        } }
     });
-    protoDefs(BigInt, { [toStr]: Number.prototype[toStr] });
-    protoDefs(Function, {
-        [bind](...args) { return this.bind(null, ...args); }
+    assignSyms(BigInt, {});
+    assignSyms(BigInt.prototype, { [toStr]: Number.prototype[toStr], [toBin]: Number.prototype[toBin] });
+    assignSyms(ArrayBuffer, {});
+    assignSyms(ArrayBuffer.prototype, {
+        [toStr]() { return dec.decode(this); },
+        [toNum]() { return (new Uint8Array(this))[toNum](); }
     });
-    protoDefs(Error, {
-        $: {
-            [assert]: (args, fn) => {
-                if (fn(args))
-                    return;
-                throw Error('assert failed')[mod]({
-                    fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
-                    args
-                });
-            },
-        },
+    assignSyms(Uint8Array, {});
+    assignSyms(Uint8Array.prototype, {
+        [toStr]() { return dec.decode(this); },
+        [toNum]() {
+            const base = 256n;
+            let sum = 0n;
+            const n = this.length;
+            for (let ind = 0; ind < n; ind++)
+                // Earlier values of `i` are more valuable; same as how with written numbers leftmost
+                // digits are more significant
+                sum += (base ** BigInt(n - ind - 1)) * BigInt(this[ind]);
+            return sum;
+        }
+    });
+    assignSyms(Error, {
+        [assert]: (args, fn) => {
+            if (fn(args))
+                return;
+            throw Error('assert failed')[mod]({
+                fn: `false === (${fn.toString().replace(/[\s]+/, ' ')})(args)`,
+                args
+            });
+        }
+    });
+    assignSyms(Error.prototype, {
         [fire](props /* { cause, msg, message, ...more } */) { throw this[mod](props); },
         [limn](seen = new Map()) {
             if (seen.has(this))
@@ -459,27 +476,27 @@ const applyClearing = (() => {
             return this;
         }
     });
-    protoDefs(Promise, {
-        $: {
-            [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 });
-            }
+    assignSyms(Promise, {
+        [allArr]: arr => Promise.all(arr).then(arr => arr.filter(v => v !== skip)),
+        [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, {
+    assignSyms(Promise.prototype, {});
+    assignSyms(Set, {});
+    assignSyms(Set.prototype, {
         [count]() { return this.size; },
         [empty]() { return !this.size; },
         [find](fn) {
@@ -519,7 +536,8 @@ const applyClearing = (() => {
             return Object.fromEntries(ret);
         }
     });
-    protoDefs(Map, {
+    assignSyms(Map, {});
+    assignSyms(Map.prototype, {
         [add]: Map.prototype.set,
         [count]() { return this.size; },
         [empty]() { return !this.size; },

package/cmp/sideEffects.d.ts

@@ -3,11 +3,13 @@ declare global {
   // Util
   type Fn<A extends any[] = any[], T = any> = (...args: A) => T;
   type Obj<V = any> = { [k: string]: V };
+  type Arr<V = any> = V[];
   
   // Differentiate between "map" and "rec" ("record") - maps have arbitrary keys; recs have fixed keys
   type ObjMode<O extends { [K: string]: any }> = O extends { [K in infer KK]: any } ? (string extends KK ? 'map' : 'rec') : never;
   type ObjKeys<O extends Obj> = Extract<keyof O, string> | `${Extract<keyof O, number>}`; // Convert numbers to strings; ignores symbols
   type ObjVals<O extends Obj> = O[Extract<keyof O, string>];
+  type ObjIterator<O extends Obj> = Iterable<[ string, O[keyof O] ]>;
   
   type Json = null | boolean | number | string | Json[] | { [K: string]: Json };
   type Skip = undefined;
@@ -40,7 +42,6 @@ declare global {
   const base64Url: unique symbol;
   const baseline:  unique symbol;
   const bind:      unique symbol;
-  const bits:      unique symbol;
   const char:      unique symbol;
   const charset:   unique symbol;
   const code:      unique symbol;
@@ -72,6 +73,7 @@ declare global {
   const slice:     unique symbol;
   const suppress:  unique symbol;
   const toArr:     unique symbol;
+  const toBin:     unique symbol;
   const toNum:     unique symbol;
   const toObj:     unique symbol;
   const toStr:     unique symbol;
@@ -95,7 +97,6 @@ declare global {
     [base64Url]: undefined,
     [baseline]:  undefined,
     [bind]:      undefined,
-    [bits]:      undefined,
     [char]:      undefined,
     [charset]:   undefined,
     [code]:      undefined,
@@ -127,6 +128,7 @@ declare global {
     [slice]:     undefined,
     [suppress]:  undefined,
     [toArr]:     undefined,
+    [toBin]:     undefined,
     [toNum]:     undefined,
     [toObj]:     undefined,
     [toStr]:     undefined,
@@ -138,8 +140,8 @@ declare global {
     [assert]: <V = any>(args: V, fn: (args: V) => boolean) => void
   }
   interface Error extends SymbolsProto {
-    [mod]:      (props: { [K: string]: any }) => Error,
-    [fire]:     (props?: { [K: string]: any }) => never,
+    [mod]:      (props:  string | Obj<any> | ((msg: string, err: Error) => Obj<any>)) => Error,
+    [fire]:     (props?: string | Obj<any> | ((msg: string, err: Error) => Obj<any>)) => never,
     [suppress]: () => Error,
     [limn]: (seen?: Map<any, any>) => (Obj<Json> & {
       form: string,
@@ -162,11 +164,6 @@ declare global {
     [group]: <G extends string>(fn: (v: T) => Skip | G) => { [K in G]?: T[] }
   }
   
-  interface FunctionConstructor {}
-  interface Function extends SymbolsProto {
-    [bind]: <Fn extends (...args: any[]) => any, To>(this: Fn, to: To) => ((...args: Parameters<Fn> extends [ infer A0, ...infer AM ] ? AM : never) => ReturnType<Fn>)
-  }
-  
   interface NumberConstructor {
     [int32]: number,
     [int64]: number
@@ -177,13 +174,14 @@ declare global {
     [toStr]: (str: string | CharSet, len?: number) => string,
     [toArr]: <T>(fn: (n: number) => T) => T[],
     [toObj]: <R extends readonly [string, any]>(fn: (n: number) => Skip | R) => { [K: string]: any },
-    [bits]: () => Generator<number>,
+    [toBin]: () => Uint8Array,
     [Symbol.iterator]: () => Generator<number>
   }
   
   interface BigIntConstructor {}
   interface BigInt extends SymbolsProto {
-    [toStr]: (str: string | CharSet, len?: number) => string
+    [toStr]: (str: string | CharSet, len?: number) => string,
+    [toBin]: () => Uint8Array
   }
   
   interface ObjectConstructor {}
@@ -202,9 +200,22 @@ declare global {
     [Symbol.iterator]: <O extends Obj>(this: O) => Iterator<[ ObjKeys<O>, ObjVals<O> ]>
   }
   
+  interface ArrayBufferConstructor {}
+  interface ArrayBuffer {
+    [toStr]: () => string,
+    [toNum]: () => bigint
+  }
+  
+  interface Uint8ArrayConstructor {}
+  interface Uint8Array {
+    [toStr]: () => string,
+    [toNum]: () => bigint
+  }
+  
   interface PromiseConstructor {
-    [allArr]: PromiseConstructor['all'],
-    [allObj]: <O extends { [K: string]: Promise<any> }>(obj: O) => Promise<{ [K in keyof O]: Exclude<Awaited<O[K]>, Skip> }>,
+    [allArr]: <V extends Promise<any>>(arr: Arr<V>) => Promise<Arr<Exclude<Awaited<V>, Skip>>>,
+    [allObj]: <V extends Promise<any>>(obj: Obj<V>) => Promise<Obj<Exclude<Awaited<V>, Skip>>>,
+    // [allObj]: <O extends { [K: string]: Promise<any> }>(obj: O)   => Promise<{ [K in keyof O]: Exclude<Awaited<O[K]>, Skip> }>,
     [later]: <T=void>() => PromiseLater<T>
   }
   interface Promise<T> {}
@@ -230,9 +241,9 @@ declare global {
     [count]: () => number,
     [empty]: () => boolean,
     [find]: (fn: (val: V, key: K) => any) => ({ found: true, val: V, key: K } | { found: false, val: null, key: null }),
-    [map]: <T>(fn: (val: V, key: K) => Skip | readonly [string, any]) => { [Key: string]: any },
+    [map]: <T>(fn: (val: V, key: K) => Skip | readonly [string, any]) => { [K: string]: any },
     [toArr]: <T>(fn: (val: V, key: K) => T) => Exclude<T, Skip>[],
-    [toObj]: <T>(fn: (val: V, key: K) => Skip | readonly [string, any]) => { [Key: string]: any },
+    [toObj]: <R>(fn: (val: V, key: K) => Skip | readonly [string, R]) => Obj<R>,
     [rem]: (key: K) => void
   }
 
@@ -252,6 +263,7 @@ declare global {
     [padHead]: (n: number, s?: string) => string,
     [padTail]: (n: number, s?: string) => string,
     [toNum]: (chrs: string | CharSet) => bigint,
+    [toBin]: () => Uint8Array,
     [hasHead]: <H extends string>(this: string, head: H) => this is `${H}${string}`,
     [hasTail]: <T extends string>(this: string, tail: T) => this is `${string}${T}`,
     [upper]: <S extends string>(this: S) => Uppercase<S>,

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@gershy/clearing",
-  "version": "0.0.23",
-  "versionCommit": "ccce646c1a4bc2ec3f349a1b02a8498a930c373e",
+  "version": "0.0.26",
   "description": "Adds the features you always wish javascript had!",
   "keywords": [
     "clearing",
@@ -43,5 +42,7 @@
     "git.pub": "npm run test && git add --all && git commit -m \"automated\" && git push",
     "npm.login": "npm login",
     "npm.pub": "npm run test && npm run build && npm publish --access public"
-  }
+  },
+  "peerDependencies": {},
+  "dependencies": {}
 }

package/readme.md

@@ -217,7 +217,7 @@ console.log(obj[mapk]((v, k) => [ k.toUpperCase(), v * 10 ])); // { A: 10, B: 20
 
 ### `Object.prototype[merge]`
 
-Deep merges another object into `this` (mutates in place). Use `clearing.skip` for deletion.
+Deep merges another object into `this` (mutates in place). Use `skip` global for deletion.
 
 ```ts
 
@@ -621,19 +621,6 @@ Same as `Number.prototype[toStr]`, but for BigInt values.
 ```ts
 console.log((1000000000000n)[toStr](String[base62])); // 'bLY38W'
 ```
-
-## `Function.prototype` extensions
-
-### `Function.prototype[bind]`
-
-Partially applies arguments to a function (like `bind`, but without a `this` context).
-
-```ts
-const add = (a, b, c) => a + b + c;
-const add10 = add[bind](10);
-console.log(add10(5, 3)); // 18
-```
-
 ## `Error` extensions
 
 ### `Error[assert]`
@@ -652,10 +639,20 @@ Error[assert]({ x: 10, y: 5 }, ({ x, y }) => x < y); // throws!
 Modifies an error's message and adds properties. Returns the error for chaining.
 
 ```ts
-throw Error('something failed')[mod]({ code: 'err99', context: { userId: 123 } });
+// Add context to errors:
+throw Error('oops')[mod]({ code: 'err99', context: { userId: 123 } });
 
-// Can also modify the message
-throw Error('base error')[mod]({ message: 'enhanced message', extra: 'data' });
+// Overwrite the error message by passing a string, or supplying "message" or "msg" properties:
+throw Error('oops')[mod]('new message');
+throw Error('oops')[mod]({ msg:     'new message', extra: 'data' });
+throw Error('oops')[mod]({ message: 'new message', extra: 'data' });
+
+// Pass a callback to succinctly reference the original message:
+throw Error('oops')[mod](msg => `Modified message! Original: ${msg}`);
+throw Error('oops')[mod](msg => ({
+  msg: `Modified message! Original: ${msg}`,
+  extra: 'data'
+}));
 ```
 
 ### `Error.prototype[fire]`