'use strict';

const {

Array,

ArrayPrototypeJoin,

ArrayPrototypePush,

ArrayPrototypeSome,

FunctionPrototype,

ObjectSetPrototypeOf,

this.modulePromise = PromiseResolve(this.modulePromise);

}

// Wait for the ModuleWrap instance being linked with all dependencies.

const link = async () => {

this.module = await this.modulePromise;

assert(this.module instanceof ModuleWrap);

// Explicitly keeping track of dependency jobs is needed in order

// to flatten out the dependency graph below in `_instantiate()`,

// so that circular dependencies can't cause a deadlock by two of

// these `link` callbacks depending on each other.

const dependencyJobs = [];

const promises = this.module.link(async (specifier, attributes) => {

const job = await this.#loader.getModuleJob(specifier, url, attributes);

debug(`async link() ${this.url} -> ${specifier}`, job);

ArrayPrototypePush(dependencyJobs, job);

return job.modulePromise;

});

if (promises !== undefined) {

await SafePromiseAllReturnVoid(promises);

}

return SafePromiseAllReturnArrayLike(dependencyJobs);

};

// Promise for the list of all dependencyJobs.

this.linked = link();

this.linked = this._link();

// This promise is awaited later anyway, so silence

// 'unhandled rejection' warnings.

PromisePrototypeThen(this.linked, undefined, noop);

this.instantiated = undefined;

}

/**

* Iterates the module requests and links with the loader.

* @returns {Promise<ModuleJob[]>} Dependency module jobs.

*/

async _link() {

this.module = await this.modulePromise;

assert(this.module instanceof ModuleWrap);

const moduleRequests = this.module.getModuleRequests();

// Explicitly keeping track of dependency jobs is needed in order

// to flatten out the dependency graph below in `_instantiate()`,

// so that circular dependencies can't cause a deadlock by two of

// these `link` callbacks depending on each other.

// Create an ArrayLike to avoid calling into userspace with `.then`

// when returned from the async function.

const dependencyJobs = Array(moduleRequests.length);

ObjectSetPrototypeOf(dependencyJobs, null);

// Specifiers should be aligned with the moduleRequests array in order.

const specifiers = Array(moduleRequests.length);

const modulePromises = Array(moduleRequests.length);

// Iterate with index to avoid calling into userspace with `Symbol.iterator`.

for (let idx = 0; idx < moduleRequests.length; idx++) {

const { specifier, attributes } = moduleRequests[idx];

const dependencyJobPromise = this.#loader.getModuleJob(

specifier, this.url, attributes,

);

const modulePromise = PromisePrototypeThen(dependencyJobPromise, (job) => {

debug(`async link() ${this.url} -> ${specifier}`, job);

dependencyJobs[idx] = job;

return job.modulePromise;

});

modulePromises[idx] = modulePromise;

specifiers[idx] = specifier;

}

const modules = await SafePromiseAllReturnArrayLike(modulePromises);

this.module.link(specifiers, modules);

return dependencyJobs;

}

instantiate() {

if (this.instantiated === undefined) {

this.instantiated = this._instantiate();

super(url, importAttributes, moduleWrap, isMain, inspectBrk, true);

assert(this.module instanceof ModuleWrap);

this.#loader = loader;

const moduleRequests = this.module.getModuleRequestsSync();

const linked = [];

const moduleRequests = this.module.getModuleRequests();

// Specifiers should be aligned with the moduleRequests array in order.

const specifiers = Array(moduleRequests.length);

const modules = Array(moduleRequests.length);

const jobs = Array(moduleRequests.length);

for (let i = 0; i < moduleRequests.length; ++i) {

const { 0: specifier, 1: attributes } = moduleRequests[i];

const job = this.#loader.getModuleWrapForRequire(specifier, url, attributes);

const isLast = (i === moduleRequests.length - 1);

// TODO(joyeecheung): make the resolution callback deal with both promisified

// an raw module wraps, then we don't need to wrap it with a promise here.

this.module.cacheResolvedWrapsSync(specifier, PromiseResolve(job.module), isLast);

ArrayPrototypePush(linked, job);

const { specifier, attributes } = moduleRequests[i];

const job = this.#loader.getModuleJobForRequire(specifier, url, attributes);

specifiers[i] = specifier;

modules[i] = job.module;

jobs[i] = job;

}

this.linked = linked;

this.module.link(specifiers, modules);

this.linked = jobs;

}

get modulePromise() {