lakutata 2.0.80 → 2.0.82

package/src/lib/helpers/ObjectHash.cjs

@@ -4,415 +4,422 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const r = require("../../../vendor/Package.5.cjs");
+const e = require("../../../vendor/Package.5.cjs");
 
-require("../../../vendor/Package.13.cjs");
+require("../../../vendor/Package.15.cjs");
 
 const t = require("crypto");
 
-const e = r => r && r.__esModule ? r : {
-    default: r
+const _interopDefault = e => e && e.__esModule ? e : {
+    default: e
 };
 
-const n = e(t);
+const r = _interopDefault(t);
 
-var i = {
+var n = {
     exports: {}
 };
 
-var o = i.exports;
+var i = n.exports;
 
-(function(r, t) {
-    "use strict";
-    var e = n.default;
-    t = r.exports = i;
-    function i(r, t) {
-        t = a(r, t);
-        return c(r, t);
-    }
-    t.sha1 = function(r) {
-        return i(r);
-    };
-    t.keys = function(r) {
-        return i(r, {
-            excludeValues: true,
-            algorithm: "sha1",
-            encoding: "hex"
-        });
-    };
-    t.MD5 = function(r) {
-        return i(r, {
-            algorithm: "md5",
-            encoding: "hex"
-        });
-    };
-    t.keysMD5 = function(r) {
-        return i(r, {
-            algorithm: "md5",
-            encoding: "hex",
-            excludeValues: true
-        });
-    };
-    var o = e.getHashes ? e.getHashes().slice() : [ "sha1", "md5" ];
-    o.push("passthrough");
-    var u = [ "buffer", "hex", "binary", "base64" ];
-    function a(r, t) {
-        t = t || {};
-        var e = {};
-        e.algorithm = t.algorithm || "sha1";
-        e.encoding = t.encoding || "hex";
-        e.excludeValues = t.excludeValues ? true : false;
-        e.algorithm = e.algorithm.toLowerCase();
-        e.encoding = e.encoding.toLowerCase();
-        e.ignoreUnknown = t.ignoreUnknown !== true ? false : true;
-        e.respectType = t.respectType === false ? false : true;
-        e.respectFunctionNames = t.respectFunctionNames === false ? false : true;
-        e.respectFunctionProperties = t.respectFunctionProperties === false ? false : true;
-        e.unorderedArrays = t.unorderedArrays !== true ? false : true;
-        e.unorderedSets = t.unorderedSets === false ? false : true;
-        e.unorderedObjects = t.unorderedObjects === false ? false : true;
-        e.replacer = t.replacer || undefined;
-        e.excludeKeys = t.excludeKeys || undefined;
-        if (typeof r === "undefined") {
-            throw new Error("Object argument required.");
+var o;
+
+function requireObjectHash() {
+    if (o) return n.exports;
+    o = 1;
+    (function(e, t) {
+        "use strict";
+        var n = r.default;
+        t = e.exports = objectHash;
+        function objectHash(e, t) {
+            t = applyDefaults(e, t);
+            return hash(e, t);
         }
-        for (var n = 0; n < o.length; ++n) {
-            if (o[n].toLowerCase() === e.algorithm.toLowerCase()) {
-                e.algorithm = o[n];
+        t.sha1 = function(e) {
+            return objectHash(e);
+        };
+        t.keys = function(e) {
+            return objectHash(e, {
+                excludeValues: true,
+                algorithm: "sha1",
+                encoding: "hex"
+            });
+        };
+        t.MD5 = function(e) {
+            return objectHash(e, {
+                algorithm: "md5",
+                encoding: "hex"
+            });
+        };
+        t.keysMD5 = function(e) {
+            return objectHash(e, {
+                algorithm: "md5",
+                encoding: "hex",
+                excludeValues: true
+            });
+        };
+        var i = n.getHashes ? n.getHashes().slice() : [ "sha1", "md5" ];
+        i.push("passthrough");
+        var o = [ "buffer", "hex", "binary", "base64" ];
+        function applyDefaults(e, t) {
+            t = t || {};
+            var r = {};
+            r.algorithm = t.algorithm || "sha1";
+            r.encoding = t.encoding || "hex";
+            r.excludeValues = t.excludeValues ? true : false;
+            r.algorithm = r.algorithm.toLowerCase();
+            r.encoding = r.encoding.toLowerCase();
+            r.ignoreUnknown = t.ignoreUnknown !== true ? false : true;
+            r.respectType = t.respectType === false ? false : true;
+            r.respectFunctionNames = t.respectFunctionNames === false ? false : true;
+            r.respectFunctionProperties = t.respectFunctionProperties === false ? false : true;
+            r.unorderedArrays = t.unorderedArrays !== true ? false : true;
+            r.unorderedSets = t.unorderedSets === false ? false : true;
+            r.unorderedObjects = t.unorderedObjects === false ? false : true;
+            r.replacer = t.replacer || undefined;
+            r.excludeKeys = t.excludeKeys || undefined;
+            if (typeof e === "undefined") {
+                throw new Error("Object argument required.");
             }
+            for (var n = 0; n < i.length; ++n) {
+                if (i[n].toLowerCase() === r.algorithm.toLowerCase()) {
+                    r.algorithm = i[n];
+                }
+            }
+            if (i.indexOf(r.algorithm) === -1) {
+                throw new Error('Algorithm "' + r.algorithm + '"  not supported. ' + "supported values: " + i.join(", "));
+            }
+            if (o.indexOf(r.encoding) === -1 && r.algorithm !== "passthrough") {
+                throw new Error('Encoding "' + r.encoding + '"  not supported. ' + "supported values: " + o.join(", "));
+            }
+            return r;
         }
-        if (o.indexOf(e.algorithm) === -1) {
-            throw new Error('Algorithm "' + e.algorithm + '"  not supported. ' + "supported values: " + o.join(", "));
-        }
-        if (u.indexOf(e.encoding) === -1 && e.algorithm !== "passthrough") {
-            throw new Error('Encoding "' + e.encoding + '"  not supported. ' + "supported values: " + u.join(", "));
-        }
-        return e;
-    }
-    function s(r) {
-        if (typeof r !== "function") {
-            return false;
-        }
-        var t = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
-        return t.exec(Function.prototype.toString.call(r)) != null;
-    }
-    function c(r, t) {
-        var n;
-        if (t.algorithm !== "passthrough") {
-            n = e.createHash(t.algorithm);
-        } else {
-            n = new l;
-        }
-        if (typeof n.write === "undefined") {
-            n.write = n.update;
-            n.end = n.update;
-        }
-        var i = f(t, n);
-        i.dispatch(r);
-        if (!n.update) {
-            n.end("");
-        }
-        if (n.digest) {
-            return n.digest(t.encoding === "buffer" ? undefined : t.encoding);
-        }
-        var o = n.read();
-        if (t.encoding === "buffer") {
-            return o;
-        }
-        return o.toString(t.encoding);
-    }
-    t.writeToStream = function(r, t, e) {
-        if (typeof e === "undefined") {
-            e = t;
-            t = {};
+        function isNativeFunction(e) {
+            if (typeof e !== "function") {
+                return false;
+            }
+            var t = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+            return t.exec(Function.prototype.toString.call(e)) != null;
         }
-        t = a(r, t);
-        return f(t, e).dispatch(r);
-    };
-    function f(r, t, e) {
-        e = e || [];
-        var n = function(r) {
-            if (t.update) {
-                return t.update(r, "utf8");
+        function hash(e, t) {
+            var r;
+            if (t.algorithm !== "passthrough") {
+                r = n.createHash(t.algorithm);
             } else {
-                return t.write(r, "utf8");
+                r = new PassThrough;
+            }
+            if (typeof r.write === "undefined") {
+                r.write = r.update;
+                r.end = r.update;
             }
+            var i = typeHasher(t, r);
+            i.dispatch(e);
+            if (!r.update) {
+                r.end("");
+            }
+            if (r.digest) {
+                return r.digest(t.encoding === "buffer" ? undefined : t.encoding);
+            }
+            var o = r.read();
+            if (t.encoding === "buffer") {
+                return o;
+            }
+            return o.toString(t.encoding);
+        }
+        t.writeToStream = function(e, t, r) {
+            if (typeof r === "undefined") {
+                r = t;
+                t = {};
+            }
+            t = applyDefaults(e, t);
+            return typeHasher(t, r).dispatch(e);
         };
-        return {
-            dispatch: function(t) {
-                if (r.replacer) {
-                    t = r.replacer(t);
-                }
-                var e = typeof t;
-                if (t === null) {
-                    e = "null";
-                }
-                return this["_" + e](t);
-            },
-            _object: function(t) {
-                var i = /\[object (.*)\]/i;
-                var o = Object.prototype.toString.call(t);
-                var u = i.exec(o);
-                if (!u) {
-                    u = "unknown:[" + o + "]";
+        function typeHasher(e, t, r) {
+            r = r || [];
+            var write = function(e) {
+                if (t.update) {
+                    return t.update(e, "utf8");
                 } else {
-                    u = u[1];
+                    return t.write(e, "utf8");
                 }
-                u = u.toLowerCase();
-                var a = null;
-                if ((a = e.indexOf(t)) >= 0) {
-                    return this.dispatch("[CIRCULAR:" + a + "]");
-                } else {
-                    e.push(t);
-                }
-                if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(t)) {
-                    n("buffer:");
-                    return n(t);
-                }
-                if (u !== "object" && u !== "function" && u !== "asyncfunction") {
-                    if (this["_" + u]) {
-                        this["_" + u](t);
-                    } else if (r.ignoreUnknown) {
-                        return n("[" + u + "]");
+            };
+            return {
+                dispatch: function(t) {
+                    if (e.replacer) {
+                        t = e.replacer(t);
+                    }
+                    var r = typeof t;
+                    if (t === null) {
+                        r = "null";
+                    }
+                    return this["_" + r](t);
+                },
+                _object: function(t) {
+                    var n = /\[object (.*)\]/i;
+                    var i = Object.prototype.toString.call(t);
+                    var o = n.exec(i);
+                    if (!o) {
+                        o = "unknown:[" + i + "]";
                     } else {
-                        throw new Error('Unknown object type "' + u + '"');
+                        o = o[1];
                     }
-                } else {
-                    var c = Object.keys(t);
-                    if (r.unorderedObjects) {
-                        c = c.sort();
+                    o = o.toLowerCase();
+                    var u = null;
+                    if ((u = r.indexOf(t)) >= 0) {
+                        return this.dispatch("[CIRCULAR:" + u + "]");
+                    } else {
+                        r.push(t);
                     }
-                    if (r.respectType !== false && !s(t)) {
-                        c.splice(0, 0, "prototype", "__proto__", "constructor");
+                    if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(t)) {
+                        write("buffer:");
+                        return write(t);
                     }
-                    if (r.excludeKeys) {
-                        c = c.filter((function(t) {
-                            return !r.excludeKeys(t);
+                    if (o !== "object" && o !== "function" && o !== "asyncfunction") {
+                        if (this["_" + o]) {
+                            this["_" + o](t);
+                        } else if (e.ignoreUnknown) {
+                            return write("[" + o + "]");
+                        } else {
+                            throw new Error('Unknown object type "' + o + '"');
+                        }
+                    } else {
+                        var a = Object.keys(t);
+                        if (e.unorderedObjects) {
+                            a = a.sort();
+                        }
+                        if (e.respectType !== false && !isNativeFunction(t)) {
+                            a.splice(0, 0, "prototype", "__proto__", "constructor");
+                        }
+                        if (e.excludeKeys) {
+                            a = a.filter((function(t) {
+                                return !e.excludeKeys(t);
+                            }));
+                        }
+                        write("object:" + a.length + ":");
+                        var s = this;
+                        return a.forEach((function(r) {
+                            s.dispatch(r);
+                            write(":");
+                            if (!e.excludeValues) {
+                                s.dispatch(t[r]);
+                            }
+                            write(",");
                         }));
                     }
-                    n("object:" + c.length + ":");
-                    var f = this;
-                    return c.forEach((function(e) {
-                        f.dispatch(e);
-                        n(":");
-                        if (!r.excludeValues) {
-                            f.dispatch(t[e]);
-                        }
-                        n(",");
-                    }));
-                }
-            },
-            _array: function(t, i) {
-                i = typeof i !== "undefined" ? i : r.unorderedArrays !== false;
-                var o = this;
-                n("array:" + t.length + ":");
-                if (!i || t.length <= 1) {
-                    return t.forEach((function(r) {
-                        return o.dispatch(r);
+                },
+                _array: function(t, n) {
+                    n = typeof n !== "undefined" ? n : e.unorderedArrays !== false;
+                    var i = this;
+                    write("array:" + t.length + ":");
+                    if (!n || t.length <= 1) {
+                        return t.forEach((function(e) {
+                            return i.dispatch(e);
+                        }));
+                    }
+                    var o = [];
+                    var u = t.map((function(t) {
+                        var n = new PassThrough;
+                        var i = r.slice();
+                        var u = typeHasher(e, n, i);
+                        u.dispatch(t);
+                        o = o.concat(i.slice(r.length));
+                        return n.read().toString();
                     }));
+                    r = r.concat(o);
+                    u.sort();
+                    return this._array(u, false);
+                },
+                _date: function(e) {
+                    return write("date:" + e.toJSON());
+                },
+                _symbol: function(e) {
+                    return write("symbol:" + e.toString());
+                },
+                _error: function(e) {
+                    return write("error:" + e.toString());
+                },
+                _boolean: function(e) {
+                    return write("bool:" + e.toString());
+                },
+                _string: function(e) {
+                    write("string:" + e.length + ":");
+                    write(e.toString());
+                },
+                _function: function(t) {
+                    write("fn:");
+                    if (isNativeFunction(t)) {
+                        this.dispatch("[native]");
+                    } else {
+                        this.dispatch(t.toString());
+                    }
+                    if (e.respectFunctionNames !== false) {
+                        this.dispatch("function-name:" + String(t.name));
+                    }
+                    if (e.respectFunctionProperties) {
+                        this._object(t);
+                    }
+                },
+                _number: function(e) {
+                    return write("number:" + e.toString());
+                },
+                _xml: function(e) {
+                    return write("xml:" + e.toString());
+                },
+                _null: function() {
+                    return write("Null");
+                },
+                _undefined: function() {
+                    return write("Undefined");
+                },
+                _regexp: function(e) {
+                    return write("regex:" + e.toString());
+                },
+                _uint8array: function(e) {
+                    write("uint8array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _uint8clampedarray: function(e) {
+                    write("uint8clampedarray:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _int8array: function(e) {
+                    write("int8array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _uint16array: function(e) {
+                    write("uint16array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _int16array: function(e) {
+                    write("int16array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _uint32array: function(e) {
+                    write("uint32array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _int32array: function(e) {
+                    write("int32array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _float32array: function(e) {
+                    write("float32array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _float64array: function(e) {
+                    write("float64array:");
+                    return this.dispatch(Array.prototype.slice.call(e));
+                },
+                _arraybuffer: function(e) {
+                    write("arraybuffer:");
+                    return this.dispatch(new Uint8Array(e));
+                },
+                _url: function(e) {
+                    return write("url:" + e.toString(), "utf8");
+                },
+                _map: function(t) {
+                    write("map:");
+                    var r = Array.from(t);
+                    return this._array(r, e.unorderedSets !== false);
+                },
+                _set: function(t) {
+                    write("set:");
+                    var r = Array.from(t);
+                    return this._array(r, e.unorderedSets !== false);
+                },
+                _file: function(e) {
+                    write("file:");
+                    return this.dispatch([ e.name, e.size, e.type, e.lastModfied ]);
+                },
+                _blob: function() {
+                    if (e.ignoreUnknown) {
+                        return write("[blob]");
+                    }
+                    throw Error("Hashing Blob objects is currently not supported\n" + "(see https://github.com/puleos/object-hash/issues/26)\n" + 'Use "options.replacer" or "options.ignoreUnknown"\n');
+                },
+                _domwindow: function() {
+                    return write("domwindow");
+                },
+                _bigint: function(e) {
+                    return write("bigint:" + e.toString());
+                },
+                _process: function() {
+                    return write("process");
+                },
+                _timer: function() {
+                    return write("timer");
+                },
+                _pipe: function() {
+                    return write("pipe");
+                },
+                _tcp: function() {
+                    return write("tcp");
+                },
+                _udp: function() {
+                    return write("udp");
+                },
+                _tty: function() {
+                    return write("tty");
+                },
+                _statwatcher: function() {
+                    return write("statwatcher");
+                },
+                _securecontext: function() {
+                    return write("securecontext");
+                },
+                _connection: function() {
+                    return write("connection");
+                },
+                _zlib: function() {
+                    return write("zlib");
+                },
+                _context: function() {
+                    return write("context");
+                },
+                _nodescript: function() {
+                    return write("nodescript");
+                },
+                _httpparser: function() {
+                    return write("httpparser");
+                },
+                _dataview: function() {
+                    return write("dataview");
+                },
+                _signal: function() {
+                    return write("signal");
+                },
+                _fsevent: function() {
+                    return write("fsevent");
+                },
+                _tlswrap: function() {
+                    return write("tlswrap");
                 }
-                var u = [];
-                var a = t.map((function(t) {
-                    var n = new l;
-                    var i = e.slice();
-                    var o = f(r, n, i);
-                    o.dispatch(t);
-                    u = u.concat(i.slice(e.length));
-                    return n.read().toString();
-                }));
-                e = e.concat(u);
-                a.sort();
-                return this._array(a, false);
-            },
-            _date: function(r) {
-                return n("date:" + r.toJSON());
-            },
-            _symbol: function(r) {
-                return n("symbol:" + r.toString());
-            },
-            _error: function(r) {
-                return n("error:" + r.toString());
-            },
-            _boolean: function(r) {
-                return n("bool:" + r.toString());
-            },
-            _string: function(r) {
-                n("string:" + r.length + ":");
-                n(r.toString());
-            },
-            _function: function(t) {
-                n("fn:");
-                if (s(t)) {
-                    this.dispatch("[native]");
-                } else {
-                    this.dispatch(t.toString());
-                }
-                if (r.respectFunctionNames !== false) {
-                    this.dispatch("function-name:" + String(t.name));
-                }
-                if (r.respectFunctionProperties) {
-                    this._object(t);
-                }
-            },
-            _number: function(r) {
-                return n("number:" + r.toString());
-            },
-            _xml: function(r) {
-                return n("xml:" + r.toString());
-            },
-            _null: function() {
-                return n("Null");
-            },
-            _undefined: function() {
-                return n("Undefined");
-            },
-            _regexp: function(r) {
-                return n("regex:" + r.toString());
-            },
-            _uint8array: function(r) {
-                n("uint8array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _uint8clampedarray: function(r) {
-                n("uint8clampedarray:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _int8array: function(r) {
-                n("int8array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _uint16array: function(r) {
-                n("uint16array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _int16array: function(r) {
-                n("int16array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _uint32array: function(r) {
-                n("uint32array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _int32array: function(r) {
-                n("int32array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _float32array: function(r) {
-                n("float32array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _float64array: function(r) {
-                n("float64array:");
-                return this.dispatch(Array.prototype.slice.call(r));
-            },
-            _arraybuffer: function(r) {
-                n("arraybuffer:");
-                return this.dispatch(new Uint8Array(r));
-            },
-            _url: function(r) {
-                return n("url:" + r.toString(), "utf8");
-            },
-            _map: function(t) {
-                n("map:");
-                var e = Array.from(t);
-                return this._array(e, r.unorderedSets !== false);
-            },
-            _set: function(t) {
-                n("set:");
-                var e = Array.from(t);
-                return this._array(e, r.unorderedSets !== false);
-            },
-            _file: function(r) {
-                n("file:");
-                return this.dispatch([ r.name, r.size, r.type, r.lastModfied ]);
-            },
-            _blob: function() {
-                if (r.ignoreUnknown) {
-                    return n("[blob]");
+            };
+        }
+        function PassThrough() {
+            return {
+                buf: "",
+                write: function(e) {
+                    this.buf += e;
+                },
+                end: function(e) {
+                    this.buf += e;
+                },
+                read: function() {
+                    return this.buf;
                 }
-                throw Error("Hashing Blob objects is currently not supported\n" + "(see https://github.com/puleos/object-hash/issues/26)\n" + 'Use "options.replacer" or "options.ignoreUnknown"\n');
-            },
-            _domwindow: function() {
-                return n("domwindow");
-            },
-            _bigint: function(r) {
-                return n("bigint:" + r.toString());
-            },
-            _process: function() {
-                return n("process");
-            },
-            _timer: function() {
-                return n("timer");
-            },
-            _pipe: function() {
-                return n("pipe");
-            },
-            _tcp: function() {
-                return n("tcp");
-            },
-            _udp: function() {
-                return n("udp");
-            },
-            _tty: function() {
-                return n("tty");
-            },
-            _statwatcher: function() {
-                return n("statwatcher");
-            },
-            _securecontext: function() {
-                return n("securecontext");
-            },
-            _connection: function() {
-                return n("connection");
-            },
-            _zlib: function() {
-                return n("zlib");
-            },
-            _context: function() {
-                return n("context");
-            },
-            _nodescript: function() {
-                return n("nodescript");
-            },
-            _httpparser: function() {
-                return n("httpparser");
-            },
-            _dataview: function() {
-                return n("dataview");
-            },
-            _signal: function() {
-                return n("signal");
-            },
-            _fsevent: function() {
-                return n("fsevent");
-            },
-            _tlswrap: function() {
-                return n("tlswrap");
-            }
-        };
-    }
-    function l() {
-        return {
-            buf: "",
-            write: function(r) {
-                this.buf += r;
-            },
-            end: function(r) {
-                this.buf += r;
-            },
-            read: function() {
-                return this.buf;
-            }
-        };
-    }
-})(i, i.exports);
+            };
+        }
+    })(n, n.exports);
+    return n.exports;
+}
 
-var u = i.exports;
+var u = requireObjectHash();
 
-const a = r.getDefaultExportFromCjs(u);
+const a = e.getDefaultExportFromCjs(u);
 
-function s(r, t) {
-    return a(r, t);
+function ObjectHash(e, t) {
+    return a(e, t);
 }
 
-exports.ObjectHash = s;
+exports.ObjectHash = ObjectHash;