Create clash-client.js

clash-client.js

@@ -0,0 +1,1659 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 7:
+/***/ ((module) => {
+
+
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+	return Function.prototype.apply.call(target, receiver, args);
+  }
+
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+	return Object.getOwnPropertyNames(target)
+	  .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+	return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+}
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+	throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+	return defaultMaxListeners;
+  },
+  set: function(arg) {
+	if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+	  throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+	}
+	defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function() {
+
+  if (this._events === undefined ||
+	  this._events === Object.getPrototypeOf(this)._events) {
+	this._events = Object.create(null);
+	this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+	throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+	return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
+
+  var events = this._events;
+  if (events !== undefined)
+	doError = (doError && events.error === undefined);
+  else if (!doError)
+	return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+	var er;
+	if (args.length > 0)
+	  er = args[0];
+	if (er instanceof Error) {
+	  // Note: The comments on the `throw` lines are intentional, they show
+	  // up in Node's output if this results in an unhandled exception.
+	  throw er; // Unhandled 'error' event
+	}
+	// At least give some kind of context to the user
+	var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+	err.context = er;
+	throw err; // Unhandled 'error' event
+  }
+
+  var handler = events[type];
+
+  if (handler === undefined)
+	return false;
+
+  if (typeof handler === 'function') {
+	ReflectApply(handler, this, args);
+  } else {
+	var len = handler.length;
+	var listeners = arrayClone(handler, len);
+	for (var i = 0; i < len; ++i)
+	  ReflectApply(listeners[i], this, args);
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
+
+  checkListener(listener);
+
+  events = target._events;
+  if (events === undefined) {
+	events = target._events = Object.create(null);
+	target._eventsCount = 0;
+  } else {
+	// To avoid recursion in the case that type === "newListener"! Before
+	// adding it to the listeners, first emit "newListener".
+	if (events.newListener !== undefined) {
+	  target.emit('newListener', type,
+				  listener.listener ? listener.listener : listener);
+
+	  // Re-assign `events` because a newListener handler could have caused the
+	  // this._events to be assigned to a new object
+	  events = target._events;
+	}
+	existing = events[type];
+  }
+
+  if (existing === undefined) {
+	// Optimize the case of one listener. Don't need the extra array object.
+	existing = events[type] = listener;
+	++target._eventsCount;
+  } else {
+	if (typeof existing === 'function') {
+	  // Adding the second element, need to change to array.
+	  existing = events[type] =
+		prepend ? [listener, existing] : [existing, listener];
+	  // If we've already got an array, just append.
+	} else if (prepend) {
+	  existing.unshift(listener);
+	} else {
+	  existing.push(listener);
+	}
+
+	// Check for listener leak
+	m = _getMaxListeners(target);
+	if (m > 0 && existing.length > m && !existing.warned) {
+	  existing.warned = true;
+	  // No error code for this since it is a Warning
+	  // eslint-disable-next-line no-restricted-syntax
+	  var w = new Error('Possible EventEmitter memory leak detected. ' +
+						  existing.length + ' ' + String(type) + ' listeners ' +
+						  'added. Use emitter.setMaxListeners() to ' +
+						  'increase limit');
+	  w.name = 'MaxListenersExceededWarning';
+	  w.emitter = target;
+	  w.type = type;
+	  w.count = existing.length;
+	  ProcessEmitWarning(w);
+	}
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+	function prependListener(type, listener) {
+	  return _addListener(this, type, listener, true);
+	};
+
+function onceWrapper() {
+  if (!this.fired) {
+	this.target.removeListener(this.type, this.wrapFn);
+	this.fired = true;
+	if (arguments.length === 0)
+	  return this.listener.call(this.target);
+	return this.listener.apply(this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+	function prependOnceListener(type, listener) {
+	  checkListener(listener);
+	  this.prependListener(type, _onceWrap(this, type, listener));
+	  return this;
+	};
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+	function removeListener(type, listener) {
+	  var list, events, position, i, originalListener;
+
+	  checkListener(listener);
+
+	  events = this._events;
+	  if (events === undefined)
+		return this;
+
+	  list = events[type];
+	  if (list === undefined)
+		return this;
+
+	  if (list === listener || list.listener === listener) {
+		if (--this._eventsCount === 0)
+		  this._events = Object.create(null);
+		else {
+		  delete events[type];
+		  if (events.removeListener)
+			this.emit('removeListener', type, list.listener || listener);
+		}
+	  } else if (typeof list !== 'function') {
+		position = -1;
+
+		for (i = list.length - 1; i >= 0; i--) {
+		  if (list[i] === listener || list[i].listener === listener) {
+			originalListener = list[i].listener;
+			position = i;
+			break;
+		  }
+		}
+
+		if (position < 0)
+		  return this;
+
+		if (position === 0)
+		  list.shift();
+		else {
+		  spliceOne(list, position);
+		}
+
+		if (list.length === 1)
+		  events[type] = list[0];
+
+		if (events.removeListener !== undefined)
+		  this.emit('removeListener', type, originalListener || listener);
+	  }
+
+	  return this;
+	};
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+	function removeAllListeners(type) {
+	  var listeners, events, i;
+
+	  events = this._events;
+	  if (events === undefined)
+		return this;
+
+	  // not listening for removeListener, no need to emit
+	  if (events.removeListener === undefined) {
+		if (arguments.length === 0) {
+		  this._events = Object.create(null);
+		  this._eventsCount = 0;
+		} else if (events[type] !== undefined) {
+		  if (--this._eventsCount === 0)
+			this._events = Object.create(null);
+		  else
+			delete events[type];
+		}
+		return this;
+	  }
+
+	  // emit removeListener for all listeners on all events
+	  if (arguments.length === 0) {
+		var keys = Object.keys(events);
+		var key;
+		for (i = 0; i < keys.length; ++i) {
+		  key = keys[i];
+		  if (key === 'removeListener') continue;
+		  this.removeAllListeners(key);
+		}
+		this.removeAllListeners('removeListener');
+		this._events = Object.create(null);
+		this._eventsCount = 0;
+		return this;
+	  }
+
+	  listeners = events[type];
+
+	  if (typeof listeners === 'function') {
+		this.removeListener(type, listeners);
+	  } else if (listeners !== undefined) {
+		// LIFO order
+		for (i = listeners.length - 1; i >= 0; i--) {
+		  this.removeListener(type, listeners[i]);
+		}
+	  }
+
+	  return this;
+	};
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (events === undefined)
+	return [];
+
+  var evlistener = events[type];
+  if (evlistener === undefined)
+	return [];
+
+  if (typeof evlistener === 'function')
+	return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ?
+	unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+	return emitter.listenerCount(type);
+  } else {
+	return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events !== undefined) {
+	var evlistener = events[type];
+
+	if (typeof evlistener === 'function') {
+	  return 1;
+	} else if (evlistener !== undefined) {
+	  return evlistener.length;
+	}
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+	copy[i] = arr[i];
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+	list[index] = list[index + 1];
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+	ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+	function errorListener(err) {
+	  emitter.removeListener(name, resolver);
+	  reject(err);
+	}
+
+	function resolver() {
+	  if (typeof emitter.removeListener === 'function') {
+		emitter.removeListener('error', errorListener);
+	  }
+	  resolve([].slice.call(arguments));
+	};
+
+	eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+	if (name !== 'error') {
+	  addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+	}
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+	eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+	if (flags.once) {
+	  emitter.once(name, listener);
+	} else {
+	  emitter.on(name, listener);
+	}
+  } else if (typeof emitter.addEventListener === 'function') {
+	// EventTarget does not have `error` event semantics like Node
+	// EventEmitters, we do not listen for `error` events here.
+	emitter.addEventListener(name, function wrapListener(arg) {
+	  // IE does not have builtin `{ once: true }` support so we
+	  // have to do it manually.
+	  if (flags.once) {
+		emitter.removeEventListener(name, wrapListener);
+	  }
+	  listener(arg);
+	});
+  } else {
+	throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+/***/ }),
+
+/***/ 58:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__.p + "3fe9f0f9e254e41ba4b4.wasm";
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		var scriptUrl;
+/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+/******/ 		var document = __webpack_require__.g.document;
+/******/ 		if (!scriptUrl && document) {
+/******/ 			if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')
+/******/ 				scriptUrl = document.currentScript.src;
+/******/ 			if (!scriptUrl) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				if(scripts.length) {
+/******/ 					var i = scripts.length - 1;
+/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
+/******/ 				}
+/******/ 			}
+/******/ 		}
+/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
+/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
+/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+/******/ 		scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+/******/ 		__webpack_require__.p = scriptUrl;
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/jsonp chunk loading */
+/******/ 	(() => {
+/******/ 		__webpack_require__.b = document.baseURI || self.location.href;
+/******/ 		
+/******/ 		// object to store loaded and loading chunks
+/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ 		var installedChunks = {
+/******/ 			792: 0
+/******/ 		};
+/******/ 		
+/******/ 		// no chunk on demand loading
+/******/ 		
+/******/ 		// no prefetching
+/******/ 		
+/******/ 		// no preloaded
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 		
+/******/ 		// no on chunks loaded
+/******/ 		
+/******/ 		// no jsonp function
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+
+// EXTERNAL MODULE: ./node_modules/events/events.js
+var events = __webpack_require__(7);
+;// CONCATENATED MODULE: ./src/control.js
+
+class Control extends events.EventEmitter {
+	constructor() {
+		super();
+		this.state = null;
+		this.player_index = null;
+		this._assets_url = null;
+
+		this.addListener("state", (data) => {
+			this.state = data;
+		});
+		// When we receive log slices, when executing a move
+		this.addListener("gamelog", (logData) => {
+			// Ignore the log data and tell the backend we want the new state
+			this.emit("fetchState");
+		});
+		this.addListener("state:updated", () => {
+			this.emit("fetchState");
+		});
+		this.addListener("player", (player) => {
+			this.player_index = player.index;
+		});
+	}
+
+	receive_state() {
+		const state = this.state;
+		this.state = null;
+		return state;
+	}
+
+	receive_player_index() {
+		const index = this.player_index;
+		this.player_index = null;
+		return index;
+	}
+
+	send_move(move) {
+		this.emit("move", move);
+	}
+
+	send_ready() {
+		console.log("Sending ready");
+		this.emit("ready");
+	}
+
+	get assets_url() {
+		return this._assets_url;
+	}
+
+	set assets_url(value) {
+		this._assets_url = value;
+	}
+}
+
+function get_control() {
+	return window.clash_control;
+}
+
+
+;// CONCATENATED MODULE: ../dist/snippets/client-cda1b8d006d10648/js/src/control.js
+
+class control_Control extends events.EventEmitter {
+	constructor() {
+		super();
+		this.state = null;
+		this.player_index = null;
+		this._assets_url = null;
+
+		this.addListener("state", (data) => {
+			this.state = data;
+		});
+		// When we receive log slices, when executing a move
+		this.addListener("gamelog", (logData) => {
+			// Ignore the log data and tell the backend we want the new state
+			this.emit("fetchState");
+		});
+		this.addListener("state:updated", () => {
+			this.emit("fetchState");
+		});
+		this.addListener("player", (player) => {
+			this.player_index = player.index;
+		});
+	}
+
+	receive_state() {
+		const state = this.state;
+		this.state = null;
+		return state;
+	}
+
+	receive_player_index() {
+		const index = this.player_index;
+		this.player_index = null;
+		return index;
+	}
+
+	send_move(move) {
+		this.emit("move", move);
+	}
+
+	send_ready() {
+		console.log("Sending ready");
+		this.emit("ready");
+	}
+
+	get assets_url() {
+		return this._assets_url;
+	}
+
+	set assets_url(value) {
+		this._assets_url = value;
+	}
+}
+
+function control_get_control() {
+	return window.clash_control;
+}
+
+
+;// CONCATENATED MODULE: ../dist/remote_client.js
+
+
+let wasm; const set_wasm = (w) => wasm = w;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+function isLikeNone(x) {
+	return x === undefined || x === null;
+}
+
+function _assertNum(n) {
+	if (typeof(n) !== 'number') throw new Error(`expected a number argument, found ${typeof(n)}`);
+}
+
+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 _assertBoolean(n) {
+	if (typeof(n) !== 'boolean') {
+		throw new Error(`expected a boolean argument, found ${typeof(n)}`);
+	}
+}
+
+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(); };
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+		cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	}
+	return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+	if (heap_next === heap.length) heap.push(heap.length + 1);
+	const idx = heap_next;
+	heap_next = heap[idx];
+
+	if (typeof(heap_next) !== 'number') throw new Error('corrupt heap');
+
+	heap[idx] = obj;
+	return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+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 (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);
+
+	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 = encodeString(arg, view);
+		if (ret.read !== arg.length) throw new Error('failed to pass whole string');
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+
+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;
+}
+
+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 _assertBigInt(n) {
+	if (typeof(n) !== 'bigint') throw new Error(`expected a bigint argument, found ${typeof(n)}`);
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+	? { register: () => {}, unregister: () => {} }
+	: new FinalizationRegistry(state => {
+	wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b)
+});
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+	const state = { a: arg0, b: arg1, cnt: 1, dtor };
+	const real = (...args) => {
+		// First up with a closure we increment the internal reference
+		// count. This ensures that the Rust closure environment won't
+		// be deallocated while we're invoking it.
+		state.cnt++;
+		const a = state.a;
+		state.a = 0;
+		try {
+			return f(a, state.b, ...args);
+		} finally {
+			if (--state.cnt === 0) {
+				wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+				CLOSURE_DTORS.unregister(state);
+			} else {
+				state.a = a;
+			}
+		}
+	};
+	real.original = state;
+	CLOSURE_DTORS.register(real, state, state);
+	return real;
+}
+
+function logError(f, args) {
+	try {
+		return f.apply(this, args);
+	} catch (e) {
+		let error = (function () {
+			try {
+				return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
+			} catch(_) {
+				return "<failed to stringify thrown value>";
+			}
+		}());
+		console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
+		throw e;
+	}
+}
+function __wbg_adapter_48(arg0, arg1, arg2) {
+	_assertNum(arg0);
+	_assertNum(arg1);
+	wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h3fa2d535db38cca6(arg0, arg1, addHeapObject(arg2));
+}
+
+/**
+* @param {any} players
+* @param {any} _expansions
+* @param {any} _options
+* @param {any} seed
+* @param {any} _creator
+* @returns {Promise<any>}
+*/
+function init(players, _expansions, _options, seed, _creator) {
+	const ret = wasm.init(addHeapObject(players), addHeapObject(_expansions), addHeapObject(_options), addHeapObject(seed), addHeapObject(_creator));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @param {any} move_data
+* @param {any} player
+* @returns {any}
+*/
+function move(game, move_data, player) {
+	const ret = wasm.move(addHeapObject(game), addHeapObject(move_data), addHeapObject(player));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function ended(game) {
+	const ret = wasm.ended(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function scores(game) {
+	const ret = wasm.scores(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @param {any} player
+* @returns {Promise<any>}
+*/
+function dropPlayer(game, player) {
+	const ret = wasm.dropPlayer(addHeapObject(game), addHeapObject(player));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function currentPlayer(game) {
+	const ret = wasm.currentPlayer(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function logLength(game) {
+	const ret = wasm.logLength(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @param {any} options
+* @returns {any}
+*/
+function logSlice(game, options) {
+	const ret = wasm.logSlice(addHeapObject(game), addHeapObject(options));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @param {any} player_index
+* @param {any} meta_data
+* @returns {any}
+*/
+function setPlayerMetaData(game, player_index, meta_data) {
+	const ret = wasm.setPlayerMetaData(addHeapObject(game), addHeapObject(player_index), addHeapObject(meta_data));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function rankings(game) {
+	const ret = wasm.rankings(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function roundNumber(game) {
+	const ret = wasm.roundNumber(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function factions(game) {
+	const ret = wasm.factions(addHeapObject(game));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @param {any} player
+* @returns {any}
+*/
+function stripSecret(game, player) {
+	const ret = wasm.stripSecret(addHeapObject(game), addHeapObject(player));
+	return takeObject(ret);
+}
+
+/**
+* @param {any} game
+* @returns {any}
+*/
+function messages(game) {
+	const ret = wasm.messages(addHeapObject(game));
+	return takeObject(ret);
+}
+
+function handleError(f, args) {
+	try {
+		return f.apply(this, args);
+	} catch (e) {
+		wasm.__wbindgen_exn_store(addHeapObject(e));
+	}
+}
+function __wbg_adapter_121(arg0, arg1, arg2, arg3) {
+	_assertNum(arg0);
+	_assertNum(arg1);
+	wasm.wasm_bindgen__convert__closures__invoke2_mut__h57a40dbe11a3c21c(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const RemoteClientFinalization = (typeof FinalizationRegistry === 'undefined')
+	? { register: () => {}, unregister: () => {} }
+	: new FinalizationRegistry(ptr => wasm.__wbg_remoteclient_free(ptr >>> 0, 1));
+/**
+*/
+class RemoteClient {
+
+	constructor() {
+		throw new Error('cannot invoke `new` directly');
+	}
+
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		RemoteClientFinalization.unregister(this);
+		return ptr;
+	}
+
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_remoteclient_free(ptr, 0);
+	}
+	/**
+	* @returns {Promise<void>}
+	*/
+	static start() {
+		const ret = wasm.remoteclient_start();
+		return takeObject(ret);
+	}
+	/**
+	* @returns {Promise<void>}
+	*/
+	run() {
+		if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
+		_assertNum(this.__wbg_ptr);
+		const ret = wasm.remoteclient_run(this.__wbg_ptr);
+		return takeObject(ret);
+	}
+}
+
+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.__wbg_log_4bdf1576e3317256 = function() { return logError(function (arg0, arg1) {
+		console.log(getStringFromWasm0(arg0, arg1));
+	}, arguments) };
+	imports.wbg.__wbg_getcontrol_3264bfc667ef7fdf = function() { return logError(function () {
+		const ret = control_get_control();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_receivestate_f4445fef81eefecf = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).receive_state();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_receiveplayerindex_ab65cd651c6192b6 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).receive_player_index();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_sendmove_fed46023fcc631cd = function() { return logError(function (arg0, arg1) {
+		getObject(arg0).send_move(takeObject(arg1));
+	}, arguments) };
+	imports.wbg.__wbg_sendready_b0dce48818afc6a8 = function() { return logError(function (arg0) {
+		getObject(arg0).send_ready();
+	}, arguments) };
+	imports.wbg.__wbg_assetsurl_f9692a68a8f05e40 = function() { return logError(function (arg0, arg1) {
+		const ret = getObject(arg1).assets_url;
+		const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len1 = WASM_VECTOR_LEN;
+		getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+	}, arguments) };
+	imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
+		const obj = getObject(arg1);
+		const ret = typeof(obj) === 'number' ? obj : undefined;
+		if (!isLikeNone(ret)) {
+			_assertNum(ret);
+		}
+		getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+	};
+	imports.wbg.__wbindgen_is_object = function(arg0) {
+		const val = getObject(arg0);
+		const ret = typeof(val) === 'object' && val !== null;
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+		const ret = new Error(getStringFromWasm0(arg0, arg1));
+		return addHeapObject(ret);
+	};
+	imports.wbg.__wbindgen_is_undefined = function(arg0) {
+		const ret = getObject(arg0) === undefined;
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_as_number = function(arg0) {
+		const ret = +getObject(arg0);
+		return ret;
+	};
+	imports.wbg.__wbindgen_in = function(arg0, arg1) {
+		const ret = getObject(arg0) in getObject(arg1);
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_boolean_get = function(arg0) {
+		const v = getObject(arg0);
+		const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+		_assertNum(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_number_new = function(arg0) {
+		const ret = arg0;
+		return addHeapObject(ret);
+	};
+	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;
+		getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+	};
+	imports.wbg.__wbindgen_is_bigint = function(arg0) {
+		const ret = typeof(getObject(arg0)) === 'bigint';
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_is_string = function(arg0) {
+		const ret = typeof(getObject(arg0)) === 'string';
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+		const ret = getObject(arg0);
+		return addHeapObject(ret);
+	};
+	imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
+		const ret = getObject(arg0) === getObject(arg1);
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+		const ret = BigInt.asUintN(64, arg0);
+		return addHeapObject(ret);
+	};
+	imports.wbg.__wbindgen_is_function = function(arg0) {
+		const ret = typeof(getObject(arg0)) === 'function';
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbindgen_cb_drop = function(arg0) {
+		const obj = takeObject(arg0).original;
+		if (obj.cnt-- == 1) {
+			obj.a = 0;
+			return true;
+		}
+		const ret = false;
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbg_queueMicrotask_12a30234db4045d3 = function() { return logError(function (arg0) {
+		queueMicrotask(getObject(arg0));
+	}, arguments) };
+	imports.wbg.__wbg_queueMicrotask_48421b3cc9052b68 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).queueMicrotask;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+		const ret = getStringFromWasm0(arg0, arg1);
+		return addHeapObject(ret);
+	};
+	imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+		const ret = getObject(arg0) == getObject(arg1);
+		_assertBoolean(ret);
+		return ret;
+	};
+	imports.wbg.__wbg_getwithrefkey_edc2c8960f0f1191 = function() { return logError(function (arg0, arg1) {
+		const ret = getObject(arg0)[getObject(arg1)];
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_set_f975102236d3c502 = function() { return logError(function (arg0, arg1, arg2) {
+		getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+	}, arguments) };
+	imports.wbg.__wbg_new_a220cf903aa02ca2 = function() { return logError(function () {
+		const ret = new Array();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_get_3baa728f9d58d3f6 = function() { return logError(function (arg0, arg1) {
+		const ret = getObject(arg0)[arg1 >>> 0];
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_set_673dda6c73d19609 = function() { return logError(function (arg0, arg1, arg2) {
+		getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+	}, arguments) };
+	imports.wbg.__wbg_isArray_8364a5371e9737d8 = function() { return logError(function (arg0) {
+		const ret = Array.isArray(getObject(arg0));
+		_assertBoolean(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_length_ae22078168b726f5 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).length;
+		_assertNum(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_instanceof_ArrayBuffer_61dfc3198373c902 = function() { return logError(function (arg0) {
+		let result;
+		try {
+			result = getObject(arg0) instanceof ArrayBuffer;
+		} catch (_) {
+			result = false;
+		}
+		const ret = result;
+		_assertBoolean(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_newnoargs_76313bd6ff35d0f2 = function() { return logError(function (arg0, arg1) {
+		const ret = new Function(getStringFromWasm0(arg0, arg1));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_call_1084a111329e68ce = function() { return handleError(function (arg0, arg1) {
+		const ret = getObject(arg0).call(getObject(arg1));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_call_89af060b4e1523f2 = function() { return handleError(function (arg0, arg1, arg2) {
+		const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_next_f9cb570345655b9a = function() { return handleError(function (arg0) {
+		const ret = getObject(arg0).next();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_next_de3e9db4440638b2 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).next;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_done_bfda7aa8f252b39f = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).done;
+		_assertBoolean(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_value_6d39332ab4788d86 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).value;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_isSafeInteger_7f1ed56200d90674 = function() { return logError(function (arg0) {
+		const ret = Number.isSafeInteger(getObject(arg0));
+		_assertBoolean(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_entries_7a0e06255456ebcd = function() { return logError(function (arg0) {
+		const ret = Object.entries(getObject(arg0));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_new_525245e2b9901204 = function() { return logError(function () {
+		const ret = new Object();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_iterator_888179a48810a9fe = function() { return logError(function () {
+		const ret = Symbol.iterator;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_new_b85e72ed1bfd57f9 = function() { return logError(function (arg0, arg1) {
+		try {
+			var state0 = {a: arg0, b: arg1};
+			var cb0 = (arg0, arg1) => {
+				const a = state0.a;
+				state0.a = 0;
+				try {
+					return __wbg_adapter_121(a, state0.b, arg0, arg1);
+				} finally {
+					state0.a = a;
+				}
+			};
+			const ret = new Promise(cb0);
+			return addHeapObject(ret);
+		} finally {
+			state0.a = state0.b = 0;
+		}
+	}, arguments) };
+	imports.wbg.__wbg_resolve_570458cb99d56a43 = function() { return logError(function (arg0) {
+		const ret = Promise.resolve(getObject(arg0));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_then_95e6edc0f89b73b1 = function() { return logError(function (arg0, arg1) {
+		const ret = getObject(arg0).then(getObject(arg1));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_globalThis_86b222e13bdf32ed = function() { return handleError(function () {
+		const ret = globalThis.globalThis;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_self_3093d5d1f7bcb682 = function() { return handleError(function () {
+		const ret = self.self;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_window_3bcfc4d31bc012f8 = function() { return handleError(function () {
+		const ret = window.window;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_global_e5a3fe56f8be9485 = function() { return handleError(function () {
+		const ret = __webpack_require__.g.global;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_instanceof_Uint8Array_247a91427532499e = function() { return logError(function (arg0) {
+		let result;
+		try {
+			result = getObject(arg0) instanceof Uint8Array;
+		} catch (_) {
+			result = false;
+		}
+		const ret = result;
+		_assertBoolean(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_new_ea1883e1e5e86686 = function() { return logError(function (arg0) {
+		const ret = new Uint8Array(getObject(arg0));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_length_8339fcf5d8ecd12e = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).length;
+		_assertNum(ret);
+		return ret;
+	}, arguments) };
+	imports.wbg.__wbg_set_d1e79e2388520f18 = function() { return logError(function (arg0, arg1, arg2) {
+		getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+	}, arguments) };
+	imports.wbg.__wbg_buffer_b7b08af79b0b0974 = function() { return logError(function (arg0) {
+		const ret = getObject(arg0).buffer;
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_get_224d16597dbbfd96 = function() { return handleError(function (arg0, arg1) {
+		const ret = Reflect.get(getObject(arg0), getObject(arg1));
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_error_f851667af71bcfc6 = function() { return logError(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);
+		}
+	}, arguments) };
+	imports.wbg.__wbg_new_abda76e883ba8a5f = function() { return logError(function () {
+		const ret = new Error();
+		return addHeapObject(ret);
+	}, arguments) };
+	imports.wbg.__wbg_stack_658279fe44541cf6 = function() { return logError(function (arg0, arg1) {
+		const ret = getObject(arg1).stack;
+		const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+		const len1 = WASM_VECTOR_LEN;
+		getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+	}, arguments) };
+	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;
+		getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+	};
+	imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
+		const v = getObject(arg1);
+		const ret = typeof(v) === 'bigint' ? v : undefined;
+		if (!isLikeNone(ret)) {
+			_assertBigInt(ret);
+		}
+		getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+		getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+	};
+	imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+		takeObject(arg0);
+	};
+	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);
+	};
+	imports.wbg.__wbindgen_closure_wrapper14642 = function() { return logError(function (arg0, arg1, arg2) {
+		const ret = makeMutClosure(arg0, arg1, 692, __wbg_adapter_48);
+		return addHeapObject(ret);
+	}, arguments) };
+	return imports.wbg;
+
+	return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+	wasm = instance.exports;
+	__wbg_init.__wbindgen_wasm_module = module;
+	cachedDataViewMemory0 = null;
+	cachedUint8ArrayMemory0 = null;
+
+	wasm.__wbindgen_start();
+	return wasm;
+}
+
+function initSync(module) {
+	if (wasm !== undefined) return wasm;
+
+	if (typeof module !== 'undefined' && Object.getPrototypeOf(module) === Object.prototype)
+	({module} = module)
+	else
+	console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+
+	return __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(module_or_path) {
+	if (wasm !== undefined) return wasm;
+
+	if (typeof module_or_path !== 'undefined' && 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 (typeof module_or_path === 'undefined') {
+		module_or_path = new URL(/* asset import */ __webpack_require__(58), __webpack_require__.b);
+	}
+	return __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);
+	}
+
+	__wbg_init_memory(imports);
+
+	const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+	return __wbg_finalize_init(instance, module);
+}
+
+/* harmony default export */ const remote_client = (__wbg_init);
+
+;// CONCATENATED MODULE: ./src/run.js
+
+function dynamicallyLoadScript(url, onload) {
+	const script = document.createElement("script");
+	script.onload = onload;
+	script.src = url;
+
+	document.head.appendChild(script);
+}
+
+async function run({selector, control}) {
+	const root = document.querySelector(selector);
+	const canvas = document.createElement("canvas");
+	canvas.setAttribute("id", "glcanvas");
+	canvas.setAttribute("style", ` 
+				margin: 0px;
+				padding: 0px;
+				width: 100%;
+				height: 100%;
+				overflow: hidden;
+				position: absolute;
+				z-index: 0;
+	`);
+	root.appendChild(canvas);
+
+	dynamicallyLoadScript("https://not-fl3.github.io/miniquad-samples/mq_js_bundle.js", async () => {
+		let wbg = await remote_client();
+		miniquad_add_plugin({
+			register_plugin: (a) => (a.wbg = wbg),
+			on_init: () => set_wasm(wasm_exports),
+			version: "0.0.1",
+			name: "wbg",
+		});
+		const src = document.head.getElementsByTagName("script")[0].src;
+		control.assets_url = src.replace("client.js", "assets/");
+		const url = src.replace("client.js", "client.wasm");
+		console.log("Loading wasm from", url);
+		await load(url);
+	});
+}
+
+;// CONCATENATED MODULE: ./src/index.js
+
+
+window.clash = {
+	launch(selector) {
+		const control = new Control();
+		window.clash_control = control;
+
+		run({selector, control});
+
+		return control;
+	},
+};
+
+
+/******/ })()
+;