Spaces:
Duplicated from radames/Candle-T5-Generation-Wasm

jbochi
/

Candle-CoEdIT-Wasm

Running

App Files Files Community

Candle-CoEdIT-Wasm / build /m.js

jbochi's picture

Change models to CoEdIT

a10bb32 verified 9 months ago

raw history blame contribute delete

No virus

24.5 kB

	let wasm;

	const heap = new Array(128).fill(undefined);

	heap.push(undefined, null, true, false);

	function getObject(idx) { return heap[idx]; }

	let WASM_VECTOR_LEN = 0;

	let cachedUint8Memory0 = null;

	function getUint8Memory0() {
	if (cachedUint8Memory0 === null \|\| cachedUint8Memory0.byteLength === 0) {
	cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
	}
	return cachedUint8Memory0;
	}

	const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );

	const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
	? function (arg, view) {
	return cachedTextEncoder.encodeInto(arg, view);
	}
	: function (arg, view) {
	const buf = cachedTextEncoder.encode(arg);
	view.set(buf);
	return {
	read: arg.length,
	written: buf.length
	};
	});

	function passStringToWasm0(arg, malloc, realloc) {

	if (realloc === undefined) {
	const buf = cachedTextEncoder.encode(arg);
	const ptr = malloc(buf.length, 1) >>> 0;
	getUint8Memory0().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 = getUint8Memory0();

	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 = getUint8Memory0().subarray(ptr + offset, ptr + len);
	const ret = encodeString(arg, view);

	offset += ret.written;
	}

	WASM_VECTOR_LEN = offset;
	return ptr;
	}

	function isLikeNone(x) {
	return x === undefined \|\| x === null;
	}

	let cachedInt32Memory0 = null;

	function getInt32Memory0() {
	if (cachedInt32Memory0 === null \|\| cachedInt32Memory0.byteLength === 0) {
	cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
	}
	return cachedInt32Memory0;
	}

	let heap_next = heap.length;

	function dropObject(idx) {
	if (idx < 132) return;
	heap[idx] = heap_next;
	heap_next = idx;
	}

	function takeObject(idx) {
	const ret = getObject(idx);
	dropObject(idx);
	return ret;
	}

	const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );

	if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };

	function getStringFromWasm0(ptr, len) {
	ptr = ptr >>> 0;
	return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
	}

	function addHeapObject(obj) {
	if (heap_next === heap.length) heap.push(heap.length + 1);
	const idx = heap_next;
	heap_next = heap[idx];

	heap[idx] = obj;
	return idx;
	}

	let cachedFloat64Memory0 = null;

	function getFloat64Memory0() {
	if (cachedFloat64Memory0 === null \|\| cachedFloat64Memory0.byteLength === 0) {
	cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
	}
	return cachedFloat64Memory0;
	}

	let cachedBigInt64Memory0 = null;

	function getBigInt64Memory0() {
	if (cachedBigInt64Memory0 === null \|\| cachedBigInt64Memory0.byteLength === 0) {
	cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
	}
	return cachedBigInt64Memory0;
	}

	function debugString(val) {
	// primitive types
	const type = typeof val;
	if (type == 'number' \|\| type == 'boolean' \|\| val == null) {
	return `${val}`;
	}
	if (type == 'string') {
	return `"${val}"`;
	}
	if (type == 'symbol') {
	const description = val.description;
	if (description == null) {
	return 'Symbol';
	} else {
	return `Symbol(${description})`;
	}
	}
	if (type == 'function') {
	const name = val.name;
	if (typeof name == 'string' && name.length > 0) {
	return `Function(${name})`;
	} else {
	return 'Function';
	}
	}
	// objects
	if (Array.isArray(val)) {
	const length = val.length;
	let debug = '[';
	if (length > 0) {
	debug += debugString(val[0]);
	}
	for(let i = 1; i < length; i++) {
	debug += ', ' + debugString(val[i]);
	}
	debug += ']';
	return debug;
	}
	// Test for built-in
	const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
	let className;
	if (builtInMatches.length > 1) {
	className = builtInMatches[1];
	} else {
	// Failed to match the standard '[object ClassName]'
	return toString.call(val);
	}
	if (className == 'Object') {
	// we're a user defined class or Object
	// JSON.stringify avoids problems with cycles, and is generally much
	// easier than looping through ownProperties of `val`.
	try {
	return 'Object(' + JSON.stringify(val) + ')';
	} catch (_) {
	return 'Object';
	}
	}
	// errors
	if (val instanceof Error) {
	return `${val.name}: ${val.message}\n${val.stack}`;
	}
	// TODO we could test for more things here, like `Set`s and `Map`s.
	return className;
	}

	function passArray8ToWasm0(arg, malloc) {
	const ptr = malloc(arg.length * 1, 1) >>> 0;
	getUint8Memory0().set(arg, ptr / 1);
	WASM_VECTOR_LEN = arg.length;
	return ptr;
	}

	function handleError(f, args) {
	try {
	return f.apply(this, args);
	} catch (e) {
	wasm.__wbindgen_exn_store(addHeapObject(e));
	}
	}
	/**
	*/
	export class ModelConditionalGeneration {

	static __wrap(ptr) {
	ptr = ptr >>> 0;
	const obj = Object.create(ModelConditionalGeneration.prototype);
	obj.__wbg_ptr = ptr;

	return obj;
	}

	__destroy_into_raw() {
	const ptr = this.__wbg_ptr;
	this.__wbg_ptr = 0;

	return ptr;
	}

	free() {
	const ptr = this.__destroy_into_raw();
	wasm.__wbg_modelconditionalgeneration_free(ptr);
	}
	/**
	* @param {Uint8Array} weights
	* @param {Uint8Array} tokenizer
	* @param {Uint8Array} config
	*/
	constructor(weights, tokenizer, config) {
	try {
	const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
	const ptr0 = passArray8ToWasm0(weights, wasm.__wbindgen_malloc);
	const len0 = WASM_VECTOR_LEN;
	const ptr1 = passArray8ToWasm0(tokenizer, wasm.__wbindgen_malloc);
	const len1 = WASM_VECTOR_LEN;
	const ptr2 = passArray8ToWasm0(config, wasm.__wbindgen_malloc);
	const len2 = WASM_VECTOR_LEN;
	wasm.modelconditionalgeneration_load(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
	var r0 = getInt32Memory0()[retptr / 4 + 0];
	var r1 = getInt32Memory0()[retptr / 4 + 1];
	var r2 = getInt32Memory0()[retptr / 4 + 2];
	if (r2) {
	throw takeObject(r1);
	}
	return ModelConditionalGeneration.__wrap(r0);
	} finally {
	wasm.__wbindgen_add_to_stack_pointer(16);
	}
	}
	/**
	* @param {any} input
	* @returns {any}
	*/
	decode(input) {
	try {
	const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
	wasm.modelconditionalgeneration_decode(retptr, this.__wbg_ptr, addHeapObject(input));
	var r0 = getInt32Memory0()[retptr / 4 + 0];
	var r1 = getInt32Memory0()[retptr / 4 + 1];
	var r2 = getInt32Memory0()[retptr / 4 + 2];
	if (r2) {
	throw takeObject(r1);
	}
	return takeObject(r0);
	} finally {
	wasm.__wbindgen_add_to_stack_pointer(16);
	}
	}
	}
	/**
	*/
	export class ModelEncoder {

	static __wrap(ptr) {
	ptr = ptr >>> 0;
	const obj = Object.create(ModelEncoder.prototype);
	obj.__wbg_ptr = ptr;

	return obj;
	}

	__destroy_into_raw() {
	const ptr = this.__wbg_ptr;
	this.__wbg_ptr = 0;

	return ptr;
	}

	free() {
	const ptr = this.__destroy_into_raw();
	wasm.__wbg_modelencoder_free(ptr);
	}
	/**
	* @param {Uint8Array} weights
	* @param {Uint8Array} tokenizer
	* @param {Uint8Array} config
	*/
	constructor(weights, tokenizer, config) {
	try {
	const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
	const ptr0 = passArray8ToWasm0(weights, wasm.__wbindgen_malloc);
	const len0 = WASM_VECTOR_LEN;
	const ptr1 = passArray8ToWasm0(tokenizer, wasm.__wbindgen_malloc);
	const len1 = WASM_VECTOR_LEN;
	const ptr2 = passArray8ToWasm0(config, wasm.__wbindgen_malloc);
	const len2 = WASM_VECTOR_LEN;
	wasm.modelencoder_load(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
	var r0 = getInt32Memory0()[retptr / 4 + 0];
	var r1 = getInt32Memory0()[retptr / 4 + 1];
	var r2 = getInt32Memory0()[retptr / 4 + 2];
	if (r2) {
	throw takeObject(r1);
	}
	return ModelEncoder.__wrap(r0);
	} finally {
	wasm.__wbindgen_add_to_stack_pointer(16);
	}
	}
	/**
	* @param {any} input
	* @returns {any}
	*/
	decode(input) {
	try {
	const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
	wasm.modelencoder_decode(retptr, this.__wbg_ptr, addHeapObject(input));
	var r0 = getInt32Memory0()[retptr / 4 + 0];
	var r1 = getInt32Memory0()[retptr / 4 + 1];
	var r2 = getInt32Memory0()[retptr / 4 + 2];
	if (r2) {
	throw takeObject(r1);
	}
	return takeObject(r0);
	} finally {
	wasm.__wbindgen_add_to_stack_pointer(16);
	}
	}
	}

	async function __wbg_load(module, imports) {
	if (typeof Response === 'function' && module instanceof Response) {
	if (typeof WebAssembly.instantiateStreaming === 'function') {
	try {
	return await WebAssembly.instantiateStreaming(module, imports);

	} catch (e) {
	if (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 __wbg_get_imports() {
	const imports = {};
	imports.wbg = {};
	imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
	const obj = getObject(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;
	getInt32Memory0()[arg0 / 4 + 1] = len1;
	getInt32Memory0()[arg0 / 4 + 0] = ptr1;
	};
	imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
	takeObject(arg0);
	};
	imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
	const ret = new Error(getStringFromWasm0(arg0, arg1));
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_is_bigint = function(arg0) {
	const ret = typeof(getObject(arg0)) === 'bigint';
	return ret;
	};
	imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
	const ret = BigInt.asUintN(64, arg0);
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
	const ret = getObject(arg0) === getObject(arg1);
	return ret;
	};
	imports.wbg.__wbindgen_boolean_get = function(arg0) {
	const v = getObject(arg0);
	const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
	return ret;
	};
	imports.wbg.__wbindgen_is_object = function(arg0) {
	const val = getObject(arg0);
	const ret = typeof(val) === 'object' && val !== null;
	return ret;
	};
	imports.wbg.__wbindgen_is_undefined = function(arg0) {
	const ret = getObject(arg0) === undefined;
	return ret;
	};
	imports.wbg.__wbindgen_in = function(arg0, arg1) {
	const ret = getObject(arg0) in getObject(arg1);
	return ret;
	};
	imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
	const obj = getObject(arg1);
	const ret = typeof(obj) === 'number' ? obj : undefined;
	getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
	getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
	};
	imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
	const ret = getObject(arg0);
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
	const ret = getObject(arg0) == getObject(arg1);
	return ret;
	};
	imports.wbg.__wbg_String_4370c5505c674d30 = function(arg0, arg1) {
	const ret = String(getObject(arg1));
	const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
	const len1 = WASM_VECTOR_LEN;
	getInt32Memory0()[arg0 / 4 + 1] = len1;
	getInt32Memory0()[arg0 / 4 + 0] = ptr1;
	};
	imports.wbg.__wbindgen_number_new = function(arg0) {
	const ret = arg0;
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
	const ret = getStringFromWasm0(arg0, arg1);
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_getwithrefkey_d1f0d12f1f1b63ea = function(arg0, arg1) {
	const ret = getObject(arg0)[getObject(arg1)];
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_set_bd72c078edfa51ad = function(arg0, arg1, arg2) {
	getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
	};
	imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
	const ret = new Error();
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
	const ret = getObject(arg1).stack;
	const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
	const len1 = WASM_VECTOR_LEN;
	getInt32Memory0()[arg0 / 4 + 1] = len1;
	getInt32Memory0()[arg0 / 4 + 0] = ptr1;
	};
	imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
	let deferred0_0;
	let deferred0_1;
	try {
	deferred0_0 = arg0;
	deferred0_1 = arg1;
	console.error(getStringFromWasm0(arg0, arg1));
	} finally {
	wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
	}
	};
	imports.wbg.__wbg_log_d03200ce29166fbd = function(arg0, arg1) {
	console.log(getStringFromWasm0(arg0, arg1));
	};
	imports.wbg.__wbg_crypto_c48a774b022d20ac = function(arg0) {
	const ret = getObject(arg0).crypto;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_process_298734cf255a885d = function(arg0) {
	const ret = getObject(arg0).process;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_versions_e2e78e134e3e5d01 = function(arg0) {
	const ret = getObject(arg0).versions;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_node_1cd7a5d853dbea79 = function(arg0) {
	const ret = getObject(arg0).node;
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_is_string = function(arg0) {
	const ret = typeof(getObject(arg0)) === 'string';
	return ret;
	};
	imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) {
	const ret = getObject(arg0).msCrypto;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () {
	const ret = module.require;
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbindgen_is_function = function(arg0) {
	const ret = typeof(getObject(arg0)) === 'function';
	return ret;
	};
	imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) {
	getObject(arg0).getRandomValues(getObject(arg1));
	}, arguments) };
	imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) {
	getObject(arg0).randomFillSync(takeObject(arg1));
	}, arguments) };
	imports.wbg.__wbg_get_44be0491f933a435 = function(arg0, arg1) {
	const ret = getObject(arg0)[arg1 >>> 0];
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_length_fff51ee6522a1a18 = function(arg0) {
	const ret = getObject(arg0).length;
	return ret;
	};
	imports.wbg.__wbg_new_898a68150f225f2e = function() {
	const ret = new Array();
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_newnoargs_581967eacc0e2604 = function(arg0, arg1) {
	const ret = new Function(getStringFromWasm0(arg0, arg1));
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_next_526fc47e980da008 = function(arg0) {
	const ret = getObject(arg0).next;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_next_ddb3312ca1c4e32a = function() { return handleError(function (arg0) {
	const ret = getObject(arg0).next();
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_done_5c1f01fb660d73b5 = function(arg0) {
	const ret = getObject(arg0).done;
	return ret;
	};
	imports.wbg.__wbg_value_1695675138684bd5 = function(arg0) {
	const ret = getObject(arg0).value;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_iterator_97f0c81209c6c35a = function() {
	const ret = Symbol.iterator;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_get_97b561fb56f034b5 = function() { return handleError(function (arg0, arg1) {
	const ret = Reflect.get(getObject(arg0), getObject(arg1));
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_call_cb65541d95d71282 = function() { return handleError(function (arg0, arg1) {
	const ret = getObject(arg0).call(getObject(arg1));
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_new_b51585de1b234aff = function() {
	const ret = new Object();
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_self_1ff1d729e9aae938 = function() { return handleError(function () {
	const ret = self.self;
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_window_5f4faef6c12b79ec = function() { return handleError(function () {
	const ret = window.window;
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_globalThis_1d39714405582d3c = function() { return handleError(function () {
	const ret = globalThis.globalThis;
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_global_651f05c6a0944d1c = function() { return handleError(function () {
	const ret = global.global;
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_set_502d29070ea18557 = function(arg0, arg1, arg2) {
	getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
	};
	imports.wbg.__wbg_isArray_4c24b343cb13cfb1 = function(arg0) {
	const ret = Array.isArray(getObject(arg0));
	return ret;
	};
	imports.wbg.__wbg_instanceof_ArrayBuffer_39ac22089b74fddb = function(arg0) {
	let result;
	try {
	result = getObject(arg0) instanceof ArrayBuffer;
	} catch {
	result = false;
	}
	const ret = result;
	return ret;
	};
	imports.wbg.__wbg_call_01734de55d61e11d = function() { return handleError(function (arg0, arg1, arg2) {
	const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
	return addHeapObject(ret);
	}, arguments) };
	imports.wbg.__wbg_isSafeInteger_bb8e18dd21c97288 = function(arg0) {
	const ret = Number.isSafeInteger(getObject(arg0));
	return ret;
	};
	imports.wbg.__wbg_buffer_085ec1f694018c4f = function(arg0) {
	const ret = getObject(arg0).buffer;
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_newwithbyteoffsetandlength_6da8e527659b86aa = function(arg0, arg1, arg2) {
	const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_new_8125e318e6245eed = function(arg0) {
	const ret = new Uint8Array(getObject(arg0));
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_set_5cf90238115182c3 = function(arg0, arg1, arg2) {
	getObject(arg0).set(getObject(arg1), arg2 >>> 0);
	};
	imports.wbg.__wbg_length_72e2208bbc0efc61 = function(arg0) {
	const ret = getObject(arg0).length;
	return ret;
	};
	imports.wbg.__wbg_instanceof_Uint8Array_d8d9cb2b8e8ac1d4 = function(arg0) {
	let result;
	try {
	result = getObject(arg0) instanceof Uint8Array;
	} catch {
	result = false;
	}
	const ret = result;
	return ret;
	};
	imports.wbg.__wbg_newwithlength_e5d69174d6984cd7 = function(arg0) {
	const ret = new Uint8Array(arg0 >>> 0);
	return addHeapObject(ret);
	};
	imports.wbg.__wbg_subarray_13db269f57aa838d = function(arg0, arg1, arg2) {
	const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
	return addHeapObject(ret);
	};
	imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
	const v = getObject(arg1);
	const ret = typeof(v) === 'bigint' ? v : undefined;
	getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
	getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
	};
	imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
	const ret = debugString(getObject(arg1));
	const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
	const len1 = WASM_VECTOR_LEN;
	getInt32Memory0()[arg0 / 4 + 1] = len1;
	getInt32Memory0()[arg0 / 4 + 0] = ptr1;
	};
	imports.wbg.__wbindgen_throw = function(arg0, arg1) {
	throw new Error(getStringFromWasm0(arg0, arg1));
	};
	imports.wbg.__wbindgen_memory = function() {
	const ret = wasm.memory;
	return addHeapObject(ret);
	};

	return imports;
	}

	function __wbg_init_memory(imports, maybe_memory) {

	}

	function __wbg_finalize_init(instance, module) {
	wasm = instance.exports;
	__wbg_init.__wbindgen_wasm_module = module;
	cachedBigInt64Memory0 = null;
	cachedFloat64Memory0 = null;
	cachedInt32Memory0 = null;
	cachedUint8Memory0 = null;

	wasm.__wbindgen_start();
	return wasm;
	}

	function initSync(module) {
	if (wasm !== undefined) return wasm;

	const imports = __wbg_get_imports();

	__wbg_init_memory(imports);

	if (!(module instanceof WebAssembly.Module)) {
	module = new WebAssembly.Module(module);
	}

	const instance = new WebAssembly.Instance(module, imports);

	return __wbg_finalize_init(instance, module);
	}

	async function __wbg_init(input) {
	if (wasm !== undefined) return wasm;

	if (typeof input === 'undefined') {
	input = new URL('m_bg.wasm', import.meta.url);
	}
	const imports = __wbg_get_imports();

	if (typeof input === 'string' \|\| (typeof Request === 'function' && input instanceof Request) \|\| (typeof URL === 'function' && input instanceof URL)) {
	input = fetch(input);
	}

	__wbg_init_memory(imports);

	const { instance, module } = await __wbg_load(await input, imports);

	return __wbg_finalize_init(instance, module);
	}

	export { initSync }
	export default __wbg_init;