$

node_modules/@webassemblyjs/ast/esm/clone.js

@@ -0,0 +1,3 @@
+export function cloneNode(n) {
+  return Object.assign({}, n);
+}

node_modules/@webassemblyjs/ast/esm/index.js

@@ -0,0 +1,7 @@
+export * from "./nodes";
+export { numberLiteralFromRaw, withLoc, withRaw, funcParam, indexLiteral, memIndexLiteral, instruction, objectInstruction } from "./node-helpers.js";
+export { traverse } from "./traverse";
+export { signatures } from "./signatures";
+export * from "./utils";
+export { cloneNode } from "./clone";
+export { moduleContextFromModuleAST } from "./transform/ast-module-to-module-context";

node_modules/@webassemblyjs/ast/esm/node-helpers.js

@@ -0,0 +1,84 @@
+import { parse32F, parse64F, parse32I, parse64I, parseU32, isNanLiteral, isInfLiteral } from "@webassemblyjs/helper-numbers";
+import { longNumberLiteral, floatLiteral, numberLiteral, instr } from "./nodes";
+export function numberLiteralFromRaw(rawValue) {
+  var instructionType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "i32";
+  var original = rawValue; // Remove numeric separators _
+
+  if (typeof rawValue === "string") {
+    rawValue = rawValue.replace(/_/g, "");
+  }
+
+  if (typeof rawValue === "number") {
+    return numberLiteral(rawValue, String(original));
+  } else {
+    switch (instructionType) {
+      case "i32":
+        {
+          return numberLiteral(parse32I(rawValue), String(original));
+        }
+
+      case "u32":
+        {
+          return numberLiteral(parseU32(rawValue), String(original));
+        }
+
+      case "i64":
+        {
+          return longNumberLiteral(parse64I(rawValue), String(original));
+        }
+
+      case "f32":
+        {
+          return floatLiteral(parse32F(rawValue), isNanLiteral(rawValue), isInfLiteral(rawValue), String(original));
+        }
+      // f64
+
+      default:
+        {
+          return floatLiteral(parse64F(rawValue), isNanLiteral(rawValue), isInfLiteral(rawValue), String(original));
+        }
+    }
+  }
+}
+export function instruction(id) {
+  var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var namedArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return instr(id, undefined, args, namedArgs);
+}
+export function objectInstruction(id, object) {
+  var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var namedArgs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  return instr(id, object, args, namedArgs);
+}
+/**
+ * Decorators
+ */
+
+export function withLoc(n, end, start) {
+  var loc = {
+    start: start,
+    end: end
+  };
+  n.loc = loc;
+  return n;
+}
+export function withRaw(n, raw) {
+  n.raw = raw;
+  return n;
+}
+export function funcParam(valtype, id) {
+  return {
+    id: id,
+    valtype: valtype
+  };
+}
+export function indexLiteral(value) {
+  // $FlowIgnore
+  var x = numberLiteralFromRaw(value, "u32");
+  return x;
+}
+export function memIndexLiteral(value) {
+  // $FlowIgnore
+  var x = numberLiteralFromRaw(value, "u32");
+  return x;
+}

node_modules/@webassemblyjs/ast/esm/node-path.js

@@ -0,0 +1,137 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function findParent(_ref, cb) {
+  var parentPath = _ref.parentPath;
+
+  if (parentPath == null) {
+    throw new Error("node is root");
+  }
+
+  var currentPath = parentPath;
+
+  while (cb(currentPath) !== false) {
+    // Hit the root node, stop
+    // $FlowIgnore
+    if (currentPath.parentPath == null) {
+      return null;
+    } // $FlowIgnore
+
+
+    currentPath = currentPath.parentPath;
+  }
+
+  return currentPath.node;
+}
+
+function insertBefore(context, newNode) {
+  return insert(context, newNode);
+}
+
+function insertAfter(context, newNode) {
+  return insert(context, newNode, 1);
+}
+
+function insert(_ref2, newNode) {
+  var node = _ref2.node,
+      inList = _ref2.inList,
+      parentPath = _ref2.parentPath,
+      parentKey = _ref2.parentKey;
+  var indexOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+  if (!inList) {
+    throw new Error('inList' + " error: " + ("insert can only be used for nodes that are within lists" || "unknown"));
+  }
+
+  if (!(parentPath != null)) {
+    throw new Error('parentPath != null' + " error: " + ("Can not remove root node" || "unknown"));
+  }
+
+  // $FlowIgnore
+  var parentList = parentPath.node[parentKey];
+  var indexInList = parentList.findIndex(function (n) {
+    return n === node;
+  });
+  parentList.splice(indexInList + indexOffset, 0, newNode);
+}
+
+function remove(_ref3) {
+  var node = _ref3.node,
+      parentKey = _ref3.parentKey,
+      parentPath = _ref3.parentPath;
+
+  if (!(parentPath != null)) {
+    throw new Error('parentPath != null' + " error: " + ("Can not remove root node" || "unknown"));
+  }
+
+  // $FlowIgnore
+  var parentNode = parentPath.node; // $FlowIgnore
+
+  var parentProperty = parentNode[parentKey];
+
+  if (Array.isArray(parentProperty)) {
+    // $FlowIgnore
+    parentNode[parentKey] = parentProperty.filter(function (n) {
+      return n !== node;
+    });
+  } else {
+    // $FlowIgnore
+    delete parentNode[parentKey];
+  }
+
+  node._deleted = true;
+}
+
+function stop(context) {
+  context.shouldStop = true;
+}
+
+function replaceWith(context, newNode) {
+  // $FlowIgnore
+  var parentNode = context.parentPath.node; // $FlowIgnore
+
+  var parentProperty = parentNode[context.parentKey];
+
+  if (Array.isArray(parentProperty)) {
+    var indexInList = parentProperty.findIndex(function (n) {
+      return n === context.node;
+    });
+    parentProperty.splice(indexInList, 1, newNode);
+  } else {
+    // $FlowIgnore
+    parentNode[context.parentKey] = newNode;
+  }
+
+  context.node._deleted = true;
+  context.node = newNode;
+} // bind the context to the first argument of node operations
+
+
+function bindNodeOperations(operations, context) {
+  var keys = Object.keys(operations);
+  var boundOperations = {};
+  keys.forEach(function (key) {
+    boundOperations[key] = operations[key].bind(null, context);
+  });
+  return boundOperations;
+}
+
+function createPathOperations(context) {
+  // $FlowIgnore
+  return bindNodeOperations({
+    findParent: findParent,
+    replaceWith: replaceWith,
+    remove: remove,
+    insertBefore: insertBefore,
+    insertAfter: insertAfter,
+    stop: stop
+  }, context);
+}
+
+export function createPath(context) {
+  var path = _extends({}, context); // $FlowIgnore
+
+
+  Object.assign(path, createPathOperations(path)); // $FlowIgnore
+
+  return path;
+}

node_modules/@webassemblyjs/ast/esm/signatures.js

@@ -0,0 +1,199 @@
+function sign(input, output) {
+  return [input, output];
+}
+
+var u32 = "u32";
+var i32 = "i32";
+var i64 = "i64";
+var f32 = "f32";
+var f64 = "f64";
+
+var vector = function vector(t) {
+  var vecType = [t]; // $FlowIgnore
+
+  vecType.vector = true;
+  return vecType;
+};
+
+var controlInstructions = {
+  unreachable: sign([], []),
+  nop: sign([], []),
+  // block ?
+  // loop ?
+  // if ?
+  // if else ?
+  br: sign([u32], []),
+  br_if: sign([u32], []),
+  br_table: sign(vector(u32), []),
+  return: sign([], []),
+  call: sign([u32], []),
+  call_indirect: sign([u32], [])
+};
+var parametricInstructions = {
+  drop: sign([], []),
+  select: sign([], [])
+};
+var variableInstructions = {
+  get_local: sign([u32], []),
+  set_local: sign([u32], []),
+  tee_local: sign([u32], []),
+  get_global: sign([u32], []),
+  set_global: sign([u32], [])
+};
+var memoryInstructions = {
+  "i32.load": sign([u32, u32], [i32]),
+  "i64.load": sign([u32, u32], []),
+  "f32.load": sign([u32, u32], []),
+  "f64.load": sign([u32, u32], []),
+  "i32.load8_s": sign([u32, u32], [i32]),
+  "i32.load8_u": sign([u32, u32], [i32]),
+  "i32.load16_s": sign([u32, u32], [i32]),
+  "i32.load16_u": sign([u32, u32], [i32]),
+  "i64.load8_s": sign([u32, u32], [i64]),
+  "i64.load8_u": sign([u32, u32], [i64]),
+  "i64.load16_s": sign([u32, u32], [i64]),
+  "i64.load16_u": sign([u32, u32], [i64]),
+  "i64.load32_s": sign([u32, u32], [i64]),
+  "i64.load32_u": sign([u32, u32], [i64]),
+  "i32.store": sign([u32, u32], []),
+  "i64.store": sign([u32, u32], []),
+  "f32.store": sign([u32, u32], []),
+  "f64.store": sign([u32, u32], []),
+  "i32.store8": sign([u32, u32], []),
+  "i32.store16": sign([u32, u32], []),
+  "i64.store8": sign([u32, u32], []),
+  "i64.store16": sign([u32, u32], []),
+  "i64.store32": sign([u32, u32], []),
+  current_memory: sign([], []),
+  grow_memory: sign([], [])
+};
+var numericInstructions = {
+  "i32.const": sign([i32], [i32]),
+  "i64.const": sign([i64], [i64]),
+  "f32.const": sign([f32], [f32]),
+  "f64.const": sign([f64], [f64]),
+  "i32.eqz": sign([i32], [i32]),
+  "i32.eq": sign([i32, i32], [i32]),
+  "i32.ne": sign([i32, i32], [i32]),
+  "i32.lt_s": sign([i32, i32], [i32]),
+  "i32.lt_u": sign([i32, i32], [i32]),
+  "i32.gt_s": sign([i32, i32], [i32]),
+  "i32.gt_u": sign([i32, i32], [i32]),
+  "i32.le_s": sign([i32, i32], [i32]),
+  "i32.le_u": sign([i32, i32], [i32]),
+  "i32.ge_s": sign([i32, i32], [i32]),
+  "i32.ge_u": sign([i32, i32], [i32]),
+  "i64.eqz": sign([i64], [i64]),
+  "i64.eq": sign([i64, i64], [i32]),
+  "i64.ne": sign([i64, i64], [i32]),
+  "i64.lt_s": sign([i64, i64], [i32]),
+  "i64.lt_u": sign([i64, i64], [i32]),
+  "i64.gt_s": sign([i64, i64], [i32]),
+  "i64.gt_u": sign([i64, i64], [i32]),
+  "i64.le_s": sign([i64, i64], [i32]),
+  "i64.le_u": sign([i64, i64], [i32]),
+  "i64.ge_s": sign([i64, i64], [i32]),
+  "i64.ge_u": sign([i64, i64], [i32]),
+  "f32.eq": sign([f32, f32], [i32]),
+  "f32.ne": sign([f32, f32], [i32]),
+  "f32.lt": sign([f32, f32], [i32]),
+  "f32.gt": sign([f32, f32], [i32]),
+  "f32.le": sign([f32, f32], [i32]),
+  "f32.ge": sign([f32, f32], [i32]),
+  "f64.eq": sign([f64, f64], [i32]),
+  "f64.ne": sign([f64, f64], [i32]),
+  "f64.lt": sign([f64, f64], [i32]),
+  "f64.gt": sign([f64, f64], [i32]),
+  "f64.le": sign([f64, f64], [i32]),
+  "f64.ge": sign([f64, f64], [i32]),
+  "i32.clz": sign([i32], [i32]),
+  "i32.ctz": sign([i32], [i32]),
+  "i32.popcnt": sign([i32], [i32]),
+  "i32.add": sign([i32, i32], [i32]),
+  "i32.sub": sign([i32, i32], [i32]),
+  "i32.mul": sign([i32, i32], [i32]),
+  "i32.div_s": sign([i32, i32], [i32]),
+  "i32.div_u": sign([i32, i32], [i32]),
+  "i32.rem_s": sign([i32, i32], [i32]),
+  "i32.rem_u": sign([i32, i32], [i32]),
+  "i32.and": sign([i32, i32], [i32]),
+  "i32.or": sign([i32, i32], [i32]),
+  "i32.xor": sign([i32, i32], [i32]),
+  "i32.shl": sign([i32, i32], [i32]),
+  "i32.shr_s": sign([i32, i32], [i32]),
+  "i32.shr_u": sign([i32, i32], [i32]),
+  "i32.rotl": sign([i32, i32], [i32]),
+  "i32.rotr": sign([i32, i32], [i32]),
+  "i64.clz": sign([i64], [i64]),
+  "i64.ctz": sign([i64], [i64]),
+  "i64.popcnt": sign([i64], [i64]),
+  "i64.add": sign([i64, i64], [i64]),
+  "i64.sub": sign([i64, i64], [i64]),
+  "i64.mul": sign([i64, i64], [i64]),
+  "i64.div_s": sign([i64, i64], [i64]),
+  "i64.div_u": sign([i64, i64], [i64]),
+  "i64.rem_s": sign([i64, i64], [i64]),
+  "i64.rem_u": sign([i64, i64], [i64]),
+  "i64.and": sign([i64, i64], [i64]),
+  "i64.or": sign([i64, i64], [i64]),
+  "i64.xor": sign([i64, i64], [i64]),
+  "i64.shl": sign([i64, i64], [i64]),
+  "i64.shr_s": sign([i64, i64], [i64]),
+  "i64.shr_u": sign([i64, i64], [i64]),
+  "i64.rotl": sign([i64, i64], [i64]),
+  "i64.rotr": sign([i64, i64], [i64]),
+  "f32.abs": sign([f32], [f32]),
+  "f32.neg": sign([f32], [f32]),
+  "f32.ceil": sign([f32], [f32]),
+  "f32.floor": sign([f32], [f32]),
+  "f32.trunc": sign([f32], [f32]),
+  "f32.nearest": sign([f32], [f32]),
+  "f32.sqrt": sign([f32], [f32]),
+  "f32.add": sign([f32, f32], [f32]),
+  "f32.sub": sign([f32, f32], [f32]),
+  "f32.mul": sign([f32, f32], [f32]),
+  "f32.div": sign([f32, f32], [f32]),
+  "f32.min": sign([f32, f32], [f32]),
+  "f32.max": sign([f32, f32], [f32]),
+  "f32.copysign": sign([f32, f32], [f32]),
+  "f64.abs": sign([f64], [f64]),
+  "f64.neg": sign([f64], [f64]),
+  "f64.ceil": sign([f64], [f64]),
+  "f64.floor": sign([f64], [f64]),
+  "f64.trunc": sign([f64], [f64]),
+  "f64.nearest": sign([f64], [f64]),
+  "f64.sqrt": sign([f64], [f64]),
+  "f64.add": sign([f64, f64], [f64]),
+  "f64.sub": sign([f64, f64], [f64]),
+  "f64.mul": sign([f64, f64], [f64]),
+  "f64.div": sign([f64, f64], [f64]),
+  "f64.min": sign([f64, f64], [f64]),
+  "f64.max": sign([f64, f64], [f64]),
+  "f64.copysign": sign([f64, f64], [f64]),
+  "i32.wrap/i64": sign([i64], [i32]),
+  "i32.trunc_s/f32": sign([f32], [i32]),
+  "i32.trunc_u/f32": sign([f32], [i32]),
+  "i32.trunc_s/f64": sign([f32], [i32]),
+  "i32.trunc_u/f64": sign([f64], [i32]),
+  "i64.extend_s/i32": sign([i32], [i64]),
+  "i64.extend_u/i32": sign([i32], [i64]),
+  "i64.trunc_s/f32": sign([f32], [i64]),
+  "i64.trunc_u/f32": sign([f32], [i64]),
+  "i64.trunc_s/f64": sign([f64], [i64]),
+  "i64.trunc_u/f64": sign([f64], [i64]),
+  "f32.convert_s/i32": sign([i32], [f32]),
+  "f32.convert_u/i32": sign([i32], [f32]),
+  "f32.convert_s/i64": sign([i64], [f32]),
+  "f32.convert_u/i64": sign([i64], [f32]),
+  "f32.demote/f64": sign([f64], [f32]),
+  "f64.convert_s/i32": sign([i32], [f64]),
+  "f64.convert_u/i32": sign([i32], [f64]),
+  "f64.convert_s/i64": sign([i64], [f64]),
+  "f64.convert_u/i64": sign([i64], [f64]),
+  "f64.promote/f32": sign([f32], [f64]),
+  "i32.reinterpret/f32": sign([f32], [i32]),
+  "i64.reinterpret/f64": sign([f64], [i64]),
+  "f32.reinterpret/i32": sign([i32], [f32]),
+  "f64.reinterpret/i64": sign([i64], [f64])
+};
+export var signatures = Object.assign({}, controlInstructions, parametricInstructions, variableInstructions, memoryInstructions, numericInstructions);

node_modules/@webassemblyjs/ast/esm/transform/ast-module-to-module-context/index.js

@@ -0,0 +1,378 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+// TODO(sven): add flow in here
+import { isSignature, isNumberLiteral } from "../../nodes.js";
+export function moduleContextFromModuleAST(m) {
+  var moduleContext = new ModuleContext();
+
+  if (!(m.type === "Module")) {
+    throw new Error('m.type === "Module"' + " error: " + (undefined || "unknown"));
+  }
+
+  m.fields.forEach(function (field) {
+    switch (field.type) {
+      case "Start":
+        {
+          moduleContext.setStart(field.index);
+          break;
+        }
+
+      case "TypeInstruction":
+        {
+          moduleContext.addType(field);
+          break;
+        }
+
+      case "Func":
+        {
+          moduleContext.addFunction(field);
+          break;
+        }
+
+      case "Global":
+        {
+          moduleContext.defineGlobal(field);
+          break;
+        }
+
+      case "ModuleImport":
+        {
+          switch (field.descr.type) {
+            case "GlobalType":
+              {
+                moduleContext.importGlobal(field.descr.valtype, field.descr.mutability);
+                break;
+              }
+
+            case "Memory":
+              {
+                moduleContext.addMemory(field.descr.limits.min, field.descr.limits.max);
+                break;
+              }
+
+            case "FuncImportDescr":
+              {
+                moduleContext.importFunction(field.descr);
+                break;
+              }
+
+            case "Table":
+              {
+                // FIXME(sven): not implemented yet
+                break;
+              }
+
+            default:
+              throw new Error("Unsupported ModuleImport of type " + JSON.stringify(field.descr.type));
+          }
+
+          break;
+        }
+
+      case "Memory":
+        {
+          moduleContext.addMemory(field.limits.min, field.limits.max);
+          break;
+        }
+    }
+  });
+  return moduleContext;
+}
+/**
+ * Module context for type checking
+ */
+
+export var ModuleContext =
+/*#__PURE__*/
+function () {
+  function ModuleContext() {
+    _classCallCheck(this, ModuleContext);
+
+    this.funcs = [];
+    this.funcsOffsetByIdentifier = [];
+    this.types = [];
+    this.globals = [];
+    this.globalsOffsetByIdentifier = [];
+    this.mems = []; // Current stack frame
+
+    this.locals = [];
+    this.labels = [];
+    this.return = [];
+    this.debugName = "unknown";
+    this.start = null;
+  }
+  /**
+   * Set start segment
+   */
+
+
+  _createClass(ModuleContext, [{
+    key: "setStart",
+    value: function setStart(index) {
+      this.start = index.value;
+    }
+    /**
+     * Get start function
+     */
+
+  }, {
+    key: "getStart",
+    value: function getStart() {
+      return this.start;
+    }
+    /**
+     * Reset the active stack frame
+     */
+
+  }, {
+    key: "newContext",
+    value: function newContext(debugName, expectedResult) {
+      this.locals = [];
+      this.labels = [expectedResult];
+      this.return = expectedResult;
+      this.debugName = debugName;
+    }
+    /**
+     * Functions
+     */
+
+  }, {
+    key: "addFunction",
+    value: function addFunction(func
+    /*: Func*/
+    ) {
+      // eslint-disable-next-line prefer-const
+      var _ref = func.signature || {},
+          _ref$params = _ref.params,
+          args = _ref$params === void 0 ? [] : _ref$params,
+          _ref$results = _ref.results,
+          result = _ref$results === void 0 ? [] : _ref$results;
+
+      args = args.map(function (arg) {
+        return arg.valtype;
+      });
+      this.funcs.push({
+        args: args,
+        result: result
+      });
+
+      if (typeof func.name !== "undefined") {
+        this.funcsOffsetByIdentifier[func.name.value] = this.funcs.length - 1;
+      }
+    }
+  }, {
+    key: "importFunction",
+    value: function importFunction(funcimport) {
+      if (isSignature(funcimport.signature)) {
+        // eslint-disable-next-line prefer-const
+        var _funcimport$signature = funcimport.signature,
+            args = _funcimport$signature.params,
+            result = _funcimport$signature.results;
+        args = args.map(function (arg) {
+          return arg.valtype;
+        });
+        this.funcs.push({
+          args: args,
+          result: result
+        });
+      } else {
+        if (!isNumberLiteral(funcimport.signature)) {
+          throw new Error('isNumberLiteral(funcimport.signature)' + " error: " + (undefined || "unknown"));
+        }
+
+        var typeId = funcimport.signature.value;
+
+        if (!this.hasType(typeId)) {
+          throw new Error('this.hasType(typeId)' + " error: " + (undefined || "unknown"));
+        }
+
+        var signature = this.getType(typeId);
+        this.funcs.push({
+          args: signature.params.map(function (arg) {
+            return arg.valtype;
+          }),
+          result: signature.results
+        });
+      }
+
+      if (typeof funcimport.id !== "undefined") {
+        // imports are first, we can assume their index in the array
+        this.funcsOffsetByIdentifier[funcimport.id.value] = this.funcs.length - 1;
+      }
+    }
+  }, {
+    key: "hasFunction",
+    value: function hasFunction(index) {
+      return typeof this.getFunction(index) !== "undefined";
+    }
+  }, {
+    key: "getFunction",
+    value: function getFunction(index) {
+      if (typeof index !== "number") {
+        throw new Error("getFunction only supported for number index");
+      }
+
+      return this.funcs[index];
+    }
+  }, {
+    key: "getFunctionOffsetByIdentifier",
+    value: function getFunctionOffsetByIdentifier(name) {
+      if (!(typeof name === "string")) {
+        throw new Error('typeof name === "string"' + " error: " + (undefined || "unknown"));
+      }
+
+      return this.funcsOffsetByIdentifier[name];
+    }
+    /**
+     * Labels
+     */
+
+  }, {
+    key: "addLabel",
+    value: function addLabel(result) {
+      this.labels.unshift(result);
+    }
+  }, {
+    key: "hasLabel",
+    value: function hasLabel(index) {
+      return this.labels.length > index && index >= 0;
+    }
+  }, {
+    key: "getLabel",
+    value: function getLabel(index) {
+      return this.labels[index];
+    }
+  }, {
+    key: "popLabel",
+    value: function popLabel() {
+      this.labels.shift();
+    }
+    /**
+     * Locals
+     */
+
+  }, {
+    key: "hasLocal",
+    value: function hasLocal(index) {
+      return typeof this.getLocal(index) !== "undefined";
+    }
+  }, {
+    key: "getLocal",
+    value: function getLocal(index) {
+      return this.locals[index];
+    }
+  }, {
+    key: "addLocal",
+    value: function addLocal(type) {
+      this.locals.push(type);
+    }
+    /**
+     * Types
+     */
+
+  }, {
+    key: "addType",
+    value: function addType(type) {
+      if (!(type.functype.type === "Signature")) {
+        throw new Error('type.functype.type === "Signature"' + " error: " + (undefined || "unknown"));
+      }
+
+      this.types.push(type.functype);
+    }
+  }, {
+    key: "hasType",
+    value: function hasType(index) {
+      return this.types[index] !== undefined;
+    }
+  }, {
+    key: "getType",
+    value: function getType(index) {
+      return this.types[index];
+    }
+    /**
+     * Globals
+     */
+
+  }, {
+    key: "hasGlobal",
+    value: function hasGlobal(index) {
+      return this.globals.length > index && index >= 0;
+    }
+  }, {
+    key: "getGlobal",
+    value: function getGlobal(index) {
+      return this.globals[index].type;
+    }
+  }, {
+    key: "getGlobalOffsetByIdentifier",
+    value: function getGlobalOffsetByIdentifier(name) {
+      if (!(typeof name === "string")) {
+        throw new Error('typeof name === "string"' + " error: " + (undefined || "unknown"));
+      }
+
+      return this.globalsOffsetByIdentifier[name];
+    }
+  }, {
+    key: "defineGlobal",
+    value: function defineGlobal(global
+    /*: Global*/
+    ) {
+      var type = global.globalType.valtype;
+      var mutability = global.globalType.mutability;
+      this.globals.push({
+        type: type,
+        mutability: mutability
+      });
+
+      if (typeof global.name !== "undefined") {
+        this.globalsOffsetByIdentifier[global.name.value] = this.globals.length - 1;
+      }
+    }
+  }, {
+    key: "importGlobal",
+    value: function importGlobal(type, mutability) {
+      this.globals.push({
+        type: type,
+        mutability: mutability
+      });
+    }
+  }, {
+    key: "isMutableGlobal",
+    value: function isMutableGlobal(index) {
+      return this.globals[index].mutability === "var";
+    }
+  }, {
+    key: "isImmutableGlobal",
+    value: function isImmutableGlobal(index) {
+      return this.globals[index].mutability === "const";
+    }
+    /**
+     * Memories
+     */
+
+  }, {
+    key: "hasMemory",
+    value: function hasMemory(index) {
+      return this.mems.length > index && index >= 0;
+    }
+  }, {
+    key: "addMemory",
+    value: function addMemory(min, max) {
+      this.mems.push({
+        min: min,
+        max: max
+      });
+    }
+  }, {
+    key: "getMemory",
+    value: function getMemory(index) {
+      return this.mems[index];
+    }
+  }]);
+
+  return ModuleContext;
+}();

node_modules/@webassemblyjs/ast/esm/transform/denormalize-type-references/index.js

@@ -0,0 +1,76 @@
+var t = require("../../index"); // func and call_indirect instructions can either define a signature inline, or
+// reference a signature, e.g.
+//
+// ;; inline signature
+// (func (result i64)
+//   (i64.const 2)
+// )
+// ;; signature reference
+// (type (func (result i64)))
+// (func (type 0)
+//   (i64.const 2))
+// )
+//
+// this AST transform denormalises the type references, making all signatures within the module
+// inline.
+
+
+export function transform(ast) {
+  var typeInstructions = [];
+  t.traverse(ast, {
+    TypeInstruction: function TypeInstruction(_ref) {
+      var node = _ref.node;
+      typeInstructions.push(node);
+    }
+  });
+
+  if (!typeInstructions.length) {
+    return;
+  }
+
+  function denormalizeSignature(signature) {
+    // signature referenced by identifier
+    if (signature.type === "Identifier") {
+      var identifier = signature;
+      var typeInstruction = typeInstructions.find(function (t) {
+        return t.id.type === identifier.type && t.id.value === identifier.value;
+      });
+
+      if (!typeInstruction) {
+        throw new Error("A type instruction reference was not found ".concat(JSON.stringify(signature)));
+      }
+
+      return typeInstruction.functype;
+    } // signature referenced by index
+
+
+    if (signature.type === "NumberLiteral") {
+      var signatureRef = signature;
+      var _typeInstruction = typeInstructions[signatureRef.value];
+      return _typeInstruction.functype;
+    }
+
+    return signature;
+  }
+
+  t.traverse(ast, {
+    Func: function (_Func) {
+      function Func(_x) {
+        return _Func.apply(this, arguments);
+      }
+
+      Func.toString = function () {
+        return _Func.toString();
+      };
+
+      return Func;
+    }(function (_ref2) {
+      var node = _ref2.node;
+      node.signature = denormalizeSignature(node.signature);
+    }),
+    CallIndirectInstruction: function CallIndirectInstruction(_ref3) {
+      var node = _ref3.node;
+      node.signature = denormalizeSignature(node.signature);
+    }
+  });
+}

node_modules/@webassemblyjs/ast/esm/transform/wast-identifier-to-index/index.js

@@ -0,0 +1,216 @@
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }
+
+import { isBlock, isFunc, isIdentifier, numberLiteralFromRaw, traverse } from "../../index";
+import { moduleContextFromModuleAST } from "../ast-module-to-module-context"; // FIXME(sven): do the same with all block instructions, must be more generic here
+
+function newUnexpectedFunction(i) {
+  return new Error("unknown function at offset: " + i);
+}
+
+export function transform(ast) {
+  var module;
+  traverse(ast, {
+    Module: function (_Module) {
+      function Module(_x) {
+        return _Module.apply(this, arguments);
+      }
+
+      Module.toString = function () {
+        return _Module.toString();
+      };
+
+      return Module;
+    }(function (path) {
+      module = path.node;
+    })
+  });
+  var moduleContext = moduleContextFromModuleAST(module); // Transform the actual instruction in function bodies
+
+  traverse(ast, {
+    Func: function (_Func) {
+      function Func(_x2) {
+        return _Func.apply(this, arguments);
+      }
+
+      Func.toString = function () {
+        return _Func.toString();
+      };
+
+      return Func;
+    }(function (path) {
+      transformFuncPath(path, moduleContext);
+    }),
+    Start: function (_Start) {
+      function Start(_x3) {
+        return _Start.apply(this, arguments);
+      }
+
+      Start.toString = function () {
+        return _Start.toString();
+      };
+
+      return Start;
+    }(function (path) {
+      var index = path.node.index;
+
+      if (isIdentifier(index) === true) {
+        var offsetInModule = moduleContext.getFunctionOffsetByIdentifier(index.value);
+
+        if (typeof offsetInModule === "undefined") {
+          throw newUnexpectedFunction(index.value);
+        } // Replace the index Identifier
+        // $FlowIgnore: reference?
+
+
+        path.node.index = numberLiteralFromRaw(offsetInModule);
+      }
+    })
+  });
+}
+
+function transformFuncPath(funcPath, moduleContext) {
+  var funcNode = funcPath.node;
+  var signature = funcNode.signature;
+
+  if (signature.type !== "Signature") {
+    throw new Error("Function signatures must be denormalised before execution");
+  }
+
+  var params = signature.params; // Add func locals in the context
+
+  params.forEach(function (p) {
+    return moduleContext.addLocal(p.valtype);
+  });
+  traverse(funcNode, {
+    Instr: function (_Instr) {
+      function Instr(_x4) {
+        return _Instr.apply(this, arguments);
+      }
+
+      Instr.toString = function () {
+        return _Instr.toString();
+      };
+
+      return Instr;
+    }(function (instrPath) {
+      var instrNode = instrPath.node;
+      /**
+       * Local access
+       */
+
+      if (instrNode.id === "get_local" || instrNode.id === "set_local" || instrNode.id === "tee_local") {
+        var _instrNode$args = _slicedToArray(instrNode.args, 1),
+            firstArg = _instrNode$args[0];
+
+        if (firstArg.type === "Identifier") {
+          var offsetInParams = params.findIndex(function (_ref) {
+            var id = _ref.id;
+            return id === firstArg.value;
+          });
+
+          if (offsetInParams === -1) {
+            throw new Error("".concat(firstArg.value, " not found in ").concat(instrNode.id, ": not declared in func params"));
+          } // Replace the Identifer node by our new NumberLiteral node
+
+
+          instrNode.args[0] = numberLiteralFromRaw(offsetInParams);
+        }
+      }
+      /**
+       * Global access
+       */
+
+
+      if (instrNode.id === "get_global" || instrNode.id === "set_global") {
+        var _instrNode$args2 = _slicedToArray(instrNode.args, 1),
+            _firstArg = _instrNode$args2[0];
+
+        if (isIdentifier(_firstArg) === true) {
+          var globalOffset = moduleContext.getGlobalOffsetByIdentifier( // $FlowIgnore: reference?
+          _firstArg.value);
+
+          if (typeof globalOffset === "undefined") {
+            // $FlowIgnore: reference?
+            throw new Error("global ".concat(_firstArg.value, " not found in module"));
+          } // Replace the Identifer node by our new NumberLiteral node
+
+
+          instrNode.args[0] = numberLiteralFromRaw(globalOffset);
+        }
+      }
+      /**
+       * Labels lookup
+       */
+
+
+      if (instrNode.id === "br") {
+        var _instrNode$args3 = _slicedToArray(instrNode.args, 1),
+            _firstArg2 = _instrNode$args3[0];
+
+        if (isIdentifier(_firstArg2) === true) {
+          // if the labels is not found it is going to be replaced with -1
+          // which is invalid.
+          var relativeBlockCount = -1; // $FlowIgnore: reference?
+
+          instrPath.findParent(function (_ref2) {
+            var node = _ref2.node;
+
+            if (isBlock(node)) {
+              relativeBlockCount++; // $FlowIgnore: reference?
+
+              var name = node.label || node.name;
+
+              if (_typeof(name) === "object") {
+                // $FlowIgnore: isIdentifier ensures that
+                if (name.value === _firstArg2.value) {
+                  // Found it
+                  return false;
+                }
+              }
+            }
+
+            if (isFunc(node)) {
+              return false;
+            }
+          }); // Replace the Identifer node by our new NumberLiteral node
+
+          instrNode.args[0] = numberLiteralFromRaw(relativeBlockCount);
+        }
+      }
+    }),
+
+    /**
+     * Func lookup
+     */
+    CallInstruction: function (_CallInstruction) {
+      function CallInstruction(_x5) {
+        return _CallInstruction.apply(this, arguments);
+      }
+
+      CallInstruction.toString = function () {
+        return _CallInstruction.toString();
+      };
+
+      return CallInstruction;
+    }(function (_ref3) {
+      var node = _ref3.node;
+      var index = node.index;
+
+      if (isIdentifier(index) === true) {
+        var offsetInModule = moduleContext.getFunctionOffsetByIdentifier(index.value);
+
+        if (typeof offsetInModule === "undefined") {
+          throw newUnexpectedFunction(index.value);
+        } // Replace the index Identifier
+        // $FlowIgnore: reference?
+
+
+        node.index = numberLiteralFromRaw(offsetInModule);
+      }
+    })
+  });
+}

node_modules/@webassemblyjs/ast/esm/traverse.js

@@ -0,0 +1,96 @@
+import { createPath } from "./node-path";
+import { unionTypesMap, nodeAndUnionTypes } from "./nodes"; // recursively walks the AST starting at the given node. The callback is invoked for
+// and object that has a 'type' property.
+
+function walk(context, callback) {
+  var stop = false;
+
+  function innerWalk(context, callback) {
+    if (stop) {
+      return;
+    }
+
+    var node = context.node;
+
+    if (node === undefined) {
+      console.warn("traversing with an empty context");
+      return;
+    }
+
+    if (node._deleted === true) {
+      return;
+    }
+
+    var path = createPath(context);
+    callback(node.type, path);
+
+    if (path.shouldStop) {
+      stop = true;
+      return;
+    }
+
+    Object.keys(node).forEach(function (prop) {
+      var value = node[prop];
+
+      if (value === null || value === undefined) {
+        return;
+      }
+
+      var valueAsArray = Array.isArray(value) ? value : [value];
+      valueAsArray.forEach(function (childNode) {
+        if (typeof childNode.type === "string") {
+          var childContext = {
+            node: childNode,
+            parentKey: prop,
+            parentPath: path,
+            shouldStop: false,
+            inList: Array.isArray(value)
+          };
+          innerWalk(childContext, callback);
+        }
+      });
+    });
+  }
+
+  innerWalk(context, callback);
+}
+
+var noop = function noop() {};
+
+export function traverse(node, visitors) {
+  var before = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
+  var after = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : noop;
+  Object.keys(visitors).forEach(function (visitor) {
+    if (!nodeAndUnionTypes.includes(visitor)) {
+      throw new Error("Unexpected visitor ".concat(visitor));
+    }
+  });
+  var context = {
+    node: node,
+    inList: false,
+    shouldStop: false,
+    parentPath: null,
+    parentKey: null
+  };
+  walk(context, function (type, path) {
+    if (typeof visitors[type] === "function") {
+      before(type, path);
+      visitors[type](path);
+      after(type, path);
+    }
+
+    var unionTypes = unionTypesMap[type];
+
+    if (!unionTypes) {
+      throw new Error("Unexpected node type ".concat(type));
+    }
+
+    unionTypes.forEach(function (unionType) {
+      if (typeof visitors[unionType] === "function") {
+        before(unionType, path);
+        visitors[unionType](path);
+        after(unionType, path);
+      }
+    });
+  });
+}

node_modules/@webassemblyjs/ast/esm/utils.js

@@ -0,0 +1,265 @@
+function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import { signatures } from "./signatures";
+import { traverse } from "./traverse";
+import constants from "@webassemblyjs/helper-wasm-bytecode";
+import { getSectionForNode } from "@webassemblyjs/helper-wasm-bytecode";
+export function isAnonymous(ident) {
+  return ident.raw === "";
+}
+export function getSectionMetadata(ast, name) {
+  var section;
+  traverse(ast, {
+    SectionMetadata: function (_SectionMetadata) {
+      function SectionMetadata(_x) {
+        return _SectionMetadata.apply(this, arguments);
+      }
+
+      SectionMetadata.toString = function () {
+        return _SectionMetadata.toString();
+      };
+
+      return SectionMetadata;
+    }(function (_ref) {
+      var node = _ref.node;
+
+      if (node.section === name) {
+        section = node;
+      }
+    })
+  });
+  return section;
+}
+export function getSectionMetadatas(ast, name) {
+  var sections = [];
+  traverse(ast, {
+    SectionMetadata: function (_SectionMetadata2) {
+      function SectionMetadata(_x2) {
+        return _SectionMetadata2.apply(this, arguments);
+      }
+
+      SectionMetadata.toString = function () {
+        return _SectionMetadata2.toString();
+      };
+
+      return SectionMetadata;
+    }(function (_ref2) {
+      var node = _ref2.node;
+
+      if (node.section === name) {
+        sections.push(node);
+      }
+    })
+  });
+  return sections;
+}
+export function sortSectionMetadata(m) {
+  if (m.metadata == null) {
+    console.warn("sortSectionMetadata: no metadata to sort");
+    return;
+  } // $FlowIgnore
+
+
+  m.metadata.sections.sort(function (a, b) {
+    var aId = constants.sections[a.section];
+    var bId = constants.sections[b.section];
+
+    if (typeof aId !== "number" || typeof bId !== "number") {
+      throw new Error("Section id not found");
+    }
+
+    return aId - bId;
+  });
+}
+export function orderedInsertNode(m, n) {
+  assertHasLoc(n);
+  var didInsert = false;
+
+  if (n.type === "ModuleExport") {
+    m.fields.push(n);
+    return;
+  }
+
+  m.fields = m.fields.reduce(function (acc, field) {
+    var fieldEndCol = Infinity;
+
+    if (field.loc != null) {
+      // $FlowIgnore
+      fieldEndCol = field.loc.end.column;
+    } // $FlowIgnore: assertHasLoc ensures that
+
+
+    if (didInsert === false && n.loc.start.column < fieldEndCol) {
+      didInsert = true;
+      acc.push(n);
+    }
+
+    acc.push(field);
+    return acc;
+  }, []); // Handles empty modules or n is the last element
+
+  if (didInsert === false) {
+    m.fields.push(n);
+  }
+}
+export function assertHasLoc(n) {
+  if (n.loc == null || n.loc.start == null || n.loc.end == null) {
+    throw new Error("Internal failure: node (".concat(JSON.stringify(n.type), ") has no location information"));
+  }
+}
+export function getEndOfSection(s) {
+  assertHasLoc(s.size);
+  return s.startOffset + s.size.value + ( // $FlowIgnore
+  s.size.loc.end.column - s.size.loc.start.column);
+}
+export function shiftLoc(node, delta) {
+  // $FlowIgnore
+  node.loc.start.column += delta; // $FlowIgnore
+
+  node.loc.end.column += delta;
+}
+export function shiftSection(ast, node, delta) {
+  if (node.type !== "SectionMetadata") {
+    throw new Error("Can not shift node " + JSON.stringify(node.type));
+  }
+
+  node.startOffset += delta;
+
+  if (_typeof(node.size.loc) === "object") {
+    shiftLoc(node.size, delta);
+  } // Custom sections doesn't have vectorOfSize
+
+
+  if (_typeof(node.vectorOfSize) === "object" && _typeof(node.vectorOfSize.loc) === "object") {
+    shiftLoc(node.vectorOfSize, delta);
+  }
+
+  var sectionName = node.section; // shift node locations within that section
+
+  traverse(ast, {
+    Node: function Node(_ref3) {
+      var node = _ref3.node;
+      var section = getSectionForNode(node);
+
+      if (section === sectionName && _typeof(node.loc) === "object") {
+        shiftLoc(node, delta);
+      }
+    }
+  });
+}
+export function signatureForOpcode(object, name) {
+  var opcodeName = name;
+
+  if (object !== undefined && object !== "") {
+    opcodeName = object + "." + name;
+  }
+
+  var sign = signatures[opcodeName];
+
+  if (sign == undefined) {
+    // TODO: Uncomment this when br_table and others has been done
+    //throw new Error("Invalid opcode: "+opcodeName);
+    return [object, object];
+  }
+
+  return sign[0];
+}
+export function getUniqueNameGenerator() {
+  var inc = {};
+  return function () {
+    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "temp";
+
+    if (!(prefix in inc)) {
+      inc[prefix] = 0;
+    } else {
+      inc[prefix] = inc[prefix] + 1;
+    }
+
+    return prefix + "_" + inc[prefix];
+  };
+}
+export function getStartByteOffset(n) {
+  // $FlowIgnore
+  if (typeof n.loc === "undefined" || typeof n.loc.start === "undefined") {
+    throw new Error( // $FlowIgnore
+    "Can not get byte offset without loc informations, node: " + String(n.id));
+  }
+
+  return n.loc.start.column;
+}
+export function getEndByteOffset(n) {
+  // $FlowIgnore
+  if (typeof n.loc === "undefined" || typeof n.loc.end === "undefined") {
+    throw new Error("Can not get byte offset without loc informations, node: " + n.type);
+  }
+
+  return n.loc.end.column;
+}
+export function getFunctionBeginingByteOffset(n) {
+  if (!(n.body.length > 0)) {
+    throw new Error('n.body.length > 0' + " error: " + (undefined || "unknown"));
+  }
+
+  var _n$body = _slicedToArray(n.body, 1),
+      firstInstruction = _n$body[0];
+
+  return getStartByteOffset(firstInstruction);
+}
+export function getEndBlockByteOffset(n) {
+  // $FlowIgnore
+  if (!(n.instr.length > 0 || n.body.length > 0)) {
+    throw new Error('n.instr.length > 0 || n.body.length > 0' + " error: " + (undefined || "unknown"));
+  }
+
+  var lastInstruction;
+
+  if (n.instr) {
+    // $FlowIgnore
+    lastInstruction = n.instr[n.instr.length - 1];
+  }
+
+  if (n.body) {
+    // $FlowIgnore
+    lastInstruction = n.body[n.body.length - 1];
+  }
+
+  if (!(_typeof(lastInstruction) === "object")) {
+    throw new Error('typeof lastInstruction === "object"' + " error: " + (undefined || "unknown"));
+  }
+
+  // $FlowIgnore
+  return getStartByteOffset(lastInstruction);
+}
+export function getStartBlockByteOffset(n) {
+  // $FlowIgnore
+  if (!(n.instr.length > 0 || n.body.length > 0)) {
+    throw new Error('n.instr.length > 0 || n.body.length > 0' + " error: " + (undefined || "unknown"));
+  }
+
+  var fistInstruction;
+
+  if (n.instr) {
+    // $FlowIgnore
+    var _n$instr = _slicedToArray(n.instr, 1);
+
+    fistInstruction = _n$instr[0];
+  }
+
+  if (n.body) {
+    // $FlowIgnore
+    var _n$body2 = _slicedToArray(n.body, 1);
+
+    fistInstruction = _n$body2[0];
+  }
+
+  if (!(_typeof(fistInstruction) === "object")) {
+    throw new Error('typeof fistInstruction === "object"' + " error: " + (undefined || "unknown"));
+  }
+
+  // $FlowIgnore
+  return getStartByteOffset(fistInstruction);
+}