err = m => { throw Error(m) }; [O, D, C] = ((rep = e => queueMicrotask(() => { throw e }), stk = [], seq = 0) => { const eq = (a, b, c = a?.constructor) => a === b ? 1 : c !== b?.constructor ? 0 : c == Array ? a.length == b.length && a.every((x, i) => eq(x, b[i])) : c == Set ? a.size == b.size && [...a].every(x => b.has(x)) : c == Object ? Object.keys(a).length == Object.keys(b).length && Object.keys(a).every(k => k in b && eq(a[k], b[k])) : 0, unt = fn => { stk.push(null); try { return fn() } finally { stk.pop() } }, pub = (s, v, o) => unt(() => [...s].sort((a, b) => a.id - b.id).forEach(f => { if (s.has(f)) try { f(v, o) } catch (e) { rep(e) } })), kil = (obs, subs) => { subs.clear(); for (let k in obs) obs[k] = () => err('disposed') }, sub = (subs, val, fn, im = 1, id = seq++) => (fn.id = id, im && unt(() => fn(val)), subs.add(fn), () => subs.has(fn) ? subs.delete(fn) : err('unsub missing')), O = (val, subs = new Set, rv) => (rv = { get: () => (stk.at(-1)?.add(rv), val), sub: (...a) => sub(subs, val, ...a), set: (v, old = val) => eq(v, val) || (val = v, pub(subs, v, old)), dis: () => (val = 0, kil(rv, subs))}, rv), D = (fn, cache, dty = 1, deps = new Map, subs = new Set, rv, id = seq++, busy) => (rv = { sub: (...a) => sub(subs, unt(rv.get), ...a), dis: () => (deps.forEach(u => u()), deps.clear(), kil(rv, subs)), get: () => { stk.at(-1)?.add(rv) if (!dty) return cache const prev = cache; stk.push(new Set); busy = 1 try { cache = fn(); dty = 0 } finally { busy = 0; const now = stk.pop(); deps.forEach((u, o) => now.has(o) || (u(), deps.delete(o))); now.forEach(o => deps.has(o) || deps.set(o, o.sub(() => { if (busy) return; dty = 1; subs.size && rv.get(); }, 0, id))) } !eq(cache, prev) && pub(subs, cache, prev) return cache }}, rv), C = fn => (...l) => { const d = [], tra = t => (t.dis && d.push(t.dis), t), obs = o => tra(O(o)), der = o => tra(D(o)), sub = (o, cb, im) => d.push(o.sub(cb, im)) const dis = () => d.splice(0).reverse().forEach(f => { try { f() } catch (e) { rep(e) } }) try { return { ...tra(fn({ tra, obs, der, sub }, ...l) ?? {}), dis } } catch (e) { dis(); throw e } } return [O, D, C] })(e => log('PUT', '/', e)); log = (o => (v, p, d) => v === 'GET' ? o.get() : v === 'PUT' ? (o.set(o.get() + d + '\n'), '') : err('not allowed'))(O('')) I = (dir = 0, d) => { const o = O(dir ? d || {} : String(d ?? '')), { get, set, dis } = o return Object.assign(o, { dir, req: (v, p, d) => { !p?.startsWith('/') && err('bad request') const parts = p.split('/') if (p === '/') { if (!['GET', 'PUT'].includes(v)) err('not allowed') if (v === 'PUT') return (dir ? d && err('is a directory') : set(d ?? '')), '' return !dir ? get() : Object.entries(get()).map(([k, x]) => `=> ${k}${x.dir ? '/' : ''}`).join('\n') } let deep = parts.length > 2, x = get()[parts[1]], rest = p.slice(parts[1].length + 1) || '/' if (v === 'DEL' && x && (!deep || !parts[2] && x.dir)) { const { [parts[1]]: _, ...e } = get(); return set(e), x.dis() } if (v === 'PUT' && !x) { x = I(deep, deep ? {} : d); const r = x.req(v, rest, d); return set({ ...get(), [parts[1]]: x }), r } if (deep && x && !x.dir) err('not a directory') return (x && (!deep || x.dir)) ? x.req(v, rest, d) : err('not found') }, dis: () => (dir && Object.values(get()).forEach(x => x.dis()), dis()) }) } ;[req, mount] = ((mt = O({})) => { const match = (t, p) => p ? Object.keys(t).filter(k => k === p || k === p + '/' || k.endsWith('/') && p.startsWith(k)).sort((a, b) => b.length - a.length)[0] : undefined, walk = (t, p, x = match(t, p)) => x ? t[x] + p.slice(x.length) : p, um = p => { const t = { ...mt.get() }; delete t[p]; mt.set(t) }, n = (skip, v, p, d) => (v2 = v, p2 = p, d2 = d, t = { ...mt.get() }, k2 = (skip.forEach(k => delete t[k]), match(t, p2))) => k2 ? mt.get()[k2](v2, '/' + p2.slice(k2.length), d2, n([...skip, k2], v2, p2, d2)) : err('not found') return [(v, p, d, ns = {}, u = walk(ns, p), k = match(mt.get(), u)) => { try { if (v === 'DEL' && k === '/' && Object.keys(mt.get()).some(x => x.startsWith(u) && x !== u)) err('busy'); return (k ? mt.get()[k](v, '/' + u.slice(k.length), d, n([k], v, u, d)) : err('bad request')) ?? '' } catch (e) { 'reason' in e || (e.reason = e.message, e.message += ': ' + p); throw e } } , (p, h, ns = {}) => (p = walk(ns, p), mt.get()[p] && err('busy: ' + p), mt.set({ ...mt.get(), [p]: h }), { dis: () => um(p) })] })()