lakutata 2.0.82 → 2.0.83

package/src/lib/helpers/ObjectHash.mjs

@@ -1,8 +1,8 @@
-import { g as t } from "../../../vendor/Package.5.mjs";
+import { g as r } from "../../../vendor/Package.5.mjs";
 
 import "../../../vendor/Package.15.mjs";
 
-import r from "crypto";
+import t from "crypto";
 
 var e = {
     exports: {}
@@ -10,404 +10,397 @@ var e = {
 
 var n = e.exports;
 
-var i;
-
-function requireObjectHash() {
-    if (i) return e.exports;
-    i = 1;
-    (function(t, e) {
-        "use strict";
-        var n = r;
-        e = t.exports = objectHash;
-        function objectHash(t, r) {
-            r = applyDefaults(t, r);
-            return hash(t, r);
+(function(r, e) {
+    "use strict";
+    var n = t;
+    e = r.exports = i;
+    function i(r, t) {
+        t = a(r, t);
+        return c(r, t);
+    }
+    e.sha1 = function(r) {
+        return i(r);
+    };
+    e.keys = function(r) {
+        return i(r, {
+            excludeValues: true,
+            algorithm: "sha1",
+            encoding: "hex"
+        });
+    };
+    e.MD5 = function(r) {
+        return i(r, {
+            algorithm: "md5",
+            encoding: "hex"
+        });
+    };
+    e.keysMD5 = function(r) {
+        return i(r, {
+            algorithm: "md5",
+            encoding: "hex",
+            excludeValues: true
+        });
+    };
+    var o = n.getHashes ? n.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.");
         }
-        e.sha1 = function(t) {
-            return objectHash(t);
-        };
-        e.keys = function(t) {
-            return objectHash(t, {
-                excludeValues: true,
-                algorithm: "sha1",
-                encoding: "hex"
-            });
-        };
-        e.MD5 = function(t) {
-            return objectHash(t, {
-                algorithm: "md5",
-                encoding: "hex"
-            });
-        };
-        e.keysMD5 = function(t) {
-            return objectHash(t, {
-                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(t, r) {
-            r = r || {};
-            var e = {};
-            e.algorithm = r.algorithm || "sha1";
-            e.encoding = r.encoding || "hex";
-            e.excludeValues = r.excludeValues ? true : false;
-            e.algorithm = e.algorithm.toLowerCase();
-            e.encoding = e.encoding.toLowerCase();
-            e.ignoreUnknown = r.ignoreUnknown !== true ? false : true;
-            e.respectType = r.respectType === false ? false : true;
-            e.respectFunctionNames = r.respectFunctionNames === false ? false : true;
-            e.respectFunctionProperties = r.respectFunctionProperties === false ? false : true;
-            e.unorderedArrays = r.unorderedArrays !== true ? false : true;
-            e.unorderedSets = r.unorderedSets === false ? false : true;
-            e.unorderedObjects = r.unorderedObjects === false ? false : true;
-            e.replacer = r.replacer || undefined;
-            e.excludeKeys = r.excludeKeys || undefined;
-            if (typeof t === "undefined") {
-                throw new Error("Object argument required.");
-            }
-            for (var n = 0; n < i.length; ++n) {
-                if (i[n].toLowerCase() === e.algorithm.toLowerCase()) {
-                    e.algorithm = i[n];
-                }
-            }
-            if (i.indexOf(e.algorithm) === -1) {
-                throw new Error('Algorithm "' + e.algorithm + '"  not supported. ' + "supported values: " + i.join(", "));
+        for (var n = 0; n < o.length; ++n) {
+            if (o[n].toLowerCase() === e.algorithm.toLowerCase()) {
+                e.algorithm = o[n];
             }
-            if (o.indexOf(e.encoding) === -1 && e.algorithm !== "passthrough") {
-                throw new Error('Encoding "' + e.encoding + '"  not supported. ' + "supported values: " + o.join(", "));
-            }
-            return e;
         }
-        function isNativeFunction(t) {
-            if (typeof t !== "function") {
-                return false;
-            }
-            var r = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
-            return r.exec(Function.prototype.toString.call(t)) != null;
+        if (o.indexOf(e.algorithm) === -1) {
+            throw new Error('Algorithm "' + e.algorithm + '"  not supported. ' + "supported values: " + o.join(", "));
         }
-        function hash(t, r) {
-            var e;
-            if (r.algorithm !== "passthrough") {
-                e = n.createHash(r.algorithm);
-            } else {
-                e = new PassThrough;
-            }
-            if (typeof e.write === "undefined") {
-                e.write = e.update;
-                e.end = e.update;
-            }
-            var i = typeHasher(r, e);
-            i.dispatch(t);
-            if (!e.update) {
-                e.end("");
-            }
-            if (e.digest) {
-                return e.digest(r.encoding === "buffer" ? undefined : r.encoding);
-            }
-            var o = e.read();
-            if (r.encoding === "buffer") {
-                return o;
-            }
-            return o.toString(r.encoding);
+        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 e;
+        if (t.algorithm !== "passthrough") {
+            e = n.createHash(t.algorithm);
+        } else {
+            e = new l;
+        }
+        if (typeof e.write === "undefined") {
+            e.write = e.update;
+            e.end = e.update;
+        }
+        var i = f(t, e);
+        i.dispatch(r);
+        if (!e.update) {
+            e.end("");
+        }
+        if (e.digest) {
+            return e.digest(t.encoding === "buffer" ? undefined : t.encoding);
+        }
+        var o = e.read();
+        if (t.encoding === "buffer") {
+            return o;
+        }
+        return o.toString(t.encoding);
+    }
+    e.writeToStream = function(r, t, e) {
+        if (typeof e === "undefined") {
+            e = t;
+            t = {};
         }
-        e.writeToStream = function(t, r, e) {
-            if (typeof e === "undefined") {
-                e = r;
-                r = {};
+        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");
+            } else {
+                return t.write(r, "utf8");
             }
-            r = applyDefaults(t, r);
-            return typeHasher(r, e).dispatch(t);
         };
-        function typeHasher(t, r, e) {
-            e = e || [];
-            var write = function(t) {
-                if (r.update) {
-                    return r.update(t, "utf8");
+        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 + "]";
                 } else {
-                    return r.write(t, "utf8");
+                    u = u[1];
                 }
-            };
-            return {
-                dispatch: function(r) {
-                    if (t.replacer) {
-                        r = t.replacer(r);
-                    }
-                    var e = typeof r;
-                    if (r === null) {
-                        e = "null";
-                    }
-                    return this["_" + e](r);
-                },
-                _object: function(r) {
-                    var n = /\[object (.*)\]/i;
-                    var i = Object.prototype.toString.call(r);
-                    var o = n.exec(i);
-                    if (!o) {
-                        o = "unknown:[" + i + "]";
-                    } else {
-                        o = o[1];
-                    }
-                    o = o.toLowerCase();
-                    var u = null;
-                    if ((u = e.indexOf(r)) >= 0) {
-                        return this.dispatch("[CIRCULAR:" + u + "]");
+                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 + "]");
                     } else {
-                        e.push(r);
+                        throw new Error('Unknown object type "' + u + '"');
                     }
-                    if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(r)) {
-                        write("buffer:");
-                        return write(r);
+                } else {
+                    var c = Object.keys(t);
+                    if (r.unorderedObjects) {
+                        c = c.sort();
                     }
-                    if (o !== "object" && o !== "function" && o !== "asyncfunction") {
-                        if (this["_" + o]) {
-                            this["_" + o](r);
-                        } else if (t.ignoreUnknown) {
-                            return write("[" + o + "]");
-                        } else {
-                            throw new Error('Unknown object type "' + o + '"');
-                        }
-                    } else {
-                        var a = Object.keys(r);
-                        if (t.unorderedObjects) {
-                            a = a.sort();
-                        }
-                        if (t.respectType !== false && !isNativeFunction(r)) {
-                            a.splice(0, 0, "prototype", "__proto__", "constructor");
-                        }
-                        if (t.excludeKeys) {
-                            a = a.filter((function(r) {
-                                return !t.excludeKeys(r);
-                            }));
-                        }
-                        write("object:" + a.length + ":");
-                        var s = this;
-                        return a.forEach((function(e) {
-                            s.dispatch(e);
-                            write(":");
-                            if (!t.excludeValues) {
-                                s.dispatch(r[e]);
-                            }
-                            write(",");
-                        }));
+                    if (r.respectType !== false && !s(t)) {
+                        c.splice(0, 0, "prototype", "__proto__", "constructor");
                     }
-                },
-                _array: function(r, n) {
-                    n = typeof n !== "undefined" ? n : t.unorderedArrays !== false;
-                    var i = this;
-                    write("array:" + r.length + ":");
-                    if (!n || r.length <= 1) {
-                        return r.forEach((function(t) {
-                            return i.dispatch(t);
+                    if (r.excludeKeys) {
+                        c = c.filter((function(t) {
+                            return !r.excludeKeys(t);
                         }));
                     }
-                    var o = [];
-                    var u = r.map((function(r) {
-                        var n = new PassThrough;
-                        var i = e.slice();
-                        var u = typeHasher(t, n, i);
-                        u.dispatch(r);
-                        o = o.concat(i.slice(e.length));
-                        return n.read().toString();
+                    n("object:" + c.length + ":");
+                    var f = this;
+                    return c.forEach((function(e) {
+                        f.dispatch(e);
+                        n(":");
+                        if (!r.excludeValues) {
+                            f.dispatch(t[e]);
+                        }
+                        n(",");
                     }));
-                    e = e.concat(o);
-                    u.sort();
-                    return this._array(u, false);
-                },
-                _date: function(t) {
-                    return write("date:" + t.toJSON());
-                },
-                _symbol: function(t) {
-                    return write("symbol:" + t.toString());
-                },
-                _error: function(t) {
-                    return write("error:" + t.toString());
-                },
-                _boolean: function(t) {
-                    return write("bool:" + t.toString());
-                },
-                _string: function(t) {
-                    write("string:" + t.length + ":");
-                    write(t.toString());
-                },
-                _function: function(r) {
-                    write("fn:");
-                    if (isNativeFunction(r)) {
-                        this.dispatch("[native]");
-                    } else {
-                        this.dispatch(r.toString());
-                    }
-                    if (t.respectFunctionNames !== false) {
-                        this.dispatch("function-name:" + String(r.name));
-                    }
-                    if (t.respectFunctionProperties) {
-                        this._object(r);
-                    }
-                },
-                _number: function(t) {
-                    return write("number:" + t.toString());
-                },
-                _xml: function(t) {
-                    return write("xml:" + t.toString());
-                },
-                _null: function() {
-                    return write("Null");
-                },
-                _undefined: function() {
-                    return write("Undefined");
-                },
-                _regexp: function(t) {
-                    return write("regex:" + t.toString());
-                },
-                _uint8array: function(t) {
-                    write("uint8array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _uint8clampedarray: function(t) {
-                    write("uint8clampedarray:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _int8array: function(t) {
-                    write("int8array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _uint16array: function(t) {
-                    write("uint16array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _int16array: function(t) {
-                    write("int16array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _uint32array: function(t) {
-                    write("uint32array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _int32array: function(t) {
-                    write("int32array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _float32array: function(t) {
-                    write("float32array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _float64array: function(t) {
-                    write("float64array:");
-                    return this.dispatch(Array.prototype.slice.call(t));
-                },
-                _arraybuffer: function(t) {
-                    write("arraybuffer:");
-                    return this.dispatch(new Uint8Array(t));
-                },
-                _url: function(t) {
-                    return write("url:" + t.toString(), "utf8");
-                },
-                _map: function(r) {
-                    write("map:");
-                    var e = Array.from(r);
-                    return this._array(e, t.unorderedSets !== false);
-                },
-                _set: function(r) {
-                    write("set:");
-                    var e = Array.from(r);
-                    return this._array(e, t.unorderedSets !== false);
-                },
-                _file: function(t) {
-                    write("file:");
-                    return this.dispatch([ t.name, t.size, t.type, t.lastModfied ]);
-                },
-                _blob: function() {
-                    if (t.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(t) {
-                    return write("bigint:" + t.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");
                 }
-            };
-        }
-        function PassThrough() {
-            return {
-                buf: "",
-                write: function(t) {
-                    this.buf += t;
-                },
-                end: function(t) {
-                    this.buf += t;
-                },
-                read: function() {
-                    return this.buf;
+            },
+            _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);
+                    }));
                 }
-            };
-        }
-    })(e, e.exports);
-    return e.exports;
-}
+                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]");
+                }
+                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;
+            }
+        };
+    }
+})(e, e.exports);
 
-var o = requireObjectHash();
+var i = e.exports;
 
-const u = t(o);
+const o = r(i);
 
-function ObjectHash(t, r) {
-    return u(t, r);
+function u(r, t) {
+    return o(r, t);
 }
 
-export { ObjectHash };
+export { u as ObjectHash };