hfs 0.26.8 → 0.27.2

package/src/throttler.js

@@ -0,0 +1,91 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalInSpeed = exports.totalOutSpeed = exports.totalGot = exports.totalSent = exports.throttler = void 0;
+const stream_1 = require("stream");
+const ThrottledStream_1 = require("./ThrottledStream");
+const config_1 = require("./config");
+const misc_1 = require("./misc");
+const connections_1 = require("./connections");
+const lodash_1 = __importDefault(require("lodash"));
+const events_1 = __importDefault(require("./events"));
+const mainThrottleGroup = new ThrottledStream_1.ThrottleGroup(Infinity);
+(0, config_1.defineConfig)('max_kbps', Infinity).sub(v => mainThrottleGroup.updateLimit(v));
+const ip2group = {};
+const SymThrStr = Symbol('stream');
+const SymTimeout = Symbol('timeout');
+const maxKbpsPerIp = (0, config_1.defineConfig)('max_kbps_per_ip', Infinity);
+const throttler = async (ctx, next) => {
+    await next();
+    const { body } = ctx;
+    if (!body || !(body instanceof stream_1.Readable))
+        return;
+    // we wrap the stream also for unlimited connections to get speed and other features
+    const ipGroup = (0, misc_1.getOrSet)(ip2group, ctx.ip, () => {
+        var _a;
+        const doLimit = ((_a = ctx.state.account) === null || _a === void 0 ? void 0 : _a.ignore_limits) || (0, misc_1.isLocalHost)(ctx) ? undefined : true;
+        const group = new ThrottledStream_1.ThrottleGroup(Infinity, doLimit && mainThrottleGroup);
+        const unsub = doLimit && maxKbpsPerIp.sub(v => group.updateLimit(v));
+        return { group, count: 0, destroy: unsub };
+    });
+    const conn = ctx.state.connection;
+    if (!conn)
+        throw 'assert throttler connection';
+    const ts = conn[SymThrStr] = new ThrottledStream_1.ThrottledStream(ipGroup.group, conn[SymThrStr]);
+    let closed = false;
+    const DELAY = 1000;
+    const update = lodash_1.default.debounce(() => {
+        const ts = conn[SymThrStr];
+        const outSpeed = roundKb(ts.getSpeed());
+        (0, connections_1.updateConnection)(conn, { outSpeed, sent: ts.getBytesSent() });
+        /* in case this stream stands still for a while (before the end), we'll have neither 'sent' or 'close' events,
+        * so who will take care to updateConnection? This artificial next-call will ensure just that */
+        clearTimeout(conn[SymTimeout]);
+        if (outSpeed || !closed)
+            conn[SymTimeout] = setTimeout(update, DELAY);
+    }, DELAY, { maxWait: DELAY });
+    ts.on('sent', (n) => {
+        exports.totalSent += n;
+        update();
+    });
+    ++ipGroup.count;
+    ts.on('close', () => {
+        var _a;
+        update.flush();
+        closed = true;
+        if (--ipGroup.count)
+            return; // any left?
+        (_a = ipGroup.destroy) === null || _a === void 0 ? void 0 : _a.call(ipGroup);
+        delete ip2group[ctx.ip];
+    });
+    const bak = ctx.response.length; // preserve
+    ctx.body = ctx.body.pipe(ts);
+    if (bak)
+        ctx.response.length = bak;
+};
+exports.throttler = throttler;
+function roundKb(n) {
+    return lodash_1.default.round(n, 1) || lodash_1.default.round(n, 3); // further precision if necessary
+}
+exports.totalSent = 0;
+exports.totalGot = 0;
+exports.totalOutSpeed = 0;
+exports.totalInSpeed = 0;
+let lastSent = exports.totalSent;
+let lastGot = exports.totalGot;
+let last = Date.now();
+setInterval(() => {
+    const now = Date.now();
+    const past = (now - last) / 1000; // seconds
+    last = now;
+    const deltaSentKb = (exports.totalSent - lastSent) / 1000;
+    lastSent = exports.totalSent;
+    const deltaGotKb = (exports.totalGot - lastGot) / 1000;
+    lastGot = exports.totalGot;
+    exports.totalOutSpeed = roundKb(deltaSentKb / past);
+    exports.totalInSpeed = roundKb(deltaGotKb / past);
+}, 1000);
+events_1.default.on('connection', (c) => c.socket.on('data', data => exports.totalGot += data.length));

package/src/update.js

@@ -0,0 +1,70 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = exports.getUpdate = void 0;
+const github_1 = require("./github");
+const const_1 = require("./const");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const misc_1 = require("./misc");
+const fs_1 = require("fs");
+const plugins_1 = require("./plugins");
+const promises_1 = require("fs/promises");
+const HFS_REPO = 'rejetto/hfs';
+async function getUpdate() {
+    const [latest] = await (0, github_1.getRepoInfo)(HFS_REPO + '/releases?per_page=1');
+    if (latest.name === const_1.VERSION)
+        throw "you already have the latest version: " + const_1.VERSION;
+    return latest;
+}
+exports.getUpdate = getUpdate;
+async function update() {
+    if (process.argv0.endsWith('node'))
+        throw "only binary versions are supported for now";
+    const update = await getUpdate();
+    const assetSearch = { win32: 'windows', darwin: 'mac', linux: 'linux' }[process.platform];
+    if (!assetSearch)
+        throw "this feature doesn't support your platform: " + process.platform;
+    const asset = update.assets.find((x) => x.name.endsWith('.zip') && x.name.includes(assetSearch));
+    if (!asset)
+        throw "asset not found";
+    const url = asset.browser_download_url;
+    console.log("downloading", url);
+    const bin = process.argv[0];
+    const binPath = (0, path_1.dirname)(bin);
+    const binFile = (0, path_1.basename)(bin);
+    const newBinFile = 'new-' + binFile;
+    plugins_1.pluginsWatcher.pause();
+    try {
+        await (0, misc_1.unzip)(await (0, misc_1.httpsStream)(url), path => (0, path_1.join)(binPath, path === binFile ? newBinFile : path));
+        const newBin = (0, path_1.join)(binPath, newBinFile);
+        if (!const_1.IS_WINDOWS) {
+            const { mode } = await (0, promises_1.stat)(bin);
+            await (0, promises_1.chmod)(newBin, mode).catch(console.error);
+        }
+        (0, misc_1.onProcessExit)(() => {
+            const oldBinFile = 'old-' + binFile;
+            console.log("old version is kept as", oldBinFile);
+            const oldBin = (0, path_1.join)(binPath, oldBinFile);
+            try {
+                (0, fs_1.unlinkSync)(oldBin);
+            }
+            catch (_a) { }
+            (0, fs_1.renameSync)(bin, oldBin);
+            console.log("launching new version in background", newBinFile);
+            (0, child_process_1.spawn)(newBin, ['--updating', binFile], { detached: true, shell: true })
+                .on('error', console.error);
+        });
+        console.log('quitting');
+        process.exit();
+    }
+    catch (_a) {
+        plugins_1.pluginsWatcher.unpause();
+    }
+}
+exports.update = update;
+if (const_1.argv.updating) { // we were launched with a temporary name, restore original name to avoid breaking references
+    const bin = process.argv[0];
+    (0, fs_1.renameSync)(bin, (0, path_1.join)((0, path_1.dirname)(bin), const_1.argv.updating));
+    console.log("renamed binary file to", const_1.argv.updating);
+}

package/src/util-files.js

@@ -0,0 +1,163 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareFolder = exports.unzip = exports.run = exports.dirStream = exports.adjustStaticPathForGlob = exports.isWindowsDrive = exports.dirTraversal = exports.watchDir = exports.readFileBusy = exports.isFile = exports.isDirectory = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const misc_1 = require("./misc");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const const_1 = require("./const");
+const child_process_1 = require("child_process");
+const stream_1 = require("stream");
+// @ts-ignore
+const unzip_stream_1 = __importDefault(require("unzip-stream"));
+async function isDirectory(path) {
+    try {
+        return (await promises_1.default.stat(path)).isDirectory();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.isDirectory = isDirectory;
+async function isFile(path) {
+    try {
+        return (await promises_1.default.stat(path)).isFile();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.isFile = isFile;
+async function readFileBusy(path) {
+    return promises_1.default.readFile(path, 'utf8').catch(e => {
+        if ((e === null || e === void 0 ? void 0 : e.code) !== 'EBUSY')
+            throw e;
+        console.debug('busy');
+        return (0, misc_1.wait)(100).then(() => readFileBusy(path));
+    });
+}
+exports.readFileBusy = readFileBusy;
+function watchDir(dir, cb) {
+    let watcher;
+    let paused = false;
+    try {
+        watcher = (0, fs_1.watch)(dir, controlledCb);
+    }
+    catch (_a) {
+        // failing watching the content of the dir, we try to monitor its parent, but filtering events only for our target dir
+        const base = (0, path_1.basename)(dir);
+        try {
+            watcher = (0, fs_1.watch)((0, path_1.dirname)(dir), (event, name) => {
+                if (name !== base)
+                    return;
+                try {
+                    watcher.close(); // if we succeed, we give up the parent watching
+                    watcher = (0, fs_1.watch)(dir, controlledCb); // attempt at passing to a more specific watching
+                }
+                catch (_a) { }
+                controlledCb();
+            });
+        }
+        catch (e) {
+            console.debug(String(e));
+        }
+    }
+    return {
+        working() { return Boolean(watcher); },
+        stop() { watcher === null || watcher === void 0 ? void 0 : watcher.close(); },
+        pause() { paused = true; },
+        unpause() { paused = false; },
+    };
+    function controlledCb() {
+        if (!paused)
+            cb();
+    }
+}
+exports.watchDir = watchDir;
+function dirTraversal(s) {
+    return s && /(^|[/\\])\.\.($|[/\\])/.test(s);
+}
+exports.dirTraversal = dirTraversal;
+function isWindowsDrive(s) {
+    return s && /^[a-zA-Z]:$/.test(s);
+}
+exports.isWindowsDrive = isWindowsDrive;
+// apply this to paths that may contain \ as separator (not supported by fast-glob) and other special chars to be escaped (parenthesis)
+function adjustStaticPathForGlob(path) {
+    return fast_glob_1.default.escapePath(path.replace(/\\/g, '/'));
+}
+exports.adjustStaticPathForGlob = adjustStaticPathForGlob;
+async function* dirStream(path, deep) {
+    if (!await isDirectory(path))
+        throw Error('ENOTDIR');
+    const dirStream = fast_glob_1.default.stream(deep ? '**/*' : '*', {
+        cwd: path,
+        dot: true,
+        deep,
+        onlyFiles: false,
+        suppressErrors: true,
+        objectMode: true,
+    });
+    const skip = await getItemsToSkip(path);
+    for await (const entry of dirStream) {
+        let { path, dirent } = entry;
+        if (!dirent.isDirectory() && !dirent.isFile())
+            continue;
+        path = String(path);
+        if (!(skip === null || skip === void 0 ? void 0 : skip.includes(path)))
+            yield path;
+    }
+    async function getItemsToSkip(path) {
+        if (!const_1.IS_WINDOWS)
+            return;
+        const out = await run('dir', ['/ah', '/b', path.replace(/\//g, '\\')])
+            .catch(() => ''); // error in case of no matching file
+        return out.split('\r\n').slice(0, -1);
+    }
+}
+exports.dirStream = dirStream;
+function run(cmd, args = []) {
+    return new Promise((resolve, reject) => (0, child_process_1.execFile)('cmd', ['/c', cmd, ...args], (err, stdout) => {
+        if (err)
+            reject(err);
+        else
+            resolve(stdout);
+    }));
+}
+exports.run = run;
+async function unzip(stream, cb) {
+    let pending = Promise.resolve();
+    return new Promise(resolve => stream.pipe(unzip_stream_1.default.Parse())
+        .on('end', () => pending.then(resolve))
+        .on('entry', async (entry) => {
+        const { path, type } = entry;
+        const dest = cb(path);
+        if (!dest || type !== 'File')
+            return entry.autodrain();
+        await pending; // don't overlap writings
+        console.debug('unzip', dest);
+        await prepareFolder(dest);
+        const thisFile = entry.pipe((0, fs_1.createWriteStream)(dest));
+        pending = (0, stream_1.once)(thisFile, 'finish');
+    }));
+}
+exports.unzip = unzip;
+async function prepareFolder(path, dirnameIt = true) {
+    if (dirnameIt)
+        path = (0, path_1.dirname)(path);
+    if (isWindowsDrive(path))
+        return;
+    try {
+        await promises_1.default.mkdir(path, { recursive: true });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.prepareFolder = prepareFolder;

package/src/util-generators.js

@@ -0,0 +1,31 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncGeneratorToReadable = exports.asyncGeneratorToArray = exports.filterMapGenerator = void 0;
+// callback can return undefined to skip element
+const stream_1 = require("stream");
+async function* filterMapGenerator(generator, filterMap) {
+    for await (const x of generator) {
+        const res = await filterMap(x);
+        if (res !== undefined)
+            yield res;
+    }
+}
+exports.filterMapGenerator = filterMapGenerator;
+async function asyncGeneratorToArray(generator) {
+    const ret = [];
+    for await (const x of generator)
+        ret.push(x);
+    return ret;
+}
+exports.asyncGeneratorToArray = asyncGeneratorToArray;
+function asyncGeneratorToReadable(generator) {
+    const iterator = generator[Symbol.asyncIterator]();
+    return new stream_1.Readable({
+        objectMode: true,
+        read() {
+            iterator.next().then(it => this.push(it.done ? null : it.value));
+        }
+    });
+}
+exports.asyncGeneratorToReadable = asyncGeneratorToReadable;

package/src/util-http.js

@@ -0,0 +1,32 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpsStream = exports.httpsString = void 0;
+const node_https_1 = __importDefault(require("node:https"));
+const const_1 = require("./const");
+function httpsString(url, options = {}) {
+    return httpsStream(url, options).then(res => new Promise(resolve => {
+        let buf = '';
+        res.on('data', chunk => buf += chunk.toString());
+        res.on('end', () => resolve(Object.assign(res, {
+            ok: (res.statusCode || 400) < 400,
+            body: buf
+        })));
+    }));
+}
+exports.httpsString = httpsString;
+function httpsStream(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        node_https_1.default.request(url, options, res => {
+            if (!res.statusCode || res.statusCode >= 400)
+                throw res;
+            if (res.statusCode === const_1.HTTP_TEMPORARY_REDIRECT && res.headers.location)
+                return resolve(httpsStream(res.headers.location, options));
+            resolve(res);
+        }).on('error', reject).end();
+    });
+}
+exports.httpsStream = httpsStream;

package/src/vfs.js

@@ -0,0 +1,232 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cantReadStatusCode = exports.walkNode = exports.hasPermission = exports.nodeIsDirectory = exports.getNodeName = exports.saveVfs = exports.vfs = exports.urlToNode = exports.MIME_AUTO = exports.defaultPerms = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = require("path");
+const micromatch_1 = require("micromatch");
+const misc_1 = require("./misc");
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = require("./config");
+const const_1 = require("./const");
+const events_1 = __importDefault(require("./events"));
+const perm_1 = require("./perm");
+const misc_2 = require("./misc");
+const WHO_ANYONE = true;
+const WHO_NO_ONE = false;
+const WHO_ANY_ACCOUNT = '*';
+exports.defaultPerms = {
+    can_see: WHO_ANYONE,
+    can_read: WHO_ANYONE,
+    can_upload: WHO_NO_ONE,
+};
+exports.MIME_AUTO = 'auto';
+function inheritFromParent(parent, child) {
+    var _a;
+    for (const k of (0, misc_1.typedKeys)(exports.defaultPerms)) {
+        const v = parent[k];
+        if (v !== undefined)
+            (_a = child[k]) !== null && _a !== void 0 ? _a : (child[k] = v);
+    }
+    if (typeof parent.mime === 'object' && typeof child.mime === 'object')
+        lodash_1.default.defaults(child.mime, parent.mime);
+    else
+        child.mime || (child.mime = parent.mime);
+    return child;
+}
+async function urlToNode(url, ctx, parent = exports.vfs, getRest) {
+    var _a;
+    let initialSlashes = 0;
+    while (url[initialSlashes] === '/')
+        initialSlashes++;
+    let nextSlash = url.indexOf('/', initialSlashes);
+    const name = decodeURIComponent(url.slice(initialSlashes, nextSlash < 0 ? undefined : nextSlash));
+    if (!name)
+        return parent;
+    const rest = nextSlash < 0 ? '' : url.slice(nextSlash + 1, url.endsWith('/') ? -1 : undefined);
+    if ((0, misc_1.dirTraversal)(name) || /[\/]/.test(name)) {
+        if (ctx)
+            ctx.status = const_1.HTTP_FOOL;
+        return;
+    }
+    // does the tree node have a child that goes by this name?
+    const sameName = !const_1.IS_WINDOWS ? (x) => x === name // easy
+        : (0, misc_2.with_)(name.toLowerCase(), lc => (x) => x.toLowerCase() === lc);
+    const child = (_a = parent.children) === null || _a === void 0 ? void 0 : _a.find(x => sameName(getNodeName(x)));
+    const ret = {
+        ...child,
+        original: child,
+        isTemp: true,
+    };
+    inheritFromParent(parent, ret);
+    inheritMasks(ret, parent, name);
+    applyMasks(ret, parent, name);
+    if (child) // yes
+        return urlToNode(rest, ctx, ret, getRest);
+    // not in the tree, we can see consider continuing on the disk
+    if (!parent.source)
+        return; // but then we need the current node to be linked to the disk, otherwise, we give up
+    let onDisk = name;
+    if (parent.rename) { // reverse the mapping
+        for (const [from, to] of Object.entries(parent.rename))
+            if (name === to) {
+                onDisk = from;
+                break; // found, search no more
+            }
+        ret.rename = renameUnderPath(parent.rename, name);
+    }
+    ret.source = (0, misc_1.enforceFinal)('/', parent.source) + onDisk;
+    if (parent.default)
+        inheritFromParent({ mime: { '*': exports.MIME_AUTO } }, ret);
+    if (rest)
+        return urlToNode(rest, ctx, ret, getRest);
+    if (ret.source)
+        try {
+            await promises_1.default.stat(ret.source);
+        } // check existence
+        catch (_b) {
+            if (!getRest)
+                return;
+            getRest(onDisk);
+            return parent;
+        }
+    return ret;
+}
+exports.urlToNode = urlToNode;
+exports.vfs = {};
+(0, config_1.defineConfig)('vfs', {}).sub(data => exports.vfs = data);
+function saveVfs() {
+    return (0, config_1.setConfig)({ vfs: lodash_1.default.cloneDeep(exports.vfs) }, true);
+}
+exports.saveVfs = saveVfs;
+function getNodeName(node) {
+    return node.name
+        || node.source && (/^[a-zA-Z]:\\?$/.test(node.source) && node.source.slice(0, 2)
+            || (0, path_1.basename)(node.source)
+            || node.source)
+        || ''; // should happen only for root
+}
+exports.getNodeName = getNodeName;
+async function nodeIsDirectory(node) {
+    return Boolean(!node.source || await (0, misc_1.isDirectory)(node.source));
+}
+exports.nodeIsDirectory = nodeIsDirectory;
+function hasPermission(node, perm, ctx) {
+    var _a;
+    return matchWho((_a = node[perm]) !== null && _a !== void 0 ? _a : exports.defaultPerms[perm], ctx)
+        && (perm !== 'can_see' || hasPermission(node, 'can_read', ctx)); // can_see is used to hide something you nonetheless can_read, so you MUST also can_read
+}
+exports.hasPermission = hasPermission;
+async function* walkNode(parent, ctx, depth = 0, prefixPath = '') {
+    var _a;
+    const { children, source } = parent;
+    const took = prefixPath ? undefined : new Set();
+    if (children)
+        for (let idx = 0; idx < children.length; idx++) {
+            const child = children[idx];
+            const name = prefixPath + getNodeName(child);
+            took === null || took === void 0 ? void 0 : took.add(name);
+            yield* workItem({
+                ...child,
+                name,
+            }, depth > 0 && await nodeIsDirectory(child).catch(() => false));
+        }
+    if (!source)
+        return;
+    try {
+        for await (const path of (0, misc_1.dirStream)(source, depth)) {
+            if (ctx === null || ctx === void 0 ? void 0 : ctx.req.aborted)
+                return;
+            const name = prefixPath + (((_a = parent.rename) === null || _a === void 0 ? void 0 : _a[path]) || path);
+            if (took === null || took === void 0 ? void 0 : took.has(name))
+                continue;
+            yield* workItem({
+                name,
+                source: (0, path_1.join)(source, path),
+                rename: renameUnderPath(parent.rename, path),
+            });
+        }
+    }
+    catch (e) {
+        console.debug('glob', source, e); // ENOTDIR, or lacking permissions
+    }
+    // item will be changed, so be sure to pass a temp node
+    async function* workItem(item, recur = false) {
+        const name = getNodeName(item);
+        // we basename for depth>0 where we already have the rest of the path in the parent's url, and would be duplicated
+        const virtualBasename = (0, path_1.basename)(name);
+        item.isTemp = true;
+        inheritFromParent(parent, item);
+        applyMasks(item, parent, virtualBasename);
+        if (ctx && !hasPermission(item, 'can_see', ctx))
+            return;
+        yield item;
+        if (!recur)
+            return;
+        inheritMasks(item, parent, virtualBasename);
+        yield* walkNode(item, ctx, depth - 1, name + '/');
+    }
+}
+exports.walkNode = walkNode;
+function applyMasks(item, parent, virtualBasename) {
+    const { masks } = parent;
+    if (!masks)
+        return;
+    for (const k in masks)
+        if (k.startsWith('**/') && (0, micromatch_1.isMatch)(virtualBasename, k.slice(3))
+            || !k.includes('/') && (0, micromatch_1.isMatch)(virtualBasename, k))
+            Object.assign(item, masks[k]);
+}
+function inheritMasks(item, parent, virtualBasename) {
+    const { masks } = parent;
+    if (!masks)
+        return;
+    const o = {};
+    for (const k in masks)
+        if (k.startsWith('**/'))
+            o[k.slice(3)] = masks[k];
+        else if (k.startsWith(virtualBasename + '/'))
+            o[k.slice(virtualBasename.length + 1)] = masks[k];
+    if (Object.keys(o).length)
+        item.masks = o;
+}
+function renameUnderPath(rename, path) {
+    if (!rename)
+        return rename;
+    const match = path + '/';
+    rename = Object.fromEntries(Object.entries(rename).map(([k, v]) => [k.startsWith(match) ? k.slice(match.length) : '', v]));
+    delete rename[''];
+    return lodash_1.default.isEmpty(rename) ? undefined : rename;
+}
+function matchWho(who, ctx) {
+    return who === WHO_ANYONE
+        || who === WHO_ANY_ACCOUNT && Boolean(ctx.state.account)
+        || Array.isArray(who) && (() => // check if I or any ancestor match `who`, but cache ancestors' usernames inside context state
+         (0, misc_1.getOrSet)(ctx.state, 'usernames', () => (0, perm_1.getCurrentUsernameExpanded)(ctx)).some((u) => who.includes(u)))();
+}
+function cantReadStatusCode(node) {
+    return node.can_read === false ? const_1.HTTP_FORBIDDEN : const_1.HTTP_UNAUTHORIZED;
+}
+exports.cantReadStatusCode = cantReadStatusCode;
+events_1.default.on('accountRenamed', (from, to) => {
+    recur(exports.vfs);
+    saveVfs();
+    function recur(n) {
+        var _a;
+        for (const k of (0, misc_1.typedKeys)(exports.defaultPerms))
+            replace(n[k]);
+        if (n.masks)
+            Object.values(n.masks).forEach(recur);
+        (_a = n.children) === null || _a === void 0 ? void 0 : _a.forEach(recur);
+    }
+    function replace(a) {
+        if (!Array.isArray(a))
+            return;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] === from)
+                a[i] = to;
+    }
+});