require(deps:string|string[], callback?:Function, errback?: RequireJSContext.ActionRequireError): any {
        var id, map, requireMod;

        if (this.options.enableBuildCallback && callback && isFunction(callback)) {
            (callback as any).__requireJsBuild = true;
        }

        if (typeof deps === 'string') {
            if (isFunction(callback)) {
                //Invalid call
                return this.context.onError(makeError('requireargs', 'Invalid require call'), errback);
            }

            //If require|exports|module are requested, get the
            //value for them from the special handlers. Caveat:
            //this only works while module is being defined.
            if (this.relMap && hasProp(this.context.handlers, deps)) {
                return this.context.handlers[deps](this.context.registry[this.relMap.id]);
            }

            //TODO: req.get
            //Synchronous access to one module. If require.get is
            //available (as in the Node adapter), prefer that.
            // if (req.get) {
            //     return req.get(this.context, deps, relMap, localRequire);
            // }

            //Normalize module name, if it contains . or ..
            map = this.context.makeModuleMap(deps, this.relMap, false, true);
            id = map.id;

            if (!hasProp(this.context.defined, id)) {
                return this.context.onError(
                    makeError(
                        'notloaded',
                        'Module name "' + id +
                        '" has not been loaded yet for context: ' + this.context.contextName +
                        (this.relMap ? '' : '. Use require([])')));
            }
            return this.context.defined[id];
        }

        //Grab defines waiting in the global queue.
        this.context.intakeDefines();

        //Mark all the dependencies as needing to be loaded.
        nextTick(() => {
            //Some defines could have been added since the
            //require call, collect them.
            this.context.intakeDefines();

            requireMod = this.context.getModule(this.context.makeModuleMap(null, this.relMap));

            //Store if map config should be applied to this require
            //call for dependencies.
            requireMod.skipMap = this.options.skipMap;

            requireMod.init(deps, callback, errback, {
                enabled: true
            });

            this.context.checkLoaded();
        });

        return this.context.require;
    }

 /**
 * On Error override
 * @param err
 **/
 onError(err: RequireJSContext.RequireError, errback?: RequireJSContext.ActionRequireError): void {
     const context = this.context;
     context.onError(err, errback);
 }

        nextTick(() => {
            //Some defines could have been added since the
            //require call, collect them.
            this.context.intakeDefines();

            requireMod = this.context.getModule(this.context.makeModuleMap(null, this.relMap));

            //Store if map config should be applied to this require
            //call for dependencies.
            requireMod.skipMap = this.options.skipMap;

            requireMod.init(deps, callback, errback, {
                enabled: true
            });

            this.context.checkLoaded();
        });

    /**
     * Converts a module name + .extension into an URL path.
     * *Requires* the use of a module name. It does not support using
     * plain URLs like nameToUrl.
     */
    toUrl(moduleNamePlusExt: string): string {
        var ext,
            index = moduleNamePlusExt.lastIndexOf('.'),
            segment = moduleNamePlusExt.split('/')[0],
            isRelative = segment === '.' || segment === '..';

        //Have a file extension alias, and it is not the
        //dots from a relative path.
        if (index !== -1 && (!isRelative || index > 1)) {
            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
        }


        return this.context.nameToUrl(
            this.context.normalize(
                moduleNamePlusExt,
                this.relMap && this.relMap.id,
                true),
            ext,
            true);
    }

    /**
     * Undefine a module
     * @param module Module to undefine.
     **/
    undef(id: string): void {
        const context = this.context;
        //Bind any waiting define() calls to this context,
        //fix for #408
        context.takeGlobalQueue();

        var map = context.makeModuleMap(id, this.relMap, true);
        var mod = getOwn(context.registry, id);

        mod.undefed = true;
        context.removeScript(id);

        delete context.defined[id];
        delete context.urlFetched[map.url];
        delete context.undefEvents[id];

        //Clean queued defines too. Go backwards
        //in array so that the splices do not
        //mess up the iteration.
        eachReverse(context.defQueue, (args, i) => {
            if (args[0] === id) {
                context.defQueue.splice(i, 1);
            }
        });
        delete context.defQueueMap[id];

        if (mod) {
            //Hold on to listeners in case the
            //module will be attempted to be reloaded
            //using a different config.
            if (mod.events.defined) {
                context.undefEvents[id] = mod.events;
            }

            context.cleanRegistry(id);
        }
    }

afterEach( async () => {
    await ctx.screenSnap('final')
})

 async get() {
     const {driver} = this.ctx
     await driver.get(this.ctx.urlFor(this.path))
 }

 async screenshot(freeze = true) {
     if (freeze)
         await this.freeze()
     return await this.ctx.screenshot()
 }

afterAll( async () => {
    await ctx.dispose()
})