diff --git a/lib/node_modules/@stdlib/wasm/instantiate/README.md b/lib/node_modules/@stdlib/wasm/instantiate/README.md
new file mode 100644
index 000000000000..5d91475ee045
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/README.md
@@ -0,0 +1,153 @@
+
+
+# Instantiate
+
+> Compile and [instantiate][mdn-webassembly-instantiate] a WebAssembly module.
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var instantiate = require( '@stdlib/wasm/instantiate' );
+```
+
+#### instantiate( source\[, importObject] )
+
+Compiles and [instantiates][mdn-webassembly-instantiate] a WebAssembly module.
+
+```javascript
+var bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+
+instantiate( bytes ).then( onReady );
+
+function onReady( result ) {
+ var mod = result.module;
+ var instance = result.instance;
+ // ...
+}
+```
+
+The function accepts the following arguments:
+
+- **source**: WebAssembly binary code (`Uint8Array` or `ArrayBuffer`) or a compiled WebAssembly module.
+- **importObject**: import object. Default: `undefined`.
+
+When `source` is binary code, the returned promise resolves to an object having the following properties:
+
+- **module**: compiled WebAssembly module.
+- **instance**: WebAssembly instance.
+
+When `source` is already a compiled WebAssembly module, the returned promise resolves to a WebAssembly instance.
+
+
+
+
+
+* * *
+
+
+
+
+
+## Notes
+
+- In environments which do not support WebAssembly, the exported function throws an error.
+- This package is a thin alias of the platform `WebAssembly.instantiate` API.
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var instantiate = require( '@stdlib/wasm/instantiate' );
+
+function main() {
+ var bytes;
+ if ( !hasWebAssemblySupport() ) {
+ console.error( 'Environment does not support WebAssembly.' );
+ return;
+ }
+ // Minimal empty WebAssembly module: (module)
+ bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+ instantiate( bytes ).then( onReady );
+}
+
+function onReady( result ) {
+ console.log( typeof result.module );
+ // => 'object'
+
+ console.log( typeof result.instance );
+ // => 'object'
+}
+
+main();
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[mdn-webassembly-instantiate]: https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/instantiate_static
+
+
+
+
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/benchmark/benchmark.js b/lib/node_modules/@stdlib/wasm/instantiate/benchmark/benchmark.js
new file mode 100644
index 000000000000..0875c4c938f2
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/benchmark/benchmark.js
@@ -0,0 +1,90 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var instantiate = require( './../lib' );
+
+
+// VARIABLES //
+
+// Minimal empty WebAssembly module: (module)
+var BYTES = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+
+
+// MAIN //
+
+bench( format( '%s::instantiate', pkg ), function benchmark( b ) {
+ var i;
+
+ if ( !hasWebAssemblySupport() ) {
+ b.fail( 'environment does not support WebAssembly' );
+ b.end();
+ return;
+ }
+
+ i = 0;
+ b.tic();
+ return next();
+
+ /**
+ * Runs the next benchmark iteration.
+ *
+ * @private
+ */
+ function next() {
+ i += 1;
+ if ( i <= b.iterations ) {
+ return instantiate( BYTES ).then( onResolve, onReject );
+ }
+ b.toc();
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+
+ /**
+ * Callback invoked upon fulfilling a promise.
+ *
+ * @private
+ * @param {Object} result - instantiation result
+ */
+ function onResolve( result ) {
+ if ( typeof result !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ next();
+ }
+
+ /**
+ * Callback invoked upon rejecting a promise.
+ *
+ * @private
+ * @param {*} error - error
+ */
+ function onReject( error ) {
+ b.fail( error.message );
+ b.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/docs/repl.txt b/lib/node_modules/@stdlib/wasm/instantiate/docs/repl.txt
new file mode 100644
index 000000000000..c39b7f85e94a
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/docs/repl.txt
@@ -0,0 +1,34 @@
+
+{{alias}}( source[, importObject] )
+ Compiles and instantiates a WebAssembly module.
+
+ When `source` is binary code, the returned promise resolves to an object
+ having `module` and `instance` properties.
+
+ When `source` is already a compiled WebAssembly module, the returned promise
+ resolves to a WebAssembly instance.
+
+ Parameters
+ ----------
+ source: Uint8Array|ArrayBuffer|Module
+ WebAssembly binary code or compiled module.
+
+ importObject: Object (optional)
+ Import object.
+
+ Returns
+ -------
+ out: Promise
+ Promise which resolves upon compiling and instantiating a WebAssembly
+ module.
+
+ Examples
+ --------
+ > var bytes = new {{alias:@stdlib/array/uint8}}( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+ > {{alias}}( bytes ).then( onReady )
+
+ > function onReady( result ) { console.log( typeof result.module ); }
+ // e.g., => 'object'
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/docs/types/index.d.ts b/lib/node_modules/@stdlib/wasm/instantiate/docs/types/index.d.ts
new file mode 100644
index 000000000000..3be9b099a48c
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/docs/types/index.d.ts
@@ -0,0 +1,64 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Compiles and instantiates a WebAssembly module from binary source.
+*
+* @param source - WebAssembly binary code
+* @param importObject - import object
+* @returns promise which resolves to a WebAssembly module and instance
+*
+* @example
+* var bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+*
+* instantiate( bytes ).then( onReady );
+*
+* function onReady( result ) {
+* // ...
+* }
+*/
+declare function instantiate( source: BufferSource, importObject?: WebAssembly.Imports ): Promise;
+
+/**
+* Instantiates a compiled WebAssembly module.
+*
+* @param source - compiled WebAssembly module
+* @param importObject - import object
+* @returns promise which resolves to a WebAssembly instance
+*
+* @example
+* var bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+*
+* WebAssembly.compile( bytes ).then( onCompile );
+*
+* function onCompile( mod ) {
+* instantiate( mod ).then( onReady );
+* }
+*
+* function onReady( instance ) {
+* // ...
+* }
+*/
+declare function instantiate( source: WebAssembly.Module, importObject?: WebAssembly.Imports ): Promise;
+
+
+// EXPORTS //
+
+export = instantiate;
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/docs/types/test.ts b/lib/node_modules/@stdlib/wasm/instantiate/docs/types/test.ts
new file mode 100644
index 000000000000..3a1b0711ec52
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/docs/types/test.ts
@@ -0,0 +1,59 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+
+import instantiate = require( './index' );
+
+
+// TESTS //
+
+// The function returns a promise...
+{
+ const bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+ instantiate( bytes ); // $ExpectType Promise
+ instantiate( bytes, {} ); // $ExpectType Promise
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a BufferSource or Module...
+{
+ instantiate( '10' ); // $ExpectError
+ instantiate( true ); // $ExpectError
+ instantiate( false ); // $ExpectError
+ instantiate( null ); // $ExpectError
+ instantiate( undefined ); // $ExpectError
+ instantiate( [] ); // $ExpectError
+ instantiate( {} ); // $ExpectError
+ instantiate( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+ const bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+ instantiate( bytes, '10' ); // $ExpectError
+ instantiate( bytes, true ); // $ExpectError
+ instantiate( bytes, false ); // $ExpectError
+ instantiate( bytes, null ); // $ExpectError
+ instantiate( bytes, [] ); // $ExpectError
+ instantiate( bytes, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided insufficient arguments...
+{
+ instantiate(); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/examples/index.js b/lib/node_modules/@stdlib/wasm/instantiate/examples/index.js
new file mode 100644
index 000000000000..c61dab770571
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/examples/index.js
@@ -0,0 +1,44 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var instantiate = require( './../lib' );
+
+function main() {
+ var bytes;
+ if ( !hasWebAssemblySupport() ) {
+ console.error( 'Environment does not support WebAssembly.' );
+ return;
+ }
+ // Minimal empty WebAssembly module: (module)
+ bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+ instantiate( bytes ).then( onReady );
+}
+
+function onReady( result ) {
+ console.log( typeof result.module );
+ // => 'object'
+
+ console.log( typeof result.instance );
+ // => 'object'
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/lib/index.js b/lib/node_modules/@stdlib/wasm/instantiate/lib/index.js
new file mode 100644
index 000000000000..1548623dfb6a
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/lib/index.js
@@ -0,0 +1,62 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Compile and instantiate a WebAssembly module.
+*
+* @module @stdlib/wasm/instantiate
+*
+* @example
+* var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+* var instantiate = require( '@stdlib/wasm/instantiate' );
+*
+* var bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+*
+* if ( !hasWebAssemblySupport() ) {
+* console.error( 'Environment does not support WebAssembly.' );
+* } else {
+* instantiate( bytes ).then( onReady );
+* }
+*
+* function onReady( result ) {
+* // ...
+* }
+*/
+
+// MODULES //
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var builtin = require( './main.js' );
+var polyfill = require( './polyfill.js' );
+
+
+// MAIN //
+
+var main;
+if ( hasWebAssemblySupport() ) {
+ main = builtin;
+} else {
+ main = polyfill;
+}
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/lib/main.js b/lib/node_modules/@stdlib/wasm/instantiate/lib/main.js
new file mode 100644
index 000000000000..6d5501fb9b52
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/lib/main.js
@@ -0,0 +1,50 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MAIN //
+
+/**
+* Compiles and instantiates a WebAssembly module.
+*
+* @name instantiate
+* @type {Function}
+* @param {(Uint8Array|ArrayBuffer|Module)} source - WebAssembly binary code or compiled module
+* @param {Object} [importObject] - import object
+* @returns {Promise} promise which resolves upon compiling and instantiating a WebAssembly module
+*
+* @example
+* var bytes = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+*
+* instantiate( bytes ).then( resolve, reject );
+*
+* function resolve( result ) {
+* // ...
+* }
+*
+* function reject( error ) {
+* // ...
+* }
+*/
+var instantiate = ( typeof WebAssembly === 'object' ) ? WebAssembly.instantiate : null;
+
+
+// EXPORTS //
+
+module.exports = instantiate;
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/lib/polyfill.js b/lib/node_modules/@stdlib/wasm/instantiate/lib/polyfill.js
new file mode 100644
index 000000000000..b518d51439f3
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/lib/polyfill.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MAIN //
+
+/**
+* Compiles and instantiates a WebAssembly module.
+*
+* @throws {Error} not implemented
+*/
+function polyfill() {
+ throw new Error( 'not implemented' );
+}
+
+
+// EXPORTS //
+
+module.exports = polyfill;
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/package.json b/lib/node_modules/@stdlib/wasm/instantiate/package.json
new file mode 100644
index 000000000000..724e9af762f4
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/package.json
@@ -0,0 +1,60 @@
+{
+ "name": "@stdlib/wasm/instantiate",
+ "version": "0.0.0",
+ "description": "Compile and instantiate a WebAssembly module.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "webassembly",
+ "wasm",
+ "instantiate",
+ "compile",
+ "module",
+ "instance"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/test/test.js b/lib/node_modules/@stdlib/wasm/instantiate/test/test.js
new file mode 100644
index 000000000000..9bf993372a8b
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/test/test.js
@@ -0,0 +1,80 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var polyfill = require( './../lib/polyfill.js' );
+var instantiate = require( './../lib' );
+
+
+// VARIABLES //
+
+var hasWebAssembly = hasWebAssemblySupport();
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof instantiate, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'if an environment supports `WebAssembly.instantiate`, the export is an alias for `WebAssembly.instantiate`', function test( t ) {
+ var fcn;
+
+ fcn = proxyquire( './../lib', {
+ '@stdlib/assert/has-wasm-support': isTrue,
+ './main.js': Mock
+ });
+ t.strictEqual( fcn, Mock, 'returns builtin' );
+
+ if ( hasWebAssembly ) {
+ t.strictEqual( instantiate, WebAssembly.instantiate, 'is alias' );
+ }
+
+ t.end();
+
+ function Mock() {
+ // No-op...
+ }
+
+ function isTrue() {
+ return true;
+ }
+});
+
+tape( 'if an environment does not support `WebAssembly.instantiate`, the export is a polyfill', function test( t ) {
+ var fcn;
+
+ fcn = proxyquire( './../lib', {
+ '@stdlib/assert/has-wasm-support': isFalse
+ });
+
+ t.strictEqual( fcn, polyfill, 'returns polyfill' );
+ t.end();
+
+ function isFalse() {
+ return false;
+ }
+});
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/test/test.main.js b/lib/node_modules/@stdlib/wasm/instantiate/test/test.main.js
new file mode 100644
index 000000000000..702b1d8ba8ba
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/test/test.main.js
@@ -0,0 +1,85 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var instantiate = require( './../lib/main.js' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+
+// Minimal empty WebAssembly module: (module)
+var BYTES = new Uint8Array( [ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00 ] );
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof instantiate, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function compiles and instantiates a WebAssembly module from binary source', opts, function test( t ) {
+ var p = instantiate( BYTES );
+ t.strictEqual( typeof p.then, 'function', 'returns a thenable' );
+
+ p.then( onResolve, onReject );
+
+ function onResolve( result ) {
+ t.strictEqual( typeof result, 'object', 'returns an object' );
+ t.strictEqual( typeof result.module, 'object', 'returns a module' );
+ t.strictEqual( typeof result.instance, 'object', 'returns an instance' );
+ t.end();
+ }
+
+ function onReject( error ) {
+ t.fail( error.message );
+ t.end();
+ }
+});
+
+tape( 'the function rejects when provided invalid WebAssembly binary source', opts, function test( t ) {
+ var bytes;
+ var p;
+
+ bytes = new Uint8Array( [ 0x00, 0x00, 0x00, 0x00 ] );
+ p = instantiate( bytes );
+ t.strictEqual( typeof p.then, 'function', 'returns a thenable' );
+
+ p.then( onResolve, onReject );
+
+ function onResolve() {
+ t.fail( 'should have rejected' );
+ t.end();
+ }
+
+ function onReject( error ) {
+ t.ok( error, 'returns an error' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/wasm/instantiate/test/test.polyfill.js b/lib/node_modules/@stdlib/wasm/instantiate/test/test.polyfill.js
new file mode 100644
index 000000000000..f934fd4c2601
--- /dev/null
+++ b/lib/node_modules/@stdlib/wasm/instantiate/test/test.polyfill.js
@@ -0,0 +1,42 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var instantiate = require( './../lib/polyfill.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof instantiate, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error when invoked', function test( t ) {
+ t.throws( foo, Error, 'throws an error' );
+ t.end();
+
+ function foo() {
+ instantiate();
+ }
+});