cryptpad-server 0.0.1

package/build/front.worker.js

@@ -0,0 +1,4619 @@
+"use strict";
+
+var require$$0 = require("tweetnacl-util");
+
+var require$$1$2 = require("express");
+
+var require$$0$2 = require("node:fs");
+
+var require$$1 = require("node:path");
+
+var require$$3 = require("node:crypto");
+
+var require$$0$1 = require("stream-to-pull-stream");
+
+var require$$1$1 = require("pull-stream");
+
+var require$$5 = require("fs-extra");
+
+var require$$6 = require("nthen");
+
+var require$$4 = require("saferphore");
+
+var require$$4$1 = require("ws");
+
+var require$$6$1 = require("cookie-parser");
+
+var require$$7 = require("body-parser");
+
+function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+var worker$1 = {};
+
+var commonUtil$2 = {
+    exports: {}
+};
+
+var commonUtil$1 = commonUtil$2.exports;
+
+var hasRequiredCommonUtil$1;
+
+function requireCommonUtil$1() {
+    if (hasRequiredCommonUtil$1) return commonUtil$2.exports;
+    hasRequiredCommonUtil$1 = 1;
+    (function(module) {
+        (function(window) {
+            const factory = NaclUtil => {
+                var Util = window.CryptPad_Util = {};
+                window.atob = window.atob || function(str) {
+                    return Buffer.from(str, "base64").toString("binary");
+                };
+                window.btoa = window.btoa || function(str) {
+                    return Buffer.from(str, "binary").toString("base64");
+                };
+                Util.encodeBase64 = NaclUtil.encodeBase64;
+                Util.decodeBase64 = str => {
+                    let i = str.length % 4;
+                    if (i) {
+                        str += "=".repeat(4 - i);
+                    }
+                    return NaclUtil.decodeBase64(str);
+                };
+                Util.encodeUTF8 = NaclUtil.encodeUTF8;
+                Util.decodeUTF8 = NaclUtil.decodeUTF8;
+                Util.slice = function(A, start, end) {
+                    return Array.prototype.slice.call(A, start, end);
+                };
+                Util.u8ToBase64 = (u8, cb) => {
+                    const reader = new FileReader;
+                    reader.onload = () => {
+                        let res = reader.result;
+                        let trim = res.slice(res.indexOf(",") + 1);
+                        cb(trim);
+                    };
+                    reader.readAsDataURL(new Blob([ u8 ]));
+                };
+                Util.shuffleArray = function(a) {
+                    for (var i = a.length - 1; i > 0; i--) {
+                        var j = Math.floor(Math.random() * (i + 1));
+                        var tmp = a[i];
+                        a[i] = a[j];
+                        a[j] = tmp;
+                    }
+                };
+                Util.bake = function(f, args) {
+                    if (typeof args === "undefined") {
+                        args = [];
+                    }
+                    if (!Array.isArray(args)) {
+                        args = [ args ];
+                    }
+                    return function() {
+                        return f.apply(null, args);
+                    };
+                };
+                Util.both = function(pre, post) {
+                    if (typeof pre !== "function") {
+                        throw new Error("INVALID_USAGE");
+                    }
+                    if (typeof post !== "function") {
+                        post = function(x) {
+                            return x;
+                        };
+                    }
+                    return function() {
+                        pre.apply(null, arguments);
+                        return post.apply(null, arguments);
+                    };
+                };
+                Util.clone = function(o) {
+                    if (o === undefined || o === null) {
+                        return o;
+                    }
+                    return JSON.parse(JSON.stringify(o));
+                };
+                Util.serializeError = function(err) {
+                    if (!(err instanceof Error)) {
+                        return err;
+                    }
+                    var ser = {};
+                    Object.getOwnPropertyNames(err).forEach(function(key) {
+                        ser[key] = err[key];
+                    });
+                    return ser;
+                };
+                Util.tryParse = function(s) {
+                    try {
+                        return JSON.parse(s);
+                    } catch (e) {
+                        return;
+                    }
+                };
+                Util.mkAsync = function(f, ms) {
+                    if (typeof f !== "function") {
+                        throw new Error("EXPECTED_FUNCTION");
+                    }
+                    return function() {
+                        var args = Array.prototype.slice.call(arguments);
+                        setTimeout(function() {
+                            f.apply(null, args);
+                        }, ms);
+                    };
+                };
+                Util.mkEvent = function(once) {
+                    var handlers = [];
+                    var fired = false;
+                    let promiseResolve;
+                    const promise = new Promise(resolve => {
+                        promiseResolve = resolve;
+                    });
+                    return {
+                        reg: function(cb) {
+                            if (once && fired) {
+                                return void setTimeout(cb);
+                            }
+                            handlers.push(cb);
+                        },
+                        unreg: function(cb) {
+                            if (handlers.indexOf(cb) === -1) {
+                                return void console.log("event handler was already unregistered");
+                            }
+                            handlers.splice(handlers.indexOf(cb), 1);
+                        },
+                        fire: function() {
+                            if (once && fired) {
+                                return;
+                            }
+                            var args = Array.prototype.slice.call(arguments);
+                            if (!fired) {
+                                promiseResolve.apply(null, args);
+                            }
+                            fired = true;
+                            handlers.forEach(function(h) {
+                                h.apply(null, args);
+                            });
+                        },
+                        promise
+                    };
+                };
+                Util.mkTimeout = function(_f, ms) {
+                    ms = ms || 0;
+                    var f = Util.once(_f);
+                    var timeout = setTimeout(function() {
+                        f("TIMEOUT");
+                    }, ms);
+                    return Util.both(f, function() {
+                        clearTimeout(timeout);
+                    });
+                };
+                Util.onClickEnter = function($element, handler, cfg) {
+                    $element.on("click keydown", function(e) {
+                        var isClick = e.type === "click";
+                        var isEnter = e.type === "keydown" && e.which === 13;
+                        var isSpace = e.type === "keydown" && e.which === 32 && cfg && cfg.space;
+                        if (!isClick && !isEnter && !isSpace) {
+                            return;
+                        }
+                        if (e.type === "keydown") {
+                            e.preventDefault();
+                        }
+                        handler(e);
+                    });
+                };
+                Util.response = function(errorHandler) {
+                    var pending = {};
+                    var timeouts = {};
+                    if (typeof errorHandler !== "function") {
+                        errorHandler = function(label) {
+                            throw new Error(label);
+                        };
+                    }
+                    var clear = function(id) {
+                        clearTimeout(timeouts[id]);
+                        delete timeouts[id];
+                        delete pending[id];
+                    };
+                    var expect = function(id, fn, ms) {
+                        if (typeof id !== "string") {
+                            errorHandler("EXPECTED_STRING");
+                        }
+                        if (typeof fn !== "function") {
+                            errorHandler("EXPECTED_CALLBACK");
+                        }
+                        pending[id] = fn;
+                        if (typeof ms === "number" && ms) {
+                            timeouts[id] = setTimeout(function() {
+                                if (typeof pending[id] === "function") {
+                                    pending[id]("TIMEOUT");
+                                }
+                                clear(id);
+                            }, ms);
+                        }
+                    };
+                    var handle = function(id, args) {
+                        var fn = pending[id];
+                        if (typeof fn !== "function") {
+                            return void errorHandler("MISSING_CALLBACK", {
+                                id,
+                                args
+                            });
+                        }
+                        try {
+                            fn.apply(null, Array.isArray(args) ? args : [ args ]);
+                        } catch (err) {
+                            console.trace(err);
+                            errorHandler("HANDLER_ERROR", {
+                                error: err,
+                                id,
+                                args
+                            });
+                        }
+                        clear(id);
+                    };
+                    return {
+                        clear,
+                        expected: function(id) {
+                            return Boolean(pending[id]);
+                        },
+                        expectation: function(id) {
+                            return pending[id];
+                        },
+                        expect,
+                        handle,
+                        _pending: pending
+                    };
+                };
+                Util.inc = function(map, key, val) {
+                    map[key] = (map[key] || 0) + (typeof val === "number" ? val : 1);
+                };
+                Util.values = function(obj) {
+                    return Object.keys(obj).map(function(k) {
+                        return obj[k];
+                    });
+                };
+                Util.find = function(map, path) {
+                    var l = path.length;
+                    for (var i = 0; i < l; i++) {
+                        if (typeof map[path[i]] === "undefined") {
+                            return;
+                        }
+                        map = map[path[i]];
+                    }
+                    return map;
+                };
+                Util.uid = function() {
+                    return Number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)).toString(32).replace(/\./g, "");
+                };
+                Util.guid = function(map) {
+                    var id = Util.uid();
+                    if (typeof map[id] === "undefined") {
+                        return id;
+                    }
+                    return Util.guid(map);
+                };
+                Util.fixHTML = function(str) {
+                    if (!str) {
+                        return "";
+                    }
+                    return str.replace(/[<>&"']/g, function(x) {
+                        return {
+                            "<": "&lt;",
+                            ">": "&gt",
+                            "&": "&amp;",
+                            '"': "&#34;",
+                            "'": "&#39;"
+                        }[x];
+                    });
+                };
+                Util.hexToBase64 = function(hex) {
+                    var hexArray = hex.replace(/\r|\n/g, "").replace(/([\da-fA-F]{2}) ?/g, "0x$1 ").replace(/ +$/, "").split(" ");
+                    var byteString = String.fromCharCode.apply(null, hexArray);
+                    return window.btoa(byteString).replace(/\//g, "-").replace(/=+$/, "");
+                };
+                Util.base64ToHex = function(b64String) {
+                    var hexArray = [];
+                    window.atob(b64String.replace(/-/g, "/")).split("").forEach(function(e) {
+                        var h = e.charCodeAt(0).toString(16);
+                        if (h.length === 1) {
+                            h = "0" + h;
+                        }
+                        hexArray.push(h);
+                    });
+                    return hexArray.join("");
+                };
+                Util.uint8ArrayToHex = function(bytes) {
+                    var hexString = "";
+                    for (var i = 0; i < bytes.length; i++) {
+                        if (bytes[i] < 16) {
+                            hexString += "0";
+                        }
+                        hexString += bytes[i].toString(16);
+                    }
+                    return hexString;
+                };
+                Util.hexToUint8Array = function(hexString) {
+                    var bytes = new Uint8Array(Math.ceil(hexString.length / 2));
+                    for (var i = 0; i < bytes.length; i++) {
+                        bytes[i] = parseInt(hexString.substr(i * 2, 2), 16);
+                    }
+                    return bytes;
+                };
+                Util.uint8ArrayJoin = function(AA) {
+                    var l = 0;
+                    var i = 0;
+                    for (;i < AA.length; i++) {
+                        l += AA[i].length;
+                    }
+                    var C = new Uint8Array(l);
+                    i = 0;
+                    for (var offset = 0; i < AA.length; i++) {
+                        C.set(AA[i], offset);
+                        offset += AA[i].length;
+                    }
+                    return C;
+                };
+                Util.escapeKeyCharacters = function(key) {
+                    return key && key.replace && key.replace(/\//g, "-");
+                };
+                Util.unescapeKeyCharacters = function(key) {
+                    return key.replace(/\-/g, "/");
+                };
+                Util.deduplicateString = function(array) {
+                    return Array.from(new Set(array));
+                };
+                Util.fixFileName = function(filename) {
+                    return filename.replace(/ /g, "-").replace(/[\/\?]/g, "_").replace(/_+/g, "_");
+                };
+                var oneKilobyte = 1024;
+                var oneMegabyte = 1024 * oneKilobyte;
+                var oneGigabyte = 1024 * oneMegabyte;
+                Util.bytesToGigabytes = function(bytes) {
+                    return Math.ceil(bytes / oneGigabyte * 100) / 100;
+                };
+                Util.bytesToMegabytes = function(bytes) {
+                    return Math.ceil(bytes / oneMegabyte * 100) / 100;
+                };
+                Util.bytesToKilobytes = function(bytes) {
+                    return Math.ceil(bytes / oneKilobyte * 100) / 100;
+                };
+                Util.magnitudeOfBytes = function(bytes) {
+                    if (bytes >= oneGigabyte) {
+                        return "GB";
+                    } else if (bytes >= oneMegabyte) {
+                        return "MB";
+                    } else {
+                        return "KB";
+                    }
+                };
+                var getCacheKey = function(src) {
+                    var _src = src.replace(/(\/)*$/, "");
+                    var idx = _src.lastIndexOf("/");
+                    var cacheKey = _src.slice(idx + 1);
+                    if (!/^[a-f0-9]{48}$/.test(cacheKey)) {
+                        cacheKey = undefined;
+                    }
+                    return cacheKey;
+                };
+                Util.getBlock = function(src, opt, cb) {
+                    var CB = Util.once(Util.mkAsync(cb));
+                    var headers = {};
+                    if (typeof opt.bearer === "string" && opt.bearer) {
+                        headers.authorization = `Bearer ${opt.bearer}`;
+                    }
+                    fetch(src, {
+                        method: "GET",
+                        credentials: "include",
+                        headers
+                    }).then(response => {
+                        if (response.ok) {
+                            return void CB(void 0, response);
+                        }
+                        if (response.status === 401 || response.status === 404) {
+                            response.json().then(data => {
+                                CB(response.status, data);
+                            }).catch(() => {
+                                CB(response.status);
+                            });
+                            return;
+                        }
+                        CB(response.status, response);
+                    }).catch(error => {
+                        CB(error);
+                    });
+                };
+                Util.fetchApi = function(origin, type, ignoreCache, cb) {
+                    const url = new URL(origin);
+                    url.pathname = `api/${type}`;
+                    let href = url.href + (ignoreCache ? "?" + +new Date : "");
+                    if (typeof self !== "undefined" && self.crypto) {
+                        fetch(href).then(res => {
+                            if (!res.ok) {
+                                throw new Error(`Fetch error: ${res.status}`);
+                            }
+                            return res.text();
+                        }).then(body => {
+                            cb(JSON.parse(body.slice(27, -5)));
+                        }).catch(err => {
+                            console.error(err.message);
+                            cb({});
+                        });
+                    } else if (typeof require !== "undefined") {
+                        const H = url.protocol === "http:" ? require("node:http") : require("node:https");
+                        H.get(url.href, res => {
+                            let body = "";
+                            res.on("data", data => {
+                                body += data;
+                            });
+                            res.on("end", () => {
+                                try {
+                                    cb(JSON.parse(body.slice(27, -5)));
+                                } catch (e) {
+                                    console.error(e);
+                                    cb({});
+                                }
+                            });
+                        });
+                    }
+                };
+                Util.fetch = function(src, cb, progress, cache) {
+                    var CB = Util.once(Util.mkAsync(cb));
+                    var cacheKey = getCacheKey(src);
+                    var getBlobCache = function(id, cb) {
+                        if (!cache || typeof cache.getBlobCache !== "function") {
+                            return void cb("EINVAL");
+                        }
+                        cache.getBlobCache(id, cb);
+                    };
+                    var setBlobCache = function(id, u8, cb) {
+                        if (!cache || typeof cache.setBlobCache !== "function") {
+                            return void cb("EINVAL");
+                        }
+                        cache.setBlobCache(id, u8, cb);
+                    };
+                    var xhr;
+                    var fetch = function() {
+                        xhr = new XMLHttpRequest;
+                        xhr.open("GET", src, true);
+                        if (progress) {
+                            xhr.addEventListener("progress", function(evt) {
+                                if (evt.lengthComputable) {
+                                    var percentComplete = evt.loaded / evt.total;
+                                    progress(percentComplete);
+                                }
+                            }, false);
+                        }
+                        xhr.responseType = "arraybuffer";
+                        xhr.onerror = function(err) {
+                            CB(err);
+                        };
+                        xhr.onload = function() {
+                            if (/^4/.test("" + this.status)) {
+                                return CB("XHR_ERROR");
+                            }
+                            var arrayBuffer = xhr.response;
+                            if (arrayBuffer) {
+                                var u8 = new Uint8Array(arrayBuffer);
+                                if (cacheKey) {
+                                    return void setBlobCache(cacheKey, u8, function() {
+                                        CB(null, u8);
+                                    });
+                                }
+                                return void CB(void 0, u8);
+                            }
+                            CB("ENOENT");
+                        };
+                        xhr.send(null);
+                    };
+                    if (!cacheKey) {
+                        return void fetch();
+                    }
+                    getBlobCache(cacheKey, function(err, u8) {
+                        if (err || !u8) {
+                            return void fetch();
+                        }
+                        CB(void 0, u8);
+                    });
+                    return {
+                        cancel: function() {
+                            if (xhr && xhr.abort) {
+                                xhr.abort();
+                            }
+                        }
+                    };
+                };
+                Util.dataURIToBlob = function(dataURI) {
+                    var byteString = atob(dataURI.split(",")[1]);
+                    var mimeString = dataURI.split(",")[0].split(":")[1].split(";")[0];
+                    var ab = new ArrayBuffer(byteString.length);
+                    var ia = new Uint8Array(ab);
+                    for (var i = 0; i < byteString.length; i++) {
+                        ia[i] = byteString.charCodeAt(i);
+                    }
+                    var bb = new Blob([ ab ], {
+                        type: mimeString
+                    });
+                    return bb;
+                };
+                Util.throttle = function(f, ms) {
+                    var last = 0;
+                    var to;
+                    var args;
+                    var defer = function(delay) {
+                        to = setTimeout(function() {
+                            to = undefined;
+                            var now = +new Date;
+                            var diff = now - last;
+                            if (diff < ms) {
+                                return void defer(ms - diff);
+                            }
+                            f.apply(null, args);
+                        }, delay);
+                    };
+                    var g = function() {
+                        last = +new Date;
+                        args = Util.slice(arguments);
+                        if (to) {
+                            return;
+                        }
+                        defer(ms);
+                    };
+                    g.clear = function() {
+                        clearTimeout(to);
+                        to = undefined;
+                    };
+                    return g;
+                };
+                Util.notAgainForAnother = function(f, t) {
+                    if (typeof f !== "function" || typeof t !== "number") {
+                        throw new Error("invalid inputs");
+                    }
+                    var last = null;
+                    return function() {
+                        var now = +new Date;
+                        if (last && now <= last + t) {
+                            return t - (now - last);
+                        }
+                        last = now;
+                        f.apply(null, Util.slice(arguments));
+                        return null;
+                    };
+                };
+                Util.createRandomInteger = function() {
+                    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+                };
+                Util.noop = function() {};
+                Util.once = function(f, g) {
+                    return function() {
+                        if (!f) {
+                            return;
+                        }
+                        f.apply(this, Array.prototype.slice.call(arguments));
+                        f = g;
+                    };
+                };
+                Util.blobToImage = function(blob, cb) {
+                    var reader = new FileReader;
+                    reader.onloadend = function() {
+                        cb(reader.result);
+                    };
+                    reader.readAsDataURL(blob);
+                };
+                Util.blobURLToImage = function(url, cb) {
+                    var xhr = new XMLHttpRequest;
+                    xhr.onload = function() {
+                        var reader = new FileReader;
+                        reader.onloadend = function() {
+                            cb(reader.result);
+                        };
+                        reader.readAsDataURL(xhr.response);
+                    };
+                    xhr.open("GET", url);
+                    xhr.responseType = "blob";
+                    xhr.send();
+                };
+                Util.isObject = function(o) {
+                    return typeof o === "object" && Object.prototype.toString.call(o) === "[object Object]";
+                };
+                Util.isCircular = function(o) {
+                    try {
+                        JSON.stringify(o);
+                        return false;
+                    } catch (e) {
+                        return true;
+                    }
+                };
+                Util.extend = function(a, b) {
+                    if (!Util.isObject(a) || !Util.isObject(b)) {
+                        return void console.log("Extend only works with 2 objects");
+                    }
+                    if (Util.isCircular(b)) {
+                        return void console.log("Extend doesn't accept circular objects");
+                    }
+                    for (var k in b) {
+                        if (Util.isObject(b[k])) {
+                            a[k] = Util.isObject(a[k]) ? a[k] : {};
+                            Util.extend(a[k], b[k]);
+                            continue;
+                        }
+                        if (Array.isArray(b[k])) {
+                            a[k] = b[k].slice();
+                            continue;
+                        }
+                        a[k] = b[k];
+                    }
+                };
+                Util.isChecked = function(el) {
+                    if (!el) {
+                        return false;
+                    }
+                    if (typeof el.tagName !== "undefined") {
+                        return Boolean(el.checked);
+                    }
+                    if (typeof el.prop === "function") {
+                        return Boolean(el.prop("checked"));
+                    }
+                    return false;
+                };
+                Util.hexToRGB = function(hex) {
+                    var h = hex.replace(/^#/, "");
+                    return [ parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16) ];
+                };
+                Util.rgbToHex = function(rgb) {
+                    return `#${rgb.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/).slice(1).map(n => parseInt(n, 10).toString(16).padStart(2, "0")).join("")}`;
+                };
+                Util.isSmallScreen = function() {
+                    return window.innerHeight < 800 || window.innerWidth < 800;
+                };
+                Util.stripTags = function(text) {
+                    var div = document.createElement("div");
+                    div.innerHTML = text;
+                    return div.innerText;
+                };
+                Util.parseFilename = function(filename) {
+                    if (!filename || !filename.trim()) {
+                        return {};
+                    }
+                    var parsedName = /^(\.?.+?)(\.[^.]+)?$/.exec(filename) || [];
+                    return {
+                        name: parsedName[1],
+                        ext: parsedName[2]
+                    };
+                };
+                Util.isPlainTextFile = function(type, name) {
+                    if (type && type.indexOf("text/") === 0) {
+                        return true;
+                    }
+                    var parsedName = Util.parseFilename(name);
+                    if (!type && name && !parsedName.ext) {
+                        return true;
+                    }
+                    if (type === "application/x-javascript") {
+                        return true;
+                    }
+                    if (type === "application/xml") {
+                        return true;
+                    }
+                    return false;
+                };
+                Util.isSpreadsheet = function(type, name) {
+                    return type && (type === "application/vnd.oasis.opendocument.spreadsheet" || type === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") || name && (name.endsWith(".xlsx") || name.endsWith(".ods"));
+                };
+                Util.isOfficeDoc = function(type, name) {
+                    return type && (type === "application/vnd.oasis.opendocument.text" || type === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") || name && (name.endsWith(".docx") || name.endsWith(".odt"));
+                };
+                Util.isPresentation = function(type, name) {
+                    return type && (type === "application/vnd.oasis.opendocument.presentation" || type === "application/vnd.openxmlformats-officedocument.presentationml.presentation") || name && (name.endsWith(".pptx") || name.endsWith(".odp"));
+                };
+                Util.isValidURL = function(str) {
+                    var pattern = new RegExp("^(https?:\\/\\/)" + "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + "((\\d{1,3}\\.){3}\\d{1,3}))" + "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + "(\\?[;&a-z\\d%_.~+=-]*)?");
+                    return !!pattern.test(str);
+                };
+                var emoji_patt = /([\uD800-\uDBFF][\uDC00-\uDFFF])/;
+                var isEmoji = function(str) {
+                    return emoji_patt.test(str);
+                };
+                var emojiStringToArray = function(str) {
+                    var split = str.split(emoji_patt);
+                    var arr = [];
+                    for (var i = 0; i < split.length; i++) {
+                        var char = split[i];
+                        if (char !== "") {
+                            arr.push(char);
+                        }
+                    }
+                    return arr;
+                };
+                Util.getFirstCharacter = function(str) {
+                    if (!str || !str.trim()) {
+                        return "?";
+                    }
+                    var emojis = emojiStringToArray(str);
+                    return isEmoji(emojis[0]) ? emojis[0] : str[0];
+                };
+                Util.getRandomColor = function(light) {
+                    var getColor = function() {
+                        if (light) {
+                            return Math.floor(Math.random() * 156) + 70;
+                        }
+                        return Math.floor(Math.random() * 200) + 25;
+                    };
+                    return "#" + getColor().toString(16) + getColor().toString(16) + getColor().toString(16);
+                };
+                Util.checkRestrictedApp = function(app, AppConfig, earlyTypes, plan, loggedIn) {
+                    if (Array.isArray(earlyTypes) && earlyTypes.includes(app) && !AppConfig.enableEarlyAccess) {
+                        return -2;
+                    }
+                    var premiumTypes = AppConfig.premiumTypes;
+                    if (!Array.isArray(premiumTypes) || !premiumTypes.includes(app)) {
+                        return 2;
+                    }
+                    if (!loggedIn) {
+                        return -1;
+                    }
+                    return plan ? 1 : 0;
+                };
+                var supportsSharedArrayBuffers = function() {
+                    try {
+                        return Object.prototype.toString.call(new window.WebAssembly.Memory({
+                            shared: true,
+                            initial: 0,
+                            maximum: 0
+                        }).buffer) === "[object SharedArrayBuffer]";
+                    } catch (err) {
+                        console.error(err);
+                    }
+                    return false;
+                };
+                Util.supportsWasm = function() {
+                    return !(typeof Atomics === "undefined" || !supportsSharedArrayBuffers() || typeof WebAssembly === "undefined");
+                };
+                Util.getKeysArray = function(length) {
+                    return [ ...Array(length).keys() ];
+                };
+                Util.getVersionFromUrlArgs = urlArgs => {
+                    let arr = /ver=([0-9.]+)(-[0-9]*)?/.exec(urlArgs);
+                    let ver = Array.isArray(arr) && arr[1];
+                    return ver || undefined;
+                };
+                Util.Saferphore = {
+                    create: resourceCount => {
+                        var queue = [];
+                        var check;
+                        var mkRa = function() {
+                            var outerCalled = 0;
+                            return function(func) {
+                                if (outerCalled++) {
+                                    throw new Error("returnAfter() called multiple times");
+                                }
+                                var called = 0;
+                                return function() {
+                                    if (called++) {
+                                        throw new Error("returnAfter wrapped callback called multiple times");
+                                    }
+                                    if (func) {
+                                        func.apply(null, arguments);
+                                    }
+                                    resourceCount++;
+                                    check();
+                                };
+                            };
+                        };
+                        check = function() {
+                            if (resourceCount < 0) {
+                                throw new Error("(resourceCount < 0) should never happen");
+                            }
+                            if (resourceCount === 0 || queue.length === 0) {
+                                return;
+                            }
+                            resourceCount--;
+                            queue.shift()(mkRa());
+                        };
+                        return {
+                            take: function(func) {
+                                queue.push(func);
+                                check();
+                            }
+                        };
+                    }
+                };
+                return Util;
+            };
+            if (module.exports) {
+                module.exports = factory(require$$0);
+            }
+        })(typeof self !== "undefined" ? self : commonUtil$1);
+    })(commonUtil$2);
+    return commonUtil$2.exports;
+}
+
+var version = "0.0.1";
+
+var require$$2 = {
+    version
+};
+
+var keys = {
+    exports: {}
+};
+
+var hasRequiredKeys;
+
+function requireKeys() {
+    if (hasRequiredKeys) return keys.exports;
+    hasRequiredKeys = 1;
+    (function(module) {
+        (function() {
+            var factory = function() {
+                var Keys = {};
+                var unescape = function(s) {
+                    return s.replace(/-/g, "/");
+                };
+                var parseNewUser = function(userString) {
+                    if (!/^\[.*?@.*\]$/.test(userString)) {
+                        return;
+                    }
+                    var temp = userString.slice(1, -1);
+                    var domain, username, pubkey;
+                    temp = temp.replace(/\/([a-zA-Z0-9+-]{43}=)$/, function(all, k) {
+                        pubkey = unescape(k);
+                        return "";
+                    });
+                    if (!pubkey) {
+                        return;
+                    }
+                    var index = temp.lastIndexOf("@");
+                    if (index < 1) {
+                        return;
+                    }
+                    domain = temp.slice(index + 1);
+                    username = temp.slice(0, index);
+                    return {
+                        domain,
+                        user: username,
+                        pubkey
+                    };
+                };
+                var isValidUser = function(parsed) {
+                    if (!parsed) {
+                        return;
+                    }
+                    if (!(parsed.domain && parsed.user && parsed.pubkey)) {
+                        return;
+                    }
+                    return true;
+                };
+                Keys.parseUser = function(user) {
+                    var parsed = parseNewUser(user);
+                    if (isValidUser(parsed)) {
+                        return parsed;
+                    }
+                    var domain, username, pubkey;
+                    user.replace(/^https*:\/\/([^\/]+)\/user\/#\/1\/([^\/]+)\/([a-zA-Z0-9+-]{43}=)$/, function(a, d, u, k) {
+                        domain = d;
+                        username = u;
+                        pubkey = unescape(k);
+                        return "";
+                    });
+                    if (!domain) {
+                        throw new Error("Could not parse user id [" + user + "]");
+                    }
+                    return {
+                        domain,
+                        user: username,
+                        pubkey
+                    };
+                };
+                Keys.serialize = function(origin, username, pubkey) {
+                    return "[" + username + "@" + origin.replace(/https*:\/\//, "") + "/" + pubkey.replace(/\//g, "-") + "]";
+                };
+                Keys.canonicalize = function(input) {
+                    if (typeof input !== "string") {
+                        return;
+                    }
+                    if (input.length === 44) {
+                        return unescape(input);
+                    }
+                    try {
+                        return Keys.parseUser(input).pubkey;
+                    } catch (err) {
+                        return;
+                    }
+                };
+                return Keys;
+            };
+            if (module.exports) {
+                module.exports = factory();
+            }
+        })();
+    })(keys);
+    return keys.exports;
+}
+
+var core = {
+    exports: {}
+};
+
+var constants;
+
+var hasRequiredConstants;
+
+function requireConstants() {
+    if (hasRequiredConstants) return constants;
+    hasRequiredConstants = 1;
+    const Constants = {};
+    Constants.CHECKPOINT_PATTERN = /^cp\|(([A-Za-z0-9+/=]+)\|)?/;
+    Constants.STANDARD_CHANNEL_LENGTH = 32;
+    Constants.ADMIN_CHANNEL_LENGTH = 33;
+    Constants.EPHEMERAL_CHANNEL_LENGTH = 34;
+    Constants.BLOB_ID_LENGTH = 48;
+    Constants.publicKeyLength = 32;
+    Constants.hkId = "0123456789abcdef";
+    Constants.TEMPORARY_CHANNEL_LIFETIME = 30 * 1e3;
+    Constants.paths = {
+        base: "./data/",
+        channel: "channel/",
+        blob: "blob/",
+        blobstage: "blobstage/",
+        block: "block/",
+        pin: "pins/",
+        archive: "archive/",
+        tasks: "tasks/",
+        decrees: "decrees/",
+        challenges: "challenges/",
+        logo: "logo/"
+    };
+    Constants.adminDecree = "decree.ndjson";
+    constants = Constants;
+    return constants;
+}
+
+var hasRequiredCore;
+
+function requireCore() {
+    if (hasRequiredCore) return core.exports;
+    hasRequiredCore = 1;
+    (function(module) {
+        const Core = module.exports;
+        const Util = requireCommonUtil$1();
+        const Constants = requireConstants();
+        const escapeKeyCharacters = Util.escapeKeyCharacters;
+        const Path = require$$1;
+        const Crypto = require$$3;
+        const Keys = requireKeys();
+        Core.DEFAULT_LIMIT = 50 * 1024 * 1024;
+        Core.SESSION_EXPIRATION_TIME = 60 * 1e3;
+        Core.isValidId = chan => chan && chan.length && /^[a-zA-Z0-9=+-]*$/.test(chan) && [ Constants.STANDARD_CHANNEL_LENGTH, Constants.ADMIN_CHANNEL_LENGTH, Constants.BLOB_ID_LENGTH ].indexOf(chan.length) > -1;
+        Core.isValidPublicKey = owner => typeof owner === "string" && owner.length === 44;
+        Core.isValidBlockId = id => typeof id === "string" && id.length === 44;
+        const makeToken = Core.makeToken = () => Number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)).toString(16);
+        Core.makeCookie = function(token) {
+            let time = +new Date;
+            time -= time % 5e3;
+            return [ time, process.pid, token ];
+        };
+        const parseCookie = cookie => {
+            if (!(cookie && cookie.split)) {
+                return null;
+            }
+            let parts = cookie.split("|");
+            if (parts.length !== 3) {
+                return null;
+            }
+            let c = {};
+            c.time = new Date(parts[0]);
+            c.pid = Number(parts[1]);
+            c.seq = parts[2];
+            return c;
+        };
+        Core.getSession = (Sessions, key) => {
+            let safeKey = escapeKeyCharacters(key);
+            if (Sessions[safeKey]) {
+                Sessions[safeKey].atime = +new Date;
+                return Sessions[safeKey];
+            }
+            let user = Sessions[safeKey] = {};
+            user.atime = +new Date;
+            user.tokens = [ makeToken() ];
+            return user;
+        };
+        Core.expireSession = (Sessions, safeKey) => {
+            let session = Sessions[safeKey];
+            if (!session) {
+                return;
+            }
+            if (session.blobstage) {
+                session.blobstage.close();
+            }
+            delete Sessions[safeKey];
+        };
+        Core.expireSessionAsync = (Env, safeKey, cb) => {
+            setTimeout(() => {
+                Core.expireSession(Env.Sessions, safeKey);
+                cb(void 0, "OK");
+            });
+        };
+        const isTooOld = (time, now) => now - time > 3e5;
+        Core.expireSessions = Sessions => {
+            let now = +new Date;
+            Object.keys(Sessions).forEach(safeKey => {
+                let session = Sessions[safeKey];
+                if (session && isTooOld(session.atime, now)) {
+                    Core.expireSession(Sessions, safeKey);
+                }
+            });
+        };
+        const addTokenForKey = (Sessions, publicKey, token) => {
+            if (!Sessions[publicKey]) {
+                throw new Error("undefined user");
+            }
+            let user = Core.getSession(Sessions, publicKey);
+            user.tokens.push(token);
+            user.atime = +new Date;
+            if (user.tokens.length > 2) {
+                user.tokens.shift();
+            }
+        };
+        Core.isValidCookie = (Sessions, publicKey, cookie) => {
+            let parsed = parseCookie(cookie);
+            if (!parsed) {
+                return false;
+            }
+            let now = +new Date;
+            if (!parsed.time) {
+                return false;
+            }
+            if (isTooOld(parsed.time, now)) {
+                return false;
+            }
+            if (process.pid !== parsed.pid) {
+                return false;
+            }
+            let user = Core.getSession(Sessions, publicKey);
+            if (!user) {
+                return false;
+            }
+            let idx = user.tokens.indexOf(parsed.seq);
+            if (idx === -1) {
+                return false;
+            }
+            if (idx > 0) {
+                addTokenForKey(Sessions, publicKey, Core.makeToken());
+            }
+            return true;
+        };
+        Core.hasOwners = function(metadata) {
+            return Boolean(metadata && Array.isArray(metadata.owners));
+        };
+        Core.hasPendingOwners = function(metadata) {
+            return Boolean(metadata && Array.isArray(metadata.pending_owners));
+        };
+        Core.isOwner = function(metadata, unsafeKey) {
+            return metadata.owners.indexOf(unsafeKey) !== -1;
+        };
+        Core.isPendingOwner = function(metadata, unsafeKey) {
+            return metadata.pending_owners.indexOf(unsafeKey) !== -1;
+        };
+        Core.haveACookie = function(Env, safeKey, cb) {
+            cb();
+        };
+        Core.getPaths = (mainConfig, isEnv) => {
+            const {index, config} = mainConfig;
+            const paths = Constants.paths;
+            const idx = String(index);
+            const all = {
+                basePath: config.basePath || Path.join(paths.base, idx),
+                filePath: config.filePath || Path.join(paths.base, idx, paths.channel),
+                blobPath: config.blobPath || Path.join(paths.base, idx, paths.blob),
+                blobStagingPath: config.blobStagingPath || Path.join(paths.base, idx, paths.blobstage),
+                blockPath: config.blockPath || Path.join(paths.base, idx, paths.block),
+                pinPath: config.pinPath || Path.join(paths.base, idx, paths.pin),
+                archivePath: config.archivePath || Path.join(paths.base, idx, paths.archive),
+                taskPath: config.taskPath || Path.join(paths.base, idx, paths.tasks),
+                decreePath: config.decreePath || Path.join(paths.base, "0", paths.decrees),
+                logoPath: config.logoPath || Path.join(paths.base, "0", paths.logo),
+                challengePath: config.challengePath || Path.join(paths.base, idx, paths.challenges)
+            };
+            if (!isEnv) {
+                return all;
+            }
+            return {
+                channel: all.filePath,
+                data: all.filePath,
+                blob: all.blobPath,
+                block: all.blockPath,
+                staging: all.blobStagingPath,
+                pin: all.pinPath,
+                decree: all.decreePath,
+                logo: all.logoPath,
+                base: all.basePath,
+                archive: all.archivePath,
+                task: all.taskPath
+            };
+        };
+        Core.getChannelsStorage = (Env, channels) => {
+            const channelsByStorage = {};
+            channels.forEach(channel => {
+                const storageId = Env.getStorageId(channel);
+                const list = channelsByStorage[storageId] ||= new Set;
+                list.add(channel);
+            });
+            Object.keys(channelsByStorage).forEach(storageId => {
+                channelsByStorage[storageId] = Array.from(channelsByStorage[storageId]);
+            });
+            return channelsByStorage;
+        };
+        Core.getChannelsCore = (Env, channels) => {
+            const channelsByCore = {};
+            channels.forEach(channel => {
+                const coreId = Env.getCoreId(channel);
+                const list = channelsByCore[coreId] ||= new Set;
+                list.add(channel);
+            });
+            Object.keys(channelsByCore).forEach(coreId => {
+                channelsByCore[coreId] = Array.from(channelsByCore[coreId]);
+            });
+            return channelsByCore;
+        };
+        Core.getUsersFront = (Env, users) => {
+            const usersByFront = {};
+            users.forEach(userId => {
+                const frontId = Env.userCache?.[userId]?.from;
+                if (!frontId) {
+                    return;
+                }
+                const list = usersByFront[frontId] ||= new Set;
+                list.add(userId);
+            });
+            Object.keys(usersByFront).forEach(frontId => {
+                usersByFront[frontId] = Array.from(usersByFront[frontId]);
+            });
+            return usersByFront;
+        };
+        const validLimitFields = [ "limit", "plan", "note", "users", "origin" ];
+        Core.isValidLimit = o => {
+            var valid = o && typeof o === "object" && typeof o.limit === "number" && typeof o.plan === "string" && typeof o.note === "string" && (Array.isArray(o.users) || typeof o.users === "undefined") && !Object.keys(o).some(function(k) {
+                return validLimitFields.indexOf(k) === -1;
+            });
+            return valid;
+        };
+        Core.applyLimits = Env => {
+            const customLimits = function(custom) {
+                const limits = {};
+                Object.keys(custom).forEach(k => {
+                    const unsafeKey = Keys.canonicalize(k);
+                    if (!unsafeKey) {
+                        return;
+                    }
+                    limits[unsafeKey] = custom[k];
+                });
+                return limits;
+            }(Env.customLimits || {});
+            Env.limits = Env.limits || {};
+            Object.keys(customLimits).forEach(k => {
+                if (!Core.isValidLimit(customLimits[k])) {
+                    return;
+                }
+                Env.limits[k] = customLimits[k];
+            });
+        };
+        Core.coreToStorage = (Env, id, cmd, data, cb) => {
+            const storageId = Env.getStorageId(id);
+            Env.interface.sendQuery(storageId, cmd, data, res => {
+                if (res.error) {
+                    return void cb(res.error);
+                }
+                cb(void 0, res.data);
+            });
+        };
+        Core.storageToStorage = (Env, id, cmd, data, cb) => {
+            if (id === "all") {
+                Env.interface.broadcast("storage", cmd, data, (errors, data) => {
+                    if (errors && errors.length) {
+                        return void cb(errors, data);
+                    }
+                    cb(void 0, data);
+                });
+                return;
+            }
+            const storageId = Env.getStorageId(id);
+            Env.interface.sendQuery(storageId, cmd, data, res => {
+                if (res.error) {
+                    return void cb(res.error);
+                }
+                cb(void 0, res.data);
+            });
+        };
+        Core.storageToFront = (Env, cmd, data, cb) => {
+            const id = String(+new Date);
+            const coreId = Env.getCoreId(id);
+            Env.interface.sendQuery(coreId, "STORAGE_FRONT", {
+                cmd,
+                data
+            }, res => {
+                if (res.error) {
+                    return void cb(res.error);
+                }
+                cb(void 0, res.data);
+            });
+        };
+        Core.checkStorage = (Env, id, cmd, data, cb) => {
+            const storageId = Env.getStorageId(id);
+            if (storageId !== Env.myId) {
+                Core.storageToStorage(Env, id, cmd, data, cb);
+                return false;
+            }
+            return true;
+        };
+        Core.createChannelId = () => Crypto.randomBytes(16).toString("hex");
+    })(core);
+    return core.exports;
+}
+
+var defaults = {
+    exports: {}
+};
+
+var hasRequiredDefaults;
+
+function requireDefaults() {
+    if (hasRequiredDefaults) return defaults.exports;
+    hasRequiredDefaults = 1;
+    (function(module) {
+        var Default = module.exports;
+        Default.commonCSP = function(Env) {
+            var domain = Env.httpUnsafeOrigin;
+            var sandbox = Env.httpSafeOrigin;
+            sandbox = sandbox && sandbox !== domain ? sandbox : "";
+            var accounts_api = Env.accounts_api || "";
+            var wsURL = domain.replace("https://", "wss://").replace("http://", "ws://");
+            return [ `default-src 'none'`, `style-src 'unsafe-inline' 'self' ${domain}`, `font-src 'self' data: ${domain}`, `child-src ${domain}`, `frame-src 'self' blob: ${sandbox}`, `connect-src 'self' blob: ${domain} ${sandbox} ${accounts_api} ${wsURL}`, `img-src 'self' data: blob: ${domain}`, `media-src blob:`, Env.enableEmbedding ? `frame-ancestors 'self' ${Env.protocol} vector:` : `frame-ancestors 'self' ${domain}`, `worker-src 'self'`, "" ];
+        };
+        Default.contentSecurity = function(Env) {
+            return (Default.commonCSP(Env).join("; ") + "script-src 'self' resource: " + Env.httpUnsafeOrigin).replace(/\s+/g, " ");
+        };
+        Default.padContentSecurity = function(Env) {
+            return (Default.commonCSP(Env).join("; ") + "script-src 'self' 'unsafe-eval' 'unsafe-inline' resource: " + Env.httpUnsafeOrigin).replace(/\s+/g, " ");
+        };
+        Default.httpHeaders = function(Env) {
+            return {
+                "X-XSS-Protection": "1; mode=block",
+                "X-Content-Type-Options": "nosniff",
+                "Access-Control-Allow-Origin": Env.enableEmbedding ? "*" : Env.permittedEmbedders,
+                "Referrer-Policy": "same-origin",
+                "Permissions-policy": "interest-cohort=()"
+            };
+        };
+        Default.mainPages = function() {
+            return [ "index", "contact", "features", "maintenance" ];
+        };
+        Default.recommendedVersion = [ 16, 14, 2 ];
+    })(defaults);
+    return defaults.exports;
+}
+
+var streamFile = {
+    exports: {}
+};
+
+var hasRequiredStreamFile;
+
+function requireStreamFile() {
+    if (hasRequiredStreamFile) return streamFile.exports;
+    hasRequiredStreamFile = 1;
+    (function(module) {
+        const ToPull = require$$0$1;
+        const Pull = require$$1$1;
+        const Stream = module.exports;
+        const NEWLINE_CHR = "\n".charCodeAt(0);
+        const mkBufferSplit = () => {
+            let remainder = null;
+            return Pull(read => (abort, cb) => {
+                read(abort, function(end, data) {
+                    if (end) {
+                        if (data) {
+                            console.log("mkBufferSplit() Data at the end");
+                        }
+                        cb(end, remainder ? [ remainder, data ] : [ data ]);
+                        remainder = null;
+                        return;
+                    }
+                    const queue = [];
+                    for (;;) {
+                        const offset = data.indexOf(NEWLINE_CHR);
+                        if (offset < 0) {
+                            remainder = remainder ? Buffer.concat([ remainder, data ]) : data;
+                            break;
+                        }
+                        let subArray = data.slice(0, offset);
+                        if (remainder) {
+                            subArray = Buffer.concat([ remainder, subArray ]);
+                            remainder = null;
+                        }
+                        queue.push(subArray);
+                        data = data.slice(offset + 1);
+                    }
+                    cb(end, queue);
+                });
+            }, Pull.flatten());
+        };
+        const mkOffsetCounter = offset => {
+            offset = offset || 0;
+            return Pull.map(buff => {
+                const out = {
+                    offset,
+                    buff
+                };
+                offset += buff.length + 1;
+                return out;
+            });
+        };
+        Stream.readFileBin = (stream, msgHandler, cb, opt) => {
+            opt = opt || {};
+            let keepReading = true;
+            Pull(ToPull.read(stream), mkBufferSplit(), mkOffsetCounter(opt.offset), Pull.asyncMap((data, moreCb) => {
+                msgHandler(data, moreCb, () => {
+                    try {
+                        stream.close();
+                    } catch (err) {
+                        console.error("READ_FILE_BIN_ERR", err);
+                    }
+                    keepReading = false;
+                    moreCb();
+                });
+            }), Pull.drain(() => keepReading, err => {
+                cb(keepReading ? err : undefined);
+            }));
+        };
+    })(streamFile);
+    return streamFile.exports;
+}
+
+var writeQueue;
+
+var hasRequiredWriteQueue;
+
+function requireWriteQueue() {
+    if (hasRequiredWriteQueue) return writeQueue;
+    hasRequiredWriteQueue = 1;
+    var fix1 = function(f, x) {
+        return function() {
+            f(x);
+        };
+    };
+    writeQueue = function() {
+        var map = {};
+        var next = function(id) {
+            setTimeout(function() {
+                if (!map[id] || map[id].length === 0) {
+                    return void delete map[id];
+                }
+                var task = map[id].shift();
+                task(fix1(next, id));
+            });
+        };
+        return function(id, task) {
+            if (typeof id === "function" && typeof task === "undefined") {
+                task = id;
+                id = "";
+            }
+            if (typeof task !== "function") {
+                throw new Error("Expected function");
+            }
+            if (map[id]) {
+                return void map[id].push(task);
+            }
+            map[id] = [ task ];
+            next(id);
+        };
+    };
+    return writeQueue;
+}
+
+var commonUtil;
+
+var hasRequiredCommonUtil;
+
+function requireCommonUtil() {
+    if (hasRequiredCommonUtil) return commonUtil;
+    hasRequiredCommonUtil = 1;
+    commonUtil = requireCommonUtil$1();
+    return commonUtil;
+}
+
+var schedule;
+
+var hasRequiredSchedule;
+
+function requireSchedule() {
+    if (hasRequiredSchedule) return schedule;
+    hasRequiredSchedule = 1;
+    var WriteQueue = requireWriteQueue();
+    var Util = requireCommonUtil();
+    var unusedUid = function(set) {
+        var uid = Util.uid();
+        if (set[uid]) {
+            return unusedUid();
+        }
+        return uid;
+    };
+    var lookup = function(map, id) {
+        return map[id] = map[id] || {
+            active: {},
+            blocked: {}
+        };
+    };
+    var isEmpty = function(map) {
+        for (var key in map) {
+            if (Object.prototype.hasOwnProperty.call(map, key)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    schedule = function() {
+        var queue = WriteQueue();
+        var Ordered = function(id, task) {
+            queue(id, task);
+        };
+        var map = {};
+        var collectGarbage = function(id) {
+            var local = map[id];
+            if (!local) {
+                return;
+            }
+            if (local.lock) {
+                return;
+            }
+            if (!isEmpty(local.active)) {
+                return;
+            }
+            delete map[id];
+        };
+        var runImmediately = function(local, task) {
+            var uid = unusedUid(local.active);
+            local.active[uid] = true;
+            task(function() {
+                delete local.active[uid];
+                if (!isEmpty(local.active)) {
+                    return;
+                }
+                if (typeof local.waiting !== "function") {
+                    return void collectGarbage();
+                }
+                setTimeout(local.waiting);
+            });
+        };
+        var runOnceUnblocked = function(local, task) {
+            var uid = unusedUid(local.blocked);
+            local.blocked[uid] = function() {
+                runImmediately(local, task);
+            };
+        };
+        var Unordered = function(id, task) {
+            var local = lookup(map, id);
+            if (local.lock) {
+                return runOnceUnblocked(local, task);
+            }
+            runImmediately(local, task);
+        };
+        var runBlocked = function(local) {
+            for (var task in local.blocked) {
+                runImmediately(local, local.blocked[task]);
+            }
+        };
+        var Blocking = function(id, task) {
+            var local = lookup(map, id);
+            queue(id, function(next) {
+                if (isEmpty(local.active)) {
+                    local.lock = true;
+                    return void task(function() {
+                        delete local.lock;
+                        runBlocked(local);
+                        next();
+                    });
+                }
+                local.waiting = function() {
+                    local.lock = true;
+                    task(function() {
+                        delete local.lock;
+                        delete local.waiting;
+                        runBlocked(local);
+                        next();
+                    });
+                };
+            });
+        };
+        return {
+            ordered: Ordered,
+            unordered: Unordered,
+            blocking: Blocking
+        };
+    };
+    return schedule;
+}
+
+var decreesCore;
+
+var hasRequiredDecreesCore;
+
+function requireDecreesCore() {
+    if (hasRequiredDecreesCore) return decreesCore;
+    hasRequiredDecreesCore = 1;
+    const Util = requireCommonUtil$1();
+    const Path = require$$1;
+    const Fs = require$$0$2;
+    const readFileBin = requireStreamFile().readFileBin;
+    const Schedule = requireSchedule();
+    const Fse = require$$5;
+    const nThen = require$$6;
+    const Decrees = {};
+    const Utils = Decrees.Utils = {};
+    const isString = str => typeof str === "string";
+    const isInteger = n => !(typeof n !== "number" || isNaN(n) || n % 1 !== 0);
+    Utils.args_isBoolean = args => !(!Array.isArray(args) || typeof args[0] !== "boolean");
+    Utils.args_isString = args => !(!Array.isArray(args) || !isString(args[0]));
+    Utils.args_isInteger = args => !(!Array.isArray(args) || !isInteger(args[0]));
+    Utils.args_isPositiveInteger = args => Array.isArray(args) && isInteger(args[0]) && args[0] > 0;
+    Decrees.create = (name, commands) => {
+        const handleCommand = (Env, line) => {
+            let command = line[0];
+            let args = line[1];
+            if (typeof commands[command] !== "function") {
+                throw new Error("DECREE_UNSUPPORTED_COMMAND");
+            }
+            let outcome = commands[command](Env, args);
+            return outcome;
+        };
+        const createLineHandler = Env => {
+            const Log = Env.Log;
+            let index = -1;
+            return (err, line) => {
+                index++;
+                if (err) {
+                    return void Log.error("DECREE_LINE_ERR", {
+                        error: err.message,
+                        index,
+                        line
+                    });
+                }
+                if (Array.isArray(line)) {
+                    try {
+                        return handleCommand(Env, line);
+                    } catch (err2) {
+                        return void Log.error("DECREE_COMMAND_ERR", {
+                            error: err2.message,
+                            index,
+                            line
+                        });
+                    }
+                }
+                Log.error("DECREE_HANDLER_WEIRD_LINE", {
+                    line,
+                    index
+                });
+            };
+        };
+        const loadRemote = (Env, decrees, cb) => {
+            cb ||= () => {};
+            if (!Array.isArray(decrees)) {
+                return void cb("INVALID_DECREES");
+            }
+            decrees.forEach(line => {
+                if (!Array.isArray(line)) {
+                    return;
+                }
+                try {
+                    handleCommand(Env, line);
+                } catch {}
+            });
+            cb();
+        };
+        const load = (Env, _cb) => {
+            Env.scheduleDecree ||= Schedule();
+            const toSend = [];
+            const cb = Util.once(Util.mkAsync(err => {
+                if (err && err.code !== "ENOENT") {
+                    return void _cb(err);
+                }
+                _cb(void 0, toSend);
+            }));
+            Env.scheduleDecree.blocking("", unblock => {
+                const done = Util.once(Util.both(cb, unblock));
+                nThen(w => {
+                    Fse.mkdirp(Env.paths.decree, w(function(err) {
+                        if (!err) {
+                            return;
+                        }
+                        w.abort();
+                        done(err);
+                    }));
+                }).nThen(function() {
+                    const decreeName = Path.join(Env.paths.decree, name);
+                    const stream = Fs.createReadStream(decreeName, {
+                        start: 0
+                    });
+                    const handler = createLineHandler(Env);
+                    readFileBin(stream, (msgObj, next) => {
+                        let text = msgObj.buff.toString("utf8");
+                        let line;
+                        let changed = false;
+                        try {
+                            line = JSON.parse(text);
+                            changed = handler(void 0, line);
+                        } catch (err) {
+                            handler(err, text);
+                        }
+                        if (changed) {
+                            toSend.push(line);
+                        }
+                        next();
+                    }, err => {
+                        done(err);
+                    });
+                });
+            });
+        };
+        const write = function(Env, decree, _cb) {
+            var path = Path.join(Env.paths.decree, name);
+            Env.scheduleDecree.ordered("", function(next) {
+                var cb = Util.both(Util.mkAsync(_cb), next);
+                Fs.appendFile(path, JSON.stringify(decree) + "\n", cb);
+            });
+        };
+        return {
+            handleCommand,
+            loadRemote,
+            load,
+            write
+        };
+    };
+    decreesCore = Decrees;
+    return decreesCore;
+}
+
+var adminDecrees;
+
+var hasRequiredAdminDecrees;
+
+function requireAdminDecrees() {
+    if (hasRequiredAdminDecrees) return adminDecrees;
+    hasRequiredAdminDecrees = 1;
+    const Core = requireCore();
+    const Keys = requireKeys();
+    const DecreesCore = requireDecreesCore();
+    const {args_isBoolean, args_isString, args_isInteger, args_isPositiveInteger} = DecreesCore.Utils;
+    const makeBooleanSetter = function(attr) {
+        return function(Env, args) {
+            if (!args_isBoolean(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var bool = args[0];
+            if (bool === Env[attr]) {
+                return false;
+            }
+            Env[attr] = bool;
+            return true;
+        };
+    };
+    const default_validator = function() {
+        return true;
+    };
+    const makeGenericSetter = function(attr, validator) {
+        validator = validator || default_validator;
+        return function(Env, args) {
+            if (!validator(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var value = args[0];
+            if (value === Env[attr]) {
+                return false;
+            }
+            Env[attr] = value;
+            return true;
+        };
+    };
+    const makeIntegerSetter = function(attr) {
+        return makeGenericSetter(attr, args_isInteger);
+    };
+    const makeTranslation = function(attr) {
+        return function(Env, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var value = args[0];
+            var state = Env[attr];
+            if (typeof value === "string") {
+                if (state.default === value) {
+                    return false;
+                }
+                state.default = value;
+                return true;
+            }
+            if (value && typeof value === "object") {
+                var changed = false;
+                Object.keys(value).forEach(function(lang) {
+                    if (state[lang] === value[lang]) {
+                        return;
+                    }
+                    state[lang] = value[lang];
+                    changed = true;
+                });
+                return changed;
+            }
+            return false;
+        };
+    };
+    const commands = {};
+    const isNumber = function(value) {
+        return typeof value === "number" && !isNaN(value);
+    };
+    const args_isMaintenance = function(args) {
+        return Array.isArray(args) && args[0] && (args[0] === "" || isNumber(args[0].end) && isNumber(args[0].start));
+    };
+    const makeBroadcastSetter = function(attr, validation) {
+        return function(Env, args) {
+            if (validation && !validation(args) && !args_isString(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var str = args[0];
+            if (str === Env[attr]) {
+                return false;
+            }
+            Env[attr] = str;
+            Env.broadcastCache = {};
+            return true;
+        };
+    };
+    commands.ENABLE_EMBEDDING = makeBooleanSetter("enableEmbedding");
+    commands.ENFORCE_MFA = makeBooleanSetter("enforceMFA");
+    commands.RESTRICT_REGISTRATION = makeBooleanSetter("restrictRegistration");
+    commands.RESTRICT_SSO_REGISTRATION = makeBooleanSetter("restrictSsoRegistration");
+    commands.DISABLE_STORE_INVITED_USERS = makeBooleanSetter("dontStoreInvitedUsers");
+    commands.DISABLE_STORE_SSO_USERS = makeBooleanSetter("dontStoreSSOUsers");
+    commands.DISABLE_INTEGRATED_EVICTION = makeBooleanSetter("disableIntegratedEviction");
+    commands.DISABLE_INTEGRATED_TASKS = makeBooleanSetter("disableIntegratedTasks");
+    commands.CONSENT_TO_CONTACT = makeBooleanSetter("consentToContact");
+    commands.LIST_MY_INSTANCE = makeBooleanSetter("listMyInstance");
+    commands.PROVIDE_AGGREGATE_STATISTICS = makeBooleanSetter("provideAggregateStatistics");
+    commands.REMOVE_DONATE_BUTTON = makeBooleanSetter("removeDonateButton");
+    commands.BLOCK_DAILY_CHECK = makeBooleanSetter("blockDailyCheck");
+    commands.SET_ACCENT_COLOR = makeGenericSetter("accentColor", args_isString);
+    commands.ENABLE_PROFILING = makeBooleanSetter("enableProfiling");
+    commands.SET_PROFILING_WINDOW = makeGenericSetter("profilingWindow", args_isPositiveInteger);
+    commands.SET_MAX_UPLOAD_SIZE = makeIntegerSetter("maxUploadSize");
+    commands.SET_PREMIUM_UPLOAD_SIZE = makeIntegerSetter("premiumUploadSize");
+    commands.UPDATE_DEFAULT_STORAGE = makeIntegerSetter("defaultStorageLimit");
+    commands.SET_INACTIVE_TIME = makeIntegerSetter("inactiveTime");
+    commands.SET_ARCHIVE_RETENTION_TIME = makeIntegerSetter("archiveRetentionTime");
+    commands.SET_ACCOUNT_RETENTION_TIME = makeIntegerSetter("accountRetentionTime");
+    commands.SET_ADMIN_EMAIL = makeGenericSetter("adminEmail", args_isString);
+    commands.HAS_CUSTOM_LOGO = makeBooleanSetter("customLogo");
+    commands.SET_SUPPORT_MAILBOX = makeGenericSetter("supportMailbox", function(args) {
+        return args_isString(args) && Core.isValidPublicKey(args[0]);
+    });
+    commands.SET_LOGO_MIME = makeGenericSetter("logoMimeType", args_isString);
+    commands.DISABLE_APPS = function(Env, args) {
+        if (!Array.isArray(args)) {
+            throw new Error("INVALID_ARGS");
+        }
+        if (JSON.stringify(args) === JSON.stringify(Env.appsToDisable)) {
+            return false;
+        }
+        Env.appsToDisable = args;
+        return true;
+    };
+    commands.SET_SUPPORT_KEYS = function(Env, args) {
+        const curvePublic = args[0];
+        const edPublic = args[1];
+        let validated = typeof curvePublic === "string" && (Core.isValidPublicKey(curvePublic) || !curvePublic) && typeof edPublic === "string" && (Core.isValidPublicKey(edPublic) || !edPublic);
+        if (!validated) {
+            throw new Error("INVALID_ARGS");
+        }
+        if (Env.supportMailboxKey === curvePublic && Env.supportPinKey === edPublic) {
+            return false;
+        }
+        Env.supportMailboxKey = curvePublic;
+        Env.supportPinKey = edPublic;
+        return true;
+    };
+    commands.SET_INSTANCE_PURPOSE = makeGenericSetter("instancePurpose", args_isString);
+    commands.SET_INSTANCE_JURISDICTION = makeTranslation("instanceJurisdiction");
+    commands.SET_INSTANCE_NAME = makeTranslation("instanceName");
+    commands.SET_INSTANCE_DESCRIPTION = makeTranslation("instanceDescription");
+    commands.SET_INSTANCE_NOTICE = makeTranslation("instanceNotice");
+    commands.SET_LAST_BROADCAST_HASH = makeBroadcastSetter("lastBroadcastHash");
+    commands.SET_SURVEY_URL = makeBroadcastSetter("surveyURL");
+    commands.SET_MAINTENANCE = makeBroadcastSetter("maintenance", args_isMaintenance);
+    commands.SET_QUOTA = function(Env, args) {
+        if (!Array.isArray(args) || args.length !== 2) {
+            throw new Error("INVALID_ARGS");
+        }
+        var unsafeKey = Keys.canonicalize(args[0]);
+        if (!unsafeKey) {
+            throw new Error("INVALID_ARGS");
+        }
+        var limit = args[1];
+        if (!Core.isValidLimit(limit)) {
+            throw new Error("INVALID_ARGS");
+        }
+        limit.origin = "decree";
+        Env.customLimits[unsafeKey] = limit;
+        Env.limits[unsafeKey] = limit;
+        return true;
+    };
+    commands.RM_QUOTA = function(Env, args) {
+        if (!Array.isArray(args) || args.length !== 1) {
+            throw new Error("INVALID_ARGS");
+        }
+        var unsafeKey = Keys.canonicalize(args[0]);
+        if (!unsafeKey) {
+            throw new Error("INVALID_ARGS");
+        }
+        if (!Env.customLimits[unsafeKey]) {
+            throw new Error("ENOENT");
+        }
+        delete Env.customLimits[unsafeKey];
+        delete Env.limits[unsafeKey];
+        return true;
+    };
+    commands.ADD_INSTALL_TOKEN = function(Env, args) {
+        if (!Array.isArray(args) || args.length !== 1 || !args[0]) {
+            throw new Error("INVALID_ARGS");
+        }
+        var token = args[0];
+        Env.installToken = token;
+        return true;
+    };
+    commands.ADD_ADMIN_KEY = function(Env, args) {
+        if (!Array.isArray(args) || args.length !== 1 || !args[0]) {
+            throw new Error("INVALID_ARGS");
+        }
+        Env.admins = Env.admins || [];
+        var key = Keys.canonicalize(args[0]);
+        if (!key) {
+            throw new Error("INVALID_KEY");
+        }
+        if (Env.admins.includes(key)) {
+            return false;
+        }
+        Env.admins.push(key);
+        Env.adminsData.push(args[0]);
+        return true;
+    };
+    commands.RM_ADMIN_KEY = function(Env, args) {
+        if (!Array.isArray(args) || args.length !== 1 || !args[0]) {
+            throw new Error("INVALID_ARGS");
+        }
+        const key = Keys.canonicalize(args[0]);
+        if (!key) {
+            throw new Error("INVALID_KEY");
+        }
+        Env.admins = Env.admins || [];
+        if (!Env.admins.includes(key)) {
+            return false;
+        }
+        if (Array.isArray(Env?.config?.adminKeys) && Env.config.adminKeys.includes(key)) {
+            throw new Error("CANT_REMOVE_CONFIG");
+        }
+        let idx = Env.admins.indexOf(key);
+        if (idx < 0) {
+            return false;
+        }
+        if (Env.admins.length === 1) {
+            throw new Error("CANT_REMOVE_LAST_ADMIN");
+        }
+        Env.admins.splice(idx, 1);
+        Env.adminsData = Env.adminsData.filter(str => {
+            const ed = Keys.canonicalize(str);
+            if (!ed) {
+                return true;
+            }
+            return ed !== key;
+        });
+        return true;
+    };
+    commands.PROOFS_MIGRATED = function(Env, args) {
+        if (args !== 1) {
+            throw new Error("INVALID_ARGS");
+        }
+        Env.proofsMigrated = true;
+        return true;
+    };
+    commands.SET_BEARER_SECRET = function(Env, args) {
+        if (!args_isString(args) || args.length !== 1 || !args[0]) {
+            throw new Error("INVALID_ARGS");
+        }
+        var secret = args[0];
+        if (secret === Env.bearerSecret) {
+            return false;
+        }
+        Env.bearerSecret = secret;
+        return true;
+    };
+    commands.TEST_DECREE = (Env, args) => {
+        if (typeof args !== "string") {
+            throw new Error("INVALID_ARGS");
+        }
+        Env.testDecreeValue = args;
+        return true;
+    };
+    adminDecrees = commands;
+    return adminDecrees;
+}
+
+var consistentHash;
+
+var hasRequiredConsistentHash;
+
+function requireConsistentHash() {
+    if (hasRequiredConsistentHash) return consistentHash;
+    hasRequiredConsistentHash = 1;
+    consistentHash = {
+        jumpConsistentHash: function(key, num_buckets) {
+            let keyBigInt = key.readBigUInt64LE();
+            let b = -1n;
+            let j = 0n;
+            while (j < num_buckets) {
+                b = j;
+                keyBigInt = (keyBigInt * 2862933555777941757n + 1n) % (1n << 64n);
+                j = BigInt(Math.floor((Number(b) + 1) * Number(1n << 31n) / Number((keyBigInt >> 33n) + 1n)));
+            }
+            return b;
+        }
+    };
+    return consistentHash;
+}
+
+var pluginManager;
+
+var hasRequiredPluginManager;
+
+function requirePluginManager() {
+    if (hasRequiredPluginManager) return pluginManager;
+    hasRequiredPluginManager = 1;
+    const fs = require$$0$2;
+    const Path = require$$1;
+    const plugins = {};
+    const extensions = plugins._extensions = [];
+    const styles = plugins._styles = [];
+    try {
+        const path = Path.join(__dirname, "..", "plugins");
+        let pluginsDir = fs.readdirSync(path);
+        pluginsDir.forEach(name => {
+            if (name === "README.md") {
+                return;
+            }
+            try {
+                let plugin = require(`../plugins/${name}/index.js`);
+                plugins[plugin.name] = plugin.modules;
+                try {
+                    let hasExt = fs.existsSync(`./plugins/${name}/client/extensions.js`);
+                    if (hasExt) {
+                        extensions.push(plugin.name.toLowerCase());
+                    }
+                } catch (e) {}
+                try {
+                    let hasStyle = fs.existsSync(`./plugins/${name}/client/style.less`);
+                    if (hasStyle) {
+                        styles.push(plugin.name.toLowerCase());
+                    }
+                } catch (e) {}
+            } catch (err) {
+                console.error(err);
+            }
+        });
+    } catch (err) {
+        if (err.code !== "ENOENT") {
+            console.error(err);
+        }
+    }
+    plugins.call = command => function() {
+        Object.values(plugins).forEach(plugin => {
+            const f = plugin?.[command];
+            if (typeof f !== "function") {
+                return;
+            }
+            f.apply(null, arguments);
+        });
+    };
+    plugins.get = attr => {
+        const result = [];
+        Object.values(plugins).forEach(plugin => {
+            const v = plugin?.[attr];
+            if (typeof v !== "undefined") {
+                result.push(v);
+            }
+        });
+        return result;
+    };
+    plugins.addHttpEndpoints = (Env, app, type) => {
+        Object.values(plugins).forEach(plugin => {
+            const ep = plugin.httpEndpoints;
+            if (!Array.isArray(ep)) {
+                return;
+            }
+            ep.forEach(obj => {
+                if (obj.type !== type && obj.target !== type) {
+                    return;
+                }
+                obj.f(Env, app);
+            });
+        });
+    };
+    plugins.getHttpProxy = () => {
+        const list = [];
+        Object.values(plugins).forEach(plugin => {
+            const ep = plugin.httpEndpoints;
+            if (!Array.isArray(ep)) {
+                return;
+            }
+            ep.forEach(obj => {
+                if (obj.type !== "proxy") {
+                    return;
+                }
+                list.push(obj);
+            });
+        });
+        return list;
+    };
+    pluginManager = plugins;
+    return pluginManager;
+}
+
+var env;
+
+var hasRequiredEnv;
+
+function requireEnv() {
+    if (hasRequiredEnv) return env;
+    hasRequiredEnv = 1;
+    const {existsSync, readdirSync} = require$$0$2;
+    const Path = require$$1;
+    const Package = require$$2;
+    const Util = requireCommonUtil$1();
+    const Keys = requireKeys();
+    const Core = requireCore();
+    const Constants = requireConstants();
+    const Default = requireDefaults();
+    const DecreesCore = requireDecreesCore();
+    const AdminDecrees = requireAdminDecrees();
+    const {jumpConsistentHash} = requireConsistentHash();
+    const plugins = requirePluginManager();
+    const isRecentVersion = function() {
+        let R = Default.recommendedVersion;
+        let V = process.version;
+        if (typeof V !== "string") {
+            return false;
+        }
+        let parts = V.replace(/^v/, "").split(".").map(Number);
+        if (parts.length < 3) {
+            return false;
+        }
+        if (!parts.every(n => typeof n === "number" && !isNaN(n))) {
+            return false;
+        }
+        if (parts[0] < R[0]) {
+            return false;
+        }
+        if (parts[0] > R[0]) {
+            return true;
+        }
+        if (parts[1] < R[1]) {
+            return false;
+        }
+        if (parts[1] > R[1]) {
+            return true;
+        }
+        if (parts[2] >= R[2]) {
+            return true;
+        }
+        return false;
+    };
+    const getInstalledOOVersions = Env => {
+        const path = Path.join(Env.clientRoot, "www/common/onlyoffice/dist");
+        if (!existsSync(path)) {
+            return [];
+        }
+        return readdirSync(path);
+    };
+    const init = (Env, mainConfig, pluginModules) => {
+        const {config, infra} = mainConfig;
+        const publicConfig = infra?.public || {};
+        Env.config = config;
+        Env.adminDecrees = DecreesCore.create(Constants.adminDecree, AdminDecrees);
+        Env.modules = {
+            Core,
+            Util,
+            Constants,
+            DecreesCore
+        };
+        Object.assign(Env.modules, pluginModules || {});
+        Env.myId = mainConfig.myId;
+        Env.clientRoot = config?.clientRoot || "../cryptpad";
+        Env.version = Package.version;
+        Env.launchTime = +new Date;
+        Env.numberStorages = infra.storage.length;
+        Env.numberCores = infra.core.length;
+        Env.Util = Util;
+        Env.Core = Core;
+        Env.getStorageId = data => {
+            data = Util.escapeKeyCharacters(data || "") + "00000000";
+            const key = Buffer.from(data.slice(0, 8));
+            const id = jumpConsistentHash(key, Env.numberStorages);
+            return "storage:" + id;
+        };
+        Env.getCoreId = data => {
+            data = Util.escapeKeyCharacters(data) + "00000000";
+            const key = Buffer.from(data.slice(0, 8));
+            const id = jumpConsistentHash(key, Env.numberCores);
+            return "core:" + id;
+        };
+        (() => {
+            Env.maxWorkers = typeof config.maxWorkers === "object" ? config.maxWorkers : {};
+            Env.maxJobs = typeof config.maxJobs === "object" ? config.maxJobs : {};
+        })();
+        Env.getDecree = type => Env.plugins[type]?.getDecree(Env) || Env.adminDecrees;
+        Env.allDecrees = {};
+        Env.cacheDecrees = (type, decrees) => {
+            type ||= "admin";
+            const cache = Env.allDecrees[type] ||= [];
+            Array.prototype.push.apply(cache, decrees);
+        };
+        Env.getCachedDecrees = () => Env.allDecrees;
+        Env.httpUnsafeOrigin = publicConfig?.origin;
+        Env.httpSafeOrigin = publicConfig?.sandboxOrigin;
+        const unsafe = new URL(Env.httpUnsafeOrigin);
+        const safe = new URL(Env.httpSafeOrigin);
+        Env.httpAddress = publicConfig?.httpHost || unsafe.hostname;
+        Env.httpPort = publicConfig?.httpPort || unsafe.port;
+        if (unsafe.port && unsafe.hostname === safe.hostname && safe.port) {
+            Env.httpSafePort = safe.port;
+        }
+        if (publicConfig?.httpSafePort) {
+            Env.httpSafePort = publicConfig.httpSafePort;
+        }
+        Env.protocol = unsafe.protocol;
+        Env.websocketPath = publicConfig.externalWebsocketURL;
+        Env.fileHost = publicConfig.fileHost || undefined;
+        Env.DEV_MODE = Boolean(process.env.DEV);
+        Env.FRESH_KEY = process.env.DEV || process.env.PACKAGE ? "" : +new Date;
+        Env.OFFLINE_MODE = Boolean(process.env.OFFLINE);
+        Env.admins = (config.adminKeys || []).map(k => {
+            try {
+                return Keys.canonicalize(k);
+            } catch (err) {
+                return;
+            }
+        }).filter(Boolean);
+        Env.adminEmail = config.adminEmail;
+        Env.adminsData = (config.adminKeys || []).slice();
+        Env.moderators = [];
+        Env.supportMailbox = undefined;
+        Env.supportMailboxKey = undefined;
+        Env.lastBroadcastHash = "";
+        Env.maintenance = undefined;
+        Env.surveyURL = undefined;
+        Env.logFeedback = Boolean(config.logFeedback);
+        Env.enableEmbedding = false;
+        Env.permittedEmbedders = publicConfig?.sandboxOrigin;
+        Env.restrictRegistration = false;
+        Env.disableIntegratedTasks = config.disableIntegratedTasks || false;
+        Env.disableIntegratedEviction = typeof config.disableIntegratedEviction === "undefined" ? true : config.disableIntegratedEviction;
+        Env.lastEviction = +new Date;
+        Env.evictionReport = {};
+        Env.installMethod = config.installMethod || undefined;
+        Env.inactiveTime = config.inactiveTime;
+        Env.accountRetentionTime = config.accountRetentionTime;
+        Env.archiveRetentionTime = config.archiveRetentionTime;
+        Env.defaultStorageLimit = typeof config.defaultStorageLimit === "number" && config.defaultStorageLimit >= 0 ? config.defaultStorageLimit : Core.DEFAULT_LIMIT;
+        Env.maxUploadSize = config.maxUploadSize || 20 * 1024 * 1024;
+        Env.premiumUploadSize = Math.max(Env.maxUploadSize, Number(config.premiumUploadSize) || 0);
+        Env.removeDonateButton = config.removeDonateButton;
+        Env.listMyInstance = false;
+        Env.enforceMFA = config.enforceMFA;
+        Env.logIP = config.logIP;
+        Env.consentToContact = false;
+        Env.instanceName = {};
+        Env.instanceDescription = {};
+        Env.instanceJurisdiction = {};
+        Env.instanceNotice = {};
+        Env.blockDailyCheck = config.blockDailyCheck === true;
+        Env.provideAggregateStatistics = false;
+        Env.updateAvailable = undefined;
+        Env.accountsLimits = {};
+        Env.customLimits = {};
+        Env.limits = {};
+        Env.otpSessionExpiration = config.otpSessionExpiration;
+        let ooVersions = getInstalledOOVersions(Env);
+        Env.onlyOffice = config.onlyOffice || (ooVersions.length ? {
+            availableVersions: ooVersions
+        } : false);
+        Env.shouldUpdateNode = !isRecentVersion();
+        Env.paths = Core.getPaths(mainConfig, true);
+        Env.plugins = plugins;
+        plugins.call("customizeEnv")(Env);
+        return Env;
+    };
+    env = {
+        init
+    };
+    return env;
+}
+
+var file = {};
+
+var metadata = {
+    exports: {}
+};
+
+var hasRequiredMetadata;
+
+function requireMetadata() {
+    if (hasRequiredMetadata) return metadata.exports;
+    hasRequiredMetadata = 1;
+    (function(module) {
+        var Meta = module.exports;
+        var Core = requireCore();
+        var deduplicate = requireCommonUtil().deduplicateString;
+        var commands = {};
+        var isValidPublicKey = Core.isValidPublicKey;
+        var isValidOwner = isValidPublicKey;
+        commands.RESTRICT_ACCESS = function(meta, args) {
+            if (!Array.isArray(args) || typeof args[0] !== "boolean") {
+                throw new Error("INVALID_STATE");
+            }
+            var bool = args[0];
+            if (meta.restricted === bool) {
+                return false;
+            }
+            meta.restricted = args[0];
+            if (!bool) {
+                return true;
+            }
+            if (Array.isArray(meta.allowed)) {
+                return true;
+            }
+            meta.allowed = [];
+            return true;
+        };
+        commands.ALLOW_LINE_DELETION = function(meta, args) {
+            if (!Array.isArray(args) || typeof args[0] !== "boolean") {
+                throw new Error("INVALID_STATE");
+            }
+            var bool = args[0];
+            if (meta.deleteLines === bool) {
+                return false;
+            }
+            meta.deleteLines = args[0];
+            return true;
+        };
+        commands.ADD_ALLOWED = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var allowed = meta.allowed || [];
+            var changed = false;
+            args.forEach(function(arg) {
+                if (!isValidPublicKey(arg)) {
+                    return;
+                }
+                if (meta.owners.indexOf(arg) >= 0) {
+                    return;
+                }
+                if (allowed.indexOf(arg) >= 0) {
+                    return;
+                }
+                allowed.push(arg);
+                changed = true;
+            });
+            if (changed) {
+                meta.allowed = meta.allowed || allowed;
+            }
+            return changed;
+        };
+        commands.RM_ALLOWED = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            if (!meta.allowed) {
+                return false;
+            }
+            var changed = false;
+            args.forEach(function(arg) {
+                var index = meta.allowed.indexOf(arg);
+                if (index < 0) {
+                    return;
+                }
+                meta.allowed.splice(index, 1);
+                changed = true;
+            });
+            return changed;
+        };
+        var arrayHasChanged = function(A, B) {
+            var changed;
+            A.some(function(a) {
+                if (B.indexOf(a) < 0) {
+                    return changed = true;
+                }
+            });
+            if (changed) {
+                return true;
+            }
+            B.some(function(b) {
+                if (A.indexOf(b) < 0) {
+                    return changed = true;
+                }
+            });
+            return changed;
+        };
+        var filterInPlace = function(A, f) {
+            for (var i = A.length - 1; i >= 0; i--) {
+                if (f(A[i], i, A)) {
+                    A.splice(i, 1);
+                }
+            }
+        };
+        commands.RESET_ALLOWED = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            var updated = args.filter(function(arg) {
+                if (!isValidPublicKey(arg)) {
+                    return false;
+                }
+                if (meta.owners.indexOf(arg)) {
+                    return false;
+                }
+                return true;
+            });
+            if (meta.allowed && meta.allowed.length !== updated.length) {
+                meta.allowed = updated;
+                return true;
+            }
+            if (!arrayHasChanged(meta.allowed, updated)) {
+                return false;
+            }
+            meta.allowed = updated;
+            return true;
+        };
+        commands.ADD_OWNERS = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("METADATA_INVALID_OWNERS");
+            }
+            if (!Array.isArray(meta.owners)) {
+                throw new Error("METADATA_NONSENSE_OWNERS");
+            }
+            var changed = false;
+            args.forEach(function(owner) {
+                if (!isValidOwner(owner)) {
+                    return;
+                }
+                if (meta.owners.indexOf(owner) >= 0) {
+                    return;
+                }
+                meta.owners.push(owner);
+                changed = true;
+            });
+            if (changed && Array.isArray(meta.allowed)) {
+                filterInPlace(meta.allowed, function(member) {
+                    return meta.owners.indexOf(member) !== -1;
+                });
+            }
+            return changed;
+        };
+        commands.RM_OWNERS = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("METADATA_INVALID_OWNERS");
+            }
+            if (!Array.isArray(meta.owners)) {
+                throw new Error("METADATA_NONSENSE_OWNERS");
+            }
+            var changed = false;
+            args.forEach(function(owner) {
+                var index = meta.owners.indexOf(owner);
+                if (index < 0) {
+                    return;
+                }
+                if (meta.mailbox) {
+                    if (typeof meta.mailbox === "string") {
+                        delete meta.mailbox;
+                    } else {
+                        delete meta.mailbox[owner];
+                    }
+                }
+                meta.owners.splice(index, 1);
+                changed = true;
+            });
+            if (meta.owners.length === 0 && meta.restricted) {
+                meta.restricted = false;
+            }
+            return changed;
+        };
+        commands.ADD_PENDING_OWNERS = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("METADATA_INVALID_PENDING_OWNERS");
+            }
+            if (meta.pending_owners && !Array.isArray(meta.pending_owners)) {
+                throw new Error("METADATA_NONSENSE_PENDING_OWNERS");
+            }
+            var changed = false;
+            if (!meta.pending_owners) {
+                meta.pending_owners = deduplicate(args);
+                return true;
+            }
+            args.forEach(function(owner) {
+                if (!isValidOwner(owner)) {
+                    return;
+                }
+                if (meta.pending_owners.indexOf(owner) >= 0) {
+                    return;
+                }
+                meta.pending_owners.push(owner);
+                changed = true;
+            });
+            return changed;
+        };
+        commands.RM_PENDING_OWNERS = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("METADATA_INVALID_PENDING_OWNERS");
+            }
+            if (!Array.isArray(meta.pending_owners)) {
+                throw new Error("METADATA_NONSENSE_PENDING_OWNERS");
+            }
+            var changed = false;
+            args.forEach(function(owner) {
+                var index = meta.pending_owners.indexOf(owner);
+                if (index < 0) {
+                    return;
+                }
+                meta.pending_owners.splice(index, 1);
+                changed = true;
+            });
+            return changed;
+        };
+        commands.RESET_OWNERS = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("METADATA_INVALID_OWNERS");
+            }
+            if (!Array.isArray(meta.owners)) {
+                throw new Error("METADATA_NONSENSE_OWNERS");
+            }
+            meta.owners = deduplicate(args.filter(isValidOwner));
+            if (Array.isArray(meta.allowed)) {
+                filterInPlace(meta.allowed, function(member) {
+                    return meta.owners.indexOf(member) !== -1;
+                });
+            }
+            if (meta.owners.length === 0 && meta.restricted) {
+                meta.restricted = false;
+            }
+            return true;
+        };
+        commands.ADD_MAILBOX = function(meta, args) {
+            if (!args || typeof args !== "object") {
+                throw new Error("METADATA_INVALID_MAILBOX");
+            }
+            if (!Array.isArray(meta.owners)) {
+                throw new Error("METADATA_NONSENSE_OWNERS");
+            }
+            var changed = false;
+            Object.keys(args).forEach(function(edPublic) {
+                if (meta.owners.indexOf(edPublic) === -1) {
+                    return;
+                }
+                if (typeof meta.mailbox === "string") {
+                    var str = meta.mailbox;
+                    meta.mailbox = {};
+                    meta.mailbox[meta.owners[0]] = str;
+                }
+                if (!meta.mailbox) {
+                    meta.mailbox = {};
+                }
+                meta.mailbox[edPublic] = args[edPublic];
+                changed = true;
+            });
+            return changed;
+        };
+        commands.RM_MAILBOX = function(meta, args) {
+            if (!Array.isArray(args)) {
+                throw new Error("INVALID_ARGS");
+            }
+            if (!meta.mailbox || typeof meta.mailbox === "undefined") {
+                return false;
+            }
+            if (typeof meta.mailbox === "string" && args.length === 0) {
+                delete meta.mailbox;
+                return true;
+            }
+            var changed = false;
+            args.forEach(function(arg) {
+                if (meta.mailbox[arg] === "undefined") {
+                    return;
+                }
+                delete meta.mailbox[arg];
+                changed = true;
+            });
+            return changed;
+        };
+        commands.UPDATE_EXPIRATION = function() {
+            throw new Error("E_NOT_IMPLEMENTED");
+        };
+        var handleCommand = Meta.handleCommand = function(meta, line) {
+            var command = line[0];
+            var args = line[1];
+            if (typeof commands[command] !== "function") {
+                throw new Error("METADATA_UNSUPPORTED_COMMAND");
+            }
+            return commands[command](meta, args);
+        };
+        Meta.commands = Object.keys(commands);
+        Meta.createLineHandler = function(ref, errorHandler) {
+            ref.meta = {};
+            ref.index = 0;
+            ref.logged = {};
+            var overwritten = false;
+            return function(err, line) {
+                if (err) {
+                    if (ref.index === 0 && err.code === "ENOENT") {
+                        return;
+                    }
+                    return void errorHandler("METADATA_HANDLER_LINE_ERR", {
+                        error: err,
+                        index: ref.index,
+                        line: JSON.stringify(line)
+                    });
+                }
+                var index = ref.index++;
+                if (typeof line === "undefined") {
+                    return;
+                }
+                if (Array.isArray(line)) {
+                    try {
+                        handleCommand(ref.meta, line);
+                    } catch (err2) {
+                        var code = err2.message;
+                        if (ref.logged[code]) {
+                            return;
+                        }
+                        ref.logged[code] = true;
+                        errorHandler("METADATA_COMMAND_ERR", {
+                            error: err2.stack,
+                            line
+                        });
+                    }
+                    return;
+                }
+                if (index < 2 && line && typeof line === "object") {
+                    if (overwritten) {
+                        return;
+                    }
+                    overwritten = true;
+                    ref.meta = line;
+                    return;
+                }
+                errorHandler("METADATA_HANDLER_WEIRDLINE", {
+                    line,
+                    index
+                });
+            };
+        };
+    })(metadata);
+    return metadata.exports;
+}
+
+var hkUtil = {
+    exports: {}
+};
+
+var hasRequiredHkUtil;
+
+function requireHkUtil() {
+    if (hasRequiredHkUtil) return hkUtil.exports;
+    hasRequiredHkUtil = 1;
+    (function(module) {
+        const Constants = requireConstants();
+        var HK = module.exports;
+        const {STANDARD_CHANNEL_LENGTH, ADMIN_CHANNEL_LENGTH, publicKeyLength} = Constants;
+        HK.STANDARD_CHANNEL_LENGTH = STANDARD_CHANNEL_LENGTH;
+        HK.ADMIN_CHANNEL_LENGTH = ADMIN_CHANNEL_LENGTH;
+        HK.getHash = function(msg, Log) {
+            if (typeof msg !== "string") {
+                if (Log) {
+                    Log.warn("HK_GET_HASH", "getHash() called on " + typeof msg + ": " + msg);
+                }
+                return "";
+            }
+            return msg.slice(0, 64);
+        };
+        HK.sliceCpIndex = function(cpIndex, line) {
+            const minLine = Math.max(0, line - 100);
+            let start = cpIndex.slice(0, -2);
+            const end = cpIndex.slice(-2);
+            start = start.filter(function(obj) {
+                return obj.line > minLine;
+            });
+            return start.concat(end);
+        };
+        HK.isMetadataMessage = function(parsed) {
+            return Boolean(parsed && parsed.channel);
+        };
+        const decodeBase64 = function(string) {
+            return Buffer.from(string, "base64");
+        };
+        HK.isValidValidateKeyString = key => {
+            try {
+                return typeof key === "string" && decodeBase64(key).length === publicKeyLength;
+            } catch {
+                return false;
+            }
+        };
+        HK.trimMapByOffset = function(map, offset) {
+            if (!offset) {
+                return;
+            }
+            for (let k in map) {
+                if (map[k] < offset) {
+                    delete map[k];
+                }
+            }
+        };
+        HK.checkOffsetMap = function(map) {
+            var prev = 0;
+            var cur;
+            var ooo = 0;
+            var count = 0;
+            for (let k in map) {
+                count++;
+                cur = map[k];
+                if (!ooo && prev > cur) {
+                    ooo = true;
+                }
+                prev = cur;
+            }
+            return ooo ? count * -1 : count;
+        };
+        HK.trimOffsetByOrder = function(map, n) {
+            var toRemove = Math.max(n - 50, 0);
+            var i = 0;
+            for (let k in map) {
+                if (i >= toRemove) {
+                    return;
+                }
+                i++;
+                delete map[k];
+            }
+        };
+        HK.listAllowedUsers = metadata => (metadata.owners || []).concat(metadata.allowed || []);
+        HK.isUserSessionAllowed = (allowed, authKeys) => {
+            if (!authKeys) {
+                return false;
+            }
+            for (var unsafeKey in authKeys) {
+                if (allowed.includes(unsafeKey)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    })(hkUtil);
+    return hkUtil.exports;
+}
+
+var batchRead;
+
+var hasRequiredBatchRead;
+
+function requireBatchRead() {
+    if (hasRequiredBatchRead) return batchRead;
+    hasRequiredBatchRead = 1;
+    batchRead = function() {
+        var map = {};
+        return function(id, cb, impl) {
+            if (typeof cb !== "function" || typeof impl !== "function") {
+                throw new Error("expected callback and implementation");
+            }
+            if (map[id]) {
+                return void map[id].push(cb);
+            }
+            map[id] = [ cb ];
+            impl(function() {
+                var args = Array.prototype.slice.call(arguments);
+                setTimeout(function() {
+                    map[id].forEach(function(h) {
+                        h.apply(null, args);
+                    });
+                    delete map[id];
+                });
+            });
+        };
+    };
+    return batchRead;
+}
+
+var hasRequiredFile;
+
+function requireFile() {
+    if (hasRequiredFile) return file;
+    hasRequiredFile = 1;
+    var Fs = require$$0$2;
+    var Fse = require$$5;
+    var Path = require$$1;
+    var nThen = require$$6;
+    var Semaphore = require$$4;
+    var Util = requireCommonUtil();
+    var Meta = requireMetadata();
+    var Extras = requireHkUtil();
+    const readFileBin = requireStreamFile().readFileBin;
+    const BatchRead = requireBatchRead();
+    const Schedule = requireSchedule();
+    const CHANNEL_WRITE_WINDOW = 3e5;
+    const STREAM_CLOSE_TIMEOUT = 12e4;
+    const STREAM_DESTROY_TIMEOUT = 3e4;
+    const isValidChannelId = function(id) {
+        return typeof id === "string" && id.length >= 32 && id.length < 50 && /^[a-zA-Z0-9=+-]*$/.test(id);
+    };
+    const PERMISSIVE = 511;
+    var mkPath = function(env, channelId) {
+        return Path.join(env.root, channelId.slice(0, 2), channelId) + ".ndjson";
+    };
+    var mkArchivePath = function(env, channelId) {
+        return Path.join(env.archiveRoot, env.volumeId, channelId.slice(0, 2), channelId) + ".ndjson";
+    };
+    var mkMetadataPath = function(env, channelId) {
+        return Path.join(env.root, channelId.slice(0, 2), channelId) + ".metadata.ndjson";
+    };
+    var mkArchiveMetadataPath = function(env, channelId) {
+        return Path.join(env.archiveRoot, env.volumeId, channelId.slice(0, 2), channelId) + ".metadata.ndjson";
+    };
+    var mkTempPath = function(env, channelId) {
+        return mkPath(env, channelId) + ".temp";
+    };
+    var mkOffsetPath = function(env, channelId) {
+        return mkPath(env, channelId) + ".offset";
+    };
+    var mkPlaceholderPath = function(env, channelId) {
+        return mkPath(env, channelId) + ".placeholder";
+    };
+    var channelExists = function(filepath, cb) {
+        Fs.stat(filepath, function(err, stat) {
+            if (err) {
+                if (err.code === "ENOENT") {
+                    return void cb(void 0, false);
+                }
+                return void cb(err);
+            }
+            if (!stat.isFile()) {
+                return void cb("E_NOT_FILE");
+            }
+            return void cb(void 0, true);
+        });
+    };
+    var isChannelAvailable = function(env, channelName, cb) {
+        var filepath = mkPath(env, channelName);
+        var metapath = mkMetadataPath(env, channelName);
+        env.schedule.unordered(channelName, function(next) {
+            var done = Util.once(Util.mkAsync(Util.both(cb, next)));
+            var exists = false;
+            var handler = function(err, _exists) {
+                if (err) {
+                    return void done(err);
+                }
+                exists = exists || _exists;
+            };
+            nThen(function(w) {
+                channelExists(filepath, w(handler));
+                channelExists(metapath, w(handler));
+            }).nThen(function() {
+                done(void 0, exists);
+            });
+        });
+    };
+    var isChannelArchived = function(env, channelName, cb) {
+        var filepath = mkArchivePath(env, channelName);
+        var metapath = mkArchiveMetadataPath(env, channelName);
+        env.schedule.unordered(channelName, function(next) {
+            var done = Util.once(Util.mkAsync(Util.both(cb, next)));
+            var exists = false;
+            var handler = function(err, _exists) {
+                if (err) {
+                    return void done(err);
+                }
+                exists = exists || _exists;
+            };
+            nThen(function(w) {
+                channelExists(filepath, w(handler));
+                channelExists(metapath, w(handler));
+            }).nThen(function() {
+                done(void 0, exists);
+            });
+        });
+    };
+    var addPlaceholder = function(env, channelId, reason, cb) {
+        if (!reason) {
+            return cb();
+        }
+        var path = mkPlaceholderPath(env, channelId);
+        var s_data = typeof reason === "string" ? reason : `${reason.code}:${reason.txt}`;
+        Fs.writeFile(path, s_data, cb);
+    };
+    var clearPlaceholder = function(env, channelId, cb) {
+        var path = mkPlaceholderPath(env, channelId);
+        Fs.unlink(path, cb);
+    };
+    var readPlaceholder = function(env, channelId, cb) {
+        var path = mkPlaceholderPath(env, channelId);
+        Fs.readFile(path, function(err, content) {
+            if (err) {
+                return void cb();
+            }
+            cb(content.toString("utf8"));
+        });
+    };
+    const destroyStream = function(stream) {
+        if (!stream) {
+            return;
+        }
+        try {
+            stream.close();
+            if (stream.closed && stream.fd === null) {
+                return;
+            }
+        } catch (err) {
+            console.error(err);
+        }
+        setTimeout(function() {
+            try {
+                stream.destroy();
+            } catch (err) {
+                console.error(err);
+            }
+        }, STREAM_DESTROY_TIMEOUT);
+    };
+    const createIdleStreamCollector = function(stream) {
+        var collector = Util.once(Util.mkAsync(Util.bake(destroyStream, [ stream ])));
+        collector.keepAlive = Util.throttle(collector, STREAM_CLOSE_TIMEOUT);
+        collector.keepAlive();
+        return collector;
+    };
+    const readMessagesBin = (env, id, start, msgHandler, cb) => {
+        const stream = Fs.createReadStream(mkPath(env, id), {
+            start
+        });
+        const collector = createIdleStreamCollector(stream);
+        const handleMessageAndKeepStreamAlive = Util.both(msgHandler, collector.keepAlive);
+        const done = Util.both(err => {
+            if (err && err.code === "ENOENT") {
+                return readPlaceholder(env, id, content => {
+                    cb(err, content);
+                });
+            }
+            cb(err);
+        }, collector);
+        return void readFileBin(stream, handleMessageAndKeepStreamAlive, done, {
+            offset: start
+        });
+    };
+    var getMetadataAtPath = function(Env, path, _cb) {
+        const stream = Fs.createReadStream(path, {
+            start: 0
+        });
+        const collector = createIdleStreamCollector(stream);
+        var cb = Util.once(Util.mkAsync(Util.both(_cb, collector)));
+        var i = 0;
+        return readFileBin(stream, function(msgObj, readMore, abort) {
+            collector.keepAlive();
+            const line = msgObj.buff.toString("utf8");
+            if (!line) {
+                return readMore();
+            }
+            if (i++ > 0) {
+                abort();
+                return void cb();
+            }
+            var metadata;
+            try {
+                metadata = JSON.parse(line);
+                if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+                    return void cb(void 0, metadata);
+                } else {
+                    return void cb();
+                }
+            } catch {
+                return void cb("INVALID_METADATA");
+            }
+        }, function(err) {
+            cb(err);
+        });
+    };
+    var closeChannel = function(env, channelName, cb) {
+        if (!env.channels[channelName]) {
+            return void cb();
+        }
+        try {
+            if (typeof Util.find(env, [ "channels", channelName, "writeStream", "close" ]) === "function") {
+                var stream = env.channels[channelName].writeStream;
+                destroyStream(stream, channelName);
+            }
+            delete env.channels[channelName];
+            cb();
+        } catch (err) {
+            cb(err);
+        }
+    };
+    var closeInactiveChannels = function(env, schedule, activeSet) {
+        Object.keys(env.channels).forEach(channelName => {
+            if (!activeSet.has(channelName)) {
+                schedule.ordered(channelName, function(next) {
+                    closeChannel(env, channelName, next);
+                });
+            }
+        });
+    };
+    var clearOffset = function(env, channelId, cb) {
+        var path = mkOffsetPath(env, channelId);
+        Fs.unlink(path, cb);
+    };
+    var writeOffset = function(env, channelId, data, cb) {
+        var path = mkOffsetPath(env, channelId);
+        var s_data;
+        try {
+            s_data = JSON.stringify(data);
+        } catch (err) {
+            return void cb(err);
+        }
+        Fs.writeFile(path, s_data, cb);
+    };
+    var getOffset = function(env, channelId, cb) {
+        var path = mkOffsetPath(env, channelId);
+        Fs.readFile(path, function(err, content) {
+            if (err) {
+                return void cb(err);
+            }
+            try {
+                var json = JSON.parse(content);
+                cb(void 0, json);
+            } catch (err2) {
+                cb(err2);
+            }
+        });
+    };
+    var clearChannel = function(env, channelId, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var path = mkPath(env, channelId);
+        getMetadataAtPath(env, path, function(e, metadata) {
+            if (e) {
+                return cb(new Error(e));
+            }
+            if (!metadata) {
+                return void Fs.truncate(path, 0, cb);
+            }
+            var len = JSON.stringify(metadata).length + 1;
+            closeChannel(env, channelId, function(err) {
+                if (err) {
+                    cb(err);
+                }
+                Fs.truncate(path, len, function(err) {
+                    if (err) {
+                        return cb(err);
+                    }
+                    cb();
+                });
+            });
+            clearOffset(env, channelId, function() {});
+        });
+    };
+    var readMessages = function(path, msgHandler, _cb) {
+        var stream = Fs.createReadStream(path, {
+            start: 0
+        });
+        var collector = createIdleStreamCollector(stream);
+        var cb = Util.once(Util.mkAsync(Util.both(_cb, collector)));
+        return readFileBin(stream, function(msgObj, readMore) {
+            collector.keepAlive();
+            msgHandler(msgObj.buff.toString("utf8"));
+            setTimeout(readMore);
+        }, function(err) {
+            cb(err);
+        });
+    };
+    var getChannelMetadata = function(Env, channelId, cb) {
+        var path = mkPath(Env, channelId);
+        getMetadataAtPath(Env, path, cb);
+    };
+    var getDedicatedMetadata = function(env, channelId, handler, _cb) {
+        var metadataPath = mkMetadataPath(env, channelId);
+        var stream = Fs.createReadStream(metadataPath, {
+            start: 0
+        });
+        const collector = createIdleStreamCollector(stream);
+        var cb = Util.both(_cb, collector);
+        readFileBin(stream, function(msgObj, readMore) {
+            collector.keepAlive();
+            var line = msgObj.buff.toString("utf8");
+            try {
+                var parsed = JSON.parse(line);
+                handler(null, parsed);
+            } catch (err) {
+                handler(err, line);
+            }
+            readMore();
+        }, function(err) {
+            if (!err || err.code === "ENOENT") {
+                if (err && err.code === "ENOENT") {
+                    return readPlaceholder(env, channelId, content => {
+                        cb(content);
+                    });
+                }
+                return void cb();
+            }
+            cb(err);
+        });
+    };
+    var readMetadata = function(env, channelId, handler, cb) {
+        let requiresChannel = true;
+        let all = [];
+        nThen(function(w) {
+            let first = true;
+            getDedicatedMetadata(env, channelId, (err, line) => {
+                if (first && !err) {
+                    if (!Array.isArray(line)) {
+                        requiresChannel = false;
+                    }
+                    first = false;
+                }
+                all.push({
+                    err,
+                    line
+                });
+            }, w(function(err) {
+                if (err) {
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+        }).nThen(function(w) {
+            if (!requiresChannel) {
+                return;
+            }
+            getChannelMetadata(env, channelId, w(function(err, data) {
+                if (err) {
+                    return void handler(err, data);
+                }
+                if (!data || typeof data !== "object" || Array.isArray(data)) {
+                    return;
+                }
+                handler(null, data);
+            }));
+        }).nThen(function() {
+            all.forEach(({err, line}) => {
+                handler(err, line);
+            });
+            cb();
+        });
+    };
+    var writeMetadata = function(env, channelId, data, cb) {
+        var path = mkMetadataPath(env, channelId);
+        Fse.mkdirp(Path.dirname(path), PERMISSIVE, function(err) {
+            if (err && err.code !== "EEXIST") {
+                return void cb(err);
+            }
+            Fs.appendFile(path, data + "\n", cb);
+        });
+    };
+    var checkPath = function(path, callback) {
+        Fs.stat(path, function(err) {
+            if (!err) {
+                callback(undefined, true);
+                return;
+            }
+            if (err.code !== "ENOENT") {
+                callback(err);
+                return;
+            }
+            Fse.mkdirp(Path.dirname(path), PERMISSIVE, function(err) {
+                if (err && err.code !== "EEXIST") {
+                    callback(err);
+                    return;
+                }
+                callback(undefined, false);
+            });
+        });
+    };
+    var labelError = function(label, err) {
+        return label + (err.code ? "_" + err.code : "");
+    };
+    var removeChannel = function(env, channelName, cb) {
+        var channelPath = mkPath(env, channelName);
+        var metadataPath = mkMetadataPath(env, channelName);
+        var CB = Util.once(cb);
+        var errors = 0;
+        nThen(function(w) {
+            Fs.unlink(channelPath, w(function(err) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        errors++;
+                        return;
+                    }
+                    w.abort();
+                    CB(labelError("E_CHANNEL_REMOVAL", err));
+                }
+            }));
+            Fs.unlink(metadataPath, w(function(err) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        errors++;
+                        return;
+                    }
+                    w.abort();
+                    CB(labelError("E_METADATA_REMOVAL", err));
+                }
+            }));
+            clearOffset(env, channelName, w());
+        }).nThen(function() {
+            if (errors === 2) {
+                return void CB(labelError("E_REMOVE_CHANNEL", new Error("ENOENT")));
+            }
+            CB();
+        });
+    };
+    var removeArchivedChannel = function(env, channelName, cb) {
+        var channelPath = mkArchivePath(env, channelName);
+        var metadataPath = mkArchiveMetadataPath(env, channelName);
+        var CB = Util.once(cb);
+        nThen(function(w) {
+            Fs.unlink(channelPath, w(function(err) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        return;
+                    }
+                    w.abort();
+                    CB(labelError("E_ARCHIVED_CHANNEL_REMOVAL", err));
+                }
+            }));
+            Fs.unlink(metadataPath, w(function(err) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        return;
+                    }
+                    w.abort();
+                    CB(labelError("E_ARCHIVED_METADATA_REMOVAL", err));
+                }
+            }));
+        }).nThen(function() {
+            CB();
+        });
+    };
+    var _getStats = function(metadataPath, filePath, channel, cb, isLonelyMetadata) {
+        var metaStat, channelStat;
+        var metaErr, channelErr;
+        nThen(function(ww) {
+            Fs.stat(metadataPath, ww(function(err, stats) {
+                if (err) {
+                    metaErr = err;
+                    return;
+                }
+                metaStat = stats;
+            }));
+            if (isLonelyMetadata) {
+                return;
+            }
+            Fs.stat(filePath, ww(function(err, stats) {
+                if (err) {
+                    channelErr = err;
+                    return;
+                }
+                channelStat = stats;
+            }));
+        }).nThen(function() {
+            if (channelErr && metaErr) {
+                return void cb(channelErr);
+            }
+            var data = {
+                channel
+            };
+            if (metaStat && channelStat) {
+                data.atime = Math.max(channelStat.atime, metaStat.atime);
+                data.mtime = Math.max(channelStat.mtime, metaStat.mtime);
+                data.ctime = Math.max(channelStat.ctime, metaStat.ctime);
+                data.size = channelStat.size + metaStat.size;
+            } else if (metaStat) {
+                data.atime = metaStat.atime;
+                data.mtime = metaStat.mtime;
+                data.ctime = metaStat.ctime;
+                data.size = metaStat.size;
+            } else if (channelStat) {
+                data.atime = channelStat.atime;
+                data.mtime = channelStat.mtime;
+                data.ctime = channelStat.ctime;
+                data.size = channelStat.size;
+            } else {
+                return void cb("NO_DATA");
+            }
+            cb(void 0, data);
+        });
+    };
+    var getStats = function(env, channelName, cb) {
+        var metadataPath = mkMetadataPath(env, channelName);
+        var filePath = mkPath(env, channelName);
+        _getStats(metadataPath, filePath, channelName, cb);
+    };
+    var listChannels = function(root, handler, cb, fast) {
+        var dirList = [];
+        nThen(function(w) {
+            Fs.readdir(root, w(function(err, list) {
+                if (err) {
+                    w.abort();
+                    return void cb(err);
+                }
+                dirList = list;
+            }));
+        }).nThen(function(waitFor) {
+            var n = nThen;
+            dirList.forEach(function(dir) {
+                n = n(function(w) {
+                    var sema = Semaphore.create(20);
+                    var nestedDirPath = Path.join(root, dir);
+                    Fs.readdir(nestedDirPath, w(function(err, list) {
+                        if (err) {
+                            return void handler(err);
+                        }
+                        list.forEach(function(item) {
+                            if (/^\./.test(item)) {
+                                return;
+                            }
+                            if (!/^[0-9a-fA-F]{32}(\.metadata?)*\.ndjson$/.test(item)) {
+                                return;
+                            }
+                            var isLonelyMetadata = false;
+                            var channelName;
+                            var metadataName;
+                            if (!/^[0-9a-fA-F]{32,33}\.ndjson$/.test(item)) {
+                                metadataName = item;
+                                channelName = item.replace(/\.metadata/, "");
+                                if (list.indexOf(channelName) !== -1) {
+                                    return;
+                                }
+                                isLonelyMetadata = true;
+                            } else {
+                                channelName = item;
+                                metadataName = channelName.replace(/\.ndjson$/, ".metadata.ndjson");
+                            }
+                            var channel = metadataName.replace(/\.metadata.ndjson$/, "");
+                            if ([ 32, 33, 34, 44 ].indexOf(channel.length) === -1) {
+                                return;
+                            }
+                            sema.take(function(give) {
+                                var next = w(give());
+                                if (fast) {
+                                    return void handler(void 0, {
+                                        channel
+                                    }, next);
+                                }
+                                var filePath = Path.join(nestedDirPath, channelName);
+                                var metadataPath = Path.join(nestedDirPath, metadataName);
+                                return void _getStats(metadataPath, filePath, channel, function(err, data) {
+                                    if (err) {
+                                        return void handler(err, void 0, next);
+                                    }
+                                    handler(void 0, data, next);
+                                }, isLonelyMetadata);
+                            });
+                        });
+                    }));
+                }).nThen;
+            });
+            n(waitFor());
+        }).nThen(function() {
+            cb();
+        });
+    };
+    var archiveChannel = function(env, channelName, reason, cb) {
+        var currentPath = mkPath(env, channelName);
+        var archivePath = mkArchivePath(env, channelName);
+        nThen(function(w) {
+            Fse.move(currentPath, archivePath, {
+                overwrite: true
+            }, w(function(err) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        return;
+                    }
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+        }).nThen(function(w) {
+            clearOffset(env, channelName, w());
+        }).nThen(function(w) {
+            if (!reason) {
+                return;
+            }
+            addPlaceholder(env, channelName, reason, w());
+        }).nThen(function(w) {
+            var metadataPath = mkMetadataPath(env, channelName);
+            var archiveMetadataPath = mkArchiveMetadataPath(env, channelName);
+            Fse.move(metadataPath, archiveMetadataPath, {
+                overwrite: true
+            }, w(function(err) {
+                if (err && err.code === "ENOENT") {
+                    return void cb();
+                }
+                if (err) {
+                    return void cb(labelError("E_METADATA_ARCHIVAL", err));
+                }
+                cb();
+            }));
+        });
+    };
+    var unarchiveChannel = function(env, channelName, cb) {
+        var channelPath = mkPath(env, channelName);
+        var metadataPath = mkMetadataPath(env, channelName);
+        var CB = Util.once(cb);
+        var ENOENT = false;
+        nThen(function(w) {
+            channelExists(channelPath, w(function(err, exists) {
+                if (err) {
+                    w.abort();
+                    return void CB(err);
+                }
+                if (exists) {
+                    w.abort();
+                    return CB("UNARCHIVE_CHANNEL_CONFLICT");
+                }
+            }));
+            channelExists(metadataPath, w(function(err, exists) {
+                if (err) {
+                    w.abort();
+                    return void CB(err);
+                }
+                if (exists) {
+                    w.abort();
+                    return CB("UNARCHIVE_METADATA_CONFLICT");
+                }
+            }));
+        }).nThen(function(w) {
+            var archiveChannelPath = mkArchivePath(env, channelName);
+            Fse.move(archiveChannelPath, channelPath, w(function(err) {
+                if (err && err.code === "ENOENT") {
+                    ENOENT = true;
+                    return;
+                }
+                if (err) {
+                    w.abort();
+                    return void CB(err);
+                }
+            }));
+        }).nThen(function(w) {
+            clearPlaceholder(env, channelName, w());
+        }).nThen(function(w) {
+            var archiveMetadataPath = mkArchiveMetadataPath(env, channelName);
+            Fse.move(archiveMetadataPath, metadataPath, w(function(err) {
+                if (err && err.code === "ENOENT") {
+                    if (ENOENT) {
+                        return void cb("ENOENT");
+                    }
+                    return CB();
+                }
+                if (err) {
+                    w.abort();
+                    return void CB(labelError("E_METADATA_RESTORATION", err));
+                }
+                CB();
+            }));
+        });
+    };
+    var channelBytes = function(env, chanName, cb) {
+        var channelPath = mkPath(env, chanName);
+        var dataPath = mkMetadataPath(env, chanName);
+        var CB = Util.once(cb);
+        var channelSize = 0;
+        var dataSize = 0;
+        nThen(function(w) {
+            Fs.stat(channelPath, w(function(err, stats) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        return;
+                    }
+                    return void CB(err);
+                }
+                channelSize = stats.size;
+            }));
+            Fs.stat(dataPath, w(function(err, stats) {
+                if (err) {
+                    if (err.code === "ENOENT") {
+                        return;
+                    }
+                    return void CB(err);
+                }
+                dataSize = stats.size;
+            }));
+        }).nThen(function() {
+            CB(void 0, channelSize + dataSize);
+        });
+    };
+    var getChannel = function(env, id, _callback) {
+        var cb = Util.once(Util.mkAsync(_callback));
+        if (env.channels[id]) {
+            var chan = env.channels[id];
+            chan.delayClose();
+            return void cb(void 0, chan);
+        }
+        return void env.batchGetChannel(id, cb, function(done) {
+            var path = mkPath(env, id);
+            var channel = {
+                onError: []
+            };
+            nThen(function(w) {
+                checkPath(path, w(function(err) {
+                    if (err) {
+                        w.abort();
+                        return void done(err);
+                    }
+                }));
+            }).nThen(function(w) {
+                var stream = channel.writeStream = Fs.createWriteStream(path, {
+                    flags: "a"
+                });
+                stream.on("open", w());
+                stream.on("error", function(err) {
+                    w.abort();
+                    channel.onError.forEach(function(handler) {
+                        handler(err);
+                    });
+                });
+            }).nThen(function() {
+                channel.delayClose = Util.throttle(Util.once(function() {
+                    delete env.channels[id];
+                    destroyStream(channel.writeStream);
+                }), CHANNEL_WRITE_WINDOW);
+                channel.delayClose();
+                env.channels[id] = channel;
+                done(void 0, channel);
+            });
+        });
+    };
+    const messageBin = (env, chanName, msgBin, cb) => {
+        var complete = Util.once(cb);
+        getChannel(env, chanName, function(err, chan) {
+            if (!chan) {
+                return void complete(err);
+            }
+            chan.onError.push(complete);
+            chan.writeStream.write(msgBin, function() {
+                chan.onError.splice(chan.onError.indexOf(complete), 1);
+                complete();
+                if (chan.onError.length) {
+                    return;
+                }
+                if (chan.delayClose && chan.delayClose.clear) {
+                    chan.delayClose.clear();
+                    destroyStream(chan.writeStream);
+                    delete env.channels[chanName];
+                }
+            });
+        });
+    };
+    var message = function(env, chanName, msg, cb) {
+        messageBin(env, chanName, Buffer.from(msg + "\n", "utf8"), cb);
+    };
+    var getMessages = function(env, chanName, handler, cb) {
+        var errorState = false;
+        var path = mkPath(env, chanName);
+        readMessages(path, function(msg) {
+            if (!msg || errorState) {
+                return;
+            }
+            try {
+                handler(msg);
+            } catch (e) {
+                errorState = true;
+                return void cb(e);
+            }
+        }, function(err) {
+            if (err) {
+                errorState = true;
+                return void cb(err);
+            }
+            cb();
+        });
+    };
+    var filterMessages = function(env, channelName, check, filterHandler, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var tempChannelPath = mkTempPath(env, channelName);
+        var channelPath = mkPath(env, channelName);
+        var metadataPath = mkMetadataPath(env, channelName);
+        var archiveChannelPath = mkArchivePath(env, channelName);
+        var archiveMetadataPath = mkArchiveMetadataPath(env, channelName);
+        var metadataReference = {};
+        var tempStream;
+        var ABORT;
+        var cleanUp = function(cb) {
+            destroyStream(tempStream);
+            Fse.unlink(tempChannelPath, function(err) {
+                if (!err || err.code === "ENOENT") {
+                    return cb();
+                }
+                cb(err);
+            });
+        };
+        nThen(function(w) {
+            closeChannel(env, channelName, w(function(err) {
+                if (err) {
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+        }).nThen(function(w) {
+            clearOffset(env, channelName, w());
+            cleanUp(w(function(err) {
+                if (err) {
+                    w.abort();
+                    cb(err);
+                }
+            }));
+        }).nThen(function(w) {
+            var lineHandler = Meta.createLineHandler(metadataReference, Util.noop);
+            readMetadata(env, channelName, lineHandler, w(function(err) {
+                if (err) {
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+        }).nThen(function(w) {
+            if (typeof check !== "function") {
+                return;
+            }
+            if (!metadataReference.meta || !check(metadataReference.meta)) {
+                w.abort();
+                return void cb("EFORBIDDEN");
+            }
+        }).nThen(function(w) {
+            tempStream = Fs.createWriteStream(tempChannelPath, {
+                flags: "a"
+            });
+            tempStream.on("open", w());
+            tempStream.on("error", function(err) {
+                w.abort();
+                ABORT = true;
+                cleanUp(function() {
+                    cb(err);
+                });
+            });
+        }).nThen(function(w) {
+            var i = 0;
+            var retain = false;
+            var handler = function(msgObj, readMore, abort) {
+                if (ABORT) {
+                    return void abort();
+                }
+                if (i++ === 0 && msgObj.buff.indexOf("{") === 0) {
+                    return readMore();
+                }
+                var s_msg = msgObj.buff.toString("utf8");
+                if (retain) {
+                    return void tempStream.write(s_msg + "\n", function() {
+                        readMore();
+                    });
+                }
+                var msg = Util.tryParse(s_msg);
+                if (!msg) {
+                    return void readMore();
+                }
+                var msgHash = Extras.getHash(msg[4]);
+                var remove = function() {
+                    readMore();
+                };
+                var preserve = function() {
+                    tempStream.write(s_msg + "\n", function() {
+                        readMore();
+                    });
+                };
+                var preserveRemaining = function() {
+                    retain = true;
+                };
+                filterHandler(msg, msgHash, abort, remove, preserve, preserveRemaining);
+            };
+            readMessagesBin(env, channelName, 0, handler, w(function(err) {
+                if (err) {
+                    w.abort();
+                    return void cleanUp(function() {
+                        cb(err);
+                    });
+                }
+                if (!retain) {
+                    w.abort();
+                    cleanUp(function() {
+                        cb("HASH_NOT_FOUND");
+                    });
+                }
+            }));
+        }).nThen(function(w) {
+            Fse.copy(channelPath, archiveChannelPath, w(function(err) {
+                if (!err || err.code === "ENOENT") {
+                    return;
+                }
+                w.abort();
+                cleanUp(function() {
+                    cb(err);
+                });
+            }));
+            Fse.copy(metadataPath, archiveMetadataPath, w(function(err) {
+                if (!err || err.code === "ENOENT") {
+                    return;
+                }
+                w.abort();
+                cleanUp(function() {
+                    cb(err);
+                });
+            }));
+        }).nThen(function(w) {
+            Fs.writeFile(metadataPath, JSON.stringify(metadataReference.meta) + "\n", w(function(err) {
+                if (err) {
+                    w.abort();
+                    cb(err);
+                }
+            }));
+            Fse.move(tempChannelPath, channelPath, {
+                overwrite: true
+            }, w(function(err) {
+                if (err) {
+                    w.abort();
+                    cb(err);
+                }
+            }));
+        }).nThen(function() {
+            cleanUp(function() {
+                cb();
+            });
+        });
+    };
+    var deleteChannelLine = function(env, channelName, hash, checkRights, _cb) {
+        var check = function(meta) {
+            return Boolean(meta.deleteLines);
+        };
+        var handler = function(msg, msgHash, abort, remove, preserve, preserveRemaining) {
+            if (msgHash === hash) {
+                if (typeof checkRights === "function" && !checkRights(msg[4])) {
+                    return void abort();
+                }
+                preserveRemaining();
+                return void remove();
+            }
+            preserve();
+        };
+        filterMessages(env, channelName, check, handler, _cb);
+    };
+    var trimChannel = function(env, channelName, hash, _cb) {
+        var handler = function(msg, msgHash, abort, remove, preserve, preserveRemaining) {
+            if (msgHash === hash) {
+                preserveRemaining();
+                return void preserve();
+            }
+            remove();
+        };
+        filterMessages(env, channelName, null, handler, _cb);
+    };
+    file.create = function(conf, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var env = {
+            root: Path.resolve(conf.filePath || "./datastore"),
+            archiveRoot: Path.resolve(conf.archivePath || "./data/archive"),
+            volumeId: conf.volumeId || "datastore",
+            channels: {},
+            batchGetChannel: BatchRead("store_batch_channel")
+        };
+        var it;
+        var schedule = env.schedule = Schedule();
+        nThen(function(w) {
+            Fse.mkdirp(env.root, PERMISSIVE, w(function(err) {
+                if (err && err.code !== "EEXIST") {
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+            Fse.mkdirp(Path.join(env.archiveRoot, env.volumeId), PERMISSIVE, w(function(err) {
+                if (err && err.code !== "EEXIST") {
+                    w.abort();
+                    return void cb(err);
+                }
+            }));
+        }).nThen(function() {
+            cb(void 0, {
+                message: function(channelName, content, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        message(env, channelName, content, Util.both(cb, next));
+                    });
+                },
+                getMessages: function(channelName, msgHandler, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        getMessages(env, channelName, msgHandler, Util.both(cb, next));
+                    });
+                },
+                messageBin: (channelName, content, cb) => {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        messageBin(env, channelName, content, Util.both(cb, next));
+                    });
+                },
+                readMessagesBin: (channelName, start, asyncMsgHandler, cb) => {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        readMessagesBin(env, channelName, start, asyncMsgHandler, Util.both(cb, next));
+                    });
+                },
+                getWeakLock: function(channelName, _cb) {
+                    var cb = Util.once(Util.mkAsync(_cb));
+                    schedule.unordered(channelName, cb);
+                },
+                removeChannel: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        removeChannel(env, channelName, Util.both(cb, next));
+                    });
+                },
+                removeArchivedChannel: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        removeArchivedChannel(env, channelName, Util.both(cb, next));
+                    });
+                },
+                clearChannel: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        clearChannel(env, channelName, Util.both(cb, next));
+                    });
+                },
+                trimChannel: function(channelName, hash, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.blocking(channelName, function(next) {
+                        trimChannel(env, channelName, hash, Util.both(cb, next));
+                    });
+                },
+                deleteChannelLine: function(channelName, hash, checkRights, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.blocking(channelName, function(next) {
+                        deleteChannelLine(env, channelName, hash, checkRights, Util.both(cb, next));
+                    });
+                },
+                isChannelAvailable: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    isChannelAvailable(env, channelName, cb);
+                },
+                isChannelArchived: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    isChannelArchived(env, channelName, cb);
+                },
+                archiveChannel: function(channelName, reason, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        archiveChannel(env, channelName, reason, Util.both(cb, next));
+                    });
+                },
+                restoreArchivedChannel: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        unarchiveChannel(env, channelName, Util.both(cb, next));
+                    });
+                },
+                clearOffset: function(channelName, _cb) {
+                    var cb = Util.once(Util.mkAsync(_cb));
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    clearOffset(env, channelName, cb);
+                },
+                writeOffset: function(channelName, data, _cb) {
+                    var cb = Util.once(Util.mkAsync(_cb));
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    writeOffset(env, channelName, data, cb);
+                },
+                getOffset: function(channelName, _cb) {
+                    var cb = Util.once(Util.mkAsync(_cb));
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    getOffset(env, channelName, cb);
+                },
+                getChannelMetadata: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        getChannelMetadata(env, channelName, Util.both(cb, next));
+                    });
+                },
+                readDedicatedMetadata: function(channelName, handler, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        getDedicatedMetadata(env, channelName, handler, Util.both(cb, next));
+                    });
+                },
+                readChannelMetadata: function(channelName, handler, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.unordered(channelName, function(next) {
+                        readMetadata(env, channelName, handler, Util.both(cb, next));
+                    });
+                },
+                writeMetadata: function(channelName, data, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        writeMetadata(env, channelName, data, Util.both(cb, next));
+                    });
+                },
+                listChannels: function(handler, cb, fastMode) {
+                    listChannels(env.root, handler, cb, fastMode);
+                },
+                listArchivedChannels: function(handler, cb, fastMode) {
+                    listChannels(Path.join(env.archiveRoot, "datastore"), handler, cb, fastMode);
+                },
+                getChannelStats: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    getStats(env, channelName, cb);
+                },
+                getChannelSize: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        channelBytes(env, channelName, Util.both(cb, next));
+                    });
+                },
+                getPlaceholder: function(channelName, cb) {
+                    readPlaceholder(env, channelName, cb);
+                },
+                closeChannel: function(channelName, cb) {
+                    if (!isValidChannelId(channelName)) {
+                        return void cb(new Error("EINVAL"));
+                    }
+                    schedule.ordered(channelName, function(next) {
+                        closeChannel(env, channelName, Util.both(cb, next));
+                    });
+                },
+                closeInactiveChannels: function(activeSet) {
+                    closeInactiveChannels(env, schedule, activeSet);
+                },
+                log: function(channelName, content, cb) {
+                    schedule.ordered(channelName, function(next) {
+                        message(env, channelName, content, Util.both(cb, next));
+                    });
+                },
+                shutdown: function() {
+                    clearInterval(it);
+                }
+            });
+        });
+    };
+    return file;
+}
+
+var logger;
+
+var hasRequiredLogger;
+
+function requireLogger() {
+    if (hasRequiredLogger) return logger;
+    hasRequiredLogger = 1;
+    const Store = requireFile();
+    const Util = requireCommonUtil$1();
+    const Path = require$$1;
+    const logLevels = [ "silly", "verbose", "debug", "feedback", "info", "warn", "error" ];
+    const handlers = {};
+    const messageTemplate = (type, time, tag, info, nodeId) => JSON.stringify([ type.toUpperCase(), time, nodeId, tag, info ]);
+    const getDateString = () => {
+        const now = new Date;
+        return now.toLocaleDateString(void 0, {
+            month: "2-digit"
+        }) + now.toLocaleDateString("en-CA");
+    };
+    const noop = function() {
+        const args = Array.prototype.slice.call(arguments);
+        if (!args.length) {
+            return;
+        }
+        let cb = args.pop();
+        if (typeof cb !== "function") {
+            return;
+        }
+        if (cb) {
+            setTimeout(cb);
+        }
+    };
+    const write = function(ctx, content, cb) {
+        if (!ctx.store) {
+            return setTimeout(cb);
+        }
+        ctx.store.log(`${getDateString()}-${ctx.logId}`, content, cb);
+    };
+    [ "silly", "debug", "verbose", "feedback", "info" ].forEach(level => {
+        handlers[level] = console.log;
+    });
+    handlers["warn"] = console.warn;
+    handlers["error"] = console.error;
+    const createLogType = function(ctx, type) {
+        if (logLevels.indexOf(type) < logLevels.indexOf(ctx.logLevel)) {
+            return noop;
+        }
+        return function() {
+            const args = Array.prototype.slice.call(arguments);
+            const tag = args.shift();
+            let cb = args.pop();
+            if (typeof cb !== "function") {
+                args.push(cb);
+                cb = () => {};
+            }
+            if (ctx.shutdown) {
+                return;
+            }
+            const time = (new Date).toISOString();
+            const info = args.length === 1 ? args[0] : args;
+            let content;
+            try {
+                content = messageTemplate(type, time, tag, info, ctx.myId);
+            } catch (e) {
+                return;
+            }
+            if (ctx.logToStdout && typeof handlers[type] === "function") {
+                handlers[type](content);
+            }
+            ctx.onReady?.reg(() => {
+                write(ctx, content, cb);
+            });
+        };
+    };
+    const createMethods = function(ctx) {
+        const log = {};
+        logLevels.forEach(function(type) {
+            log[type] = createLogType(ctx, type);
+        });
+        return log;
+    };
+    const Logger = (loggerConfig, myId) => {
+        loggerConfig ||= {};
+        const logId = myId ? myId.split(":")?.[0] : "unknown";
+        if (typeof loggerConfig?.logLevel !== "string") {
+            loggerConfig.logLevel = "info";
+        }
+        const ctx = {
+            logFeedback: Boolean(loggerConfig.logFeedback),
+            logLevel: loggerConfig.logLevel,
+            logToStdout: loggerConfig.logToStdout,
+            logPath: loggerConfig.logPath,
+            logId,
+            myId
+        };
+        if (!loggerConfig.logPath) {
+            console.log(`${myId}: No logPath configured. Logging to file disabled`);
+            const logger = createMethods(ctx);
+            logger.shutdown = () => {};
+            return logger;
+        }
+        ctx.onReady = Util.mkEvent(true);
+        const year = (new Date).getFullYear().toString();
+        Store.create({
+            filePath: Path.join(loggerConfig.logPath, year),
+            archivePath: loggerConfig.archivePath
+        }, function(err, store) {
+            if (err) {
+                throw err;
+            }
+            ctx.store = store;
+            ctx.onReady.fire();
+        });
+        const logger = createMethods(ctx);
+        logger.shutdown = () => {
+            delete ctx.store;
+            ctx.shutdown = true;
+            ctx.store.shutdown();
+        };
+        return Object.freeze(logger);
+    };
+    logger = Logger;
+    return logger;
+}
+
+var headers;
+
+var hasRequiredHeaders;
+
+function requireHeaders() {
+    if (hasRequiredHeaders) return headers;
+    hasRequiredHeaders = 1;
+    const Default = requireDefaults();
+    const Util = requireCommonUtil$1();
+    const EXEMPT = [ /^\/common\/onlyoffice\/.*\.html.*/, /^\/common\/onlyoffice\/dist\/.*\/sdkjs\/common\/spell\/spell\/spell.js.*/, /^\/(sheet|presentation|doc)\/inner\.html.*/, /^\/unsafeiframe\/inner\.html.*$/ ];
+    const applyHeaderMap = (res, map) => {
+        for (let header in map) {
+            if (typeof map[header] === "string") {
+                res.setHeader(header, map[header]);
+            }
+        }
+    };
+    const cacheHeaders = (Env, key, headers) => {
+        if (Env.DEV_MODE) {
+            return;
+        }
+        Env[key] = headers;
+    };
+    const getHeaders = (Env, type) => {
+        const key = type + "HeadersCache";
+        if (Env[key]) {
+            return Util.clone(Env[key]);
+        }
+        const headers = Default.httpHeaders(Env);
+        let csp;
+        if (type === "office") {
+            csp = Default.padContentSecurity(Env);
+        } else {
+            csp = Default.contentSecurity(Env);
+        }
+        headers["Content-Security-Policy"] = csp;
+        headers["Cross-Origin-Resource-Policy"] = "cross-origin";
+        headers["Cross-Origin-Embedder-Policy"] = "require-corp";
+        cacheHeaders(Env, key, headers);
+        if (type === "api") {
+            delete headers["Content-Security-Policy"];
+        }
+        return Util.clone(headers);
+    };
+    const setHeaders = (Env, req, res) => {
+        let type;
+        if (EXEMPT.some(regex => regex.test(req.url))) {
+            type = "office";
+        } else if (/^\/api\/(broadcast|config)/.test(req.url)) {
+            type = "api";
+        } else {
+            type = "standard";
+        }
+        let h = getHeaders(Env, type);
+        if (!Env.enableEmbedding && req.get("origin") === Env.httpUnsafeOrigin && /^\/common\/onlyoffice\/dist\/.*\/fonts\/.*/.test(req.url)) {
+            h["Access-Control-Allow-Origin"] = Env.httpUnsafeOrigin;
+        }
+        applyHeaderMap(res, h);
+    };
+    headers = {
+        setHeaders
+    };
+    return headers;
+}
+
+var hasRequiredWorker;
+
+function requireWorker() {
+    if (hasRequiredWorker) return worker$1;
+    hasRequiredWorker = 1;
+    const Util = requireCommonUtil$1();
+    const Http = require("node:http");
+    const Express = require$$1$2;
+    const Environment = requireEnv();
+    const Logger = requireLogger();
+    const WebSocketServer = require$$4$1.Server;
+    const {setHeaders} = requireHeaders();
+    const Crypto = require("crypto");
+    const cookieParser = require$$6$1;
+    const bodyParser = require$$7;
+    const COMMANDS = {};
+    const Env = {
+        active: true,
+        isWorker: true,
+        users: {}
+    };
+    const onEnvReady = Util.mkEvent(true);
+    const app = Express();
+    app.use(function(req, res, next) {
+        setHeaders(Env, req, res);
+        if (/[\?\&]ver=[^\/]+$/.test(req.url)) {
+            res.setHeader("Cache-Control", "max-age=31536000");
+        } else {
+            res.setHeader("Cache-Control", "no-cache");
+        }
+        next();
+    });
+    const response = Util.response((errLabel, info) => {
+        Env.Log.error("WORKER__" + errLabel, info);
+    });
+    const guid = () => {
+        let id = Util.uid();
+        return response.expected(id) ? guid() : id;
+    };
+    const sendCommand = (cmd, data, cb) => {
+        const txid = guid();
+        response.expect(txid, (err, response) => {
+            cb(err, response);
+        }, 2 * 6e4);
+        process.send({
+            txid,
+            cmd,
+            data,
+            pid: Env.pid
+        });
+    };
+    app.use(bodyParser.urlencoded({
+        extended: true
+    }));
+    app.use(cookieParser());
+    const cacheString = () => (Env.FRESH_KEY ? "-" + Env.FRESH_KEY : "") + (Env.DEV_MODE ? "-" + +new Date : "");
+    const makeRouteCache = (template, cacheName) => {
+        const cleanUp = {};
+        return function(req, res) {
+            const cache = Env[cacheName] ||= {};
+            const host = req.headers.host.replace(/\:[0-9]+/, "");
+            res.setHeader("Content-Type", "text/javascript");
+            if (Env.DEV_MODE) {
+                return void res.send(template(host));
+            }
+            let cacheKey = host + ":" + cacheString();
+            if (!cache[cacheKey]) {
+                cache[cacheKey] = template(host);
+                cleanUp[cacheKey] = Util.throttle(function() {
+                    delete cleanUp[cacheKey];
+                    delete cache[cacheKey];
+                }, 2e4);
+            }
+            if (typeof cleanUp[cacheKey] === "function") {
+                cleanUp[cacheKey]();
+            }
+            return void res.send(cache[cacheKey]);
+        };
+    };
+    const serveConfig = makeRouteCache(function() {
+        const ssoList = Env.sso && Env.sso.enabled && Array.isArray(Env.sso.list) && Env.sso.list.map(function(obj) {
+            return obj.name;
+        }) || [];
+        const SSOUtils = Env?.plugins?.SSO?.utils;
+        const ssoCfg = SSOUtils && ssoList.length ? {
+            force: Env.sso && Env.sso.enforced && 1 || 0,
+            password: Env.sso && Env.sso.cpPassword && (Env.sso.forceCpPassword ? 2 : 1) || 0,
+            list: ssoList
+        } : false;
+        return [ "define(function(){", "return " + JSON.stringify({
+            requireConf: {
+                waitSeconds: 600,
+                urlArgs: "ver=" + Env.version + cacheString()
+            },
+            removeDonateButton: Env.removeDonateButton === true,
+            accounts_api: Env.accounts_api,
+            websocketPath: Env.websocketPath,
+            httpUnsafeOrigin: Env.httpUnsafeOrigin,
+            adminEmail: Env.adminEmail,
+            adminKeys: Env.admins,
+            moderatorKeys: Env.moderators,
+            inactiveTime: Env.inactiveTime,
+            supportMailbox: Env.supportMailbox,
+            supportMailboxKey: Env.supportMailboxKey,
+            defaultStorageLimit: Env.defaultStorageLimit,
+            maxUploadSize: Env.maxUploadSize,
+            premiumUploadSize: Env.premiumUploadSize,
+            restrictRegistration: Env.restrictRegistration,
+            restrictSsoRegistration: Env.restrictSsoRegistration,
+            appsToDisable: Env.appsToDisable,
+            httpSafeOrigin: Env.httpSafeOrigin,
+            enableEmbedding: Env.enableEmbedding,
+            fileHost: Env.fileHost,
+            shouldUpdateNode: Env.shouldUpdateNode || undefined,
+            listMyInstance: Env.listMyInstance,
+            sso: ssoCfg,
+            enforceMFA: Env.enforceMFA,
+            onlyOffice: Env.onlyOffice
+        }, null, "\t"), "});" ].join(";\n");
+    }, "configCache");
+    const serveBroadcast = makeRouteCache(function() {
+        let maintenance = Env.maintenance;
+        if (maintenance && maintenance.end && maintenance.end < +new Date) {
+            maintenance = undefined;
+        }
+        return [ "define(function(){", "return " + JSON.stringify({
+            curvePublic: Env?.curveKeys?.curvePublic,
+            lastBroadcastHash: Env.lastBroadcastHash,
+            surveyURL: Env.surveyURL,
+            maintenance
+        }, null, "\t"), "});" ].join(";\n");
+    }, "broadcastCache");
+    const Define = obj => `define(function (){\n    return ${JSON.stringify(obj, null, "\t")};\n});`;
+    const serveInstance = (req, res) => {
+        res.setHeader("Content-Type", "text/javascript");
+        res.send(Define({
+            color: Env.accentColor,
+            name: Env.instanceName,
+            description: Env.instanceDescription,
+            location: Env.instanceJurisdiction,
+            notice: Env.instanceNotice
+        }));
+    };
+    app.get("/api/config", serveConfig);
+    app.get("/api/broadcast", serveBroadcast);
+    app.get("/api/instance", serveInstance);
+    const servePlugins = Env => {
+        const plugins = Env.plugins;
+        let extensions = plugins._extensions;
+        let styles = plugins._styles;
+        let str = JSON.stringify(extensions);
+        let str2 = JSON.stringify(styles);
+        let js = `let extensions = ${str};\nlet styles = ${str2};\nlet lang = window.cryptpadLanguage;\nlet paths = [];\nextensions.forEach(name => {\n    paths.push(\`optional!/\${name}/extensions.js\`);\n    paths.push(\`optional!json!/\${name}/translations/messages.json\`);\n    const l = lang === "en" ? '' : \`\${lang}.\`;\n    paths.push(\`optional!json!/\${name}/translations/messages.\${l}json\`);\n});\nstyles.forEach(name => {\n    paths.push(\`optional!less!/\${name}/style.less\`);\n});\ndefine(paths, function () {\n    let args = Array.prototype.slice.apply(arguments);\n    return args;\n}, function () {\n    // ignore missing files\n});`;
+        app.get("/extensions.js", (req, res) => {
+            res.setHeader("Content-Type", "text/javascript");
+            res.send(js);
+        });
+    };
+    app.get("/api/profiling", () => {
+        throw new Error("NOT_IMPLEMENTED");
+    });
+    app.use(Express.json());
+    app.post("/api/auth", (req, res) => {
+        const body = Util.clone(req.body);
+        const cookies = req.cookies;
+        body._cookies = cookies;
+        sendCommand("HTTP_COMMAND", body, (err, response) => {
+            if (err) {
+                return res.status(500).json({
+                    error: err
+                });
+            }
+            if (response._cookie) {
+                res.setHeader("Set-Cookie", response._cookie);
+            }
+            res.status(200).json(response);
+        });
+    });
+    COMMANDS.NEW_DECREES = (data, cb) => {
+        const {decrees, type, curveKeys, freshKey} = data;
+        Env.FRESH_KEY = freshKey;
+        Env.curveKeys ||= curveKeys;
+        Env.getDecree(type).loadRemote(Env, decrees);
+        [ "configCache", "broadcastCache" ].forEach(key => {
+            Env[key] = {};
+        });
+        onEnvReady.fire();
+        cb();
+    };
+    COMMANDS.FLUSH_CACHE = (args, cb) => {
+        Env.FRESH_KEY = args.freshKey;
+        cb();
+    };
+    const now = () => +new Date;
+    const randName = () => Crypto.randomBytes(16).toString("hex");
+    const createUniqueName = Env => {
+        const name = randName();
+        if (typeof Env.users[name] === "undefined") {
+            return name;
+        }
+        return createUniqueName(Env);
+    };
+    const socketSendable = socket => socket && socket.readyState === 1;
+    const QUEUE_CHR = 1024 * 1024 * 4;
+    const WEBSOCKET_CLOSING = 2;
+    const WEBSOCKET_CLOSED = 3;
+    const dropUser = (user, reason) => {
+        if (!user || !user.socket) {
+            return;
+        }
+        if (user.socket.readyState !== WEBSOCKET_CLOSING && user.socket.readyState !== WEBSOCKET_CLOSED) {
+            try {
+                user.socket.close();
+            } catch (e) {
+                Env.Log.error(e, "FAIL_TO_DISCONNECT", {
+                    id: user.id
+                });
+                try {
+                    user.socket.terminate();
+                } catch (ee) {
+                    Env.Log.error(ee, "FAIL_TO_TERMINATE", {
+                        id: user.id
+                    });
+                }
+            }
+        }
+        sendCommand("WS_DROP_USER", {
+            id: user.id,
+            reason
+        }, () => {});
+        delete Env.users[user.id];
+        if (Env.logIP && ![ "SOCKET_CLOSED", "INACTIVITY" ].includes(reason)) {
+            return void Env.Log.info("USER_DISCONNECTED_ERROR", {
+                userId: user.id,
+                reason
+            });
+        }
+        if ([ "BAD_MESSAGE", "SEND_MESSAGE_FAIL_2" ].includes(reason)) {
+            return void Env.Log.error("SESSION_CLOSE_WITH_ERROR", {
+                userId: user.id,
+                reason
+            });
+        }
+        if ([ "SOCKET_CLOSED", "SOCKET_ERROR" ].includes(reason)) {
+            return;
+        }
+        Env.Log.silly("SESSION_CLOSE_ROUTINE", {
+            userId: user.id,
+            reason
+        });
+    };
+    const sendMsgPromise = (user, msg) => new Promise((resolve, reject) => {
+        if (!user) {
+            return void reject("NO_USER");
+        }
+        if (!socketSendable(user.socket)) {
+            return void reject("UNSENDABLE");
+        }
+        Env.Log.silly("Sending", msg, "to", user.id);
+        try {
+            const strMsg = JSON.stringify(msg);
+            user.inQueue += strMsg.length;
+            user.sendMsgCallbacks.push(() => {
+                resolve({
+                    length: strMsg.length
+                });
+            });
+            user.socket.send(strMsg, () => {
+                user.inQueue -= strMsg.length;
+                if (user.inQueue > QUEUE_CHR) {
+                    return;
+                }
+                const smcb = user.sendMsgCallbacks;
+                user.sendMsgCallbacks = [];
+                try {
+                    smcb.forEach(cb => {
+                        cb();
+                    });
+                } catch (e) {
+                    Env.Log.error(e, "SEND_MESSAGE_FAIL");
+                }
+            });
+        } catch (e) {
+            reject(e);
+            Env.Log.error(e, "SEND_MESSAGE_FAIL_2");
+            dropUser(user, "SEND_MESSAGE_FAIL_2");
+        }
+    });
+    const sendMsg = (user, msg) => {
+        sendMsgPromise(user, msg).catch(e => {
+            if ([ "NO_USER", "UNSENDABLE" ].includes(e)) {
+                return;
+            }
+            Env.Log.error(e, "SEND_MESSAGE", {
+                user: user.id,
+                message: msg
+            });
+        });
+    };
+    const handleMessage = (user, msg, cb) => {
+        try {
+            let json = JSON.parse(msg);
+            let seq = json.shift();
+            let cmd = json[0];
+            user.timeOfLastMessage = now();
+            user.pingOutstanding = false;
+            sendCommand("WS_MESSAGE", {
+                userId: user.id,
+                cmd,
+                seq,
+                json,
+                length: msg.length
+            }, cb);
+        } catch (e) {
+            cb(e);
+        }
+    };
+    const LAG_MAX_BEFORE_DISCONNECT = 6e4;
+    const LAG_MAX_BEFORE_PING = 15e3;
+    const checkUserActivity = () => {
+        const time = now();
+        Object.keys(Env.users).forEach(userId => {
+            const u = Env.users[userId];
+            try {
+                if (time - u.timeOfLastMessage > LAG_MAX_BEFORE_DISCONNECT) {
+                    dropUser(u, "INACTIVITY");
+                }
+                if (!u.pingOutstanding && time - u.timeOfLastMessage > LAG_MAX_BEFORE_PING) {
+                    sendMsg(u, [ 0, "", "PING", now() ]);
+                    u.pingOutstanding = true;
+                    sendCommand("WS_SEND_PING", {}, () => {});
+                }
+            } catch (err) {
+                Env.Log.error(err, "USER_ACTIVITY_CHECK");
+            }
+        });
+    };
+    const initServerHandlers = () => {
+        if (!Env.wss) {
+            throw new Error("No WebSocket Server");
+        }
+        setInterval(() => {
+            checkUserActivity();
+        }, 5e3);
+        Env.wss.on("connection", (socket, req) => {
+            if (!Env.active) {
+                return;
+            }
+            if (!socket.upgradeReq) {
+                socket.upgradeReq = req;
+            }
+            const ip = req.headers && req.headers["x-real-ip"] || req.socket.remoteAddress || "";
+            const user = {
+                socket,
+                id: createUniqueName(Env),
+                timeOfLastMessage: now(),
+                pingOutstanding: false,
+                inQueue: 0,
+                ip: ip.replace(/^::ffff:/, ""),
+                sendMsgCallbacks: []
+            };
+            Env.users[user.id] = user;
+            sendMsg(user, [ 0, "", "IDENT", user.id ]);
+            sendCommand("WS_NEW_USER", {
+                id: user.id,
+                ip: user.ip
+            }, () => {});
+            socket.on("message", message => {
+                if (!Env.users[user.id]) {
+                    return;
+                }
+                Env.Log.silly("Receiving", JSON.parse(message), "from", user.id);
+                handleMessage(user, message, e => {
+                    if (!e) {
+                        return;
+                    }
+                    Env.Log.error(e, "NETFLUX_BAD_MESSAGE", {
+                        user: user.id,
+                        message
+                    });
+                    dropUser(user, "BAD_MESSAGE");
+                });
+            });
+            socket.on("close", function() {
+                dropUser(user, "SOCKET_CLOSED");
+            });
+            socket.on("error", function(err) {
+                Env.Log.error(err, "NETFLUX_WEBSOCKET_ERROR");
+                dropUser(user, "SOCKET_ERROR");
+            });
+        });
+    };
+    COMMANDS.WS_SEND_MESSAGE = (args, cb) => {
+        const {id, msg} = args;
+        const user = Env.users[id];
+        sendMsgPromise(user, msg).then(obj => {
+            cb(void 0, obj);
+        }).catch(e => {
+            cb(e);
+        });
+    };
+    COMMANDS.WS_SHUTDOWN = (args, cb) => {
+        if (!Env.wss) {
+            return;
+        }
+        Env.active = false;
+        Env.wss.close();
+        delete Env.wss;
+        cb();
+    };
+    COMMANDS.SET_MODERATORS = (args, cb) => {
+        Env.Log.silly("SET_MODERATORS_FRONT_WORKER");
+        Env.moderators = args;
+        cb();
+    };
+    COMMANDS.BROADCAST_MESSAGE = (args, cb) => {
+        const message = args?.message;
+        if (!message) {
+            return void cb();
+        }
+        Object.keys(Env.users).forEach(userId => {
+            const u = Env.users[userId];
+            sendMsg(u, message);
+        });
+        cb();
+    };
+    COMMANDS.GET_WS_DATA = (args, cb) => {
+        cb(void 0, {
+            pid: process?.pid,
+            nb: Object.keys(Env.users)?.length,
+            nb_wss: Env?.wss?.clients?.size
+        });
+    };
+    const init = (config, cb) => {
+        Env.Log = Logger(config.config, config.myId);
+        Environment.init(Env, config);
+        servePlugins(Env);
+        onEnvReady.reg(() => {
+            const cfg = config?.infra?.front[config.index];
+            const server = Http.createServer(app);
+            server.listen(cfg.port, cfg.host, () => {
+                Env.Log.debug("HTTP worker listening on port", cfg.port);
+            });
+            Env.wss = new WebSocketServer({
+                server
+            });
+            initServerHandlers();
+        });
+        cb();
+    };
+    let ready = false;
+    process.on("message", function(obj) {
+        if (!obj || !obj.txid || !obj.pid) {
+            return void process.send({
+                error: "E_INVAL",
+                data: obj
+            });
+        }
+        if (response.expected(obj.txid) && (obj.response || obj.error)) {
+            response.handle(obj.txid, [ obj.error, obj.response ]);
+            return;
+        }
+        const command = COMMANDS[obj.command];
+        const data = obj.data;
+        Env.pid = obj.pid;
+        const cb = function(err, value) {
+            process.send({
+                error: Util.serializeError(err),
+                txid: obj.txid,
+                pid: obj.pid,
+                value
+            });
+        };
+        if (!ready) {
+            return void init(obj.config, err => {
+                if (err) {
+                    return void cb(Util.serializeError(err));
+                }
+                ready = true;
+                cb();
+            });
+        }
+        if (typeof command !== "function") {
+            return void cb("E_BAD_COMMAND");
+        }
+        command(data, cb);
+    });
+    process.on("uncaughtException", function(err) {
+        console.error("[%s] UNCAUGHT EXCEPTION IN DB WORKER", new Date);
+        console.error(err);
+        console.error("TERMINATING");
+        process.exit(1);
+    });
+    return worker$1;
+}
+
+var workerExports = requireWorker();
+
+var worker = getDefaultExportFromCjs(workerExports);
+
+module.exports = worker;