Fix module proxy to use proxies

[dead-claudia]

Why not save a bit of memory by using proxies with caching to lighten the footprint of methods? Also, while we're at it, the length is a bit useless, and could probably be shed. (Most of the time functions depend on lengths, they also have a facility to specify it explicitly.)

Example implementation

const methodData = new WeakMap()
const methodCache = new Map()
const hasOwn = Object.prototype.hasOwnProperty
const proxyTarget = Object.create(null)

Object.defineProperty(proxyTarget, Symbol.toStringTag, {
    configurable: false, enumerable: false, writable: false,
    value: "Module Proxy",
})

function compileMethod(name) {
    let memo = methodCache.get(name)

    if (memo == null) {
        methodCache.set(name, memo = /** @this */ function (...args) {
            const {module, options} = methodData.get(this)

            return module.pool.invoke(
                {module, options, name},
                args.length ? args : undefined
            )
        })
    }

    return memo
}

exports.ModuleWrap = class ModuleWrap {
    constructor(pool, name, methods) {
        this.pool = pool
        this.name = name
        this.methods = methods
        this.proxy = this.apply(proxyTarget, undefined, [])
    }

    apply(target, thisArg, [options]) {
        if (options == null || typeof options !== "object") {
            throw new TypeError("`options` must be an object")
        }

        const proxy = new Proxy(target, this)

        methodData.set(proxy, {module: this, options})
        return proxy
    }

    get(target, key, receiver) {
        return hasOwn.call(this.methods, key)
            ? compileMethod(key)
            : Reflect.get(target, key, receiver)
    }

    has(target, key) {
        return hasOwn.call(this.methods, key) || Reflect.has(target, key)
    }

    set() { return false }
    defineProperty() { return false }
    deleteProperty() { return false }
    setPrototypeOf() { return false }
    preventExtensions() { return false }
}