Polyfill for Promise might breaks wasm on edge

[clouds56]

We might fix for WebAssembly.instantiateStreaming.

(function() {
	var proxied = WebAssembly.instantiateStreaming;
	WebAssembly.instantiateStreaming = function(response, importObject) {
		return Promise.resolve(response).then(res => {
			return proxied(res, importObject);
		});
	};
})();

See also webpack/webpack#10560

[JakeChampion]

That looks like a bug in WebAssembly.instantiateStreaming and not in the Promise polyfill. It looks like you need to polyfill WebAssembly.instantiateStreaming; in browsers which don't support it receiving a Promise.

[clouds56]

But before core-js polyfills Promise, WebAssembly.instantiateStreaming of Edge do work with native Promise.
If core-js breaks something and refused to fix we should at least document it (something like known issues).
It takes lots of time for us to track down what's happening inside.

[JakeChampion]

I found this comment about Edge and core-js Promise #579 (comment)

[clouds56]

Thanks for related link.
IIRC, it is a comment that why we wrap fetch, but not mention the consequence of breaking built-in APIs.

I'm not a expert at js but I think it is definitely a bug in core-js: it fakes Promise but not be compatible with built-in APIs. What's worse it wraps fetch (another built-in API) and you could not get a native Promise in this case.
An idealistic solution should be make polyfilled Promise recognized as Promise in built-in API like WebAssembly.instantiateStreaming at least on Edge.

[slowcheetah]

@clouds56 in case with strict type checking we can't do anything else like hack that you provide in first message. See #178 (comment) and the whole issue.

[zloirock]

At this moment, in case of polyfilled Promise, core-js patch native Promise implementation for make native Promise instances look like core-js Promise instances:

nativePromiseBasedAPI();                         // -> it's a native, not `core-js`, promise, but:
nativePromiseBasedAPI() instanceof Promise;      // -> true
nativePromiseBasedAPI().constructor === Promise; // -> true
nativePromiseBasedAPI().then(fn);                // -> it's a `core-js` promise
nativePromiseBasedAPI().catch(fn);               // -> it's a `core-js` promise
nativePromiseBasedAPI().finally(fn);             // -> it's a `core-js` promise

and that fixes most possible related problems.

But we can't patch all possible native promise-based APIs to make them return or accept (the case of this issue) core-js promises - however, most APIs should be generic and accept all thenables. Feel free to use the workarounds like you proposed.

[zloirock]

BTW your problem case most likely will work in the actual core-js version since native fetch should return patched native, not core-js, promise and WebAssembly.instantiateStreaming could accept it.