@swf2es/codegen 0.0.0-stage → 0.1.0

package/dist/codegen.js

@@ -0,0 +1,308 @@
+export async function instantiate(module, imports = {}) {
+  const adaptedImports = {
+    env: Object.setPrototypeOf({
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+    }, Object.assign(Object.create(globalThis), imports.env || {})),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    compilerVersion() {
+      // assembly/index/compilerVersion() => ~lib/string/String
+      return __liftString(exports.compilerVersion() >>> 0);
+    },
+    abcVersion(abc) {
+      // assembly/index/abcVersion(~lib/typedarray/Uint8Array) => i32
+      abc = __lowerTypedArray(Uint8Array, 27, 0, abc) || __notnull();
+      return exports.abcVersion(abc);
+    },
+    actionsEmitEach(swf, offsets, lengths, version, blocks, reuse) {
+      // assembly/avm1/compile/actionsEmitEach(~lib/typedarray/Uint8Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, i32, ~lib/string/String, bool) => ~lib/string/String
+      swf = __retain(__lowerTypedArray(Uint8Array, 27, 0, swf) || __notnull());
+      offsets = __retain(__lowerTypedArray(Int32Array, 31, 2, offsets) || __notnull());
+      lengths = __retain(__lowerTypedArray(Int32Array, 31, 2, lengths) || __notnull());
+      blocks = __lowerString(blocks) || __notnull();
+      reuse = reuse ? 1 : 0;
+      try {
+        return __liftString(exports.actionsEmitEach(swf, offsets, lengths, version, blocks, reuse) >>> 0);
+      } finally {
+        __release(swf);
+        __release(offsets);
+        __release(lengths);
+      }
+    },
+    actionsEmitEachBytes(swf, offsets, lengths, version, blocks, reuse) {
+      // assembly/avm1/compile/actionsEmitEachBytes(~lib/typedarray/Uint8Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, i32, ~lib/string/String, bool) => usize
+      swf = __retain(__lowerTypedArray(Uint8Array, 27, 0, swf) || __notnull());
+      offsets = __retain(__lowerTypedArray(Int32Array, 31, 2, offsets) || __notnull());
+      lengths = __retain(__lowerTypedArray(Int32Array, 31, 2, lengths) || __notnull());
+      blocks = __lowerString(blocks) || __notnull();
+      reuse = reuse ? 1 : 0;
+      try {
+        return exports.actionsEmitEachBytes(swf, offsets, lengths, version, blocks, reuse) >>> 0;
+      } finally {
+        __release(swf);
+        __release(offsets);
+        __release(lengths);
+      }
+    },
+    actionsHeldEmitEachBytes(handle, version, blocks) {
+      // assembly/avm1/compile/actionsHeldEmitEachBytes(i32, i32, ~lib/string/String) => usize
+      blocks = __lowerString(blocks) || __notnull();
+      return exports.actionsHeldEmitEachBytes(handle, version, blocks) >>> 0;
+    },
+    actionsHeldUnitBytes(handle, version, at, end, bound, five) {
+      // assembly/avm1/compile/actionsHeldUnitBytes(i32, i32, i32, i32, i32, bool) => usize
+      five = five ? 1 : 0;
+      return exports.actionsHeldUnitBytes(handle, version, at, end, bound, five) >>> 0;
+    },
+    actionsHold(handle, swf, offsets, lengths) {
+      // assembly/avm1/compile/actionsHold(i32, ~lib/typedarray/Uint8Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array) => void
+      swf = __retain(__lowerTypedArray(Uint8Array, 27, 0, swf) || __notnull());
+      offsets = __retain(__lowerTypedArray(Int32Array, 31, 2, offsets) || __notnull());
+      lengths = __lowerTypedArray(Int32Array, 31, 2, lengths) || __notnull();
+      try {
+        exports.actionsHold(handle, swf, offsets, lengths);
+      } finally {
+        __release(swf);
+        __release(offsets);
+      }
+    },
+    actionsModuleBytes(swf, offsets, lengths, version, keep) {
+      // assembly/avm1/compile/actionsModuleBytes(~lib/typedarray/Uint8Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, i32, bool?) => usize
+      swf = __retain(__lowerTypedArray(Uint8Array, 27, 0, swf) || __notnull());
+      offsets = __retain(__lowerTypedArray(Int32Array, 31, 2, offsets) || __notnull());
+      lengths = __lowerTypedArray(Int32Array, 31, 2, lengths) || __notnull();
+      keep = keep ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        return exports.actionsModuleBytes(swf, offsets, lengths, version, keep) >>> 0;
+      } finally {
+        __release(swf);
+        __release(offsets);
+      }
+    },
+    actionsModuleEntries() {
+      // assembly/avm1/compile/actionsModuleEntries() => ~lib/string/String
+      return __liftString(exports.actionsModuleEntries() >>> 0);
+    },
+    actionsModuleUnits() {
+      // assembly/avm1/compile/actionsModuleUnits() => ~lib/string/String
+      return __liftString(exports.actionsModuleUnits() >>> 0);
+    },
+    actionsUnitBytes(swf, offsets, lengths, version, at, end, bound, five) {
+      // assembly/avm1/compile/actionsUnitBytes(~lib/typedarray/Uint8Array, ~lib/typedarray/Int32Array, ~lib/typedarray/Int32Array, i32, i32, i32, i32, bool) => usize
+      swf = __retain(__lowerTypedArray(Uint8Array, 27, 0, swf) || __notnull());
+      offsets = __retain(__lowerTypedArray(Int32Array, 31, 2, offsets) || __notnull());
+      lengths = __lowerTypedArray(Int32Array, 31, 2, lengths) || __notnull();
+      five = five ? 1 : 0;
+      try {
+        return exports.actionsUnitBytes(swf, offsets, lengths, version, at, end, bound, five) >>> 0;
+      } finally {
+        __release(swf);
+        __release(offsets);
+      }
+    },
+    actionsUnitLimits() {
+      // assembly/avm1/compile/actionsUnitLimits() => ~lib/typedarray/Float64Array
+      return __liftTypedArray(Float64Array, exports.actionsUnitLimits() >>> 0);
+    },
+    domainAdd(bytes, builtin, appDomain) {
+      // assembly/compile/domainAdd(~lib/typedarray/Uint8Array, bool, i32?) => i32
+      bytes = __lowerTypedArray(Uint8Array, 27, 0, bytes) || __notnull();
+      builtin = builtin ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return exports.domainAdd(bytes, builtin, appDomain);
+    },
+    domainCompact() {
+      // assembly/compile/domainCompact() => bool
+      return exports.domainCompact() != 0;
+    },
+    domainContext(index, after, upTo) {
+      // assembly/compile/domainContext(i32?, i32?, i32?) => ~lib/string/String
+      exports.__setArgumentsLength(arguments.length);
+      return __liftString(exports.domainContext(index, after, upTo) >>> 0);
+    },
+    domainEmitEach(bodies, reuse, which) {
+      // assembly/compile/domainEmitEach(~lib/string/String, bool, i32?) => ~lib/string/String
+      bodies = __lowerString(bodies) || __notnull();
+      reuse = reuse ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return __liftString(exports.domainEmitEach(bodies, reuse, which) >>> 0);
+    },
+    domainEmitEachBytes(bodies, reuse, which) {
+      // assembly/compile/domainEmitEachBytes(~lib/string/String, bool, i32?) => usize
+      bodies = __lowerString(bodies) || __notnull();
+      reuse = reuse ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return exports.domainEmitEachBytes(bodies, reuse, which) >>> 0;
+    },
+    domainFound(appDomain, nsKind, uri, name, abc, asType) {
+      // assembly/compile/domainFound(i32, i32, ~lib/string/String, ~lib/string/String, i32, bool) => void
+      uri = __retain(__lowerString(uri) || __notnull());
+      name = __lowerString(name) || __notnull();
+      asType = asType ? 1 : 0;
+      try {
+        exports.domainFound(appDomain, nsKind, uri, name, abc, asType);
+      } finally {
+        __release(uri);
+      }
+    },
+    domainLazyModuleBytes(hashes, index) {
+      // assembly/compile/domainLazyModuleBytes(~lib/string/String?, i32?) => usize
+      hashes = __lowerString(hashes) || __notnull();
+      exports.__setArgumentsLength(arguments.length);
+      return exports.domainLazyModuleBytes(hashes, index) >>> 0;
+    },
+    domainLinked(index) {
+      // assembly/compile/domainLinked(i32?) => ~lib/string/String
+      exports.__setArgumentsLength(arguments.length);
+      return __liftString(exports.domainLinked(index) >>> 0);
+    },
+    domainLogSince(mark, index) {
+      // assembly/compile/domainLogSince(i32, i32?) => ~lib/string/String
+      exports.__setArgumentsLength(arguments.length);
+      return __liftString(exports.domainLogSince(mark, index) >>> 0);
+    },
+    domainModule(hashes, index, keep, linkedOnly) {
+      // assembly/compile/domainModule(~lib/string/String?, i32?, bool?, bool?) => ~lib/string/String
+      hashes = __lowerString(hashes) || __notnull();
+      keep = keep ? 1 : 0;
+      linkedOnly = linkedOnly ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return __liftString(exports.domainModule(hashes, index, keep, linkedOnly) >>> 0);
+    },
+    domainModuleBytes(hashes, index, keep, linkedOnly) {
+      // assembly/compile/domainModuleBytes(~lib/string/String?, i32?, bool?, bool?) => usize
+      hashes = __lowerString(hashes) || __notnull();
+      keep = keep ? 1 : 0;
+      linkedOnly = linkedOnly ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return exports.domainModuleBytes(hashes, index, keep, linkedOnly) >>> 0;
+    },
+    domainModuleEntries() {
+      // assembly/compile/domainModuleEntries() => ~lib/string/String
+      return __liftString(exports.domainModuleEntries() >>> 0);
+    },
+    domainReplay(log, index) {
+      // assembly/compile/domainReplay(~lib/string/String, i32?) => bool
+      log = __lowerString(log) || __notnull();
+      exports.__setArgumentsLength(arguments.length);
+      return exports.domainReplay(log, index) != 0;
+    },
+    domainRestore(index, bytes) {
+      // assembly/compile/domainRestore(i32, ~lib/typedarray/Uint8Array) => i32
+      bytes = __lowerTypedArray(Uint8Array, 27, 0, bytes) || __notnull();
+      return exports.domainRestore(index, bytes);
+    },
+    domainRevision() {
+      // assembly/compile/domainRevision() => ~lib/string/String
+      return __liftString(exports.domainRevision() >>> 0);
+    },
+    domainSourceMap() {
+      // assembly/compile/domainSourceMap() => ~lib/string/String
+      return __liftString(exports.domainSourceMap() >>> 0);
+    },
+    domainUsage() {
+      // assembly/compile/domainUsage() => ~lib/string/String
+      return __liftString(exports.domainUsage() >>> 0);
+    },
+    domainWantsCompact() {
+      // assembly/compile/domainWantsCompact() => bool
+      return exports.domainWantsCompact() != 0;
+    },
+    outputLength() {
+      // assembly/output/outputLength() => u32
+      return exports.outputLength() >>> 0;
+    },
+  }, exports);
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __lowerString(value) {
+    if (value == null) return 0;
+    const
+      length = value.length,
+      pointer = exports.__new(length << 1, 2) >>> 0,
+      memoryU16 = new Uint16Array(memory.buffer);
+    for (let i = 0; i < length; ++i) memoryU16[(pointer >>> 1) + i] = value.charCodeAt(i);
+    return pointer;
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  return adaptedExports;
+}