@cloudbase/container 2.5.29-beta.0

package/dist/esm/go_wams_exec.js

@@ -0,0 +1,536 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+if (typeof global !== 'undefined') {
+}
+else if (typeof window !== 'undefined') {
+    window.global = window;
+}
+else if (typeof self !== 'undefined') {
+    self.global = self;
+}
+else {
+    throw new Error('cannot export Go (neither global, window nor self is defined)');
+}
+if (!global.require && typeof require !== 'undefined') {
+}
+var enosys = function () {
+    var err = new Error('not implemented');
+    err.code = 'ENOSYS';
+    return err;
+};
+if (!global.fs) {
+    var outputBuf_1 = '';
+    global.fs = {
+        constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 },
+        writeSync: function (fd, buf) {
+            outputBuf_1 += decoder.decode(buf);
+            var nl = outputBuf_1.lastIndexOf('\n');
+            if (nl != -1) {
+                console.log(outputBuf_1.substr(0, nl));
+                outputBuf_1 = outputBuf_1.substr(nl + 1);
+            }
+            return buf.length;
+        },
+        write: function (fd, buf, offset, length, position, callback) {
+            if (offset !== 0 || length !== buf.length || position !== null) {
+                callback(enosys());
+                return;
+            }
+            var n = this.writeSync(fd, buf);
+            callback(null, n);
+        },
+        chmod: function (path, mode, callback) {
+            callback(enosys());
+        },
+        chown: function (path, uid, gid, callback) {
+            callback(enosys());
+        },
+        close: function (fd, callback) {
+            callback(enosys());
+        },
+        fchmod: function (fd, mode, callback) {
+            callback(enosys());
+        },
+        fchown: function (fd, uid, gid, callback) {
+            callback(enosys());
+        },
+        fstat: function (fd, callback) {
+            callback(enosys());
+        },
+        fsync: function (fd, callback) {
+            callback(null);
+        },
+        ftruncate: function (fd, length, callback) {
+            callback(enosys());
+        },
+        lchown: function (path, uid, gid, callback) {
+            callback(enosys());
+        },
+        link: function (path, link, callback) {
+            callback(enosys());
+        },
+        lstat: function (path, callback) {
+            callback(enosys());
+        },
+        mkdir: function (path, perm, callback) {
+            callback(enosys());
+        },
+        open: function (path, flags, mode, callback) {
+            callback(enosys());
+        },
+        read: function (fd, buffer, offset, length, position, callback) {
+            callback(enosys());
+        },
+        readdir: function (path, callback) {
+            callback(enosys());
+        },
+        readlink: function (path, callback) {
+            callback(enosys());
+        },
+        rename: function (from, to, callback) {
+            callback(enosys());
+        },
+        rmdir: function (path, callback) {
+            callback(enosys());
+        },
+        stat: function (path, callback) {
+            callback(enosys());
+        },
+        symlink: function (path, link, callback) {
+            callback(enosys());
+        },
+        truncate: function (path, length, callback) {
+            callback(enosys());
+        },
+        unlink: function (path, callback) {
+            callback(enosys());
+        },
+        utimes: function (path, atime, mtime, callback) {
+            callback(enosys());
+        },
+    };
+}
+if (!global.process) {
+    global.process = {
+        getuid: function () {
+            return -1;
+        },
+        getgid: function () {
+            return -1;
+        },
+        geteuid: function () {
+            return -1;
+        },
+        getegid: function () {
+            return -1;
+        },
+        getgroups: function () {
+            throw enosys();
+        },
+        pid: -1,
+        ppid: -1,
+        umask: function () {
+            throw enosys();
+        },
+        cwd: function () {
+            throw enosys();
+        },
+        chdir: function () {
+            throw enosys();
+        },
+    };
+}
+if (!global.crypto) {
+    throw new Error('globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)');
+}
+if (!global.performance) {
+    throw new Error('globalThis.performance is not available, polyfill required (performance.now only)');
+}
+if (!global.TextEncoder) {
+    throw new Error('globalThis.TextEncoder is not available, polyfill required');
+}
+if (!global.TextDecoder) {
+    throw new Error('globalThis.TextDecoder is not available, polyfill required');
+}
+var encoder = new TextEncoder('utf-8');
+var decoder = new TextDecoder('utf-8');
+var logLine = [];
+global.Go = (function () {
+    function class_1() {
+        var _this = this;
+        this._callbackTimeouts = new Map();
+        this._nextCallbackTimeoutID = 1;
+        var mem = function () {
+            return new DataView(_this._inst.exports.memory.buffer);
+        };
+        var setInt64 = function (addr, v) {
+            mem().setUint32(addr + 0, v, true);
+            mem().setUint32(addr + 4, Math.floor(v / 4294967296), true);
+        };
+        var getInt64 = function (addr) {
+            var low = mem().getUint32(addr + 0, true);
+            var high = mem().getInt32(addr + 4, true);
+            return low + high * 4294967296;
+        };
+        var loadValue = function (addr) {
+            var f = mem().getFloat64(addr, true);
+            if (f === 0) {
+                return undefined;
+            }
+            if (!isNaN(f)) {
+                return f;
+            }
+            var id = mem().getUint32(addr, true);
+            return _this._values[id];
+        };
+        var storeValue = function (addr, v) {
+            var nanHead = 0x7ff80000;
+            if (typeof v === 'number') {
+                if (isNaN(v)) {
+                    mem().setUint32(addr + 4, nanHead, true);
+                    mem().setUint32(addr, 0, true);
+                    return;
+                }
+                if (v === 0) {
+                    mem().setUint32(addr + 4, nanHead, true);
+                    mem().setUint32(addr, 1, true);
+                    return;
+                }
+                mem().setFloat64(addr, v, true);
+                return;
+            }
+            switch (v) {
+                case undefined:
+                    mem().setFloat64(addr, 0, true);
+                    return;
+                case null:
+                    mem().setUint32(addr + 4, nanHead, true);
+                    mem().setUint32(addr, 2, true);
+                    return;
+                case true:
+                    mem().setUint32(addr + 4, nanHead, true);
+                    mem().setUint32(addr, 3, true);
+                    return;
+                case false:
+                    mem().setUint32(addr + 4, nanHead, true);
+                    mem().setUint32(addr, 4, true);
+                    return;
+            }
+            var id = _this._ids.get(v);
+            if (id === undefined) {
+                id = _this._idPool.pop();
+                if (id === undefined) {
+                    id = _this._values.length;
+                }
+                _this._values[id] = v;
+                _this._goRefCounts[id] = 0;
+                _this._ids.set(v, id);
+            }
+            _this._goRefCounts[id]++;
+            var typeFlag = 1;
+            switch (typeof v) {
+                case 'string':
+                    typeFlag = 2;
+                    break;
+                case 'symbol':
+                    typeFlag = 3;
+                    break;
+                case 'function':
+                    typeFlag = 4;
+                    break;
+            }
+            mem().setUint32(addr + 4, nanHead | typeFlag, true);
+            mem().setUint32(addr, id, true);
+        };
+        var loadSlice = function (array, len, cap) {
+            return new Uint8Array(_this._inst.exports.memory.buffer, array, len);
+        };
+        var loadSliceOfValues = function (array, len, cap) {
+            var a = new Array(len);
+            for (var i = 0; i < len; i++) {
+                a[i] = loadValue(array + i * 8);
+            }
+            return a;
+        };
+        var loadString = function (ptr, len) {
+            return decoder.decode(new DataView(_this._inst.exports.memory.buffer, ptr, len));
+        };
+        var timeOrigin = Date.now() - performance.now();
+        this.importObject = {
+            wasi_snapshot_preview1: {
+                fd_write: function (fd, iovs_ptr, iovs_len, nwritten_ptr) {
+                    var nwritten = 0;
+                    if (fd == 1) {
+                        for (var iovs_i = 0; iovs_i < iovs_len; iovs_i++) {
+                            var iov_ptr = iovs_ptr + iovs_i * 8;
+                            var ptr = mem().getUint32(iov_ptr + 0, true);
+                            var len = mem().getUint32(iov_ptr + 4, true);
+                            nwritten += len;
+                            for (var i = 0; i < len; i++) {
+                                var c = mem().getUint8(ptr + i);
+                                if (c == 13) {
+                                }
+                                else if (c == 10) {
+                                    var line = decoder.decode(new Uint8Array(logLine));
+                                    logLine = [];
+                                    console.log(line);
+                                }
+                                else {
+                                    logLine.push(c);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        console.error('invalid file descriptor:', fd);
+                    }
+                    mem().setUint32(nwritten_ptr, nwritten, true);
+                    return 0;
+                },
+                fd_close: function () { return 0; },
+                fd_fdstat_get: function () { return 0; },
+                fd_seek: function () { return 0; },
+                proc_exit: function (code) {
+                    if (global.process) {
+                        process.exit(code);
+                    }
+                    else {
+                        throw 'trying to exit with code ' + code;
+                    }
+                },
+                random_get: function (bufPtr, bufLen) {
+                    crypto.getRandomValues(loadSlice(bufPtr, bufLen));
+                    return 0;
+                },
+            },
+            env: {
+                'runtime.ticks': function () {
+                    return timeOrigin + performance.now();
+                },
+                'runtime.sleepTicks': function (timeout) {
+                    setTimeout(_this._inst.exports.go_scheduler, timeout);
+                },
+                'syscall/js.finalizeRef': function (sp) {
+                    var id = mem().getUint32(sp, true);
+                    _this._goRefCounts[id]--;
+                    if (_this._goRefCounts[id] === 0) {
+                        var v = _this._values[id];
+                        _this._values[id] = null;
+                        _this._ids.delete(v);
+                        _this._idPool.push(id);
+                    }
+                },
+                'syscall/js.stringVal': function (ret_ptr, value_ptr, value_len) {
+                    var s = loadString(value_ptr, value_len);
+                    storeValue(ret_ptr, s);
+                },
+                'syscall/js.valueGet': function (retval, v_addr, p_ptr, p_len) {
+                    var prop = loadString(p_ptr, p_len);
+                    var value = loadValue(v_addr);
+                    var result = Reflect.get(value, prop);
+                    storeValue(retval, result);
+                },
+                'syscall/js.valueSet': function (v_addr, p_ptr, p_len, x_addr) {
+                    var v = loadValue(v_addr);
+                    var p = loadString(p_ptr, p_len);
+                    var x = loadValue(x_addr);
+                    Reflect.set(v, p, x);
+                },
+                'syscall/js.valueDelete': function (v_addr, p_ptr, p_len) {
+                    var v = loadValue(v_addr);
+                    var p = loadString(p_ptr, p_len);
+                    Reflect.deleteProperty(v, p);
+                },
+                'syscall/js.valueIndex': function (ret_addr, v_addr, i) {
+                    storeValue(ret_addr, Reflect.get(loadValue(v_addr), i));
+                },
+                'syscall/js.valueSetIndex': function (v_addr, i, x_addr) {
+                    Reflect.set(loadValue(v_addr), i, loadValue(x_addr));
+                },
+                'syscall/js.valueCall': function (ret_addr, v_addr, m_ptr, m_len, args_ptr, args_len, args_cap) {
+                    var v = loadValue(v_addr);
+                    var name = loadString(m_ptr, m_len);
+                    var args = loadSliceOfValues(args_ptr, args_len, args_cap);
+                    try {
+                        var m = Reflect.get(v, name);
+                        storeValue(ret_addr, Reflect.apply(m, v, args));
+                        mem().setUint8(ret_addr + 8, 1);
+                    }
+                    catch (err) {
+                        storeValue(ret_addr, err);
+                        mem().setUint8(ret_addr + 8, 0);
+                    }
+                },
+                'syscall/js.valueInvoke': function (ret_addr, v_addr, args_ptr, args_len, args_cap) {
+                    try {
+                        var v = loadValue(v_addr);
+                        var args = loadSliceOfValues(args_ptr, args_len, args_cap);
+                        storeValue(ret_addr, Reflect.apply(v, undefined, args));
+                        mem().setUint8(ret_addr + 8, 1);
+                    }
+                    catch (err) {
+                        storeValue(ret_addr, err);
+                        mem().setUint8(ret_addr + 8, 0);
+                    }
+                },
+                'syscall/js.valueNew': function (ret_addr, v_addr, args_ptr, args_len, args_cap) {
+                    var v = loadValue(v_addr);
+                    var args = loadSliceOfValues(args_ptr, args_len, args_cap);
+                    try {
+                        storeValue(ret_addr, Reflect.construct(v, args));
+                        mem().setUint8(ret_addr + 8, 1);
+                    }
+                    catch (err) {
+                        storeValue(ret_addr, err);
+                        mem().setUint8(ret_addr + 8, 0);
+                    }
+                },
+                'syscall/js.valueLength': function (v_addr) {
+                    return loadValue(v_addr).length;
+                },
+                'syscall/js.valuePrepareString': function (ret_addr, v_addr) {
+                    var s = String(loadValue(v_addr));
+                    var str = encoder.encode(s);
+                    storeValue(ret_addr, str);
+                    setInt64(ret_addr + 8, str.length);
+                },
+                'syscall/js.valueLoadString': function (v_addr, slice_ptr, slice_len, slice_cap) {
+                    var str = loadValue(v_addr);
+                    loadSlice(slice_ptr, slice_len, slice_cap).set(str);
+                },
+                'syscall/js.valueInstanceOf': function (v_addr, t_addr) {
+                    return loadValue(v_addr) instanceof loadValue(t_addr);
+                },
+                'syscall/js.copyBytesToGo': function (ret_addr, dest_addr, dest_len, dest_cap, source_addr) {
+                    var num_bytes_copied_addr = ret_addr;
+                    var returned_status_addr = ret_addr + 4;
+                    var dst = loadSlice(dest_addr, dest_len);
+                    var src = loadValue(source_addr);
+                    if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+                        mem().setUint8(returned_status_addr, 0);
+                        return;
+                    }
+                    var toCopy = src.subarray(0, dst.length);
+                    dst.set(toCopy);
+                    setInt64(num_bytes_copied_addr, toCopy.length);
+                    mem().setUint8(returned_status_addr, 1);
+                },
+                'syscall/js.copyBytesToJS': function (ret_addr, dest_addr, source_addr, source_len, source_cap) {
+                    var num_bytes_copied_addr = ret_addr;
+                    var returned_status_addr = ret_addr + 4;
+                    var dst = loadValue(dest_addr);
+                    var src = loadSlice(source_addr, source_len);
+                    if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+                        mem().setUint8(returned_status_addr, 0);
+                        return;
+                    }
+                    var toCopy = src.subarray(0, dst.length);
+                    dst.set(toCopy);
+                    setInt64(num_bytes_copied_addr, toCopy.length);
+                    mem().setUint8(returned_status_addr, 1);
+                },
+            },
+        };
+    }
+    class_1.prototype.run = function (instance) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mem, callbackPromise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._inst = instance;
+                        this._values = [
+                            NaN,
+                            0,
+                            null,
+                            true,
+                            false,
+                            global,
+                            this,
+                        ];
+                        this._goRefCounts = [];
+                        this._ids = new Map();
+                        this._idPool = [];
+                        this.exited = false;
+                        mem = new DataView(this._inst.exports.memory.buffer);
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3, 3];
+                        callbackPromise = new Promise(function (resolve) {
+                            _this._resolveCallbackPromise = function () {
+                                if (_this.exited) {
+                                    throw new Error('bad callback: Go program has already exited');
+                                }
+                                setTimeout(resolve, 0);
+                            };
+                        });
+                        this._inst.exports._start();
+                        if (this.exited) {
+                            return [3, 3];
+                        }
+                        return [4, callbackPromise];
+                    case 2:
+                        _a.sent();
+                        return [3, 1];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    class_1.prototype._resume = function () {
+        if (this.exited) {
+            throw new Error('Go program has already exited');
+        }
+        this._inst.exports.resume();
+        if (this.exited) {
+            this._resolveExitPromise();
+        }
+    };
+    class_1.prototype._makeFuncWrapper = function (id) {
+        var go = this;
+        return function () {
+            var event = { id: id, this: this, args: arguments };
+            go._pendingEvent = event;
+            go._resume();
+            return event.result;
+        };
+    };
+    return class_1;
+}());
+export default global.Go;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"go_wams_exec.js","sourceRoot":"","sources":["../../src/go_wams_exec.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-nocheck\n/* eslint-disable */\n\n// This file has been modified for use by the TinyGo compiler.\n\n// Map multiple JavaScript environments to a single common API,\n// preferring web standards over Node.js API.\n//\n// Environments considered:\n// - Browsers\n// - Node.js\n// - Electron\n// - Parcel\n\nif (typeof global !== 'undefined') {\n  // global already exists\n} else if (typeof window !== 'undefined') {\n  window.global = window\n} else if (typeof self !== 'undefined') {\n  self.global = self\n} else {\n  throw new Error('cannot export Go (neither global, window nor self is defined)')\n}\n\nif (!global.require && typeof require !== 'undefined') {\n  // global.require = require\n}\n\n// if (!global.fs && global.require) {\n//   global.fs = require('fs')\n// }\n\nconst enosys = () => {\n  const err = new Error('not implemented')\n  err.code = 'ENOSYS'\n  return err\n}\n\nif (!global.fs) {\n  let outputBuf = ''\n  global.fs = {\n    constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused\n    writeSync(fd, buf) {\n      outputBuf += decoder.decode(buf)\n      const nl = outputBuf.lastIndexOf('\\n')\n      if (nl != -1) {\n        console.log(outputBuf.substr(0, nl))\n        outputBuf = outputBuf.substr(nl + 1)\n      }\n      return buf.length\n    },\n    write(fd, buf, offset, length, position, callback) {\n      if (offset !== 0 || length !== buf.length || position !== null) {\n        callback(enosys())\n        return\n      }\n      const n = this.writeSync(fd, buf)\n      callback(null, n)\n    },\n    chmod(path, mode, callback) {\n      callback(enosys())\n    },\n    chown(path, uid, gid, callback) {\n      callback(enosys())\n    },\n    close(fd, callback) {\n      callback(enosys())\n    },\n    fchmod(fd, mode, callback) {\n      callback(enosys())\n    },\n    fchown(fd, uid, gid, callback) {\n      callback(enosys())\n    },\n    fstat(fd, callback) {\n      callback(enosys())\n    },\n    fsync(fd, callback) {\n      callback(null)\n    },\n    ftruncate(fd, length, callback) {\n      callback(enosys())\n    },\n    lchown(path, uid, gid, callback) {\n      callback(enosys())\n    },\n    link(path, link, callback) {\n      callback(enosys())\n    },\n    lstat(path, callback) {\n      callback(enosys())\n    },\n    mkdir(path, perm, callback) {\n      callback(enosys())\n    },\n    open(path, flags, mode, callback) {\n      callback(enosys())\n    },\n    read(fd, buffer, offset, length, position, callback) {\n      callback(enosys())\n    },\n    readdir(path, callback) {\n      callback(enosys())\n    },\n    readlink(path, callback) {\n      callback(enosys())\n    },\n    rename(from, to, callback) {\n      callback(enosys())\n    },\n    rmdir(path, callback) {\n      callback(enosys())\n    },\n    stat(path, callback) {\n      callback(enosys())\n    },\n    symlink(path, link, callback) {\n      callback(enosys())\n    },\n    truncate(path, length, callback) {\n      callback(enosys())\n    },\n    unlink(path, callback) {\n      callback(enosys())\n    },\n    utimes(path, atime, mtime, callback) {\n      callback(enosys())\n    },\n  }\n}\n\nif (!global.process) {\n  global.process = {\n    getuid() {\n      return -1\n    },\n    getgid() {\n      return -1\n    },\n    geteuid() {\n      return -1\n    },\n    getegid() {\n      return -1\n    },\n    getgroups() {\n      throw enosys()\n    },\n    pid: -1,\n    ppid: -1,\n    umask() {\n      throw enosys()\n    },\n    cwd() {\n      throw enosys()\n    },\n    chdir() {\n      throw enosys()\n    },\n  }\n}\n\nif (!global.crypto) {\n  throw new Error('globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)')\n  // const nodeCrypto = require('crypto')\n  // global.crypto = {\n  //   getRandomValues(b) {\n  //     nodeCrypto.randomFillSync(b)\n  //   },\n  // }\n}\n\nif (!global.performance) {\n  throw new Error('globalThis.performance is not available, polyfill required (performance.now only)')\n  // global.performance = {\n  //   now() {\n  //     const [sec, nsec] = process.hrtime()\n  //     return sec * 1000 + nsec / 1000000\n  //   },\n  // }\n}\n\nif (!global.TextEncoder) {\n  throw new Error('globalThis.TextEncoder is not available, polyfill required')\n  // global.TextEncoder = require('util').TextEncoder\n}\n\nif (!global.TextDecoder) {\n  throw new Error('globalThis.TextDecoder is not available, polyfill required')\n  // global.TextDecoder = require('util').TextDecoder\n}\n\n// End of polyfills for common API.\n\nconst encoder = new TextEncoder('utf-8')\nconst decoder = new TextDecoder('utf-8')\nvar logLine = []\n\nglobal.Go = class {\n  constructor() {\n    this._callbackTimeouts = new Map()\n    this._nextCallbackTimeoutID = 1\n\n    const mem = () => {\n      // The buffer may change when requesting more memory.\n      return new DataView(this._inst.exports.memory.buffer)\n    }\n\n    const setInt64 = (addr, v) => {\n      mem().setUint32(addr + 0, v, true)\n      mem().setUint32(addr + 4, Math.floor(v / 4294967296), true)\n    }\n\n    const getInt64 = (addr) => {\n      const low = mem().getUint32(addr + 0, true)\n      const high = mem().getInt32(addr + 4, true)\n      return low + high * 4294967296\n    }\n\n    const loadValue = (addr) => {\n      const f = mem().getFloat64(addr, true)\n      if (f === 0) {\n        return undefined\n      }\n      if (!isNaN(f)) {\n        return f\n      }\n\n      const id = mem().getUint32(addr, true)\n      return this._values[id]\n    }\n\n    const storeValue = (addr, v) => {\n      const nanHead = 0x7ff80000\n\n      if (typeof v === 'number') {\n        if (isNaN(v)) {\n          mem().setUint32(addr + 4, nanHead, true)\n          mem().setUint32(addr, 0, true)\n          return\n        }\n        if (v === 0) {\n          mem().setUint32(addr + 4, nanHead, true)\n          mem().setUint32(addr, 1, true)\n          return\n        }\n        mem().setFloat64(addr, v, true)\n        return\n      }\n\n      switch (v) {\n        case undefined:\n          mem().setFloat64(addr, 0, true)\n          return\n        case null:\n          mem().setUint32(addr + 4, nanHead, true)\n          mem().setUint32(addr, 2, true)\n          return\n        case true:\n          mem().setUint32(addr + 4, nanHead, true)\n          mem().setUint32(addr, 3, true)\n          return\n        case false:\n          mem().setUint32(addr + 4, nanHead, true)\n          mem().setUint32(addr, 4, true)\n          return\n      }\n\n      let id = this._ids.get(v)\n      if (id === undefined) {\n        id = this._idPool.pop()\n        if (id === undefined) {\n          id = this._values.length\n        }\n        this._values[id] = v\n        this._goRefCounts[id] = 0\n        this._ids.set(v, id)\n      }\n      this._goRefCounts[id]++\n      let typeFlag = 1\n      switch (typeof v) {\n        case 'string':\n          typeFlag = 2\n          break\n        case 'symbol':\n          typeFlag = 3\n          break\n        case 'function':\n          typeFlag = 4\n          break\n      }\n      mem().setUint32(addr + 4, nanHead | typeFlag, true)\n      mem().setUint32(addr, id, true)\n    }\n\n    const loadSlice = (array, len, cap) => {\n      return new Uint8Array(this._inst.exports.memory.buffer, array, len)\n    }\n\n    const loadSliceOfValues = (array, len, cap) => {\n      const a = new Array(len)\n      for (let i = 0; i < len; i++) {\n        a[i] = loadValue(array + i * 8)\n      }\n      return a\n    }\n\n    const loadString = (ptr, len) => {\n      return decoder.decode(new DataView(this._inst.exports.memory.buffer, ptr, len))\n    }\n\n    const timeOrigin = Date.now() - performance.now()\n    this.importObject = {\n      wasi_snapshot_preview1: {\n        // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write\n        fd_write: function (fd, iovs_ptr, iovs_len, nwritten_ptr) {\n          let nwritten = 0\n          if (fd == 1) {\n            for (let iovs_i = 0; iovs_i < iovs_len; iovs_i++) {\n              let iov_ptr = iovs_ptr + iovs_i * 8 // assuming wasm32\n              let ptr = mem().getUint32(iov_ptr + 0, true)\n              let len = mem().getUint32(iov_ptr + 4, true)\n              nwritten += len\n              for (let i = 0; i < len; i++) {\n                let c = mem().getUint8(ptr + i)\n                if (c == 13) {\n                  // CR\n                  // ignore\n                } else if (c == 10) {\n                  // LF\n                  // write line\n                  let line = decoder.decode(new Uint8Array(logLine))\n                  logLine = []\n                  console.log(line)\n                } else {\n                  logLine.push(c)\n                }\n              }\n            }\n          } else {\n            console.error('invalid file descriptor:', fd)\n          }\n          mem().setUint32(nwritten_ptr, nwritten, true)\n          return 0\n        },\n        fd_close: () => 0, // dummy\n        fd_fdstat_get: () => 0, // dummy\n        fd_seek: () => 0, // dummy\n        proc_exit: (code) => {\n          if (global.process) {\n            // Node.js\n            process.exit(code)\n          } else {\n            // Can't exit in a browser.\n            throw 'trying to exit with code ' + code\n          }\n        },\n        random_get: (bufPtr, bufLen) => {\n          crypto.getRandomValues(loadSlice(bufPtr, bufLen))\n          return 0\n        },\n      },\n      env: {\n        // func ticks() float64\n        'runtime.ticks': () => {\n          return timeOrigin + performance.now()\n        },\n\n        // func sleepTicks(timeout float64)\n        'runtime.sleepTicks': (timeout) => {\n          // Do not sleep, only reactivate scheduler after the given timeout.\n          setTimeout(this._inst.exports.go_scheduler, timeout)\n        },\n\n        // func finalizeRef(v ref)\n        'syscall/js.finalizeRef': (sp) => {\n          // Note: TinyGo does not support finalizers so this should never be\n          // called.\n          const id = mem().getUint32(sp, true)\n          this._goRefCounts[id]--\n          if (this._goRefCounts[id] === 0) {\n            const v = this._values[id]\n            this._values[id] = null\n            this._ids.delete(v)\n            this._idPool.push(id)\n          }\n          // console.error('syscall/js.finalizeRef not implemented');\n        },\n\n        // func stringVal(value string) ref\n        'syscall/js.stringVal': (ret_ptr, value_ptr, value_len) => {\n          const s = loadString(value_ptr, value_len)\n          storeValue(ret_ptr, s)\n        },\n\n        // func valueGet(v ref, p string) ref\n        'syscall/js.valueGet': (retval, v_addr, p_ptr, p_len) => {\n          let prop = loadString(p_ptr, p_len)\n          let value = loadValue(v_addr)\n          let result = Reflect.get(value, prop)\n          storeValue(retval, result)\n        },\n\n        // func valueSet(v ref, p string, x ref)\n        'syscall/js.valueSet': (v_addr, p_ptr, p_len, x_addr) => {\n          const v = loadValue(v_addr)\n          const p = loadString(p_ptr, p_len)\n          const x = loadValue(x_addr)\n          Reflect.set(v, p, x)\n        },\n\n        // func valueDelete(v ref, p string)\n        'syscall/js.valueDelete': (v_addr, p_ptr, p_len) => {\n          const v = loadValue(v_addr)\n          const p = loadString(p_ptr, p_len)\n          Reflect.deleteProperty(v, p)\n        },\n\n        // func valueIndex(v ref, i int) ref\n        'syscall/js.valueIndex': (ret_addr, v_addr, i) => {\n          storeValue(ret_addr, Reflect.get(loadValue(v_addr), i))\n        },\n\n        // valueSetIndex(v ref, i int, x ref)\n        'syscall/js.valueSetIndex': (v_addr, i, x_addr) => {\n          Reflect.set(loadValue(v_addr), i, loadValue(x_addr))\n        },\n\n        // func valueCall(v ref, m string, args []ref) (ref, bool)\n        'syscall/js.valueCall': (ret_addr, v_addr, m_ptr, m_len, args_ptr, args_len, args_cap) => {\n          const v = loadValue(v_addr)\n          const name = loadString(m_ptr, m_len)\n          const args = loadSliceOfValues(args_ptr, args_len, args_cap)\n          try {\n            const m = Reflect.get(v, name)\n            storeValue(ret_addr, Reflect.apply(m, v, args))\n            mem().setUint8(ret_addr + 8, 1)\n          } catch (err) {\n            storeValue(ret_addr, err)\n            mem().setUint8(ret_addr + 8, 0)\n          }\n        },\n\n        // func valueInvoke(v ref, args []ref) (ref, bool)\n        'syscall/js.valueInvoke': (ret_addr, v_addr, args_ptr, args_len, args_cap) => {\n          try {\n            const v = loadValue(v_addr)\n            const args = loadSliceOfValues(args_ptr, args_len, args_cap)\n            storeValue(ret_addr, Reflect.apply(v, undefined, args))\n            mem().setUint8(ret_addr + 8, 1)\n          } catch (err) {\n            storeValue(ret_addr, err)\n            mem().setUint8(ret_addr + 8, 0)\n          }\n        },\n\n        // func valueNew(v ref, args []ref) (ref, bool)\n        'syscall/js.valueNew': (ret_addr, v_addr, args_ptr, args_len, args_cap) => {\n          const v = loadValue(v_addr)\n          const args = loadSliceOfValues(args_ptr, args_len, args_cap)\n          try {\n            storeValue(ret_addr, Reflect.construct(v, args))\n            mem().setUint8(ret_addr + 8, 1)\n          } catch (err) {\n            storeValue(ret_addr, err)\n            mem().setUint8(ret_addr + 8, 0)\n          }\n        },\n\n        // func valueLength(v ref) int\n        'syscall/js.valueLength': (v_addr) => {\n          return loadValue(v_addr).length\n        },\n\n        // valuePrepareString(v ref) (ref, int)\n        'syscall/js.valuePrepareString': (ret_addr, v_addr) => {\n          const s = String(loadValue(v_addr))\n          const str = encoder.encode(s)\n          storeValue(ret_addr, str)\n          setInt64(ret_addr + 8, str.length)\n        },\n\n        // valueLoadString(v ref, b []byte)\n        'syscall/js.valueLoadString': (v_addr, slice_ptr, slice_len, slice_cap) => {\n          const str = loadValue(v_addr)\n          loadSlice(slice_ptr, slice_len, slice_cap).set(str)\n        },\n\n        // func valueInstanceOf(v ref, t ref) bool\n        'syscall/js.valueInstanceOf': (v_addr, t_addr) => {\n          return loadValue(v_addr) instanceof loadValue(t_addr)\n        },\n\n        // func copyBytesToGo(dst []byte, src ref) (int, bool)\n        'syscall/js.copyBytesToGo': (ret_addr, dest_addr, dest_len, dest_cap, source_addr) => {\n          let num_bytes_copied_addr = ret_addr\n          let returned_status_addr = ret_addr + 4 // Address of returned boolean status variable\n\n          const dst = loadSlice(dest_addr, dest_len)\n          const src = loadValue(source_addr)\n          if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {\n            mem().setUint8(returned_status_addr, 0) // Return \"not ok\" status\n            return\n          }\n          const toCopy = src.subarray(0, dst.length)\n          dst.set(toCopy)\n          setInt64(num_bytes_copied_addr, toCopy.length)\n          mem().setUint8(returned_status_addr, 1) // Return \"ok\" status\n        },\n\n        // copyBytesToJS(dst ref, src []byte) (int, bool)\n        // Originally copied from upstream Go project, then modified:\n        //   https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416\n        'syscall/js.copyBytesToJS': (ret_addr, dest_addr, source_addr, source_len, source_cap) => {\n          let num_bytes_copied_addr = ret_addr\n          let returned_status_addr = ret_addr + 4 // Address of returned boolean status variable\n\n          const dst = loadValue(dest_addr)\n          const src = loadSlice(source_addr, source_len)\n          if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {\n            mem().setUint8(returned_status_addr, 0) // Return \"not ok\" status\n            return\n          }\n          const toCopy = src.subarray(0, dst.length)\n          dst.set(toCopy)\n          setInt64(num_bytes_copied_addr, toCopy.length)\n          mem().setUint8(returned_status_addr, 1) // Return \"ok\" status\n        },\n      },\n    }\n  }\n\n  async run(instance) {\n    this._inst = instance\n    this._values = [\n      // JS values that Go currently has references to, indexed by reference id\n      NaN,\n      0,\n      null,\n      true,\n      false,\n      global,\n      this,\n    ]\n    this._goRefCounts = [] // number of references that Go has to a JS value, indexed by reference id\n    this._ids = new Map() // mapping from JS values to reference ids\n    this._idPool = [] // unused ids that have been garbage collected\n    this.exited = false // whether the Go program has exited\n\n    const mem = new DataView(this._inst.exports.memory.buffer)\n\n    while (true) {\n      const callbackPromise = new Promise((resolve) => {\n        this._resolveCallbackPromise = () => {\n          if (this.exited) {\n            throw new Error('bad callback: Go program has already exited')\n          }\n          setTimeout(resolve, 0) // make sure it is asynchronous\n        }\n      })\n      this._inst.exports._start()\n      if (this.exited) {\n        break\n      }\n      await callbackPromise\n    }\n  }\n\n  _resume() {\n    if (this.exited) {\n      throw new Error('Go program has already exited')\n    }\n    this._inst.exports.resume()\n    if (this.exited) {\n      this._resolveExitPromise()\n    }\n  }\n\n  _makeFuncWrapper(id) {\n    const go = this\n    return function () {\n      const event = { id: id, this: this, args: arguments }\n      go._pendingEvent = event\n      go._resume()\n      return event.result\n    }\n  }\n}\n\nexport default global.Go\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+import { ICloudbase } from '@cloudbase/types';
+export declare function registerContainers(app: Pick<ICloudbase, 'registerComponent'>): void;