@meritt/gsx-wasm 0.0.0-stage → 0.1.0

package/gsx.js

@@ -0,0 +1,727 @@
+export const load = (() => {
+  const VERSION = '0.1.0';
+
+  class ParseError extends Error {
+    constructor({ code, range, details }) {
+      super(range === null ? code : `${code} at ${range[0]}..${range[1]}`);
+      this.name = 'ParseError';
+      this.code = code;
+      this.range = range;
+      this.details = details;
+    }
+  }
+
+  class VersionError extends Error {
+    constructor(found) {
+      super(
+        `gsx.wasm is ${found === undefined ? 'from another build' : `version ${found}`}, gsx.js is version ${VERSION}`
+      );
+      this.name = 'VersionError';
+      this.expected = VERSION;
+      this.found = found;
+    }
+  }
+
+  function firstLoneSurrogate(text) {
+    for (let i = 0; i < text.length; i++) {
+      const unit = text.charCodeAt(i);
+
+      if (unit >= 0xd800 && unit <= 0xdbff) {
+        const next = text.charCodeAt(i + 1);
+
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          i++;
+          continue;
+        }
+
+        return i;
+      }
+
+      if (unit >= 0xdc00 && unit <= 0xdfff) {
+        return i;
+      }
+    }
+
+    return text.length;
+  }
+
+  function invalid(text) {
+    if (typeof text !== 'string') {
+      throw new TypeError('text must be a string');
+    }
+
+    if (text.isWellFormed()) return null;
+
+    const at = firstLoneSurrogate(text);
+    return [at, text.charCodeAt(at)];
+  }
+
+  function split(media) {
+    const ids = [];
+    const covers = [];
+
+    for (const { id, cover } of media) {
+      if (typeof id !== 'string' || !id.isWellFormed()) {
+        throw new TypeError('media id must be a well-formed string');
+      }
+
+      if (cover != null && (typeof cover !== 'string' || !cover.isWellFormed())) {
+        throw new TypeError('media cover must be a well-formed string, null or undefined');
+      }
+
+      ids.push(id);
+      covers.push(cover ?? undefined);
+    }
+
+    return [ids, covers];
+  }
+
+  const KINDS = { image: 1, video: 2 };
+  const FORMATS = { image: 0, gif: 1, video: 2, audio: 3 };
+
+  function mediaFacts(items) {
+    const ids = [];
+    const formats = [];
+    const alts = [];
+    const flags = [];
+
+    for (const { id, format, alt = null, spoiler = false, inline = false } of items) {
+      if (typeof id !== 'string' || !id.isWellFormed()) {
+        throw new TypeError('facts.items id must be a well-formed string');
+      }
+
+      if (!Object.hasOwn(FORMATS, format)) {
+        throw new TypeError("facts.items format must be 'image', 'gif', 'video' or 'audio'");
+      }
+
+      if (alt !== null && (typeof alt !== 'string' || !alt.isWellFormed())) {
+        throw new TypeError('facts.items alt must be a well-formed string or null');
+      }
+
+      if (typeof spoiler !== 'boolean' || typeof inline !== 'boolean') {
+        throw new TypeError('facts.items spoiler and inline must be booleans');
+      }
+
+      ids.push(id);
+      formats.push(FORMATS[format]);
+      alts.push(alt ?? undefined);
+      flags.push(Number(spoiler) | (Number(inline) << 1));
+    }
+
+    return [ids, Uint8Array.from(formats), alts, Uint8Array.from(flags)];
+  }
+
+  function count(value, name) {
+    if (value == null) return undefined;
+
+    if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
+      throw new RangeError(`${name} must be an integer from 0 to 2^32 - 1`);
+    }
+
+    return value;
+  }
+
+  function unwrap(json, key) {
+    const result = JSON.parse(json);
+
+    if (result.error) {
+      throw new ParseError(result.error);
+    }
+
+    return result[key];
+  }
+
+  function bind(wasm, memory) {
+    const encoder = new TextEncoder();
+    let bytes = new Uint8Array(0);
+
+    function pass(text) {
+      const capacity = text.length * 3;
+      const at = wasm.input(capacity);
+      if (bytes.buffer !== memory.buffer) bytes = new Uint8Array(memory.buffer);
+      return encoder.encodeInto(text, bytes.subarray(at, at + capacity)).written;
+    }
+
+    function parseJSON(text, media = []) {
+      const entries = split(media);
+      const at = invalid(text);
+      if (at) return wasm.invalidText(...at);
+
+      return wasm.parse(pass(text), ...entries);
+    }
+
+    function serializeJSON(text, media = []) {
+      const entries = split(media);
+      const at = invalid(text);
+      if (at) return wasm.invalidText(...at);
+
+      return wasm.serialize(pass(text), ...entries);
+    }
+
+    function projectJSON(text, target, facts = {}, media = []) {
+      if (typeof target !== 'string') {
+        throw new TypeError('target must be a string');
+      }
+
+      const { title = null, entitiesAllowed = false, items = [] } = facts;
+      const kind = facts.media == null ? 0 : KINDS[facts.media];
+
+      if (kind === undefined) {
+        throw new TypeError("facts.media must be 'image', 'video', null or undefined");
+      }
+
+      if (title !== null && (typeof title !== 'string' || !title.isWellFormed())) {
+        throw new TypeError('facts.title must be a well-formed string or null');
+      }
+
+      if (typeof entitiesAllowed !== 'boolean') {
+        throw new TypeError('facts.entitiesAllowed must be a boolean');
+      }
+
+      const entries = split(media);
+      const described = mediaFacts(items);
+      const at = invalid(text);
+      if (at) return wasm.invalidText(...at);
+
+      return wasm.project(
+        pass(text),
+        ...entries,
+        target,
+        kind,
+        count(facts.mediaCount, 'facts.mediaCount') ?? 0,
+        title ?? undefined,
+        count(facts.maxCharacters, 'facts.maxCharacters'),
+        count(facts.charactersReservedPerUrl, 'facts.charactersReservedPerUrl'),
+        count(facts.captionLimit, 'facts.captionLimit'),
+        entitiesAllowed,
+        ...described
+      );
+    }
+
+    let listed;
+
+    return {
+      parse: (text, media) => unwrap(parseJSON(text, media), 'document'),
+      parseJSON,
+      serialize: (text, media) => unwrap(serializeJSON(text, media), 'serialized'),
+      serializeJSON,
+      project: (text, target, facts, media) => unwrap(projectJSON(text, target, facts, media), 'projection'),
+      projectJSON,
+      targets: () => (listed ??= Object.freeze(JSON.parse(wasm.targets()).targets.map(Object.freeze))),
+    };
+  }
+
+  function glue() {
+    let wasm_bindgen = (function(exports) {
+    let script_src;
+    if (typeof document !== 'undefined' && document.currentScript !== null) {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+
+    /**
+     * @param {number} capacity
+     * @returns {number}
+     */
+    function input(capacity) {
+        const ret = wasm.input(capacity);
+        return ret >>> 0;
+    }
+    exports.input = input;
+
+    /**
+     * @param {number} offset
+     * @param {number} unit
+     * @returns {string}
+     */
+    function invalidText(offset, unit) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.invalidText(offset, unit);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.invalidText = invalidText;
+
+    /**
+     * @param {number} len
+     * @param {string[]} ids
+     * @param {any[]} covers
+     * @returns {string}
+     */
+    function parse(len, ids, covers) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const val3 = +len;
+            let ptr0, len0, ptr1, len1;
+            try {
+                ptr0 = passArrayJsValueToWasm0(ids, wasm.__wbindgen_malloc);
+                len0 = WASM_VECTOR_LEN;
+                ptr1 = passArrayJsValueToWasm0(covers, wasm.__wbindgen_malloc);
+                len1 = WASM_VECTOR_LEN;
+            } catch (e) {
+                if (ptr1) { wasm.__externref_drop_slice(ptr1, len1); wasm.__wbindgen_free(ptr1, len1 * 4, 4); }
+                if (ptr0) { wasm.__externref_drop_slice(ptr0, len0); wasm.__wbindgen_free(ptr0, len0 * 4, 4); }
+                throw e;
+            }
+            const ret = wasm.parse(val3, ptr0, len0, ptr1, len1);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    exports.parse = parse;
+
+    /**
+     * @param {number} len
+     * @param {string[]} ids
+     * @param {any[]} covers
+     * @param {string} target
+     * @param {number} kind
+     * @param {number} count
+     * @param {string | null | undefined} title
+     * @param {number | null | undefined} max_characters
+     * @param {number | null | undefined} characters_reserved_per_url
+     * @param {number | null | undefined} caption_limit
+     * @param {boolean} entities_allowed
+     * @param {string[]} item_ids
+     * @param {Uint8Array | number[]} item_formats
+     * @param {any[]} item_alts
+     * @param {Uint8Array | number[]} item_flags
+     * @returns {string}
+     */
+    function project(len, ids, covers, target, kind, count, title, max_characters, characters_reserved_per_url, caption_limit, entities_allowed, item_ids, item_formats, item_alts, item_flags) {
+        let deferred17_0;
+        let deferred17_1;
+        try {
+            const val9 = +len;
+            const val10 = +kind;
+            const val11 = +count;
+            const val12 = +(isLikeNone(max_characters) ? Number.MAX_SAFE_INTEGER : (max_characters) >>> 0);
+            const val13 = +(isLikeNone(characters_reserved_per_url) ? Number.MAX_SAFE_INTEGER : (characters_reserved_per_url) >>> 0);
+            const val14 = +(isLikeNone(caption_limit) ? Number.MAX_SAFE_INTEGER : (caption_limit) >>> 0);
+            const val15 = +entities_allowed;
+            let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7;
+            try {
+                ptr0 = passArrayJsValueToWasm0(ids, wasm.__wbindgen_malloc);
+                len0 = WASM_VECTOR_LEN;
+                ptr1 = passArrayJsValueToWasm0(covers, wasm.__wbindgen_malloc);
+                len1 = WASM_VECTOR_LEN;
+                ptr2 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+                len2 = WASM_VECTOR_LEN;
+                ptr3 = isLikeNone(title) ? 0 : passStringToWasm0(title, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+                len3 = WASM_VECTOR_LEN;
+                ptr4 = passArrayJsValueToWasm0(item_ids, wasm.__wbindgen_malloc);
+                len4 = WASM_VECTOR_LEN;
+                ptr5 = passArray8ToWasm0(item_formats, wasm.__wbindgen_malloc);
+                len5 = WASM_VECTOR_LEN;
+                ptr6 = passArrayJsValueToWasm0(item_alts, wasm.__wbindgen_malloc);
+                len6 = WASM_VECTOR_LEN;
+                ptr7 = passArray8ToWasm0(item_flags, wasm.__wbindgen_malloc);
+                len7 = WASM_VECTOR_LEN;
+            } catch (e) {
+                if (ptr7) { wasm.__wbindgen_free(ptr7, len7 * 1, 1); }
+                if (ptr6) { wasm.__externref_drop_slice(ptr6, len6); wasm.__wbindgen_free(ptr6, len6 * 4, 4); }
+                if (ptr5) { wasm.__wbindgen_free(ptr5, len5 * 1, 1); }
+                if (ptr4) { wasm.__externref_drop_slice(ptr4, len4); wasm.__wbindgen_free(ptr4, len4 * 4, 4); }
+                if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+                if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+                if (ptr1) { wasm.__externref_drop_slice(ptr1, len1); wasm.__wbindgen_free(ptr1, len1 * 4, 4); }
+                if (ptr0) { wasm.__externref_drop_slice(ptr0, len0); wasm.__wbindgen_free(ptr0, len0 * 4, 4); }
+                throw e;
+            }
+            const ret = wasm.project(val9, ptr0, len0, ptr1, len1, ptr2, len2, val10, val11, ptr3, len3, val12, val13, val14, val15, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7);
+            var ptr16 = ret[0];
+            var len16 = ret[1];
+            if (ret[3]) {
+                ptr16 = 0; len16 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred17_0 = ptr16;
+            deferred17_1 = len16;
+            return getStringFromWasm0(ptr16, len16);
+        } finally {
+            wasm.__wbindgen_free(deferred17_0, deferred17_1, 1);
+        }
+    }
+    exports.project = project;
+
+    /**
+     * @param {number} len
+     * @param {string[]} ids
+     * @param {any[]} covers
+     * @returns {string}
+     */
+    function serialize(len, ids, covers) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const val3 = +len;
+            let ptr0, len0, ptr1, len1;
+            try {
+                ptr0 = passArrayJsValueToWasm0(ids, wasm.__wbindgen_malloc);
+                len0 = WASM_VECTOR_LEN;
+                ptr1 = passArrayJsValueToWasm0(covers, wasm.__wbindgen_malloc);
+                len1 = WASM_VECTOR_LEN;
+            } catch (e) {
+                if (ptr1) { wasm.__externref_drop_slice(ptr1, len1); wasm.__wbindgen_free(ptr1, len1 * 4, 4); }
+                if (ptr0) { wasm.__externref_drop_slice(ptr0, len0); wasm.__wbindgen_free(ptr0, len0 * 4, 4); }
+                throw e;
+            }
+            const ret = wasm.serialize(val3, ptr0, len0, ptr1, len1);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    exports.serialize = serialize;
+
+    /**
+     * @returns {string}
+     */
+    function targets() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.targets();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.targets = targets;
+
+    /**
+     * @returns {string}
+     */
+    function version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.version();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.version = version;
+    function __wbg_get_imports() {
+        const import0 = {
+            __proto__: null,
+            __wbg_Error_208446807d0d1e30: function(arg0, arg1) {
+                const ret = Error(getStringFromWasm0(arg0, arg1));
+                return ret;
+            },
+            __wbg___wbindgen_string_get_7ce8eee7fd327545: function(arg0, arg1) {
+                const obj = arg1;
+                const ret = typeof(obj) === 'string' ? obj : undefined;
+                var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+                var len1 = WASM_VECTOR_LEN;
+                getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 1, len1, true);
+                getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 0, ptr1, true);
+            },
+            __wbg___wbindgen_throw_4c88d8bf264fd984: function(arg0, arg1) {
+                throw new Error(getStringFromWasm0(arg0, arg1));
+            },
+            __wbindgen_init_externref_table: function() {
+                const table = wasm.__wbindgen_externrefs;
+                table.set(0, undefined);
+                table.set(1024, undefined);
+                table.set(1025, null);
+                table.set(1026, true);
+                table.set(1027, false);
+            },
+        };
+        return {
+            __proto__: null,
+            "./gsx_wasm_bg.js": import0,
+        };
+    }
+
+    function addToExternrefTable0(obj) {
+        const idx = wasm.__externref_table_alloc();
+        wasm.__wbindgen_externrefs.set(idx, obj);
+        return idx;
+    }
+
+    let cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+        if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+            cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+        }
+        return cachedDataViewMemory0;
+    }
+
+    function getStringFromWasm0(ptr, len) {
+        ptr = ptr >>> 0;
+        return decodeText(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+
+    let cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+        if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+            cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachedUint8ArrayMemory0;
+    }
+
+    function isLikeNone(x) {
+        return x === undefined || x === null;
+    }
+
+    function passArray8ToWasm0(arg, malloc) {
+        const ptr = malloc(arg.length * 1, 1) >>> 0;
+        getUint8ArrayMemory0().set(arg, ptr / 1);
+        WASM_VECTOR_LEN = arg.length;
+        return ptr;
+    }
+
+    function passArrayJsValueToWasm0(array, malloc) {
+        const ptr = malloc(array.length * 4, 4) >>> 0;
+        for (let i = 0; i < array.length; i++) {
+            const add = addToExternrefTable0(array[i]);
+            getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+        }
+        WASM_VECTOR_LEN = array.length;
+        return ptr;
+    }
+
+    function passStringToWasm0(arg, malloc, realloc) {
+        if (realloc === undefined) {
+            const buf = cachedTextEncoder.encode(arg);
+            const ptr = malloc(buf.length, 1) >>> 0;
+            getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+            WASM_VECTOR_LEN = buf.length;
+            return ptr;
+        }
+
+        let len = arg.length;
+        let ptr = malloc(len, 1) >>> 0;
+
+        const mem = getUint8ArrayMemory0();
+
+        let offset = 0;
+
+        for (; offset < len; offset++) {
+            const code = arg.charCodeAt(offset);
+            if (code > 0x7F) break;
+            mem[ptr + offset] = code;
+        }
+        if (offset !== len) {
+            if (offset !== 0) {
+                arg = arg.slice(offset);
+            }
+            ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+            const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+            const ret = cachedTextEncoder.encodeInto(arg, view);
+
+            offset += ret.written;
+            ptr = realloc(ptr, len, offset, 1) >>> 0;
+        }
+
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+    }
+
+    function takeFromExternrefTable0(idx) {
+        const value = wasm.__wbindgen_externrefs.get(idx);
+        wasm.__externref_table_dealloc(idx);
+        return value;
+    }
+
+    let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
+    cachedTextDecoder.decode();
+    function decodeText(bytes) {
+        return cachedTextDecoder.decode(bytes);
+    }
+
+    const cachedTextEncoder = new TextEncoder();
+
+    if (!('encodeInto' in cachedTextEncoder)) {
+        cachedTextEncoder.encodeInto = function (arg, view) {
+            const buf = cachedTextEncoder.encode(arg);
+            view.set(buf);
+            return {
+                read: arg.length,
+                written: buf.length
+            };
+        };
+    }
+
+    let WASM_VECTOR_LEN = 0;
+
+    let wasmModule, wasmInstance, wasm;
+    function __wbg_finalize_init(instance, module) {
+        wasmInstance = instance;
+        wasm = instance.exports;
+        wasmModule = module;
+        cachedDataViewMemory0 = null;
+        cachedUint8ArrayMemory0 = null;
+        wasm.__wbindgen_start();
+        return wasm;
+    }
+
+    async function __wbg_load(module, imports) {
+        if (typeof Response === 'function' && module instanceof Response) {
+            if (!module.ok) {
+                throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+            }
+
+            if (typeof WebAssembly.instantiateStreaming === 'function') {
+                try {
+                    return await WebAssembly.instantiateStreaming(module, imports);
+                } catch (e) {
+                    const validResponse = expectedResponseType(module.type);
+
+                    if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                        console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                    } else { throw e; }
+                }
+            }
+
+            const bytes = await module.arrayBuffer();
+            return await WebAssembly.instantiate(bytes, imports);
+        } else {
+            const instance = await WebAssembly.instantiate(module, imports);
+
+            if (instance instanceof WebAssembly.Instance) {
+                return { instance, module };
+            } else {
+                return instance;
+            }
+        }
+
+        function expectedResponseType(type) {
+            switch (type) {
+                case 'basic': case 'cors': case 'default': return true;
+            }
+            return false;
+        }
+    }
+
+    function initSync(module) {
+        if (wasm !== undefined) return wasm;
+
+
+        if (module !== undefined) {
+            if (Object.getPrototypeOf(module) === Object.prototype) {
+                ({module} = module)
+            } else {
+                console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+            }
+        }
+
+        const imports = __wbg_get_imports();
+        if (!(module instanceof WebAssembly.Module)) {
+            module = new WebAssembly.Module(module);
+        }
+        const instance = new WebAssembly.Instance(module, imports);
+        return __wbg_finalize_init(instance, module);
+    }
+
+    let __wbg_init_promise;
+    async function __wbg_init(module_or_path) {
+        if (wasm !== undefined) return wasm;
+        if (__wbg_init_promise === undefined) {
+            __wbg_init_promise = __wbg_init_once(module_or_path);
+            __wbg_init_promise.catch(() => { __wbg_init_promise = undefined; });
+        }
+        return __wbg_init_promise;
+    }
+
+    async function __wbg_init_once(module_or_path) {
+
+        if (module_or_path !== undefined) {
+            if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+                ({module_or_path} = module_or_path)
+            } else {
+                console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+            }
+        }
+
+        if (module_or_path === undefined && script_src !== undefined) {
+            module_or_path = script_src.replace(/\.js$/, "_bg.wasm");
+        }
+        const imports = __wbg_get_imports();
+
+        if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+            module_or_path = fetch(module_or_path);
+        }
+
+        const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+        return __wbg_finalize_init(instance, module);
+    }
+
+    return Object.assign(__wbg_init, { initSync }, exports);
+})({ __proto__: null });
+    return wasm_bindgen;
+  }
+
+  async function compile(source) {
+    if (source instanceof WebAssembly.Module) return source;
+    if (typeof source === 'string') source = new URL(source, import.meta.url);
+    if (source instanceof URL) {
+      if (source.protocol === 'file:') {
+        const { readFile } = await import('node:fs/promises');
+        return WebAssembly.compile(await readFile(source));
+      }
+      source = fetch(source);
+    }
+    if (source instanceof Promise || (typeof Response === 'function' && source instanceof Response)) {
+      return WebAssembly.compileStreaming(source);
+    }
+    return WebAssembly.compile(source);
+  }
+
+  return async function load(source = new URL('./gsx.wasm', import.meta.url)) {
+    const module = await compile(source);
+    const wasm = glue();
+
+    if (!WebAssembly.Module.exports(module).some(({ name }) => name === 'version')) {
+      throw new VersionError(undefined);
+    }
+
+    let exports;
+
+    try {
+      exports = wasm.initSync({ module });
+    } catch (error) {
+      throw error instanceof WebAssembly.LinkError ? new VersionError(undefined) : error;
+    }
+
+    const found = wasm.version();
+
+    if (found !== VERSION) {
+      throw new VersionError(found);
+    }
+
+    return Object.freeze({ ...bind(wasm, exports.memory), VERSION, ParseError, VersionError });
+  };
+})();