Finished the README

Author: torch2424

README.md

@@ -174,16 +174,36 @@ An AsBindInstance is vaugley similar to a [WebAssembly instance](https://develop
 
 ##### exports
 
+Similar to to [WebAssembly.Instance.prototype.exports](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports), this is an object containing all of the exported fields from the WebAssembly module. However, **exported functions** are bound / wrapped in which they will handle passing the supported high-level data types to the exported AssemblyScript function.
+
+Each **exported function** has the property: `shouldCacheTypes`. If you would like to disable type caching (speculative execution) for a particular function, you can do: `asBindInstance.exports.myFunction.shouldCacheTypes = false;`. Or set to true, to re-enable type caching.
+
 ##### unboundExports
 
+This is essentially the same as the [WebAssembly.Instance.prototype.exports](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports), this is an object containing all of the exported fields from the WebAssembly module. These are not bound / wrapped, so you can access the original exported functions.
+
+#### importObject
+
+Similar to to [WebAssembly.instantiateStreaming() importObject](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming), This is the original passed importObject on instantiation, after the **importObject functions** are bound / wrapped by as-bind.
+
+Each wrapped **importObject function** has the property: `shouldCacheTypes`. If you would like to disable type caching (speculative execution) for a particular function, you can do: `asBindInstance.importObject.myFunction.shouldCacheTypes = false;`. Or set to true, to re-enable type caching.
+
 ##### enableExportFunctionTypeCaching
 
+This will (re-)enable type caching (speculative execution) for ALL exported functions on the AsBindInstance.
+
 ##### disableExportFunctionTypeCaching
 
+This will disable type caching (speculative execution) for ALL exported functions on the AsBindInstance.
+
 ##### enableImportFunctionTypeCaching
 
+This will (re-)enable type caching (speculative execution) for ALL importObject functions on the AsBindInstance.
+
 ##### disableExportFunctionTypeCaching
 
+This will disable type caching (speculative execution) for ALL importObject functions on the AsBindInstance.
+
 ## License
 
 [MIT](https://oss.ninja/mit/torch2424).

lib/asbind-instance.js

@@ -32,31 +32,31 @@ export default class AsbindInstance {
   constructor() {
     this.unboundExports = {};
     this.exports = {};
-    this._importObject = {};
+    this.importObject = {};
   }
 
   async _instantiate(source, importObject) {
     // Set our import object, as we will need it to store type caching
-    this._importObject = importObject;
+    this.importObject = importObject;
 
     // Need to traverse the importObject and bind all import functions
     traverseObjectAndRunCallbackForFunctions(
-      this._importObject,
+      this.importObject,
       [],
       (baseObject, keys, baseObjectKey) => {
         // Wrap the original key, but then expose a new key for the unbound import
         let importFunction = baseObject[baseObjectKey];
         baseObject[`__asbind_unbound_${baseObjectKey}`] = importFunction;
         baseObject[baseObjectKey] = bindImportFunction(
           this,
-          this._importObject,
+          this.importObject,
           [...keys, baseObjectKey]
         );
       }
     );
 
     // Instantiate the module through the loader
-    this.unboundExports = await asbindInstantiate(source, this._importObject);
+    this.unboundExports = await asbindInstantiate(source, this.importObject);
 
     // Wrap appropriate the appropriate export functions
     this.exports = {};
@@ -91,7 +91,7 @@ export default class AsbindInstance {
   enableImportFunctionTypeCaching() {
     // Need to traverse the importObject and bind all import functions
     traverseObjectAndRunCallbackForFunctions(
-      this._importObject,
+      this.importObject,
       [],
       (baseObject, keys, baseObjectKey) => {
         // Wrap the original key, but then expose a new key for the unbound import
@@ -104,7 +104,7 @@ export default class AsbindInstance {
   disableImportFunctionTypeCaching() {
     // Need to traverse the importObject and bind all import functions
     traverseObjectAndRunCallbackForFunctions(
-      this._importObject,
+      this.importObject,
       [],
       (baseObject, keys, baseObjectKey) => {
         // Wrap the original key, but then expose a new key for the unbound import