@gershy/clearing 0.0.29 → 0.0.31

package/cmp/mjs/main.js

@@ -1,58 +1,55 @@
-export 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';
-};
-export const getCls = i => Object.getPrototypeOf(i)?.constructor ?? null;
-export 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;
-};
-export const inCls = (i, C) => i instanceof C;
-export const skip = undefined;
-export const then = (val, rsv = (v => v), rjc = ((e) => { throw e; })) => {
-    // Act on `val` regardless of whether it's a Promise or immediate value; return `rsv(val)`
-    // either immediately or as a Promise
-    if (inCls(val, Promise))
-        return val.then(rsv).catch(rjc);
-    try {
-        return rsv(val);
-    }
-    catch (err) {
-        return rjc(err);
-    }
-};
-export const safe = (fn, rjc = e => { throw e; }) => {
-    // Execute a function which returns a value either synchronously or asynchronously; in both cases
-    // allows errors occurring from function execution to be handled
-    try {
-        return then(fn(), v => v, rjc);
-    }
-    catch (err) {
-        return rjc(err);
-    }
-};
 const applyClearing = (() => {
-    const global = globalThis;
     // Prevent multiple installations...
-    const pfx = '@gershy/clearing';
-    const memSym = Symbol.for(`${pfx}:mem`);
-    if (global[memSym])
+    const global = globalThis;
+    if (global[Symbol.for(`@gershy/clearing:mem`)])
         return;
-    global[memSym] = true;
-    const [enc, dec] = [new TextEncoder(), new TextDecoder()];
+    global[Symbol.for(`@gershy/clearing:mem`)] = true;
+    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;
+    const then = (val, rsv = (v => v), rjc = ((e) => { throw e; })) => {
+        // Act on `val` regardless of whether it's a Promise or immediate value; return `rsv(val)`
+        // either immediately or as a Promise
+        if (inCls(val, Promise))
+            return val.then(rsv).catch(rjc);
+        try {
+            return rsv(val);
+        }
+        catch (err) {
+            return rjc(err);
+        }
+    };
+    const safe = (fn, rjc = e => { throw e; }) => {
+        // Execute a function which returns a value either synchronously or asynchronously; in both cases
+        // allows errors occurring from function execution to be handled
+        try {
+            return then(fn(), v => v, rjc);
+        }
+        catch (err) {
+            return rjc(err);
+        }
+    };
     const symNames = [
-        // <SYMBOLS> :: definitions :: /[']([a-zA-Z0-9]+)[']/
+        // <SYMBOLS> :: runtimeNames :: /[']([a-zA-Z0-9]+)[']/
         'add',
         'allArr',
         'allObj',
@@ -64,13 +61,11 @@ const applyClearing = (() => {
         'base64Std',
         'base64Url',
         'baseline',
-        'bind',
         'char',
         'charset',
         'code',
         'count',
         'cut',
-        'dive',
         'empty',
         'find',
         'fire',
@@ -100,18 +95,71 @@ const applyClearing = (() => {
         'toNum',
         'toObj',
         'toStr',
-        'upper'
+        'upper',
+        'walk'
         // </SYMBOLS>
     ];
-    const syms = Object.fromEntries(symNames.map(term => [term, Symbol(`${pfx}:${term}`)]));
-    Object.assign(global, { ...syms });
+    const cl = {
+        getClsName, getCls, isCls, inCls, then, safe, skip,
+        ...Object.fromEntries(symNames.map(term => [term, Symbol(`@gershy/clearing:${term}`)]))
+    };
+    Object.assign(global, { cl, clearing: cl });
+    // <SYMBOLS> :: runtimeRefs :: /^[ ]*const[ ]([a-zA-Z0-9]+)[:]/
+    const add = clearing.add;
+    const allArr = clearing.allArr;
+    const allObj = clearing.allObj;
+    const at = clearing.at;
+    const assert = clearing.assert;
+    const base32 = clearing.base32;
+    const base36 = clearing.base36;
+    const base62 = clearing.base62;
+    const base64Std = clearing.base64Std;
+    const base64Url = clearing.base64Url;
+    const baseline = clearing.baseline;
+    const char = clearing.char;
+    const charset = clearing.charset;
+    const code = clearing.code;
+    const count = clearing.count;
+    const cut = clearing.cut;
+    const empty = clearing.empty;
+    const find = clearing.find;
+    const fire = clearing.fire;
+    const group = clearing.group;
+    const has = clearing.has;
+    const hasHead = clearing.hasHead;
+    const hasTail = clearing.hasTail;
+    const indent = clearing.indent;
+    const int32 = clearing.int32;
+    const int64 = clearing.int64;
+    const isInt = clearing.isInt;
+    const later = clearing.later;
+    const limn = clearing.limn;
+    const lower = clearing.lower;
+    const map = clearing.map;
+    const mapk = clearing.mapk;
+    const merge = clearing.merge;
+    const mod = clearing.mod;
+    const padHead = clearing.padHead;
+    const padTail = clearing.padTail;
+    const rem = clearing.rem;
+    const slash = clearing.slash;
+    const slice = clearing.slice;
+    const suppress = clearing.suppress;
+    const toArr = clearing.toArr;
+    const toBin = clearing.toBin;
+    const toNum = clearing.toNum;
+    const toObj = clearing.toObj;
+    const toStr = clearing.toStr;
+    const upper = clearing.upper;
+    const walk = clearing.walk;
+    // </SYMBOLS>
     const assignSyms = (Cls, def) => {
         const protoVals = [];
-        for (const key of Reflect.ownKeys(def)) {
+        for (const key of Reflect.ownKeys(def))
             if (!isCls(key, Symbol))
                 throw Object.assign(Error('invalid proto key'), { Cls, keyClsName: getClsName(key), key });
-            protoVals.push([key, def[key]]);
-        }
+            else
+                protoVals.push([key, def[key]]);
         // Assign class properties
         for (const [sym, value] of protoVals)
             Object.defineProperty(Cls, sym, { enumerable: false, value });
@@ -142,7 +190,7 @@ const applyClearing = (() => {
             //  });
             //  >> { 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) {
+            for (const [k, v] of this[walk]()) {
                 const g = fn(v, k);
                 if (g === skip)
                     continue;
@@ -173,8 +221,8 @@ const applyClearing = (() => {
             }
             return Object.fromEntries(arr);
         },
-        [merge](o) {
-            for (const [k, v] of o) {
+        [merge](obj) {
+            for (const [k, v] of obj[walk]()) {
                 // `skip` can be passed to remove properties
                 if (v === skip) {
                     delete this[k];
@@ -213,7 +261,7 @@ const applyClearing = (() => {
             }
             return ret;
         },
-        *[Symbol.iterator]() { for (const k in this)
+        *[walk]() { for (const k in this)
             yield [k, this[k]]; }
     });
     assignSyms(Array, {});
@@ -270,6 +318,7 @@ const applyClearing = (() => {
             return Object.fromEntries(ret);
         }
     });
+    const [enc, dec] = [new TextEncoder(), new TextDecoder()];
     assignSyms(String, {
         [baseline]: (str, seq = '| ') => {
             return str.split('\n')[map](ln => {
@@ -414,6 +463,11 @@ const applyClearing = (() => {
         [toStr]() { return dec.decode(this); },
         [toNum]() { return (new Uint8Array(this))[toNum](); }
     });
+    assignSyms(SharedArrayBuffer, {});
+    assignSyms(SharedArrayBuffer.prototype, {
+        [toStr]() { return dec.decode(new Uint8Array(this)); },
+        [toNum]() { return (new Uint8Array(this))[toNum](); }
+    });
     assignSyms(Uint8Array, {});
     assignSyms(Uint8Array.prototype, {
         [toStr]() { return dec.decode(this); },
@@ -448,7 +502,7 @@ const applyClearing = (() => {
             return {
                 form: getClsName(this),
                 msg: message,
-                trace: stack?.split('\n').slice(1)[map](v => v.trim() ?? skip) ?? [],
+                trace: (stack ?? '<no stack>').split('\n')[map](v => v.trim() ?? skip),
                 ...props,
                 cause: !cause ? null : cause[limn](seen)
             };