GimitHack

Guest

Apr 27th, 2026

Never

Not a member of GistPad yet? Sign Up, it unlocks many cool features!

None 0.00 KB | None | 0 0

copy raw download clone embed print report

RAW Paste Data Copied

// ==UserScript==
// @name        Gimkit Cheat
// @description A userscript that allows you to cheat across various gimkit games
// @namespace   https://www.github.com/TheLazySquid/GimkitCheat/
// @match       https://www.gimkit.com/join*
// @run-at      document-start
// @iconURL     https://www.gimkit.com/favicon.png
// @author      TheLazySquid
// @updateURL   https://raw.githubusercontent.com/TheLazySquid/GimkitCheat/main/build/bundle.user.js
// @downloadURL https://raw.githubusercontent.com/TheLazySquid/GimkitCheat/main/build/bundle.user.js
// @version     1.2.2
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_deleteValue
// ==/UserScript==
(function () {
	'use strict';

/** @returns {void} */
	function noop() {}

/**
	 * @template T
	 * @template S
	 * @param {T} tar
	 * @param {S} src
	 * @returns {T & S}
	 */
	function assign(tar, src) {
		// @ts-ignore
		for (const k in src) tar[k] = src[k];
		return /** @type {T & S} */ (tar);
	}

function run(fn) {
		return fn();
	}

function blank_object() {
		return Object.create(null);
	}

/**
	 * @param {Function[]} fns
	 * @returns {void}
	 */
	function run_all(fns) {
		fns.forEach(run);
	}

/**
	 * @param {any} thing
	 * @returns {thing is Function}
	 */
	function is_function(thing) {
		return typeof thing === 'function';
	}

/** @returns {boolean} */
	function safe_not_equal(a, b) {
		return a != a ? b == b : a !== b || (a && typeof a === 'object') || typeof a === 'function';
	}

/** @returns {boolean} */
	function is_empty(obj) {
		return Object.keys(obj).length === 0;
	}

/**
	 * Get the current value from a store by subscribing and immediately unsubscribing.
	 *
	 * https://svelte.dev/docs/svelte-store#get
	 * @template T
	 * @param {import('../store/public.js').Readable<T>} store
	 * @returns {T}
	 */
	function get_store_value(store) {
		let value;
		subscribe(store, (_) => (value = _))();
		return value;
	}

/** @returns {void} */
	function component_subscribe(component, store, callback) {
		component.$$.on_destroy.push(subscribe(store, callback));
	}

function create_slot(definition, ctx, $$scope, fn) {
		if (definition) {
			const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
			return definition[0](slot_ctx);
		}
	}

function get_slot_context(definition, ctx, $$scope, fn) {
		return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
	}

/** @returns {void} */
	function update_slot_base(
		slot,
		slot_definition,
		ctx,
		$$scope,
		slot_changes,
		get_slot_context_fn
	) {
		if (slot_changes) {
			const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
			slot.p(slot_context, slot_changes);
		}
	}

/** @returns {any[] | -1} */
	function get_all_dirty_from_scope($$scope) {
		if ($$scope.ctx.length > 32) {
			const dirty = [];
			const length = $$scope.ctx.length / 32;
			for (let i = 0; i < length; i++) {
				dirty[i] = -1;
			}
			return dirty;
		}
		return -1;
	}

const is_client = typeof window !== 'undefined';

/** @type {() => number} */
	let now = is_client ? () => window.performance.now() : () => Date.now();

let raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;

const tasks = new Set();

/**
	 * @param {number} now
	 * @returns {void}
	 */
	function run_tasks(now) {
		tasks.forEach((task) => {
			if (!task.c(now)) {
				tasks.delete(task);
				task.f();
			}
		});
		if (tasks.size !== 0) raf(run_tasks);
	}

/**
	 * Creates a new task that runs on each raf frame
	 * until it returns a falsy value or is aborted
	 * @param {import('./private.js').TaskCallback} callback
	 * @returns {import('./private.js').Task}
	 */
	function loop(callback) {
		/** @type {import('./private.js').TaskEntry} */
		let task;
		if (tasks.size === 0) raf(run_tasks);
		return {
			promise: new Promise((fulfill) => {
				tasks.add((task = { c: callback, f: fulfill }));
			}),
			abort() {
				tasks.delete(task);
			}
		};
	}

/** @type {typeof globalThis} */
	const globals =
		typeof window !== 'undefined'
			? window
			: typeof globalThis !== 'undefined'
			? globalThis
			: // @ts-ignore Node typings have this
			  global;

/**
	 * @param {Node} target
	 * @param {Node} node
	 * @returns {void}
	 */
	function append(target, node) {
		target.appendChild(node);
	}

/**
	 * @param {Node} target
	 * @param {string} style_sheet_id
	 * @param {string} styles
	 * @returns {void}
	 */
	function append_styles(target, style_sheet_id, styles) {
		const append_styles_to = get_root_for_style(target);
		if (!append_styles_to.getElementById(style_sheet_id)) {
			const style = element('style');
			style.id = style_sheet_id;
			style.textContent = styles;
			append_stylesheet(append_styles_to, style);
		}
	}

/**
	 * @param {Node} node
	 * @returns {ShadowRoot | Document}
	 */
	function get_root_for_style(node) {
		if (!node) return document;
		const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
		if (root && /** @type {ShadowRoot} */ (root).host) {
			return /** @type {ShadowRoot} */ (root);
		}
		return node.ownerDocument;
	}

/**
	 * @param {ShadowRoot | Document} node
	 * @param {HTMLStyleElement} style
	 * @returns {CSSStyleSheet}
	 */
	function append_stylesheet(node, style) {
		append(/** @type {Document} */ (node).head || node, style);
		return style.sheet;
	}

/**
	 * @param {Node} target
	 * @param {Node} node
	 * @param {Node} [anchor]
	 * @returns {void}
	 */
	function insert(target, node, anchor) {
		target.insertBefore(node, anchor || null);
	}

/**
	 * @param {Node} node
	 * @returns {void}
	 */
	function detach(node) {
		if (node.parentNode) {
			node.parentNode.removeChild(node);
		}
	}

/**
	 * @returns {void} */
	function destroy_each(iterations, detaching) {
		for (let i = 0; i < iterations.length; i += 1) {
			if (iterations[i]) iterations[i].d(detaching);
		}
	}

/**
	 * @template {keyof HTMLElementTagNameMap} K
	 * @param {K} name
	 * @returns {HTMLElementTagNameMap[K]}
	 */
	function element(name) {
		return document.createElement(name);
	}

/**
	 * @template {keyof SVGElementTagNameMap} K
	 * @param {K} name
	 * @returns {SVGElement}
	 */
	function svg_element(name) {
		return document.createElementNS('http://www.w3.org/2000/svg', name);
	}

/**
	 * @param {string} data
	 * @returns {Text}
	 */
	function text(data) {
		return document.createTextNode(data);
	}

/**
	 * @returns {Text} */
	function space() {
		return text(' ');
	}

/**
	 * @returns {Text} */
	function empty() {
		return text('');
	}

/**
	 * @param {EventTarget} node
	 * @param {string} event
	 * @param {EventListenerOrEventListenerObject} handler
	 * @param {boolean | AddEventListenerOptions | EventListenerOptions} [options]
	 * @returns {() => void}
	 */
	function listen(node, event, handler, options) {
		node.addEventListener(event, handler, options);
		return () => node.removeEventListener(event, handler, options);
	}

/**
	 * @returns {(event: any) => any} */
	function prevent_default(fn) {
		return function (event) {
			event.preventDefault();
			// @ts-ignore
			return fn.call(this, event);
		};
	}

/**
	 * @returns {(event: any) => any} */
	function stop_propagation(fn) {
		return function (event) {
			event.stopPropagation();
			// @ts-ignore
			return fn.call(this, event);
		};
	}

/**
	 * @param {Element} node
	 * @param {string} attribute
	 * @param {string} [value]
	 * @returns {void}
	 */
	function attr(node, attribute, value) {
		if (value == null) node.removeAttribute(attribute);
		else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value);
	}

/** @returns {number} */
	function to_number(value) {
		return value === '' ? null : +value;
	}

/**
	 * @param {Element} element
	 * @returns {ChildNode[]}
	 */
	function children(element) {
		return Array.from(element.childNodes);
	}

/**
	 * @param {Text} text
	 * @param {unknown} data
	 * @returns {void}
	 */
	function set_data(text, data) {
		data = '' + data;
		if (text.data === data) return;
		text.data = /** @type {string} */ (data);
	}

/**
	 * @returns {void} */
	function set_input_value(input, value) {
		input.value = value == null ? '' : value;
	}

/**
	 * @returns {void} */
	function set_style(node, key, value, important) {
		if (value == null) {
			node.style.removeProperty(key);
		} else {
			node.style.setProperty(key, value, '');
		}
	}

/**
	 * @returns {void} */
	function toggle_class(element, name, toggle) {
		// The `!!` is required because an `undefined` flag means flipping the current state.
		element.classList.toggle(name, !!toggle);
	}

/**
	 * @template T
	 * @param {string} type
	 * @param {T} [detail]
	 * @param {{ bubbles?: boolean, cancelable?: boolean }} [options]
	 * @returns {CustomEvent<T>}
	 */
	function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
		return new CustomEvent(type, { detail, bubbles, cancelable });
	}

/**
	 * @typedef {Node & {
	 * 	claim_order?: number;
	 * 	hydrate_init?: true;
	 * 	actual_end_child?: NodeEx;
	 * 	childNodes: NodeListOf<NodeEx>;
	 * }} NodeEx
	 */

/** @typedef {ChildNode & NodeEx} ChildNodeEx */

/** @typedef {NodeEx & { claim_order: number }} NodeEx2 */

/**
	 * @typedef {ChildNodeEx[] & {
	 * 	claim_info?: {
	 * 		last_index: number;
	 * 		total_claimed: number;
	 * 	};
	 * }} ChildNodeArray
	 */

let current_component;

/** @returns {void} */
	function set_current_component(component) {
		current_component = component;
	}

function get_current_component() {
		if (!current_component) throw new Error('Function called outside component initialization');
		return current_component;
	}

/**
	 * The `onMount` function schedules a callback to run as soon as the component has been mounted to the DOM.
	 * It must be called during the component's initialisation (but doesn't need to live *inside* the component;
	 * it can be called from an external module).
	 *
	 * If a function is returned _synchronously_ from `onMount`, it will be called when the component is unmounted.
	 *
	 * `onMount` does not run inside a [server-side component](https://svelte.dev/docs#run-time-server-side-component-api).
	 *
	 * https://svelte.dev/docs/svelte#onmount
	 * @template T
	 * @param {() => import('./private.js').NotFunction<T> | Promise<import('./private.js').NotFunction<T>> | (() => any)} fn
	 * @returns {void}
	 */
	function onMount(fn) {
		get_current_component().$$.on_mount.push(fn);
	}

/**
	 * Schedules a callback to run immediately before the component is unmounted.
	 *
	 * Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the
	 * only one that runs inside a server-side component.
	 *
	 * https://svelte.dev/docs/svelte#ondestroy
	 * @param {() => any} fn
	 * @returns {void}
	 */
	function onDestroy(fn) {
		get_current_component().$$.on_destroy.push(fn);
	}

/**
	 * Creates an event dispatcher that can be used to dispatch [component events](https://svelte.dev/docs#template-syntax-component-directives-on-eventname).
	 * Event dispatchers are functions that can take two arguments: `name` and `detail`.
	 *
	 * Component events created with `createEventDispatcher` create a
	 * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
	 * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
	 * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
	 * property and can contain any type of data.
	 *
	 * The event dispatcher can be typed to narrow the allowed event names and the type of the `detail` argument:
	 * ```ts
	 * const dispatch = createEventDispatcher<{
	 *  loaded: never; // does not take a detail argument
	 *  change: string; // takes a detail argument of type string, which is required
	 *  optional: number | null; // takes an optional detail argument of type number
	 * }>();
	 * ```
	 *
	 * https://svelte.dev/docs/svelte#createeventdispatcher
	 * @template {Record<string, any>} [EventMap=any]
	 * @returns {import('./public.js').EventDispatcher<EventMap>}
	 */
	function createEventDispatcher() {
		const component = get_current_component();
		return (type, detail, { cancelable = false } = {}) => {
			const callbacks = component.$$.callbacks[type];
			if (callbacks) {
				// TODO are there situations where events could be dispatched
				// in a server (non-DOM) environment?
				const event = custom_event(/** @type {string} */ (type), detail, { cancelable });
				callbacks.slice().forEach((fn) => {
					fn.call(component, event);
				});
				return !event.defaultPrevented;
			}
			return true;
		};
	}

// TODO figure out if we still want to support
	// shorthand events, or if we want to implement
	// a real bubbling mechanism
	/**
	 * @param component
	 * @param event
	 * @returns {void}
	 */
	function bubble(component, event) {
		const callbacks = component.$$.callbacks[event.type];
		if (callbacks) {
			// @ts-ignore
			callbacks.slice().forEach((fn) => fn.call(this, event));
		}
	}

const dirty_components = [];
	const binding_callbacks = [];

let render_callbacks = [];

const flush_callbacks = [];

const resolved_promise = /* @__PURE__ */ Promise.resolve();

let update_scheduled = false;

/** @returns {void} */
	function schedule_update() {
		if (!update_scheduled) {
			update_scheduled = true;
			resolved_promise.then(flush);
		}
	}

/** @returns {void} */
	function add_render_callback(fn) {
		render_callbacks.push(fn);
	}

/** @returns {void} */
	function add_flush_callback(fn) {
		flush_callbacks.push(fn);
	}

// flush() calls callbacks in this order:
	// 1. All beforeUpdate callbacks, in order: parents before children
	// 2. All bind:this callbacks, in reverse order: children before parents.
	// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
	//    for afterUpdates called during the initial onMount, which are called in
	//    reverse order: children before parents.
	// Since callbacks might update component values, which could trigger another
	// call to flush(), the following steps guard against this:
	// 1. During beforeUpdate, any updated components will be added to the
	//    dirty_components array and will cause a reentrant call to flush(). Because
	//    the flush index is kept outside the function, the reentrant call will pick
	//    up where the earlier call left off and go through all dirty components. The
	//    current_component value is saved and restored so that the reentrant call will
	//    not interfere with the "parent" flush() call.
	// 2. bind:this callbacks cannot trigger new flush() calls.
	// 3. During afterUpdate, any updated components will NOT have their afterUpdate
	//    callback called a second time; the seen_callbacks set, outside the flush()
	//    function, guarantees this behavior.
	const seen_callbacks = new Set();

let flushidx = 0; // Do *not* move this inside the flush() function

/** @returns {void} */
	function flush() {
		// Do not reenter flush while dirty components are updated, as this can
		// result in an infinite loop. Instead, let the inner flush handle it.
		// Reentrancy is ok afterwards for bindings etc.
		if (flushidx !== 0) {
			return;
		}
		const saved_component = current_component;
		do {
			// first, call beforeUpdate functions
			// and update components
			try {
				while (flushidx < dirty_components.length) {
					const component = dirty_components[flushidx];
					flushidx++;
					set_current_component(component);
					update(component.$$);
				}
			} catch (e) {
				// reset dirty state to not end up in a deadlocked state and then rethrow
				dirty_components.length = 0;
				flushidx = 0;
				throw e;
			}
			set_current_component(null);
			dirty_components.length = 0;
			flushidx = 0;
			while (binding_callbacks.length) binding_callbacks.pop()();
			// then, once components are updated, call
			// afterUpdate functions. This may cause
			// subsequent updates...
			for (let i = 0; i < render_callbacks.length; i += 1) {
				const callback = render_callbacks[i];
				if (!seen_callbacks.has(callback)) {
					// ...so guard against infinite loops
					seen_callbacks.add(callback);
					callback();
				}
			}
			render_callbacks.length = 0;
		} while (dirty_components.length);
		while (flush_callbacks.length) {
			flush_callbacks.pop()();
		}
		update_scheduled = false;
		seen_callbacks.clear();
		set_current_component(saved_component);
	}

/** @returns {void} */
	function update($$) {
		if ($$.fragment !== null) {
			$$.update();
			run_all($$.before_update);
			const dirty = $$.dirty;
			$$.dirty = [-1];
			$$.fragment && $$.fragment.p($$.ctx, dirty);
			$$.after_update.forEach(add_render_callback);
		}
	}

/**
	 * Useful for example to execute remaining `afterUpdate` callbacks before executing `destroy`.
	 * @param {Function[]} fns
	 * @returns {void}
	 */
	function flush_render_callbacks(fns) {
		const filtered = [];
		const targets = [];
		render_callbacks.forEach((c) => (fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c)));
		targets.forEach((c) => c());
		render_callbacks = filtered;
	}

const outroing = new Set();

/**
	 * @type {Outro}
	 */
	let outros;

/**
	 * @returns {void} */
	function group_outros() {
		outros = {
			r: 0,
			c: [],
			p: outros // parent group
		};
	}

/**
	 * @returns {void} */
	function check_outros() {
		if (!outros.r) {
			run_all(outros.c);
		}
		outros = outros.p;
	}

/**
	 * @param {import('./private.js').Fragment} block
	 * @param {0 | 1} [local]
	 * @returns {void}
	 */
	function transition_in(block, local) {
		if (block && block.i) {
			outroing.delete(block);
			block.i(local);
		}
	}

/**
	 * @param {import('./private.js').Fragment} block
	 * @param {0 | 1} local
	 * @param {0 | 1} [detach]
	 * @param {() => void} [callback]
	 * @returns {void}
	 */
	function transition_out(block, local, detach, callback) {
		if (block && block.o) {
			if (outroing.has(block)) return;
			outroing.add(block);
			outros.c.push(() => {
				outroing.delete(block);
				if (callback) {
					if (detach) block.d(1);
					callback();
				}
			});
			block.o(local);
		} else if (callback) {
			callback();
		}
	}

/** @typedef {1} INTRO */
	/** @typedef {0} OUTRO */
	/** @typedef {{ direction: 'in' | 'out' | 'both' }} TransitionOptions */
	/** @typedef {(node: Element, params: any, options: TransitionOptions) => import('../transition/public.js').TransitionConfig} TransitionFn */

/**
	 * @typedef {Object} Outro
	 * @property {number} r
	 * @property {Function[]} c
	 * @property {Object} p
	 */

/**
	 * @typedef {Object} PendingProgram
	 * @property {number} start
	 * @property {INTRO|OUTRO} b
	 * @property {Outro} [group]
	 */

/**
	 * @typedef {Object} Program
	 * @property {number} a
	 * @property {INTRO|OUTRO} b
	 * @property {1|-1} d
	 * @property {number} duration
	 * @property {number} start
	 * @property {number} end
	 * @property {Outro} [group]
	 */

// general each functions:

function ensure_array_like(array_like_or_iterator) {
		return array_like_or_iterator?.length !== undefined
			? array_like_or_iterator
			: Array.from(array_like_or_iterator);
	}

/** @returns {void} */
	function bind(component, name, callback) {
		const index = component.$$.props[name];
		if (index !== undefined) {
			component.$$.bound[index] = callback;
			callback(component.$$.ctx[index]);
		}
	}

/** @returns {void} */
	function create_component(block) {
		block && block.c();
	}

/** @returns {void} */
	function mount_component(component, target, anchor) {
		const { fragment, after_update } = component.$$;
		fragment && fragment.m(target, anchor);
		// onMount happens before the initial afterUpdate
		add_render_callback(() => {
			const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
			// if the component was destroyed immediately
			// it will update the `$$.on_destroy` reference to `null`.
			// the destructured on_destroy may still reference to the old array
			if (component.$$.on_destroy) {
				component.$$.on_destroy.push(...new_on_destroy);
			} else {
				// Edge case - component was destroyed immediately,
				// most likely as a result of a binding initialising
				run_all(new_on_destroy);
			}
			component.$$.on_mount = [];
		});
		after_update.forEach(add_render_callback);
	}

/** @returns {void} */
	function destroy_component(component, detaching) {
		const $$ = component.$$;
		if ($$.fragment !== null) {
			flush_render_callbacks($$.after_update);
			run_all($$.on_destroy);
			$$.fragment && $$.fragment.d(detaching);
			// TODO null out other refs, including component.$$ (but need to
			// preserve final state?)
			$$.on_destroy = $$.fragment = null;
			$$.ctx = [];
		}
	}

/** @returns {void} */
	function make_dirty(component, i) {
		if (component.$$.dirty[0] === -1) {
			dirty_components.push(component);
			schedule_update();
			component.$$.dirty.fill(0);
		}
		component.$$.dirty[(i / 31) | 0] |= 1 << i % 31;
	}

// TODO: Document the other params
	/**
	 * @param {SvelteComponent} component
	 * @param {import('./public.js').ComponentConstructorOptions} options
	 *
	 * @param {import('./utils.js')['not_equal']} not_equal Used to compare props and state values.
	 * @param {(target: Element | ShadowRoot) => void} [append_styles] Function that appends styles to the DOM when the component is first initialised.
	 * This will be the `add_css` function from the compiled component.
	 *
	 * @returns {void}
	 */
	function init(
		component,
		options,
		instance,
		create_fragment,
		not_equal,
		props,
		append_styles = null,
		dirty = [-1]
	) {
		const parent_component = current_component;
		set_current_component(component);
		/** @type {import('./private.js').T$$} */
		const $$ = (component.$$ = {
			fragment: null,
			ctx: [],
			// state
			props,
			update: noop,
			not_equal,
			bound: blank_object(),
			// lifecycle
			on_mount: [],
			on_destroy: [],
			on_disconnect: [],
			before_update: [],
			after_update: [],
			context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
			// everything else
			callbacks: blank_object(),
			dirty,
			skip_bound: false,
			root: options.target || parent_component.$$.root
		});
		append_styles && append_styles($$.root);
		let ready = false;
		$$.ctx = instance
			? instance(component, options.props || {}, (i, ret, ...rest) => {
					const value = rest.length ? rest[0] : ret;
					if ($$.ctx && not_equal($$.ctx[i], ($$.ctx[i] = value))) {
						if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
						if (ready) make_dirty(component, i);
					}
					return ret;
			  })
			: [];
		$$.update();
		ready = true;
		run_all($$.before_update);
		// `false` as a special case of no DOM component
		$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
		if (options.target) {
			if (options.hydrate) {
				// TODO: what is the correct type here?
				// @ts-expect-error
				const nodes = children(options.target);
				$$.fragment && $$.fragment.l(nodes);
				nodes.forEach(detach);
			} else {
				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
				$$.fragment && $$.fragment.c();
			}
			if (options.intro) transition_in(component.$$.fragment);
			mount_component(component, options.target, options.anchor);
			flush();
		}
		set_current_component(parent_component);
	}

/**
	 * Base class for Svelte components. Used when dev=false.
	 *
	 * @template {Record<string, any>} [Props=any]
	 * @template {Record<string, any>} [Events=any]
	 */
	class SvelteComponent {
		/**
		 * ### PRIVATE API
		 *
		 * Do not use, may change at any time
		 *
		 * @type {any}
		 */
		$$ = undefined;
		/**
		 * ### PRIVATE API
		 *
		 * Do not use, may change at any time
		 *
		 * @type {any}
		 */
		$$set = undefined;

/** @returns {void} */
		$destroy() {
			destroy_component(this, 1);
			this.$destroy = noop;
		}

/**
		 * @template {Extract<keyof Events, string>} K
		 * @param {K} type
		 * @param {((e: Events[K]) => void) | null | undefined} callback
		 * @returns {() => void}
		 */
		$on(type, callback) {
			if (!is_function(callback)) {
				return noop;
			}
			const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
			callbacks.push(callback);
			return () => {
				const index = callbacks.indexOf(callback);
				if (index !== -1) callbacks.splice(index, 1);
			};
		}

/**
		 * @param {Partial<Props>} props
		 * @returns {void}
		 */
		$set(props) {
			if (this.$$set && !is_empty(props)) {
				this.$$.skip_bound = true;
				this.$$set(props);
				this.$$.skip_bound = false;
			}
		}
	}

/**
	 * @typedef {Object} CustomElementPropDefinition
	 * @property {string} [attribute]
	 * @property {boolean} [reflect]
	 * @property {'String'|'Boolean'|'Number'|'Array'|'Object'} [type]
	 */

// generated during release, do not modify

const PUBLIC_VERSION = '4';

if (typeof window !== 'undefined')
		// @ts-ignore
		(window.__svelte || (window.__svelte = { v: new Set() })).v.add(PUBLIC_VERSION);

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function getDefaultExportFromCjs (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

var debounce$2 = {exports: {}};

function debounce(function_, wait = 100, options = {}) {
		if (typeof function_ !== 'function') {
			throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
		}

if (wait < 0) {
			throw new RangeError('`wait` must not be negative.');
		}

// TODO: Deprecate the boolean parameter at some point.
		const {immediate} = typeof options === 'boolean' ? {immediate: options} : options;

let storedContext;
		let storedArguments;
		let timeoutId;
		let timestamp;
		let result;

function run() {
			const callContext = storedContext;
			const callArguments = storedArguments;
			storedContext = undefined;
			storedArguments = undefined;
			result = function_.apply(callContext, callArguments);
			return result;
		}

function later() {
			const last = Date.now() - timestamp;

if (last < wait && last >= 0) {
				timeoutId = setTimeout(later, wait - last);
			} else {
				timeoutId = undefined;

if (!immediate) {
					result = run();
				}
			}
		}

const debounced = function (...arguments_) {
			if (storedContext && this !== storedContext) {
				throw new Error('Debounced method called with different contexts.');
			}

storedContext = this; // eslint-disable-line unicorn/no-this-assignment
			storedArguments = arguments_;
			timestamp = Date.now();

const callNow = immediate && !timeoutId;

if (!timeoutId) {
				timeoutId = setTimeout(later, wait);
			}

if (callNow) {
				result = run();
			}

return result;
		};

debounced.clear = () => {
			if (!timeoutId) {
				return;
			}

clearTimeout(timeoutId);
			timeoutId = undefined;
		};

debounced.flush = () => {
			if (!timeoutId) {
				return;
			}

debounced.trigger();
		};

debounced.trigger = () => {
			result = run();

debounced.clear();
		};

return debounced;
	}

// Adds compatibility for ES modules
	debounce$2.exports.debounce = debounce;

debounce$2.exports = debounce;

var debounceExports = debounce$2.exports;
	var debounce$1 = /*@__PURE__*/getDefaultExportFromCjs(debounceExports);

const subscriber_queue = [];

/**
	 * Create a `Writable` store that allows both updating and reading by subscription.
	 *
	 * https://svelte.dev/docs/svelte-store#writable
	 * @template T
	 * @param {T} [value] initial value
	 * @param {import('./public.js').StartStopNotifier<T>} [start]
	 * @returns {import('./public.js').Writable<T>}
	 */
	function writable(value, start = noop) {
		/** @type {import('./public.js').Unsubscriber} */
		let stop;
		/** @type {Set<import('./private.js').SubscribeInvalidateTuple<T>>} */
		const subscribers = new Set();
		/** @param {T} new_value
		 * @returns {void}
		 */
		function set(new_value) {
			if (safe_not_equal(value, new_value)) {
				value = new_value;
				if (stop) {
					// store is ready
					const run_queue = !subscriber_queue.length;
					for (const subscriber of subscribers) {
						subscriber[1]();
						subscriber_queue.push(subscriber, value);
					}
					if (run_queue) {
						for (let i = 0; i < subscriber_queue.length; i += 2) {
							subscriber_queue[i][0](subscriber_queue[i + 1]);
						}
						subscriber_queue.length = 0;
					}
				}
			}
		}

/**
		 * @param {import('./public.js').Updater<T>} fn
		 * @returns {void}
		 */
		function update(fn) {
			set(fn(value));
		}

/**
		 * @param {import('./public.js').Subscriber<T>} run
		 * @param {import('./private.js').Invalidator<T>} [invalidate]
		 * @returns {import('./public.js').Unsubscriber}
		 */
		function subscribe(run, invalidate = noop) {
			/** @type {import('./private.js').SubscribeInvalidateTuple<T>} */
			const subscriber = [run, invalidate];
			subscribers.add(subscriber);
			if (subscribers.size === 1) {
				stop = start(set, update) || noop;
			}
			run(value);
			return () => {
				subscribers.delete(subscriber);
				if (subscribers.size === 0 && stop) {
					stop();
					stop = null;
				}
			};
		}
		return { set, update, subscribe };
	}

/**
	 * @param {any} obj
	 * @returns {boolean}
	 */
	function is_date(obj) {
		return Object.prototype.toString.call(obj) === '[object Date]';
	}

/**
	 * @template T
	 * @param {import('./private.js').TickContext<T>} ctx
	 * @param {T} last_value
	 * @param {T} current_value
	 * @param {T} target_value
	 * @returns {T}
	 */
	function tick_spring(ctx, last_value, current_value, target_value) {
		if (typeof current_value === 'number' || is_date(current_value)) {
			// @ts-ignore
			const delta = target_value - current_value;
			// @ts-ignore
			const velocity = (current_value - last_value) / (ctx.dt || 1 / 60); // guard div by 0
			const spring = ctx.opts.stiffness * delta;
			const damper = ctx.opts.damping * velocity;
			const acceleration = (spring - damper) * ctx.inv_mass;
			const d = (velocity + acceleration) * ctx.dt;
			if (Math.abs(d) < ctx.opts.precision && Math.abs(delta) < ctx.opts.precision) {
				return target_value; // settled
			} else {
				ctx.settled = false; // signal loop to keep ticking
				// @ts-ignore
				return is_date(current_value) ? new Date(current_value.getTime() + d) : current_value + d;
			}
		} else if (Array.isArray(current_value)) {
			// @ts-ignore
			return current_value.map((_, i) =>
				tick_spring(ctx, last_value[i], current_value[i], target_value[i])
			);
		} else if (typeof current_value === 'object') {
			const next_value = {};
			for (const k in current_value) {
				// @ts-ignore
				next_value[k] = tick_spring(ctx, last_value[k], current_value[k], target_value[k]);
			}
			// @ts-ignore
			return next_value;
		} else {
			throw new Error(`Cannot spring ${typeof current_value} values`);
		}
	}

/**
	 * The spring function in Svelte creates a store whose value is animated, with a motion that simulates the behavior of a spring. This means when the value changes, instead of transitioning at a steady rate, it "bounces" like a spring would, depending on the physics parameters provided. This adds a level of realism to the transitions and can enhance the user experience.
	 *
	 * https://svelte.dev/docs/svelte-motion#spring
	 * @template [T=any]
	 * @param {T} [value]
	 * @param {import('./private.js').SpringOpts} [opts]
	 * @returns {import('./public.js').Spring<T>}
	 */
	function spring(value, opts = {}) {
		const store = writable(value);
		const { stiffness = 0.15, damping = 0.8, precision = 0.01 } = opts;
		/** @type {number} */
		let last_time;
		/** @type {import('../internal/private.js').Task} */
		let task;
		/** @type {object} */
		let current_token;
		/** @type {T} */
		let last_value = value;
		/** @type {T} */
		let target_value = value;
		let inv_mass = 1;
		let inv_mass_recovery_rate = 0;
		let cancel_task = false;
		/**
		 * @param {T} new_value
		 * @param {import('./private.js').SpringUpdateOpts} opts
		 * @returns {Promise<void>}
		 */
		function set(new_value, opts = {}) {
			target_value = new_value;
			const token = (current_token = {});
			if (value == null || opts.hard || (spring.stiffness >= 1 && spring.damping >= 1)) {
				cancel_task = true; // cancel any running animation
				last_time = now();
				last_value = new_value;
				store.set((value = target_value));
				return Promise.resolve();
			} else if (opts.soft) {
				const rate = opts.soft === true ? 0.5 : +opts.soft;
				inv_mass_recovery_rate = 1 / (rate * 60);
				inv_mass = 0; // infinite mass, unaffected by spring forces
			}
			if (!task) {
				last_time = now();
				cancel_task = false;
				task = loop((now) => {
					if (cancel_task) {
						cancel_task = false;
						task = null;
						return false;
					}
					inv_mass = Math.min(inv_mass + inv_mass_recovery_rate, 1);
					const ctx = {
						inv_mass,
						opts: spring,
						settled: true,
						dt: ((now - last_time) * 60) / 1000
					};
					const next_value = tick_spring(ctx, last_value, value, target_value);
					last_time = now;
					last_value = value;
					store.set((value = next_value));
					if (ctx.settled) {
						task = null;
					}
					return !ctx.settled;
				});
			}
			return new Promise((fulfil) => {
				task.promise.then(() => {
					if (token === current_token) fulfil();
				});
			});
		}
		/** @type {import('./public.js').Spring<T>} */
		const spring = {
			set,
			update: (fn, opts) => set(fn(target_value, value), opts),
			subscribe: store.subscribe,
			stiffness,
			damping,
			precision
		};
		return spring;
	}

const defaultCss = {
	    textColor: "rgba(255, 255, 255, 1)",
	    menuBackgroundColor: "rgba(0, 0, 0, 0.5)",
	    menuOutlineColor: "rgba(255, 255, 255, 0)",
	    menuHeaderBackgroundColor: "rgba(0, 0, 255, 0.5)",
	    menuHeaderTextColor: "rgba(255, 255, 255, 1)",
	    buttonBackgroundColor: "rgba(0, 0, 0, 0.5)",
	    buttonBorderColor: "rgba(255, 255, 255, 1)"
	};
	const defaultMenuTransforms = {
	    "General Cheats": {
	        x: 0,
	        y: 0,
	        width: window.innerWidth / 4,
	        height: window.innerHeight / 3 * 2,
	        minimized: false
	    },
	    "Gamemode Specific Cheats": {
	        x: window.innerWidth / 8 * 3,
	        y: 0,
	        width: window.innerWidth / 4,
	        height: window.innerHeight / 3 * 2,
	        minimized: false
	    },
	    "Customization": {
	        x: window.innerWidth / 4 * 3,
	        y: 0,
	        width: window.innerWidth / 4,
	        height: window.innerHeight / 3 * 2,
	        minimized: false
	    }
	};

// this code was stolen from the original Gimkit Util extension
	function n(t, e, n) {
	    for (var i = 0, s = 0, o = n.length; s < o; s++)(i = n.charCodeAt(s)) < 128 ? t.setUint8(e++, i) : (i < 2048 ? t.setUint8(e++, 192 | i >> 6) : (i < 55296 || 57344 <= i ? t.setUint8(e++, 224 | i >> 12) : (s++, i = 65536 + ((1023 & i) << 10 | 1023 & n.charCodeAt(s)), t.setUint8(e++, 240 | i >> 18), t.setUint8(e++, 128 | i >> 12 & 63)), t.setUint8(e++, 128 | i >> 6 & 63)), t.setUint8(e++, 128 | 63 & i));
	}

function encode$1(t, e, s) {
	    let o;

if(Array.isArray(t)) {
	        o = {
	            type: 2,
	            data: t,
	            options: {
	                compress: !0
	            },
	            nsp: "/"
	        };
	    } else {
	        o = {
	            type: 2,
	            data: ["blueboat_SEND_MESSAGE", {
	                room: s,
	                key: t,
	                data: e
	            }],
	            options: {
	                compress: !0
	            },
	            nsp: "/"
	        };
	    }

return function(t) {
	        var e = [],
	            i = [],
	            s = function t(e, n, i) {
	                var s = typeof i,
	                    o = 0,
	                    r = 0,
	                    a = 0,
	                    c = 0,
	                    l = 0,
	                    u = 0;
	                if ("string" === s) {
	                    if ((l = function(t) {
	                            for (var e = 0, n = 0, i = 0, s = t.length; i < s; i++)(e = t.charCodeAt(i)) < 128 ? n += 1 : e < 2048 ? n += 2 : e < 55296 || 57344 <= e ? n += 3 : (i++, n += 4);
	                            return n
	                        }(i)) < 32) e.push(160 | l), u = 1;
	                    else if (l < 256) e.push(217, l), u = 2;
	                    else if (l < 65536) e.push(218, l >> 8, l), u = 3;
	                    else {
	                        if (!(l < 4294967296)) throw new Error("String too long");
	                        e.push(219, l >> 24, l >> 16, l >> 8, l), u = 5;
	                    }
	                    return n.push({
	                        h: i,
	                        u: l,
	                        t: e.length
	                    }), u + l
	                }
	                if ("number" === s) return Math.floor(i) === i && isFinite(i) ? 0 <= i ? i < 128 ? (e.push(i), 1) : i < 256 ? (e.push(204, i), 2) : i < 65536 ? (e.push(205, i >> 8, i), 3) : i < 4294967296 ? (e.push(206, i >> 24, i >> 16, i >> 8, i), 5) : (a = i / Math.pow(2, 32) >> 0, c = i >>> 0, e.push(207, a >> 24, a >> 16, a >> 8, a, c >> 24, c >> 16, c >> 8, c), 9) : -32 <= i ? (e.push(i), 1) : -128 <= i ? (e.push(208, i), 2) : -32768 <= i ? (e.push(209, i >> 8, i), 3) : -2147483648 <= i ? (e.push(210, i >> 24, i >> 16, i >> 8, i), 5) : (a = Math.floor(i / Math.pow(2, 32)), c = i >>> 0, e.push(211, a >> 24, a >> 16, a >> 8, a, c >> 24, c >> 16, c >> 8, c), 9) : (e.push(203), n.push({
	                    o: i,
	                    u: 8,
	                    t: e.length
	                }), 9);
	                if ("object" === s) {
	                    if (null === i) return e.push(192), 1;
	                    if (Array.isArray(i)) {
	                        if ((l = i.length) < 16) e.push(144 | l), u = 1;
	                        else if (l < 65536) e.push(220, l >> 8, l), u = 3;
	                        else {
	                            if (!(l < 4294967296)) throw new Error("Array too large");
	                            e.push(221, l >> 24, l >> 16, l >> 8, l), u = 5;
	                        }
	                        for (o = 0; o < l; o++) u += t(e, n, i[o]);
	                        return u
	                    }
	                    if (i instanceof Date) {
	                        var h = i.getTime();
	                        return a = Math.floor(h / Math.pow(2, 32)), c = h >>> 0, e.push(215, 0, a >> 24, a >> 16, a >> 8, a, c >> 24, c >> 16, c >> 8, c), 10
	                    }
	                    if (i instanceof ArrayBuffer) {
	                        if ((l = i.byteLength) < 256) e.push(196, l), u = 2;
	                        else if (l < 65536) e.push(197, l >> 8, l), u = 3;
	                        else {
	                            if (!(l < 4294967296)) throw new Error("Buffer too large");
	                            e.push(198, l >> 24, l >> 16, l >> 8, l), u = 5;
	                        }
	                        return n.push({
	                            l: i,
	                            u: l,
	                            t: e.length
	                        }), u + l
	                    }
	                    if ("function" == typeof i.toJSON) return t(e, n, i.toJSON());
	                    var d = [],
	                        f = "",
	                        p = Object.keys(i);
	                    for (o = 0, r = p.length; o < r; o++) "function" != typeof i[f = p[o]] && d.push(f);
	                    if ((l = d.length) < 16) e.push(128 | l), u = 1;
	                    else if (l < 65536) e.push(222, l >> 8, l), u = 3;
	                    else {
	                        if (!(l < 4294967296)) throw new Error("Object too large");
	                        e.push(223, l >> 24, l >> 16, l >> 8, l), u = 5;
	                    }
	                    for (o = 0; o < l; o++) u += t(e, n, f = d[o]), u += t(e, n, i[f]);
	                    return u
	                }
	                if ("boolean" === s) return e.push(i ? 195 : 194), 1;
	                if ("undefined" === s) return e.push(212, 0, 0), 3;
	                throw new Error("Could not encode")
	            }(e, i, t),
	            o = new ArrayBuffer(s),
	            r = new DataView(o),
	            a = 0,
	            c = 0,
	            l = -1;
	        0 < i.length && (l = i[0].t);
	        for (var u, h = 0, d = 0, f = 0, p = e.length; f < p; f++)
	            if (r.setUint8(c + f, e[f]), f + 1 === l) {
	                if (h = (u = i[a]).u, d = c + l, u.l)
	                    for (var g = new Uint8Array(u.l), E = 0; E < h; E++) r.setUint8(d + E, g[E]);
	                else u.h ? n(r, d, u.h) : void 0 !== u.o && r.setFloat64(d, u.o);
	                c += h, i[++a] && (l = i[a].t);
	            } let y = Array.from(new Uint8Array(o));
	        y.unshift(4);
	        return new Uint8Array(y).buffer 
	    }(o)
	}

function decode$1(packet) {
	    function e(t) {
	        if (this.t = 0, t instanceof ArrayBuffer) this.i = t, this.s = new DataView(this.i);
	        else {
	            if (!ArrayBuffer.isView(t)) return null;
	            this.i = t.buffer, this.s = new DataView(this.i, t.byteOffset, t.byteLength);
	        }
	    }

e.prototype.g = function(t) {
	        for (var e = new Array(t), n = 0; n < t; n++) e[n] = this.v();
	        return e
	    }, e.prototype.M = function(t) {
	        for (var e = {}, n = 0; n < t; n++) e[this.v()] = this.v();
	        return e
	    }, e.prototype.h = function(t) {
	        var e = function(t, e, n) {
	            for (var i = "", s = 0, o = e, r = e + n; o < r; o++) {
	                var a = t.getUint8(o);
	                if (0 != (128 & a))
	                    if (192 != (224 & a))
	                        if (224 != (240 & a)) {
	                            if (240 != (248 & a)) throw new Error("Invalid byte " + a.toString(16));
	                            65536 <= (s = (7 & a) << 18 | (63 & t.getUint8(++o)) << 12 | (63 & t.getUint8(++o)) << 6 | (63 & t.getUint8(++o)) << 0) ? (s -= 65536, i += String.fromCharCode(55296 + (s >>> 10), 56320 + (1023 & s))) : i += String.fromCharCode(s);
	                        } else i += String.fromCharCode((15 & a) << 12 | (63 & t.getUint8(++o)) << 6 | (63 & t.getUint8(++o)) << 0);
	                else i += String.fromCharCode((31 & a) << 6 | 63 & t.getUint8(++o));
	                else i += String.fromCharCode(a);
	            }
	            return i
	        }(this.s, this.t, t);
	        return this.t += t, e
	    }, e.prototype.l = function(t) {
	        var e = this.i.slice(this.t, this.t + t);
	        return this.t += t, e
	    }, e.prototype.v = function() {
	        if(!this.s) return null;
	        var t, e = this.s.getUint8(this.t++),
	            n = 0,
	            i = 0,
	            s = 0,
	            o = 0;
	        if (e < 192) return e < 128 ? e : e < 144 ? this.M(15 & e) : e < 160 ? this.g(15 & e) : this.h(31 & e);
	        if (223 < e) return -1 * (255 - e + 1);
	        switch (e) {
	            case 192:
	                return null;
	            case 194:
	                return !1;
	            case 195:
	                return !0;
	            case 196:
	                return n = this.s.getUint8(this.t), this.t += 1, this.l(n);
	            case 197:
	                return n = this.s.getUint16(this.t), this.t += 2, this.l(n);
	            case 198:
	                return n = this.s.getUint32(this.t), this.t += 4, this.l(n);
	            case 199:
	                return n = this.s.getUint8(this.t), i = this.s.getInt8(this.t + 1), this.t += 2, [i, this.l(n)];
	            case 200:
	                return n = this.s.getUint16(this.t), i = this.s.getInt8(this.t + 2), this.t += 3, [i, this.l(n)];
	            case 201:
	                return n = this.s.getUint32(this.t), i = this.s.getInt8(this.t + 4), this.t += 5, [i, this.l(n)];
	            case 202:
	                return t = this.s.getFloat32(this.t), this.t += 4, t;
	            case 203:
	                return t = this.s.getFloat64(this.t), this.t += 8, t;
	            case 204:
	                return t = this.s.getUint8(this.t), this.t += 1, t;
	            case 205:
	                return t = this.s.getUint16(this.t), this.t += 2, t;
	            case 206:
	                return t = this.s.getUint32(this.t), this.t += 4, t;
	            case 207:
	                return s = this.s.getUint32(this.t) * Math.pow(2, 32), o = this.s.getUint32(this.t + 4), this.t += 8, s + o;
	            case 208:
	                return t = this.s.getInt8(this.t), this.t += 1, t;
	            case 209:
	                return t = this.s.getInt16(this.t), this.t += 2, t;
	            case 210:
	                return t = this.s.getInt32(this.t), this.t += 4, t;
	            case 211:
	                return s = this.s.getInt32(this.t) * Math.pow(2, 32), o = this.s.getUint32(this.t + 4), this.t += 8, s + o;
	            case 212:
	                return i = this.s.getInt8(this.t), this.t += 1, 0 === i ? void(this.t += 1) : [i, this.l(1)];
	            case 213:
	                return i = this.s.getInt8(this.t), this.t += 1, [i, this.l(2)];
	            case 214:
	                return i = this.s.getInt8(this.t), this.t += 1, [i, this.l(4)];
	            case 215:
	                return i = this.s.getInt8(this.t), this.t += 1, 0 === i ? (s = this.s.getInt32(this.t) * Math.pow(2, 32), o = this.s.getUint32(this.t + 4), this.t += 8, new Date(s + o)) : [i, this.l(8)];
	            case 216:
	                return i = this.s.getInt8(this.t), this.t += 1, [i, this.l(16)];
	            case 217:
	                return n = this.s.getUint8(this.t), this.t += 1, this.h(n);
	            case 218:
	                return n = this.s.getUint16(this.t), this.t += 2, this.h(n);
	            case 219:
	                return n = this.s.getUint32(this.t), this.t += 4, this.h(n);
	            case 220:
	                return n = this.s.getUint16(this.t), this.t += 2, this.g(n);
	            case 221:
	                return n = this.s.getUint32(this.t), this.t += 4, this.g(n);
	            case 222:
	                return n = this.s.getUint16(this.t), this.t += 2, this.M(n);
	            case 223:
	                return n = this.s.getUint32(this.t), this.t += 4, this.M(n)
	        }
	        throw new Error("Could not parse")
	    };

const q = function(t) {
	        var n = new e(t = t.slice(1)),
	            i = n.v();
	        if (n.t === t.byteLength) return i;
	        return null
	    }(packet);

return q?.data?.[1];
	}

var blueboat = {
	    encode: encode$1,
	    decode: decode$1
	};

var msgpack = {};

/**
	 * Copyright (c) 2014 Ion Drive Software Ltd.
	 * https://github.com/darrachequesne/notepack/
	 *
	 * Permission is hereby granted, free of charge, to any person obtaining a copy
	 * of this software and associated documentation files (the "Software"), to deal
	 * in the Software without restriction, including without limitation the rights
	 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	 * copies of the Software, and to permit persons to whom the Software is
	 * furnished to do so, subject to the following conditions:
	 *
	 * The above copyright notice and this permission notice shall be included in all
	 * copies or substantial portions of the Software.
	 *
	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	 * SOFTWARE.
	 */
	Object.defineProperty(msgpack, "__esModule", { value: true });
	var decode_1 = msgpack.decode = encode_1 = msgpack.encode = void 0;
	/**
	 * Patch for Colyseus:
	 * -------------------
	 * notepack.io@3.0.1
	 *
	 * added `offset` on Decoder constructor, for messages arriving with a code
	 * before actual msgpack data
	 */
	//
	// DECODER
	//
	function Decoder(buffer, offset) {
	    this._offset = offset;
	    if (buffer instanceof ArrayBuffer) {
	        this._buffer = buffer;
	        this._view = new DataView(this._buffer);
	    }
	    else if (ArrayBuffer.isView(buffer)) {
	        this._buffer = buffer.buffer;
	        this._view = new DataView(this._buffer, buffer.byteOffset, buffer.byteLength);
	    }
	    else {
	        throw new Error('Invalid argument');
	    }
	}
	function utf8Read(view, offset, length) {
	    var string = '', chr = 0;
	    for (var i = offset, end = offset + length; i < end; i++) {
	        var byte = view.getUint8(i);
	        if ((byte & 0x80) === 0x00) {
	            string += String.fromCharCode(byte);
	            continue;
	        }
	        if ((byte & 0xe0) === 0xc0) {
	            string += String.fromCharCode(((byte & 0x1f) << 6) |
	                (view.getUint8(++i) & 0x3f));
	            continue;
	        }
	        if ((byte & 0xf0) === 0xe0) {
	            string += String.fromCharCode(((byte & 0x0f) << 12) |
	                ((view.getUint8(++i) & 0x3f) << 6) |
	                ((view.getUint8(++i) & 0x3f) << 0));
	            continue;
	        }
	        if ((byte & 0xf8) === 0xf0) {
	            chr = ((byte & 0x07) << 18) |
	                ((view.getUint8(++i) & 0x3f) << 12) |
	                ((view.getUint8(++i) & 0x3f) << 6) |
	                ((view.getUint8(++i) & 0x3f) << 0);
	            if (chr >= 0x010000) { // surrogate pair
	                chr -= 0x010000;
	                string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
	            }
	            else {
	                string += String.fromCharCode(chr);
	            }
	            continue;
	        }
	        throw new Error('Invalid byte ' + byte.toString(16));
	    }
	    return string;
	}
	Decoder.prototype._array = function (length) {
	    var value = new Array(length);
	    for (var i = 0; i < length; i++) {
	        value[i] = this._parse();
	    }
	    return value;
	};
	Decoder.prototype._map = function (length) {
	    var key = '', value = {};
	    for (var i = 0; i < length; i++) {
	        key = this._parse();
	        value[key] = this._parse();
	    }
	    return value;
	};
	Decoder.prototype._str = function (length) {
	    var value = utf8Read(this._view, this._offset, length);
	    this._offset += length;
	    return value;
	};
	Decoder.prototype._bin = function (length) {
	    var value = this._buffer.slice(this._offset, this._offset + length);
	    this._offset += length;
	    return value;
	};
	Decoder.prototype._parse = function () {
	    var prefix = this._view.getUint8(this._offset++);
	    var value, length = 0, type = 0, hi = 0, lo = 0;
	    if (prefix < 0xc0) {
	        // positive fixint
	        if (prefix < 0x80) {
	            return prefix;
	        }
	        // fixmap
	        if (prefix < 0x90) {
	            return this._map(prefix & 0x0f);
	        }
	        // fixarray
	        if (prefix < 0xa0) {
	            return this._array(prefix & 0x0f);
	        }
	        // fixstr
	        return this._str(prefix & 0x1f);
	    }
	    // negative fixint
	    if (prefix > 0xdf) {
	        return (0xff - prefix + 1) * -1;
	    }
	    switch (prefix) {
	        // nil
	        case 0xc0:
	            return null;
	        // false
	        case 0xc2:
	            return false;
	        // true
	        case 0xc3:
	            return true;
	        // bin
	        case 0xc4:
	            length = this._view.getUint8(this._offset);
	            this._offset += 1;
	            return this._bin(length);
	        case 0xc5:
	            length = this._view.getUint16(this._offset);
	            this._offset += 2;
	            return this._bin(length);
	        case 0xc6:
	            length = this._view.getUint32(this._offset);
	            this._offset += 4;
	            return this._bin(length);
	        // ext
	        case 0xc7:
	            length = this._view.getUint8(this._offset);
	            type = this._view.getInt8(this._offset + 1);
	            this._offset += 2;
	            if (type === -1) {
	                // timestamp 96
	                var ns = this._view.getUint32(this._offset);
	                hi = this._view.getInt32(this._offset + 4);
	                lo = this._view.getUint32(this._offset + 8);
	                this._offset += 12;
	                return new Date((hi * 0x100000000 + lo) * 1e3 + ns / 1e6);
	            }
	            return [type, this._bin(length)];
	        case 0xc8:
	            length = this._view.getUint16(this._offset);
	            type = this._view.getInt8(this._offset + 2);
	            this._offset += 3;
	            return [type, this._bin(length)];
	        case 0xc9:
	            length = this._view.getUint32(this._offset);
	            type = this._view.getInt8(this._offset + 4);
	            this._offset += 5;
	            return [type, this._bin(length)];
	        // float
	        case 0xca:
	            value = this._view.getFloat32(this._offset);
	            this._offset += 4;
	            return value;
	        case 0xcb:
	            value = this._view.getFloat64(this._offset);
	            this._offset += 8;
	            return value;
	        // uint
	        case 0xcc:
	            value = this._view.getUint8(this._offset);
	            this._offset += 1;
	            return value;
	        case 0xcd:
	            value = this._view.getUint16(this._offset);
	            this._offset += 2;
	            return value;
	        case 0xce:
	            value = this._view.getUint32(this._offset);
	            this._offset += 4;
	            return value;
	        case 0xcf:
	            hi = this._view.getUint32(this._offset) * Math.pow(2, 32);
	            lo = this._view.getUint32(this._offset + 4);
	            this._offset += 8;
	            return hi + lo;
	        // int
	        case 0xd0:
	            value = this._view.getInt8(this._offset);
	            this._offset += 1;
	            return value;
	        case 0xd1:
	            value = this._view.getInt16(this._offset);
	            this._offset += 2;
	            return value;
	        case 0xd2:
	            value = this._view.getInt32(this._offset);
	            this._offset += 4;
	            return value;
	        case 0xd3:
	            hi = this._view.getInt32(this._offset) * Math.pow(2, 32);
	            lo = this._view.getUint32(this._offset + 4);
	            this._offset += 8;
	            return hi + lo;
	        // fixext
	        case 0xd4:
	            type = this._view.getInt8(this._offset);
	            this._offset += 1;
	            if (type === 0x00) {
	                // custom encoding for 'undefined' (kept for backward-compatibility)
	                this._offset += 1;
	                return void 0;
	            }
	            return [type, this._bin(1)];
	        case 0xd5:
	            type = this._view.getInt8(this._offset);
	            this._offset += 1;
	            return [type, this._bin(2)];
	        case 0xd6:
	            type = this._view.getInt8(this._offset);
	            this._offset += 1;
	            if (type === -1) {
	                // timestamp 32
	                value = this._view.getUint32(this._offset);
	                this._offset += 4;
	                return new Date(value * 1e3);
	            }
	            return [type, this._bin(4)];
	        case 0xd7:
	            type = this._view.getInt8(this._offset);
	            this._offset += 1;
	            if (type === 0x00) {
	                // custom date encoding (kept for backward-compatibility)
	                hi = this._view.getInt32(this._offset) * Math.pow(2, 32);
	                lo = this._view.getUint32(this._offset + 4);
	                this._offset += 8;
	                return new Date(hi + lo);
	            }
	            if (type === -1) {
	                // timestamp 64
	                hi = this._view.getUint32(this._offset);
	                lo = this._view.getUint32(this._offset + 4);
	                this._offset += 8;
	                var s = (hi & 0x3) * 0x100000000 + lo;
	                return new Date(s * 1e3 + (hi >>> 2) / 1e6);
	            }
	            return [type, this._bin(8)];
	        case 0xd8:
	            type = this._view.getInt8(this._offset);
	            this._offset += 1;
	            return [type, this._bin(16)];
	        // str
	        case 0xd9:
	            length = this._view.getUint8(this._offset);
	            this._offset += 1;
	            return this._str(length);
	        case 0xda:
	            length = this._view.getUint16(this._offset);
	            this._offset += 2;
	            return this._str(length);
	        case 0xdb:
	            length = this._view.getUint32(this._offset);
	            this._offset += 4;
	            return this._str(length);
	        // array
	        case 0xdc:
	            length = this._view.getUint16(this._offset);
	            this._offset += 2;
	            return this._array(length);
	        case 0xdd:
	            length = this._view.getUint32(this._offset);
	            this._offset += 4;
	            return this._array(length);
	        // map
	        case 0xde:
	            length = this._view.getUint16(this._offset);
	            this._offset += 2;
	            return this._map(length);
	        case 0xdf:
	            length = this._view.getUint32(this._offset);
	            this._offset += 4;
	            return this._map(length);
	    }
	    throw new Error('Could not parse');
	};
	function decode(buffer, offset = 0) {
	    var decoder = new Decoder(buffer, offset);
	    var value = decoder._parse();
	    if (decoder._offset !== buffer.byteLength) {
	        throw new Error((buffer.byteLength - decoder._offset) + ' trailing bytes');
	    }
	    return value;
	}
	decode_1 = msgpack.decode = decode;
	//
	// ENCODER
	//
	var TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
	var TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
	function utf8Write(view, offset, str) {
	    var c = 0;
	    for (var i = 0, l = str.length; i < l; i++) {
	        c = str.charCodeAt(i);
	        if (c < 0x80) {
	            view.setUint8(offset++, c);
	        }
	        else if (c < 0x800) {
	            view.setUint8(offset++, 0xc0 | (c >> 6));
	            view.setUint8(offset++, 0x80 | (c & 0x3f));
	        }
	        else if (c < 0xd800 || c >= 0xe000) {
	            view.setUint8(offset++, 0xe0 | (c >> 12));
	            view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
	            view.setUint8(offset++, 0x80 | (c & 0x3f));
	        }
	        else {
	            i++;
	            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
	            view.setUint8(offset++, 0xf0 | (c >> 18));
	            view.setUint8(offset++, 0x80 | (c >> 12) & 0x3f);
	            view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
	            view.setUint8(offset++, 0x80 | (c & 0x3f));
	        }
	    }
	}
	function utf8Length(str) {
	    var c = 0, length = 0;
	    for (var i = 0, l = str.length; i < l; i++) {
	        c = str.charCodeAt(i);
	        if (c < 0x80) {
	            length += 1;
	        }
	        else if (c < 0x800) {
	            length += 2;
	        }
	        else if (c < 0xd800 || c >= 0xe000) {
	            length += 3;
	        }
	        else {
	            i++;
	            length += 4;
	        }
	    }
	    return length;
	}
	function _encode(bytes, defers, value) {
	    var type = typeof value, i = 0, l = 0, hi = 0, lo = 0, length = 0, size = 0;
	    if (type === 'string') {
	        length = utf8Length(value);
	        // fixstr
	        if (length < 0x20) {
	            bytes.push(length | 0xa0);
	            size = 1;
	        }
	        // str 8
	        else if (length < 0x100) {
	            bytes.push(0xd9, length);
	            size = 2;
	        }
	        // str 16
	        else if (length < 0x10000) {
	            bytes.push(0xda, length >> 8, length);
	            size = 3;
	        }
	        // str 32
	        else if (length < 0x100000000) {
	            bytes.push(0xdb, length >> 24, length >> 16, length >> 8, length);
	            size = 5;
	        }
	        else {
	            throw new Error('String too long');
	        }
	        defers.push({ _str: value, _length: length, _offset: bytes.length });
	        return size + length;
	    }
	    if (type === 'number') {
	        // TODO: encode to float 32?
	        // float 64
	        if (Math.floor(value) !== value || !isFinite(value)) {
	            bytes.push(0xcb);
	            defers.push({ _float: value, _length: 8, _offset: bytes.length });
	            return 9;
	        }
	        if (value >= 0) {
	            // positive fixnum
	            if (value < 0x80) {
	                bytes.push(value);
	                return 1;
	            }
	            // uint 8
	            if (value < 0x100) {
	                bytes.push(0xcc, value);
	                return 2;
	            }
	            // uint 16
	            if (value < 0x10000) {
	                bytes.push(0xcd, value >> 8, value);
	                return 3;
	            }
	            // uint 32
	            if (value < 0x100000000) {
	                bytes.push(0xce, value >> 24, value >> 16, value >> 8, value);
	                return 5;
	            }
	            // uint 64
	            hi = (value / Math.pow(2, 32)) >> 0;
	            lo = value >>> 0;
	            bytes.push(0xcf, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
	            return 9;
	        }
	        else {
	            // negative fixnum
	            if (value >= -0x20) {
	                bytes.push(value);
	                return 1;
	            }
	            // int 8
	            if (value >= -0x80) {
	                bytes.push(0xd0, value);
	                return 2;
	            }
	            // int 16
	            if (value >= -0x8000) {
	                bytes.push(0xd1, value >> 8, value);
	                return 3;
	            }
	            // int 32
	            if (value >= -0x80000000) {
	                bytes.push(0xd2, value >> 24, value >> 16, value >> 8, value);
	                return 5;
	            }
	            // int 64
	            hi = Math.floor(value / Math.pow(2, 32));
	            lo = value >>> 0;
	            bytes.push(0xd3, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
	            return 9;
	        }
	    }
	    if (type === 'object') {
	        // nil
	        if (value === null) {
	            bytes.push(0xc0);
	            return 1;
	        }
	        if (Array.isArray(value)) {
	            length = value.length;
	            // fixarray
	            if (length < 0x10) {
	                bytes.push(length | 0x90);
	                size = 1;
	            }
	            // array 16
	            else if (length < 0x10000) {
	                bytes.push(0xdc, length >> 8, length);
	                size = 3;
	            }
	            // array 32
	            else if (length < 0x100000000) {
	                bytes.push(0xdd, length >> 24, length >> 16, length >> 8, length);
	                size = 5;
	            }
	            else {
	                throw new Error('Array too large');
	            }
	            for (i = 0; i < length; i++) {
	                size += _encode(bytes, defers, value[i]);
	            }
	            return size;
	        }
	        if (value instanceof Date) {
	            var ms = value.getTime();
	            var s = Math.floor(ms / 1e3);
	            var ns = (ms - s * 1e3) * 1e6;
	            if (s >= 0 && ns >= 0 && s <= TIMESTAMP64_MAX_SEC) {
	                if (ns === 0 && s <= TIMESTAMP32_MAX_SEC) {
	                    // timestamp 32
	                    bytes.push(0xd6, 0xff, s >> 24, s >> 16, s >> 8, s);
	                    return 6;
	                }
	                else {
	                    // timestamp 64
	                    hi = s / 0x100000000;
	                    lo = s & 0xffffffff;
	                    bytes.push(0xd7, 0xff, ns >> 22, ns >> 14, ns >> 6, hi, lo >> 24, lo >> 16, lo >> 8, lo);
	                    return 10;
	                }
	            }
	            else {
	                // timestamp 96
	                hi = Math.floor(s / 0x100000000);
	                lo = s >>> 0;
	                bytes.push(0xc7, 0x0c, 0xff, ns >> 24, ns >> 16, ns >> 8, ns, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
	                return 15;
	            }
	        }
	        if (value instanceof ArrayBuffer) {
	            length = value.byteLength;
	            // bin 8
	            if (length < 0x100) {
	                bytes.push(0xc4, length);
	                size = 2;
	            }
	            else 
	            // bin 16
	            if (length < 0x10000) {
	                bytes.push(0xc5, length >> 8, length);
	                size = 3;
	            }
	            else 
	            // bin 32
	            if (length < 0x100000000) {
	                bytes.push(0xc6, length >> 24, length >> 16, length >> 8, length);
	                size = 5;
	            }
	            else {
	                throw new Error('Buffer too large');
	            }
	            defers.push({ _bin: value, _length: length, _offset: bytes.length });
	            return size + length;
	        }
	        if (typeof value.toJSON === 'function') {
	            return _encode(bytes, defers, value.toJSON());
	        }
	        var keys = [], key = '';
	        var allKeys = Object.keys(value);
	        for (i = 0, l = allKeys.length; i < l; i++) {
	            key = allKeys[i];
	            if (value[key] !== undefined && typeof value[key] !== 'function') {
	                keys.push(key);
	            }
	        }
	        length = keys.length;
	        // fixmap
	        if (length < 0x10) {
	            bytes.push(length | 0x80);
	            size = 1;
	        }
	        // map 16
	        else if (length < 0x10000) {
	            bytes.push(0xde, length >> 8, length);
	            size = 3;
	        }
	        // map 32
	        else if (length < 0x100000000) {
	            bytes.push(0xdf, length >> 24, length >> 16, length >> 8, length);
	            size = 5;
	        }
	        else {
	            throw new Error('Object too large');
	        }
	        for (i = 0; i < length; i++) {
	            key = keys[i];
	            size += _encode(bytes, defers, key);
	            size += _encode(bytes, defers, value[key]);
	        }
	        return size;
	    }
	    // false/true
	    if (type === 'boolean') {
	        bytes.push(value ? 0xc3 : 0xc2);
	        return 1;
	    }
	    if (type === 'undefined') {
	        bytes.push(0xc0);
	        return 1;
	    }
	    // custom types like BigInt (typeof value === 'bigint')
	    if (typeof value.toJSON === 'function') {
	        return _encode(bytes, defers, value.toJSON());
	    }
	    throw new Error('Could not encode');
	}
	function encode(value) {
	    var bytes = [];
	    var defers = [];
	    var size = _encode(bytes, defers, value);
	    var buf = new ArrayBuffer(size);
	    var view = new DataView(buf);
	    var deferIndex = 0;
	    var deferWritten = 0;
	    var nextOffset = -1;
	    if (defers.length > 0) {
	        nextOffset = defers[0]._offset;
	    }
	    var defer, deferLength = 0, offset = 0;
	    for (var i = 0, l = bytes.length; i < l; i++) {
	        view.setUint8(deferWritten + i, bytes[i]);
	        if (i + 1 !== nextOffset) {
	            continue;
	        }
	        defer = defers[deferIndex];
	        deferLength = defer._length;
	        offset = deferWritten + nextOffset;
	        if (defer._bin) {
	            var bin = new Uint8Array(defer._bin);
	            for (var j = 0; j < deferLength; j++) {
	                view.setUint8(offset + j, bin[j]);
	            }
	        }
	        else if (defer._str) {
	            utf8Write(view, offset, defer._str);
	        }
	        else if (defer._float !== undefined) {
	            view.setFloat64(offset, defer._float);
	        }
	        deferIndex++;
	        deferWritten += deferLength;
	        if (defers[deferIndex]) {
	            nextOffset = defers[deferIndex]._offset;
	        }
	    }
	    return buf;
	}
	var encode_1 = msgpack.encode = encode;

var colyseus = {exports: {}};

//
		    // Polyfills for legacy environments
		    //
		    /*
		     * Support Android 4.4.x
		     */
		    if (!ArrayBuffer.isView) {
		        ArrayBuffer.isView = function (a) {
		            return a !== null && typeof (a) === 'object' && a.buffer instanceof ArrayBuffer;
		        };
		    }
		    // Define globalThis if not available.
		    // https://github.com/colyseus/colyseus.js/issues/86
		    if (typeof (globalThis) === "undefined" &&
		        typeof (window) !== "undefined") {
		        // @ts-ignore
		        window['globalThis'] = window;
		    }

/******************************************************************************
		    Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
		    purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
		    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
		    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
		    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
		    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
		    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
		    PERFORMANCE OF THIS SOFTWARE.
		    ***************************************************************************** */
		    /* global Reflect, Promise */

function __extends(d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    }

function __classPrivateFieldGet(receiver, state, kind, f) {
		        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
		        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
		        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
		    }

function __classPrivateFieldSet(receiver, state, value, kind, f) {
		        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
		        return (state.set(receiver, value)), value;
		    }

var CloseCode;
		    (function (CloseCode) {
		        CloseCode[CloseCode["CONSENTED"] = 4000] = "CONSENTED";
		        CloseCode[CloseCode["DEVMODE_RESTART"] = 4010] = "DEVMODE_RESTART";
		    })(CloseCode || (CloseCode = {}));
		    var ServerError = /** @class */ (function (_super) {
		        __extends(ServerError, _super);
		        function ServerError(code, message) {
		            var _this = _super.call(this, message) || this;
		            _this.name = "ServerError";
		            _this.code = code;
		            return _this;
		        }
		        return ServerError;
		    }(Error));

/**
		     * Copyright (c) 2014 Ion Drive Software Ltd.
		     * https://github.com/darrachequesne/notepack/
		     *
		     * Permission is hereby granted, free of charge, to any person obtaining a copy
		     * of this software and associated documentation files (the "Software"), to deal
		     * in the Software without restriction, including without limitation the rights
		     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		     * copies of the Software, and to permit persons to whom the Software is
		     * furnished to do so, subject to the following conditions:
		     *
		     * The above copyright notice and this permission notice shall be included in all
		     * copies or substantial portions of the Software.
		     *
		     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		     * SOFTWARE.
		     */
		    /**
		     * Patch for Colyseus:
		     * -------------------
		     * notepack.io@3.0.1
		     *
		     * added `offset` on Decoder constructor, for messages arriving with a code
		     * before actual msgpack data
		     */
		    //
		    // DECODER
		    //
		    function Decoder(buffer, offset) {
		        this._offset = offset;
		        if (buffer instanceof ArrayBuffer) {
		            this._buffer = buffer;
		            this._view = new DataView(this._buffer);
		        }
		        else if (ArrayBuffer.isView(buffer)) {
		            this._buffer = buffer.buffer;
		            this._view = new DataView(this._buffer, buffer.byteOffset, buffer.byteLength);
		        }
		        else {
		            throw new Error('Invalid argument');
		        }
		    }
		    function utf8Read$1(view, offset, length) {
		        var string = '', chr = 0;
		        for (var i = offset, end = offset + length; i < end; i++) {
		            var byte = view.getUint8(i);
		            if ((byte & 0x80) === 0x00) {
		                string += String.fromCharCode(byte);
		                continue;
		            }
		            if ((byte & 0xe0) === 0xc0) {
		                string += String.fromCharCode(((byte & 0x1f) << 6) |
		                    (view.getUint8(++i) & 0x3f));
		                continue;
		            }
		            if ((byte & 0xf0) === 0xe0) {
		                string += String.fromCharCode(((byte & 0x0f) << 12) |
		                    ((view.getUint8(++i) & 0x3f) << 6) |
		                    ((view.getUint8(++i) & 0x3f) << 0));
		                continue;
		            }
		            if ((byte & 0xf8) === 0xf0) {
		                chr = ((byte & 0x07) << 18) |
		                    ((view.getUint8(++i) & 0x3f) << 12) |
		                    ((view.getUint8(++i) & 0x3f) << 6) |
		                    ((view.getUint8(++i) & 0x3f) << 0);
		                if (chr >= 0x010000) { // surrogate pair
		                    chr -= 0x010000;
		                    string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
		                }
		                else {
		                    string += String.fromCharCode(chr);
		                }
		                continue;
		            }
		            throw new Error('Invalid byte ' + byte.toString(16));
		        }
		        return string;
		    }
		    Decoder.prototype._array = function (length) {
		        var value = new Array(length);
		        for (var i = 0; i < length; i++) {
		            value[i] = this._parse();
		        }
		        return value;
		    };
		    Decoder.prototype._map = function (length) {
		        var key = '', value = {};
		        for (var i = 0; i < length; i++) {
		            key = this._parse();
		            value[key] = this._parse();
		        }
		        return value;
		    };
		    Decoder.prototype._str = function (length) {
		        var value = utf8Read$1(this._view, this._offset, length);
		        this._offset += length;
		        return value;
		    };
		    Decoder.prototype._bin = function (length) {
		        var value = this._buffer.slice(this._offset, this._offset + length);
		        this._offset += length;
		        return value;
		    };
		    Decoder.prototype._parse = function () {
		        var prefix = this._view.getUint8(this._offset++);
		        var value, length = 0, type = 0, hi = 0, lo = 0;
		        if (prefix < 0xc0) {
		            // positive fixint
		            if (prefix < 0x80) {
		                return prefix;
		            }
		            // fixmap
		            if (prefix < 0x90) {
		                return this._map(prefix & 0x0f);
		            }
		            // fixarray
		            if (prefix < 0xa0) {
		                return this._array(prefix & 0x0f);
		            }
		            // fixstr
		            return this._str(prefix & 0x1f);
		        }
		        // negative fixint
		        if (prefix > 0xdf) {
		            return (0xff - prefix + 1) * -1;
		        }
		        switch (prefix) {
		            // nil
		            case 0xc0:
		                return null;
		            // false
		            case 0xc2:
		                return false;
		            // true
		            case 0xc3:
		                return true;
		            // bin
		            case 0xc4:
		                length = this._view.getUint8(this._offset);
		                this._offset += 1;
		                return this._bin(length);
		            case 0xc5:
		                length = this._view.getUint16(this._offset);
		                this._offset += 2;
		                return this._bin(length);
		            case 0xc6:
		                length = this._view.getUint32(this._offset);
		                this._offset += 4;
		                return this._bin(length);
		            // ext
		            case 0xc7:
		                length = this._view.getUint8(this._offset);
		                type = this._view.getInt8(this._offset + 1);
		                this._offset += 2;
		                if (type === -1) {
		                    // timestamp 96
		                    var ns = this._view.getUint32(this._offset);
		                    hi = this._view.getInt32(this._offset + 4);
		                    lo = this._view.getUint32(this._offset + 8);
		                    this._offset += 12;
		                    return new Date((hi * 0x100000000 + lo) * 1e3 + ns / 1e6);
		                }
		                return [type, this._bin(length)];
		            case 0xc8:
		                length = this._view.getUint16(this._offset);
		                type = this._view.getInt8(this._offset + 2);
		                this._offset += 3;
		                return [type, this._bin(length)];
		            case 0xc9:
		                length = this._view.getUint32(this._offset);
		                type = this._view.getInt8(this._offset + 4);
		                this._offset += 5;
		                return [type, this._bin(length)];
		            // float
		            case 0xca:
		                value = this._view.getFloat32(this._offset);
		                this._offset += 4;
		                return value;
		            case 0xcb:
		                value = this._view.getFloat64(this._offset);
		                this._offset += 8;
		                return value;
		            // uint
		            case 0xcc:
		                value = this._view.getUint8(this._offset);
		                this._offset += 1;
		                return value;
		            case 0xcd:
		                value = this._view.getUint16(this._offset);
		                this._offset += 2;
		                return value;
		            case 0xce:
		                value = this._view.getUint32(this._offset);
		                this._offset += 4;
		                return value;
		            case 0xcf:
		                hi = this._view.getUint32(this._offset) * Math.pow(2, 32);
		                lo = this._view.getUint32(this._offset + 4);
		                this._offset += 8;
		                return hi + lo;
		            // int
		            case 0xd0:
		                value = this._view.getInt8(this._offset);
		                this._offset += 1;
		                return value;
		            case 0xd1:
		                value = this._view.getInt16(this._offset);
		                this._offset += 2;
		                return value;
		            case 0xd2:
		                value = this._view.getInt32(this._offset);
		                this._offset += 4;
		                return value;
		            case 0xd3:
		                hi = this._view.getInt32(this._offset) * Math.pow(2, 32);
		                lo = this._view.getUint32(this._offset + 4);
		                this._offset += 8;
		                return hi + lo;
		            // fixext
		            case 0xd4:
		                type = this._view.getInt8(this._offset);
		                this._offset += 1;
		                if (type === 0x00) {
		                    // custom encoding for 'undefined' (kept for backward-compatibility)
		                    this._offset += 1;
		                    return void 0;
		                }
		                return [type, this._bin(1)];
		            case 0xd5:
		                type = this._view.getInt8(this._offset);
		                this._offset += 1;
		                return [type, this._bin(2)];
		            case 0xd6:
		                type = this._view.getInt8(this._offset);
		                this._offset += 1;
		                if (type === -1) {
		                    // timestamp 32
		                    value = this._view.getUint32(this._offset);
		                    this._offset += 4;
		                    return new Date(value * 1e3);
		                }
		                return [type, this._bin(4)];
		            case 0xd7:
		                type = this._view.getInt8(this._offset);
		                this._offset += 1;
		                if (type === 0x00) {
		                    // custom date encoding (kept for backward-compatibility)
		                    hi = this._view.getInt32(this._offset) * Math.pow(2, 32);
		                    lo = this._view.getUint32(this._offset + 4);
		                    this._offset += 8;
		                    return new Date(hi + lo);
		                }
		                if (type === -1) {
		                    // timestamp 64
		                    hi = this._view.getUint32(this._offset);
		                    lo = this._view.getUint32(this._offset + 4);
		                    this._offset += 8;
		                    var s = (hi & 0x3) * 0x100000000 + lo;
		                    return new Date(s * 1e3 + (hi >>> 2) / 1e6);
		                }
		                return [type, this._bin(8)];
		            case 0xd8:
		                type = this._view.getInt8(this._offset);
		                this._offset += 1;
		                return [type, this._bin(16)];
		            // str
		            case 0xd9:
		                length = this._view.getUint8(this._offset);
		                this._offset += 1;
		                return this._str(length);
		            case 0xda:
		                length = this._view.getUint16(this._offset);
		                this._offset += 2;
		                return this._str(length);
		            case 0xdb:
		                length = this._view.getUint32(this._offset);
		                this._offset += 4;
		                return this._str(length);
		            // array
		            case 0xdc:
		                length = this._view.getUint16(this._offset);
		                this._offset += 2;
		                return this._array(length);
		            case 0xdd:
		                length = this._view.getUint32(this._offset);
		                this._offset += 4;
		                return this._array(length);
		            // map
		            case 0xde:
		                length = this._view.getUint16(this._offset);
		                this._offset += 2;
		                return this._map(length);
		            case 0xdf:
		                length = this._view.getUint32(this._offset);
		                this._offset += 4;
		                return this._map(length);
		        }
		        throw new Error('Could not parse');
		    };
		    function decode(buffer, offset) {
		        if (offset === void 0) { offset = 0; }
		        var decoder = new Decoder(buffer, offset);
		        var value = decoder._parse();
		        if (decoder._offset !== buffer.byteLength) {
		            throw new Error((buffer.byteLength - decoder._offset) + ' trailing bytes');
		        }
		        return value;
		    }
		    //
		    // ENCODER
		    //
		    var TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
		    var TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
		    function utf8Write(view, offset, str) {
		        var c = 0;
		        for (var i = 0, l = str.length; i < l; i++) {
		            c = str.charCodeAt(i);
		            if (c < 0x80) {
		                view.setUint8(offset++, c);
		            }
		            else if (c < 0x800) {
		                view.setUint8(offset++, 0xc0 | (c >> 6));
		                view.setUint8(offset++, 0x80 | (c & 0x3f));
		            }
		            else if (c < 0xd800 || c >= 0xe000) {
		                view.setUint8(offset++, 0xe0 | (c >> 12));
		                view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
		                view.setUint8(offset++, 0x80 | (c & 0x3f));
		            }
		            else {
		                i++;
		                c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
		                view.setUint8(offset++, 0xf0 | (c >> 18));
		                view.setUint8(offset++, 0x80 | (c >> 12) & 0x3f);
		                view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
		                view.setUint8(offset++, 0x80 | (c & 0x3f));
		            }
		        }
		    }
		    function utf8Length$1(str) {
		        var c = 0, length = 0;
		        for (var i = 0, l = str.length; i < l; i++) {
		            c = str.charCodeAt(i);
		            if (c < 0x80) {
		                length += 1;
		            }
		            else if (c < 0x800) {
		                length += 2;
		            }
		            else if (c < 0xd800 || c >= 0xe000) {
		                length += 3;
		            }
		            else {
		                i++;
		                length += 4;
		            }
		        }
		        return length;
		    }
		    function _encode(bytes, defers, value) {
		        var type = typeof value, i = 0, l = 0, hi = 0, lo = 0, length = 0, size = 0;
		        if (type === 'string') {
		            length = utf8Length$1(value);
		            // fixstr
		            if (length < 0x20) {
		                bytes.push(length | 0xa0);
		                size = 1;
		            }
		            // str 8
		            else if (length < 0x100) {
		                bytes.push(0xd9, length);
		                size = 2;
		            }
		            // str 16
		            else if (length < 0x10000) {
		                bytes.push(0xda, length >> 8, length);
		                size = 3;
		            }
		            // str 32
		            else if (length < 0x100000000) {
		                bytes.push(0xdb, length >> 24, length >> 16, length >> 8, length);
		                size = 5;
		            }
		            else {
		                throw new Error('String too long');
		            }
		            defers.push({ _str: value, _length: length, _offset: bytes.length });
		            return size + length;
		        }
		        if (type === 'number') {
		            // TODO: encode to float 32?
		            // float 64
		            if (Math.floor(value) !== value || !isFinite(value)) {
		                bytes.push(0xcb);
		                defers.push({ _float: value, _length: 8, _offset: bytes.length });
		                return 9;
		            }
		            if (value >= 0) {
		                // positive fixnum
		                if (value < 0x80) {
		                    bytes.push(value);
		                    return 1;
		                }
		                // uint 8
		                if (value < 0x100) {
		                    bytes.push(0xcc, value);
		                    return 2;
		                }
		                // uint 16
		                if (value < 0x10000) {
		                    bytes.push(0xcd, value >> 8, value);
		                    return 3;
		                }
		                // uint 32
		                if (value < 0x100000000) {
		                    bytes.push(0xce, value >> 24, value >> 16, value >> 8, value);
		                    return 5;
		                }
		                // uint 64
		                hi = (value / Math.pow(2, 32)) >> 0;
		                lo = value >>> 0;
		                bytes.push(0xcf, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
		                return 9;
		            }
		            else {
		                // negative fixnum
		                if (value >= -0x20) {
		                    bytes.push(value);
		                    return 1;
		                }
		                // int 8
		                if (value >= -0x80) {
		                    bytes.push(0xd0, value);
		                    return 2;
		                }
		                // int 16
		                if (value >= -0x8000) {
		                    bytes.push(0xd1, value >> 8, value);
		                    return 3;
		                }
		                // int 32
		                if (value >= -0x80000000) {
		                    bytes.push(0xd2, value >> 24, value >> 16, value >> 8, value);
		                    return 5;
		                }
		                // int 64
		                hi = Math.floor(value / Math.pow(2, 32));
		                lo = value >>> 0;
		                bytes.push(0xd3, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
		                return 9;
		            }
		        }
		        if (type === 'object') {
		            // nil
		            if (value === null) {
		                bytes.push(0xc0);
		                return 1;
		            }
		            if (Array.isArray(value)) {
		                length = value.length;
		                // fixarray
		                if (length < 0x10) {
		                    bytes.push(length | 0x90);
		                    size = 1;
		                }
		                // array 16
		                else if (length < 0x10000) {
		                    bytes.push(0xdc, length >> 8, length);
		                    size = 3;
		                }
		                // array 32
		                else if (length < 0x100000000) {
		                    bytes.push(0xdd, length >> 24, length >> 16, length >> 8, length);
		                    size = 5;
		                }
		                else {
		                    throw new Error('Array too large');
		                }
		                for (i = 0; i < length; i++) {
		                    size += _encode(bytes, defers, value[i]);
		                }
		                return size;
		            }
		            if (value instanceof Date) {
		                var ms = value.getTime();
		                var s = Math.floor(ms / 1e3);
		                var ns = (ms - s * 1e3) * 1e6;
		                if (s >= 0 && ns >= 0 && s <= TIMESTAMP64_MAX_SEC) {
		                    if (ns === 0 && s <= TIMESTAMP32_MAX_SEC) {
		                        // timestamp 32
		                        bytes.push(0xd6, 0xff, s >> 24, s >> 16, s >> 8, s);
		                        return 6;
		                    }
		                    else {
		                        // timestamp 64
		                        hi = s / 0x100000000;
		                        lo = s & 0xffffffff;
		                        bytes.push(0xd7, 0xff, ns >> 22, ns >> 14, ns >> 6, hi, lo >> 24, lo >> 16, lo >> 8, lo);
		                        return 10;
		                    }
		                }
		                else {
		                    // timestamp 96
		                    hi = Math.floor(s / 0x100000000);
		                    lo = s >>> 0;
		                    bytes.push(0xc7, 0x0c, 0xff, ns >> 24, ns >> 16, ns >> 8, ns, hi >> 24, hi >> 16, hi >> 8, hi, lo >> 24, lo >> 16, lo >> 8, lo);
		                    return 15;
		                }
		            }
		            if (value instanceof ArrayBuffer) {
		                length = value.byteLength;
		                // bin 8
		                if (length < 0x100) {
		                    bytes.push(0xc4, length);
		                    size = 2;
		                }
		                else 
		                // bin 16
		                if (length < 0x10000) {
		                    bytes.push(0xc5, length >> 8, length);
		                    size = 3;
		                }
		                else 
		                // bin 32
		                if (length < 0x100000000) {
		                    bytes.push(0xc6, length >> 24, length >> 16, length >> 8, length);
		                    size = 5;
		                }
		                else {
		                    throw new Error('Buffer too large');
		                }
		                defers.push({ _bin: value, _length: length, _offset: bytes.length });
		                return size + length;
		            }
		            if (typeof value.toJSON === 'function') {
		                return _encode(bytes, defers, value.toJSON());
		            }
		            var keys = [], key = '';
		            var allKeys = Object.keys(value);
		            for (i = 0, l = allKeys.length; i < l; i++) {
		                key = allKeys[i];
		                if (value[key] !== undefined && typeof value[key] !== 'function') {
		                    keys.push(key);
		                }
		            }
		            length = keys.length;
		            // fixmap
		            if (length < 0x10) {
		                bytes.push(length | 0x80);
		                size = 1;
		            }
		            // map 16
		            else if (length < 0x10000) {
		                bytes.push(0xde, length >> 8, length);
		                size = 3;
		            }
		            // map 32
		            else if (length < 0x100000000) {
		                bytes.push(0xdf, length >> 24, length >> 16, length >> 8, length);
		                size = 5;
		            }
		            else {
		                throw new Error('Object too large');
		            }
		            for (i = 0; i < length; i++) {
		                key = keys[i];
		                size += _encode(bytes, defers, key);
		                size += _encode(bytes, defers, value[key]);
		            }
		            return size;
		        }
		        // false/true
		        if (type === 'boolean') {
		            bytes.push(value ? 0xc3 : 0xc2);
		            return 1;
		        }
		        if (type === 'undefined') {
		            bytes.push(0xc0);
		            return 1;
		        }
		        // custom types like BigInt (typeof value === 'bigint')
		        if (typeof value.toJSON === 'function') {
		            return _encode(bytes, defers, value.toJSON());
		        }
		        throw new Error('Could not encode');
		    }
		    function encode(value) {
		        var bytes = [];
		        var defers = [];
		        var size = _encode(bytes, defers, value);
		        var buf = new ArrayBuffer(size);
		        var view = new DataView(buf);
		        var deferIndex = 0;
		        var deferWritten = 0;
		        var nextOffset = -1;
		        if (defers.length > 0) {
		            nextOffset = defers[0]._offset;
		        }
		        var defer, deferLength = 0, offset = 0;
		        for (var i = 0, l = bytes.length; i < l; i++) {
		            view.setUint8(deferWritten + i, bytes[i]);
		            if (i + 1 !== nextOffset) {
		                continue;
		            }
		            defer = defers[deferIndex];
		            deferLength = defer._length;
		            offset = deferWritten + nextOffset;
		            if (defer._bin) {
		                var bin = new Uint8Array(defer._bin);
		                for (var j = 0; j < deferLength; j++) {
		                    view.setUint8(offset + j, bin[j]);
		                }
		            }
		            else if (defer._str) {
		                utf8Write(view, offset, defer._str);
		            }
		            else if (defer._float !== undefined) {
		                view.setFloat64(offset, defer._float);
		            }
		            deferIndex++;
		            deferWritten += deferLength;
		            if (defers[deferIndex]) {
		                nextOffset = defers[deferIndex]._offset;
		            }
		        }
		        return buf;
		    }

var browser = function () {
		      throw new Error(
		        'ws does not work in the browser. Browser clients must use the native ' +
		          'WebSocket object'
		      );
		    };

// Use codes between 0~127 for lesser throughput (1 byte)
		    exports.Protocol = void 0;
		    (function (Protocol) {
		        // Room-related (10~19)
		        Protocol[Protocol["HANDSHAKE"] = 9] = "HANDSHAKE";
		        Protocol[Protocol["JOIN_ROOM"] = 10] = "JOIN_ROOM";
		        Protocol[Protocol["ERROR"] = 11] = "ERROR";
		        Protocol[Protocol["LEAVE_ROOM"] = 12] = "LEAVE_ROOM";
		        Protocol[Protocol["ROOM_DATA"] = 13] = "ROOM_DATA";
		        Protocol[Protocol["ROOM_STATE"] = 14] = "ROOM_STATE";
		        Protocol[Protocol["ROOM_STATE_PATCH"] = 15] = "ROOM_STATE_PATCH";
		        Protocol[Protocol["ROOM_DATA_SCHEMA"] = 16] = "ROOM_DATA_SCHEMA";
		        Protocol[Protocol["ROOM_DATA_BYTES"] = 17] = "ROOM_DATA_BYTES";
		    })(exports.Protocol || (exports.Protocol = {}));
		    exports.ErrorCode = void 0;
		    (function (ErrorCode) {
		        ErrorCode[ErrorCode["MATCHMAKE_NO_HANDLER"] = 4210] = "MATCHMAKE_NO_HANDLER";
		        ErrorCode[ErrorCode["MATCHMAKE_INVALID_CRITERIA"] = 4211] = "MATCHMAKE_INVALID_CRITERIA";
		        ErrorCode[ErrorCode["MATCHMAKE_INVALID_ROOM_ID"] = 4212] = "MATCHMAKE_INVALID_ROOM_ID";
		        ErrorCode[ErrorCode["MATCHMAKE_UNHANDLED"] = 4213] = "MATCHMAKE_UNHANDLED";
		        ErrorCode[ErrorCode["MATCHMAKE_EXPIRED"] = 4214] = "MATCHMAKE_EXPIRED";
		        ErrorCode[ErrorCode["AUTH_FAILED"] = 4215] = "AUTH_FAILED";
		        ErrorCode[ErrorCode["APPLICATION_ERROR"] = 4216] = "APPLICATION_ERROR";
		    })(exports.ErrorCode || (exports.ErrorCode = {}));
		    function utf8Read(view, offset) {
		        var length = view[offset++];
		        var string = '', chr = 0;
		        for (var i = offset, end = offset + length; i < end; i++) {
		            var byte = view[i];
		            if ((byte & 0x80) === 0x00) {
		                string += String.fromCharCode(byte);
		                continue;
		            }
		            if ((byte & 0xe0) === 0xc0) {
		                string += String.fromCharCode(((byte & 0x1f) << 6) |
		                    (view[++i] & 0x3f));
		                continue;
		            }
		            if ((byte & 0xf0) === 0xe0) {
		                string += String.fromCharCode(((byte & 0x0f) << 12) |
		                    ((view[++i] & 0x3f) << 6) |
		                    ((view[++i] & 0x3f) << 0));
		                continue;
		            }
		            if ((byte & 0xf8) === 0xf0) {
		                chr = ((byte & 0x07) << 18) |
		                    ((view[++i] & 0x3f) << 12) |
		                    ((view[++i] & 0x3f) << 6) |
		                    ((view[++i] & 0x3f) << 0);
		                if (chr >= 0x010000) { // surrogate pair
		                    chr -= 0x010000;
		                    string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
		                }
		                else {
		                    string += String.fromCharCode(chr);
		                }
		                continue;
		            }
		            throw new Error('Invalid byte ' + byte.toString(16));
		        }
		        return string;
		    }
		    // Faster for short strings than Buffer.byteLength
		    function utf8Length(str) {
		        if (str === void 0) { str = ''; }
		        var c = 0;
		        var length = 0;
		        for (var i = 0, l = str.length; i < l; i++) {
		            c = str.charCodeAt(i);
		            if (c < 0x80) {
		                length += 1;
		            }
		            else if (c < 0x800) {
		                length += 2;
		            }
		            else if (c < 0xd800 || c >= 0xe000) {
		                length += 3;
		            }
		            else {
		                i++;
		                length += 4;
		            }
		        }
		        return length + 1;
		    }

/**
		     * The MIT License (MIT)
		     *
		     * Copyright 2016 Andrey Sitnik <andrey@sitnik.ru>
		     *
		     * Permission is hereby granted, free of charge, to any person obtaining a copy of
		     * this software and associated documentation files (the "Software"), to deal in
		     * the Software without restriction, including without limitation the rights to
		     * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
		     * the Software, and to permit persons to whom the Software is furnished to do so,
		     * subject to the following conditions:
		     *
		     * The above copyright notice and this permission notice shall be included in all
		     * copies or substantial portions of the Software.
		     *
		     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
		     * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
		     * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
		     * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		     * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		     */
		    var createNanoEvents = function () { return ({
		        emit: function (event) {
		            var args = [];
		            for (var _i = 1; _i < arguments.length; _i++) {
		                args[_i - 1] = arguments[_i];
		            }
		            var callbacks = this.events[event] || [];
		            for (var i = 0, length_1 = callbacks.length; i < length_1; i++) {
		                callbacks[i].apply(callbacks, args);
		            }
		        },
		        events: {},
		        on: function (event, cb) {
		            var _this = this;
		            var _a;
		            ((_a = this.events[event]) === null || _a === void 0 ? void 0 : _a.push(cb)) || (this.events[event] = [cb]);
		            return function () {
		                var _a;
		                _this.events[event] = (_a = _this.events[event]) === null || _a === void 0 ? void 0 : _a.filter(function (i) { return cb !== i; });
		            };
		        }
		    }); };

var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn) {
		      var module = { exports: {} };
		    	return fn(module, module.exports), module.exports;
		    }

var umd = createCommonjsModule(function (module, exports) {
		    (function (global, factory) {
		        factory(exports) ;
		    })(commonjsGlobal$1, (function (exports) {
		        /******************************************************************************
		        Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
		        purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
		        REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
		        AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
		        INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
		        LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
		        OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
		        PERFORMANCE OF THIS SOFTWARE.
		        ***************************************************************************** */
		        /* global Reflect, Promise */

function __extends(d, b) {
		            if (typeof b !== "function" && b !== null)
		                throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		            extendStatics(d, b);
		            function __() { this.constructor = d; }
		            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		        }

function __decorate(decorators, target, key, desc) {
		            var c = arguments.length, r = c < 3 ? target : desc, d;
		            if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
		            else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
		            return c > 3 && r && Object.defineProperty(target, key, r), r;
		        }

// export const SWITCH_TO_STRUCTURE = 193; (easily collides with DELETE_AND_ADD + fieldIndex = 2)
		        var SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
		        var TYPE_ID = 213;
		        /**
		         * Encoding Schema field operations.
		         */
		        exports.OPERATION = void 0;
		        (function (OPERATION) {
		            // add new structure/primitive
		            OPERATION[OPERATION["ADD"] = 128] = "ADD";
		            // replace structure/primitive
		            OPERATION[OPERATION["REPLACE"] = 0] = "REPLACE";
		            // delete field
		            OPERATION[OPERATION["DELETE"] = 64] = "DELETE";
		            // DELETE field, followed by an ADD
		            OPERATION[OPERATION["DELETE_AND_ADD"] = 192] = "DELETE_AND_ADD";
		            // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
		            // touches are NOT encoded.
		            OPERATION[OPERATION["TOUCH"] = 1] = "TOUCH";
		            // MapSchema Operations
		            OPERATION[OPERATION["CLEAR"] = 10] = "CLEAR";
		        })(exports.OPERATION || (exports.OPERATION = {}));
		        // export enum OPERATION {
		        //     // add new structure/primitive
		        //     // (128)
		        //     ADD = 128, // 10000000,
		        //     // replace structure/primitive
		        //     REPLACE = 1,// 00000001
		        //     // delete field
		        //     DELETE = 192, // 11000000
		        //     // DELETE field, followed by an ADD
		        //     DELETE_AND_ADD = 224, // 11100000
		        //     // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
		        //     // touches are NOT encoded.
		        //     TOUCH = 0, // 00000000
		        //     // MapSchema Operations
		        //     CLEAR = 10,
		        // }

/**
		         * Copyright (c) 2018 Endel Dreyer
		         * Copyright (c) 2014 Ion Drive Software Ltd.
		         *
		         * Permission is hereby granted, free of charge, to any person obtaining a copy
		         * of this software and associated documentation files (the "Software"), to deal
		         * in the Software without restriction, including without limitation the rights
		         * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		         * copies of the Software, and to permit persons to whom the Software is
		         * furnished to do so, subject to the following conditions:
		         *
		         * The above copyright notice and this permission notice shall be included in all
		         * copies or substantial portions of the Software.
		         *
		         * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		         * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		         * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		         * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		         * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		         * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		         * SOFTWARE
		         */
		        /**
		         * msgpack implementation highly based on notepack.io
		         * https://github.com/darrachequesne/notepack
		         */
		        function utf8Length(str) {
		            var c = 0, length = 0;
		            for (var i = 0, l = str.length; i < l; i++) {
		                c = str.charCodeAt(i);
		                if (c < 0x80) {
		                    length += 1;
		                }
		                else if (c < 0x800) {
		                    length += 2;
		                }
		                else if (c < 0xd800 || c >= 0xe000) {
		                    length += 3;
		                }
		                else {
		                    i++;
		                    length += 4;
		                }
		            }
		            return length;
		        }
		        function utf8Write(view, offset, str) {
		            var c = 0;
		            for (var i = 0, l = str.length; i < l; i++) {
		                c = str.charCodeAt(i);
		                if (c < 0x80) {
		                    view[offset++] = c;
		                }
		                else if (c < 0x800) {
		                    view[offset++] = 0xc0 | (c >> 6);
		                    view[offset++] = 0x80 | (c & 0x3f);
		                }
		                else if (c < 0xd800 || c >= 0xe000) {
		                    view[offset++] = 0xe0 | (c >> 12);
		                    view[offset++] = 0x80 | (c >> 6 & 0x3f);
		                    view[offset++] = 0x80 | (c & 0x3f);
		                }
		                else {
		                    i++;
		                    c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
		                    view[offset++] = 0xf0 | (c >> 18);
		                    view[offset++] = 0x80 | (c >> 12 & 0x3f);
		                    view[offset++] = 0x80 | (c >> 6 & 0x3f);
		                    view[offset++] = 0x80 | (c & 0x3f);
		                }
		            }
		        }
		        function int8$1(bytes, value) {
		            bytes.push(value & 255);
		        }
		        function uint8$1(bytes, value) {
		            bytes.push(value & 255);
		        }
		        function int16$1(bytes, value) {
		            bytes.push(value & 255);
		            bytes.push((value >> 8) & 255);
		        }
		        function uint16$1(bytes, value) {
		            bytes.push(value & 255);
		            bytes.push((value >> 8) & 255);
		        }
		        function int32$1(bytes, value) {
		            bytes.push(value & 255);
		            bytes.push((value >> 8) & 255);
		            bytes.push((value >> 16) & 255);
		            bytes.push((value >> 24) & 255);
		        }
		        function uint32$1(bytes, value) {
		            var b4 = value >> 24;
		            var b3 = value >> 16;
		            var b2 = value >> 8;
		            var b1 = value;
		            bytes.push(b1 & 255);
		            bytes.push(b2 & 255);
		            bytes.push(b3 & 255);
		            bytes.push(b4 & 255);
		        }
		        function int64$1(bytes, value) {
		            var high = Math.floor(value / Math.pow(2, 32));
		            var low = value >>> 0;
		            uint32$1(bytes, low);
		            uint32$1(bytes, high);
		        }
		        function uint64$1(bytes, value) {
		            var high = (value / Math.pow(2, 32)) >> 0;
		            var low = value >>> 0;
		            uint32$1(bytes, low);
		            uint32$1(bytes, high);
		        }
		        function float32$1(bytes, value) {
		            writeFloat32(bytes, value);
		        }
		        function float64$1(bytes, value) {
		            writeFloat64(bytes, value);
		        }
		        var _int32$1 = new Int32Array(2);
		        var _float32$1 = new Float32Array(_int32$1.buffer);
		        var _float64$1 = new Float64Array(_int32$1.buffer);
		        function writeFloat32(bytes, value) {
		            _float32$1[0] = value;
		            int32$1(bytes, _int32$1[0]);
		        }
		        function writeFloat64(bytes, value) {
		            _float64$1[0] = value;
		            int32$1(bytes, _int32$1[0 ]);
		            int32$1(bytes, _int32$1[1 ]);
		        }
		        function boolean$1(bytes, value) {
		            return uint8$1(bytes, value ? 1 : 0);
		        }
		        function string$1(bytes, value) {
		            // encode `null` strings as empty.
		            if (!value) {
		                value = "";
		            }
		            var length = utf8Length(value);
		            var size = 0;
		            // fixstr
		            if (length < 0x20) {
		                bytes.push(length | 0xa0);
		                size = 1;
		            }
		            // str 8
		            else if (length < 0x100) {
		                bytes.push(0xd9);
		                uint8$1(bytes, length);
		                size = 2;
		            }
		            // str 16
		            else if (length < 0x10000) {
		                bytes.push(0xda);
		                uint16$1(bytes, length);
		                size = 3;
		            }
		            // str 32
		            else if (length < 0x100000000) {
		                bytes.push(0xdb);
		                uint32$1(bytes, length);
		                size = 5;
		            }
		            else {
		                throw new Error('String too long');
		            }
		            utf8Write(bytes, bytes.length, value);
		            return size + length;
		        }
		        function number$1(bytes, value) {
		            if (isNaN(value)) {
		                return number$1(bytes, 0);
		            }
		            else if (!isFinite(value)) {
		                return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER);
		            }
		            else if (value !== (value | 0)) {
		                bytes.push(0xcb);
		                writeFloat64(bytes, value);
		                return 9;
		                // TODO: encode float 32?
		                // is it possible to differentiate between float32 / float64 here?
		                // // float 32
		                // bytes.push(0xca);
		                // writeFloat32(bytes, value);
		                // return 5;
		            }
		            if (value >= 0) {
		                // positive fixnum
		                if (value < 0x80) {
		                    uint8$1(bytes, value);
		                    return 1;
		                }
		                // uint 8
		                if (value < 0x100) {
		                    bytes.push(0xcc);
		                    uint8$1(bytes, value);
		                    return 2;
		                }
		                // uint 16
		                if (value < 0x10000) {
		                    bytes.push(0xcd);
		                    uint16$1(bytes, value);
		                    return 3;
		                }
		                // uint 32
		                if (value < 0x100000000) {
		                    bytes.push(0xce);
		                    uint32$1(bytes, value);
		                    return 5;
		                }
		                // uint 64
		                bytes.push(0xcf);
		                uint64$1(bytes, value);
		                return 9;
		            }
		            else {
		                // negative fixnum
		                if (value >= -0x20) {
		                    bytes.push(0xe0 | (value + 0x20));
		                    return 1;
		                }
		                // int 8
		                if (value >= -0x80) {
		                    bytes.push(0xd0);
		                    int8$1(bytes, value);
		                    return 2;
		                }
		                // int 16
		                if (value >= -0x8000) {
		                    bytes.push(0xd1);
		                    int16$1(bytes, value);
		                    return 3;
		                }
		                // int 32
		                if (value >= -0x80000000) {
		                    bytes.push(0xd2);
		                    int32$1(bytes, value);
		                    return 5;
		                }
		                // int 64
		                bytes.push(0xd3);
		                int64$1(bytes, value);
		                return 9;
		            }
		        }

var encode = /*#__PURE__*/Object.freeze({
		            __proto__: null,
		            utf8Write: utf8Write,
		            int8: int8$1,
		            uint8: uint8$1,
		            int16: int16$1,
		            uint16: uint16$1,
		            int32: int32$1,
		            uint32: uint32$1,
		            int64: int64$1,
		            uint64: uint64$1,
		            float32: float32$1,
		            float64: float64$1,
		            writeFloat32: writeFloat32,
		            writeFloat64: writeFloat64,
		            boolean: boolean$1,
		            string: string$1,
		            number: number$1
		        });

/**
		         * Copyright (c) 2018 Endel Dreyer
		         * Copyright (c) 2014 Ion Drive Software Ltd.
		         *
		         * Permission is hereby granted, free of charge, to any person obtaining a copy
		         * of this software and associated documentation files (the "Software"), to deal
		         * in the Software without restriction, including without limitation the rights
		         * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		         * copies of the Software, and to permit persons to whom the Software is
		         * furnished to do so, subject to the following conditions:
		         *
		         * The above copyright notice and this permission notice shall be included in all
		         * copies or substantial portions of the Software.
		         *
		         * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		         * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		         * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		         * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		         * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		         * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		         * SOFTWARE
		         */
		        function utf8Read(bytes, offset, length) {
		            var string = '', chr = 0;
		            for (var i = offset, end = offset + length; i < end; i++) {
		                var byte = bytes[i];
		                if ((byte & 0x80) === 0x00) {
		                    string += String.fromCharCode(byte);
		                    continue;
		                }
		                if ((byte & 0xe0) === 0xc0) {
		                    string += String.fromCharCode(((byte & 0x1f) << 6) |
		                        (bytes[++i] & 0x3f));
		                    continue;
		                }
		                if ((byte & 0xf0) === 0xe0) {
		                    string += String.fromCharCode(((byte & 0x0f) << 12) |
		                        ((bytes[++i] & 0x3f) << 6) |
		                        ((bytes[++i] & 0x3f) << 0));
		                    continue;
		                }
		                if ((byte & 0xf8) === 0xf0) {
		                    chr = ((byte & 0x07) << 18) |
		                        ((bytes[++i] & 0x3f) << 12) |
		                        ((bytes[++i] & 0x3f) << 6) |
		                        ((bytes[++i] & 0x3f) << 0);
		                    if (chr >= 0x010000) { // surrogate pair
		                        chr -= 0x010000;
		                        string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
		                    }
		                    else {
		                        string += String.fromCharCode(chr);
		                    }
		                    continue;
		                }
		                console.error('Invalid byte ' + byte.toString(16));
		                // (do not throw error to avoid server/client from crashing due to hack attemps)
		                // throw new Error('Invalid byte ' + byte.toString(16));
		            }
		            return string;
		        }
		        function int8(bytes, it) {
		            return uint8(bytes, it) << 24 >> 24;
		        }
		        function uint8(bytes, it) {
		            return bytes[it.offset++];
		        }
		        function int16(bytes, it) {
		            return uint16(bytes, it) << 16 >> 16;
		        }
		        function uint16(bytes, it) {
		            return bytes[it.offset++] | bytes[it.offset++] << 8;
		        }
		        function int32(bytes, it) {
		            return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
		        }
		        function uint32(bytes, it) {
		            return int32(bytes, it) >>> 0;
		        }
		        function float32(bytes, it) {
		            return readFloat32(bytes, it);
		        }
		        function float64(bytes, it) {
		            return readFloat64(bytes, it);
		        }
		        function int64(bytes, it) {
		            var low = uint32(bytes, it);
		            var high = int32(bytes, it) * Math.pow(2, 32);
		            return high + low;
		        }
		        function uint64(bytes, it) {
		            var low = uint32(bytes, it);
		            var high = uint32(bytes, it) * Math.pow(2, 32);
		            return high + low;
		        }
		        var _int32 = new Int32Array(2);
		        var _float32 = new Float32Array(_int32.buffer);
		        var _float64 = new Float64Array(_int32.buffer);
		        function readFloat32(bytes, it) {
		            _int32[0] = int32(bytes, it);
		            return _float32[0];
		        }
		        function readFloat64(bytes, it) {
		            _int32[0 ] = int32(bytes, it);
		            _int32[1 ] = int32(bytes, it);
		            return _float64[0];
		        }
		        function boolean(bytes, it) {
		            return uint8(bytes, it) > 0;
		        }
		        function string(bytes, it) {
		            var prefix = bytes[it.offset++];
		            var length;
		            if (prefix < 0xc0) {
		                // fixstr
		                length = prefix & 0x1f;
		            }
		            else if (prefix === 0xd9) {
		                length = uint8(bytes, it);
		            }
		            else if (prefix === 0xda) {
		                length = uint16(bytes, it);
		            }
		            else if (prefix === 0xdb) {
		                length = uint32(bytes, it);
		            }
		            var value = utf8Read(bytes, it.offset, length);
		            it.offset += length;
		            return value;
		        }
		        function stringCheck(bytes, it) {
		            var prefix = bytes[it.offset];
		            return (
		            // fixstr
		            (prefix < 0xc0 && prefix > 0xa0) ||
		                // str 8
		                prefix === 0xd9 ||
		                // str 16
		                prefix === 0xda ||
		                // str 32
		                prefix === 0xdb);
		        }
		        function number(bytes, it) {
		            var prefix = bytes[it.offset++];
		            if (prefix < 0x80) {
		                // positive fixint
		                return prefix;
		            }
		            else if (prefix === 0xca) {
		                // float 32
		                return readFloat32(bytes, it);
		            }
		            else if (prefix === 0xcb) {
		                // float 64
		                return readFloat64(bytes, it);
		            }
		            else if (prefix === 0xcc) {
		                // uint 8
		                return uint8(bytes, it);
		            }
		            else if (prefix === 0xcd) {
		                // uint 16
		                return uint16(bytes, it);
		            }
		            else if (prefix === 0xce) {
		                // uint 32
		                return uint32(bytes, it);
		            }
		            else if (prefix === 0xcf) {
		                // uint 64
		                return uint64(bytes, it);
		            }
		            else if (prefix === 0xd0) {
		                // int 8
		                return int8(bytes, it);
		            }
		            else if (prefix === 0xd1) {
		                // int 16
		                return int16(bytes, it);
		            }
		            else if (prefix === 0xd2) {
		                // int 32
		                return int32(bytes, it);
		            }
		            else if (prefix === 0xd3) {
		                // int 64
		                return int64(bytes, it);
		            }
		            else if (prefix > 0xdf) {
		                // negative fixint
		                return (0xff - prefix + 1) * -1;
		            }
		        }
		        function numberCheck(bytes, it) {
		            var prefix = bytes[it.offset];
		            // positive fixint - 0x00 - 0x7f
		            // float 32        - 0xca
		            // float 64        - 0xcb
		            // uint 8          - 0xcc
		            // uint 16         - 0xcd
		            // uint 32         - 0xce
		            // uint 64         - 0xcf
		            // int 8           - 0xd0
		            // int 16          - 0xd1
		            // int 32          - 0xd2
		            // int 64          - 0xd3
		            return (prefix < 0x80 ||
		                (prefix >= 0xca && prefix <= 0xd3));
		        }
		        function arrayCheck(bytes, it) {
		            return bytes[it.offset] < 0xa0;
		            // const prefix = bytes[it.offset] ;
		            // if (prefix < 0xa0) {
		            //   return prefix;
		            // // array
		            // } else if (prefix === 0xdc) {
		            //   it.offset += 2;
		            // } else if (0xdd) {
		            //   it.offset += 4;
		            // }
		            // return prefix;
		        }
		        function switchStructureCheck(bytes, it) {
		            return (
		            // previous byte should be `SWITCH_TO_STRUCTURE`
		            bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
		                // next byte should be a number
		                (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3)));
		        }

var decode = /*#__PURE__*/Object.freeze({
		            __proto__: null,
		            int8: int8,
		            uint8: uint8,
		            int16: int16,
		            uint16: uint16,
		            int32: int32,
		            uint32: uint32,
		            float32: float32,
		            float64: float64,
		            int64: int64,
		            uint64: uint64,
		            readFloat32: readFloat32,
		            readFloat64: readFloat64,
		            boolean: boolean,
		            string: string,
		            stringCheck: stringCheck,
		            number: number,
		            numberCheck: numberCheck,
		            arrayCheck: arrayCheck,
		            switchStructureCheck: switchStructureCheck
		        });

registerType("map", { constructor: MapSchema });
		        registerType("array", { constructor: ArraySchema });
		        registerType("set", { constructor: SetSchema });
		        registerType("collection", { constructor: CollectionSchema, });

exports.ArraySchema = ArraySchema;
		        exports.CollectionSchema = CollectionSchema;
		        exports.Context = Context;
		        exports.MapSchema = MapSchema;
		        exports.Reflection = Reflection;
		        exports.ReflectionField = ReflectionField;
		        exports.ReflectionType = ReflectionType;
		        exports.Schema = Schema;
		        exports.SchemaDefinition = SchemaDefinition;
		        exports.SetSchema = SetSchema;
		        exports.decode = decode;
		        exports.defineTypes = defineTypes;
		        exports.deprecated = deprecated;
		        exports.dumpChanges = dumpChanges;
		        exports.encode = encode;
		        exports.filter = filter;
		        exports.filterChildren = filterChildren;
		        exports.hasFilter = hasFilter;
		        exports.registerType = registerType;
		        exports.type = type;

Object.defineProperty(exports, '__esModule', { value: true });

}));
		    });

function apply(src, tar) {
		    	tar.statusMessage = src.statusText;
		    	tar.statusCode = src.status;
		    	tar.data = src.body;
		    }

function send(method, uri, opts) {
		    	opts = opts || {};
		    	var timer, ctrl, tmp=opts.body;

opts.method = method;
		    	opts.headers = opts.headers || {};

if (tmp instanceof FormData) ; else if (tmp && typeof tmp == 'object') {
		    		opts.headers['content-type'] = 'application/json';
		    		opts.body = JSON.stringify(tmp);
		    	}

if (opts.withCredentials) {
		    		opts.credentials = 'include';
		    	}

if (opts.timeout) {
		    		ctrl = new AbortController;
		    		opts.signal = ctrl.signal;
		    		timer = setTimeout(ctrl.abort, opts.timeout);
		    	}

return new Promise((res, rej) => {
		    		fetch(uri, opts).then((rr, reply) => {
		    			clearTimeout(timer);

apply(rr, rr); //=> rr.headers
		    			reply = rr.status >= 400 ? rej : res;

tmp = rr.headers.get('content-type');
		    			if (!tmp || !~tmp.indexOf('application/json')) {
		    				reply(rr);
		    			} else {
		    				rr.text().then(str => {
		    					try {
		    						rr.data = JSON.parse(str, opts.reviver);
		    						reply(rr);
		    					} catch (err) {
		    						err.headers = rr.headers;
		    						apply(rr, err);
		    						rej(err);
		    					}
		    				});
		    			}
		    		}).catch(err => {
		    			err.timeout = ctrl && ctrl.signal.aborted;
		    			rej(err);
		    		});
		    	});
		    }

var get = /*#__PURE__*/ send.bind(send, 'GET');
		    var post = /*#__PURE__*/ send.bind(send, 'POST');
		    var patch = /*#__PURE__*/ send.bind(send, 'PATCH');
		    var del = /*#__PURE__*/ send.bind(send, 'DELETE');
		    var put = /*#__PURE__*/ send.bind(send, 'PUT');

var del_1 = del;
		    var get_1 = get;
		    var patch_1 = patch;
		    var post_1 = post;
		    var put_1 = put;
		    var send_1 = send;

var fetch_1 = {
		    	del: del_1,
		    	get: get_1,
		    	patch: patch_1,
		    	post: post_1,
		    	put: put_1,
		    	send: send_1
		    };

var httpie = /*#__PURE__*/_mergeNamespaces({
		        __proto__: null,
		        'default': fetch_1,
		        del: del_1,
		        get: get_1,
		        patch: patch_1,
		        post: post_1,
		        put: put_1,
		        send: send_1
		    }, [fetch_1]);

/// <reference path="../typings/cocos-creator.d.ts" />
		    /**
		     * We do not assign 'storage' to window.localStorage immediatelly for React
		     * Native compatibility. window.localStorage is not present when this module is
		     * loaded.
		     */
		    var storage;
		    function getStorage() {
		        if (!storage) {
		            try {
		                storage = (typeof (cc) !== 'undefined' && cc.sys && cc.sys.localStorage)
		                    ? cc.sys.localStorage // compatibility with cocos creator
		                    : window.localStorage; // RN does have window object at this point, but localStorage is not defined
		            }
		            catch (e) {
		                // ignore error
		            }
		        }
		        if (!storage) {
		            // mock localStorage if not available (Node.js or RN environment)
		            storage = {
		                cache: {},
		                setItem: function (key, value) { this.cache[key] = value; },
		                getItem: function (key) { this.cache[key]; },
		                removeItem: function (key) { delete this.cache[key]; },
		            };
		        }
		        return storage;
		    }
		    function setItem(key, value) {
		        getStorage().setItem(key, value);
		    }
		    function removeItem(key) {
		        getStorage().removeItem(key);
		    }
		    function getItem(key, callback) {
		        var value = getStorage().getItem(key);
		        if (typeof (Promise) === 'undefined' || // old browsers
		            !(value instanceof Promise)) {
		            // browser has synchronous return
		            callback(value);
		        }
		        else {
		            // react-native is asynchronous
		            value.then(function (id) { return callback(id); });
		        }
		    }

var _Auth__initialized, _Auth__initializationPromise, _Auth__signInWindow, _Auth__events;
		    var Auth = /** @class */ (function () {
		        function Auth(http) {
		            var _this = this;
		            this.http = http;
		            this.settings = {
		                path: "/auth",
		                key: "colyseus-auth-token",
		            };
		            _Auth__initialized.set(this, false);
		            _Auth__initializationPromise.set(this, void 0);
		            _Auth__signInWindow.set(this, undefined);
		            _Auth__events.set(this, createNanoEvents());
		            getItem(this.settings.key, function (token) { return _this.token = token; });
		        }
		        Object.defineProperty(Auth.prototype, "token", {
		            get: function () {
		                return this.http.authToken;
		            },
		            set: function (token) {
		                this.http.authToken = token;
		            },
		            enumerable: false,
		            configurable: true
		        });
		        Auth.prototype.onChange = function (callback) {
		            var _this = this;
		            var unbindChange = __classPrivateFieldGet(this, _Auth__events, "f").on("change", callback);
		            if (!__classPrivateFieldGet(this, _Auth__initialized, "f")) {
		                __classPrivateFieldSet(this, _Auth__initializationPromise, new Promise(function (resolve, reject) {
		                    _this.getUserData().then(function (userData) {
		                        _this.emitChange(__assign(__assign({}, userData), { token: _this.token }));
		                    }).catch(function (e) {
		                        // user is not logged in, or service is down
		                        _this.emitChange({ user: null, token: undefined });
		                    }).finally(function () {
		                        resolve();
		                    });
		                }));
		            }
		            __classPrivateFieldSet(this, _Auth__initialized, true);
		            return unbindChange;
		        };
		        Auth.prototype.getUserData = function () {
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            if (!this.token) return [3 /*break*/, 2];
		                            return [4 /*yield*/, this.http.get("".concat(this.settings.path, "/userdata"))];
		                        case 1: return [2 /*return*/, (_a.sent()).data];
		                        case 2: throw new Error("missing auth.token");
		                    }
		                });
		            });
		        };
		        Auth.prototype.registerWithEmailAndPassword = function (email, password, options) {
		            return __awaiter(this, void 0, void 0, function () {
		                var data;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.post("".concat(this.settings.path, "/register"), {
		                                body: { email: email, password: password, options: options, },
		                            })];
		                        case 1:
		                            data = (_a.sent()).data;
		                            this.emitChange(data);
		                            return [2 /*return*/, data];
		                    }
		                });
		            });
		        };
		        Auth.prototype.signInWithEmailAndPassword = function (email, password) {
		            return __awaiter(this, void 0, void 0, function () {
		                var data;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.post("".concat(this.settings.path, "/login"), {
		                                body: { email: email, password: password, },
		                            })];
		                        case 1:
		                            data = (_a.sent()).data;
		                            this.emitChange(data);
		                            return [2 /*return*/, data];
		                    }
		                });
		            });
		        };
		        Auth.prototype.signInAnonymously = function (options) {
		            return __awaiter(this, void 0, void 0, function () {
		                var data;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.post("".concat(this.settings.path, "/anonymous"), {
		                                body: { options: options, }
		                            })];
		                        case 1:
		                            data = (_a.sent()).data;
		                            this.emitChange(data);
		                            return [2 /*return*/, data];
		                    }
		                });
		            });
		        };
		        Auth.prototype.sendPasswordResetEmail = function (email) {
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.post("".concat(this.settings.path, "/forgot-password"), {
		                                body: { email: email, }
		                            })];
		                        case 1: return [2 /*return*/, (_a.sent()).data];
		                    }
		                });
		            });
		        };
		        Auth.prototype.signInWithProvider = function (providerName, settings) {
		            if (settings === void 0) { settings = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                var _this = this;
		                return __generator(this, function (_a) {
		                    return [2 /*return*/, new Promise(function (resolve, reject) {
		                            var w = settings.width || 480;
		                            var h = settings.height || 768;
		                            // forward existing token for upgrading
		                            var upgradingToken = _this.token ? "?token=".concat(_this.token) : "";
		                            // Capitalize first letter of providerName
		                            var title = "Login with ".concat((providerName[0].toUpperCase() + providerName.substring(1)));
		                            var url = _this.http['client']['getHttpEndpoint']("".concat((settings.prefix || "".concat(_this.settings.path, "/provider")), "/").concat(providerName).concat(upgradingToken));
		                            var left = (screen.width / 2) - (w / 2);
		                            var top = (screen.height / 2) - (h / 2);
		                            __classPrivateFieldSet(_this, _Auth__signInWindow, window.open(url, title, 'toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=' + w + ', height=' + h + ', top=' + top + ', left=' + left));
		                            var onMessage = function (event) {
		                                // TODO: it is a good idea to check if event.origin can be trusted!
		                                // if (event.origin.indexOf(window.location.hostname) === -1) { return; }
		                                // require 'user' and 'token' inside received data.
		                                if (event.data.user === undefined && event.data.token === undefined) {
		                                    return;
		                                }
		                                clearInterval(rejectionChecker);
		                                __classPrivateFieldGet(_this, _Auth__signInWindow, "f").close();
		                                __classPrivateFieldSet(_this, _Auth__signInWindow, undefined);
		                                window.removeEventListener("message", onMessage);
		                                if (event.data.error !== undefined) {
		                                    reject(event.data.error);
		                                }
		                                else {
		                                    resolve(event.data);
		                                    _this.emitChange(event.data);
		                                }
		                            };
		                            var rejectionChecker = setInterval(function () {
		                                if (!__classPrivateFieldGet(_this, _Auth__signInWindow, "f") || __classPrivateFieldGet(_this, _Auth__signInWindow, "f").closed) {
		                                    __classPrivateFieldSet(_this, _Auth__signInWindow, undefined);
		                                    reject("cancelled");
		                                    window.removeEventListener("message", onMessage);
		                                }
		                            }, 200);
		                            window.addEventListener("message", onMessage);
		                        })];
		                });
		            });
		        };
		        Auth.prototype.signOut = function () {
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    this.emitChange({ user: null, token: null });
		                    return [2 /*return*/];
		                });
		            });
		        };
		        Auth.prototype.emitChange = function (authData) {
		            if (authData.token !== undefined) {
		                this.token = authData.token;
		                if (authData.token === null) {
		                    removeItem(this.settings.key);
		                }
		                else {
		                    // store key in localStorage
		                    setItem(this.settings.key, authData.token);
		                }
		            }
		            __classPrivateFieldGet(this, _Auth__events, "f").emit("change", authData);
		        };
		        return Auth;
		    }());
		    _Auth__initialized = new WeakMap(), _Auth__initializationPromise = new WeakMap(), _Auth__signInWindow = new WeakMap(), _Auth__events = new WeakMap();

/**
		     * Discord Embedded App SDK
		     * https://github.com/colyseus/colyseus/issues/707
		     *
		     * All URLs must go through the local proxy from
		     * https://<app_id>.discordsays.com/.proxy/<mapped_url>/...
		     *
		     * URL Mapping Examples:
		     *
		     * 1. Using Colyseus Cloud:
		     *   - /colyseus/{subdomain} -> {subdomain}.colyseus.cloud
		     *
		     *   Example:
		     *     const client = new Client("https://xxxx.colyseus.cloud");
		     *
		     * -------------------------------------------------------------
		     *
		     * 2. Using `cloudflared` tunnel:
		     *   - /colyseus/ -> <your-cloudflared-url>.trycloudflare.com
		     *
		     *   Example:
		     *     const client = new Client("https://<your-cloudflared-url>.trycloudflare.com");
		     *
		     * -------------------------------------------------------------
		     *
		     * 3. Providing a manual /.proxy/your-mapping:
		     *   - /your-mapping/ -> your-endpoint.com
		     *
		     *   Example:
		     *     const client = new Client("/.proxy/your-mapping");
		     *
		     */
		    function discordURLBuilder(url) {
		        var _a;
		        var localHostname = ((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.hostname) || "localhost";
		        var remoteHostnameSplitted = url.hostname.split('.');
		        var subdomain = (!url.hostname.includes("trycloudflare.com") && // ignore cloudflared subdomains
		            !url.hostname.includes("discordsays.com") && // ignore discordsays.com subdomains
		            remoteHostnameSplitted.length > 2)
		            ? "/".concat(remoteHostnameSplitted[0])
		            : '';
		        return (url.pathname.startsWith("/.proxy"))
		            ? "".concat(url.protocol, "//").concat(localHostname).concat(subdomain).concat(url.pathname).concat(url.search)
		            : "".concat(url.protocol, "//").concat(localHostname, "/.proxy/colyseus").concat(subdomain).concat(url.pathname).concat(url.search);
		    }

var _a;
		    var MatchMakeError = /** @class */ (function (_super) {
		        __extends(MatchMakeError, _super);
		        function MatchMakeError(message, code) {
		            var _this = _super.call(this, message) || this;
		            _this.code = code;
		            Object.setPrototypeOf(_this, MatchMakeError.prototype);
		            return _this;
		        }
		        return MatchMakeError;
		    }(Error));
		    // - React Native does not provide `window.location`
		    // - Cocos Creator (Native) does not provide `window.location.hostname`
		    var DEFAULT_ENDPOINT = (typeof (window) !== "undefined" && typeof ((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.hostname) !== "undefined")
		        ? "".concat(window.location.protocol.replace("http", "ws"), "//").concat(window.location.hostname).concat((window.location.port && ":".concat(window.location.port)))
		        : "ws://127.0.0.1:2567";
		    var Client = /** @class */ (function () {
		        function Client(settings, customURLBuilder) {
		            if (settings === void 0) { settings = DEFAULT_ENDPOINT; }
		            var _a, _b;
		            if (typeof (settings) === "string") {
		                //
		                // endpoint by url
		                //
		                var url = (settings.startsWith("/"))
		                    ? new URL(settings, DEFAULT_ENDPOINT)
		                    : new URL(settings);
		                var secure = (url.protocol === "https:" || url.protocol === "wss:");
		                var port = Number(url.port || (secure ? 443 : 80));
		                this.settings = {
		                    hostname: url.hostname,
		                    pathname: url.pathname,
		                    port: port,
		                    secure: secure
		                };
		            }
		            else {
		                //
		                // endpoint by settings
		                //
		                if (settings.port === undefined) {
		                    settings.port = (settings.secure) ? 443 : 80;
		                }
		                if (settings.pathname === undefined) {
		                    settings.pathname = "";
		                }
		                this.settings = settings;
		            }
		            // make sure pathname does not end with "/"
		            if (this.settings.pathname.endsWith("/")) {
		                this.settings.pathname = this.settings.pathname.slice(0, -1);
		            }
		            this.http = new HTTP(this);
		            this.auth = new Auth(this.http);
		            this.urlBuilder = customURLBuilder;
		            //
		            // Discord Embedded SDK requires a custom URL builder
		            //
		            if (!this.urlBuilder &&
		                typeof (window) !== "undefined" &&
		                ((_b = (_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.hostname) === null || _b === void 0 ? void 0 : _b.includes("discordsays.com"))) {
		                this.urlBuilder = discordURLBuilder;
		                console.log("Colyseus SDK: Discord Embedded SDK detected. Using custom URL builder.");
		            }
		        }
		        Client.prototype.joinOrCreate = function (roomName, options, rootSchema) {
		            if (options === void 0) { options = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.createMatchMakeRequest('joinOrCreate', roomName, options, rootSchema)];
		                        case 1: return [2 /*return*/, _a.sent()];
		                    }
		                });
		            });
		        };
		        Client.prototype.create = function (roomName, options, rootSchema) {
		            if (options === void 0) { options = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.createMatchMakeRequest('create', roomName, options, rootSchema)];
		                        case 1: return [2 /*return*/, _a.sent()];
		                    }
		                });
		            });
		        };
		        Client.prototype.join = function (roomName, options, rootSchema) {
		            if (options === void 0) { options = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.createMatchMakeRequest('join', roomName, options, rootSchema)];
		                        case 1: return [2 /*return*/, _a.sent()];
		                    }
		                });
		            });
		        };
		        Client.prototype.joinById = function (roomId, options, rootSchema) {
		            if (options === void 0) { options = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.createMatchMakeRequest('joinById', roomId, options, rootSchema)];
		                        case 1: return [2 /*return*/, _a.sent()];
		                    }
		                });
		            });
		        };
		        /**
		         * Re-establish connection with a room this client was previously connected to.
		         *
		         * @param reconnectionToken The `room.reconnectionToken` from previously connected room.
		         * @param rootSchema (optional) Concrete root schema definition
		         * @returns Promise<Room>
		         */
		        Client.prototype.reconnect = function (reconnectionToken, rootSchema) {
		            return __awaiter(this, void 0, void 0, function () {
		                var _a, roomId, token;
		                return __generator(this, function (_b) {
		                    switch (_b.label) {
		                        case 0:
		                            if (typeof (reconnectionToken) === "string" && typeof (rootSchema) === "string") {
		                                throw new Error("DEPRECATED: .reconnect() now only accepts 'reconnectionToken' as argument.\nYou can get this token from previously connected `room.reconnectionToken`");
		                            }
		                            _a = reconnectionToken.split(":"), roomId = _a[0], token = _a[1];
		                            if (!roomId || !token) {
		                                throw new Error("Invalid reconnection token format.\nThe format should be roomId:reconnectionToken");
		                            }
		                            return [4 /*yield*/, this.createMatchMakeRequest('reconnect', roomId, { reconnectionToken: token }, rootSchema)];
		                        case 1: return [2 /*return*/, _b.sent()];
		                    }
		                });
		            });
		        };
		        Client.prototype.getAvailableRooms = function (roomName) {
		            if (roomName === void 0) { roomName = ""; }
		            return __awaiter(this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.get("matchmake/".concat(roomName), {
		                                headers: {
		                                    'Accept': 'application/json'
		                                }
		                            })];
		                        case 1: return [2 /*return*/, (_a.sent()).data];
		                    }
		                });
		            });
		        };
		        Client.prototype.consumeSeatReservation = function (response, rootSchema, reuseRoomInstance // used in devMode
		        ) {
		            return __awaiter(this, void 0, void 0, function () {
		                var room, options, targetRoom;
		                var _this = this;
		                return __generator(this, function (_a) {
		                    room = this.createRoom(response.room.name, rootSchema);
		                    room.roomId = response.room.roomId;
		                    room.sessionId = response.sessionId;
		                    options = { sessionId: room.sessionId };
		                    // forward "reconnection token" in case of reconnection.
		                    if (response.reconnectionToken) {
		                        options.reconnectionToken = response.reconnectionToken;
		                    }
		                    targetRoom = reuseRoomInstance || room;
		                    room.connect(this.buildEndpoint(response.room, options), response.devMode && (function () { return __awaiter(_this, void 0, void 0, function () {
		                        var retryCount, retryMaxRetries, retryReconnection;
		                        var _this = this;
		                        return __generator(this, function (_a) {
		                            console.info("[Colyseus devMode]: ".concat(String.fromCodePoint(0x1F504), " Re-establishing connection with room id '").concat(room.roomId, "'...")); // 🔄
		                            retryCount = 0;
		                            retryMaxRetries = 8;
		                            retryReconnection = function () { return __awaiter(_this, void 0, void 0, function () {
		                                return __generator(this, function (_a) {
		                                    switch (_a.label) {
		                                        case 0:
		                                            retryCount++;
		                                            _a.label = 1;
		                                        case 1:
		                                            _a.trys.push([1, 3, , 4]);
		                                            return [4 /*yield*/, this.consumeSeatReservation(response, rootSchema, targetRoom)];
		                                        case 2:
		                                            _a.sent();
		                                            console.info("[Colyseus devMode]: ".concat(String.fromCodePoint(0x2705), " Successfully re-established connection with room '").concat(room.roomId, "'")); // ✅
		                                            return [3 /*break*/, 4];
		                                        case 3:
		                                            _a.sent();
		                                            if (retryCount < retryMaxRetries) {
		                                                console.info("[Colyseus devMode]: ".concat(String.fromCodePoint(0x1F504), " retrying... (").concat(retryCount, " out of ").concat(retryMaxRetries, ")")); // 🔄
		                                                setTimeout(retryReconnection, 2000);
		                                            }
		                                            else {
		                                                console.info("[Colyseus devMode]: ".concat(String.fromCodePoint(0x274C), " Failed to reconnect. Is your server running? Please check server logs.")); // ❌
		                                            }
		                                            return [3 /*break*/, 4];
		                                        case 4: return [2 /*return*/];
		                                    }
		                                });
		                            }); };
		                            setTimeout(retryReconnection, 2000);
		                            return [2 /*return*/];
		                        });
		                    }); }), targetRoom);
		                    return [2 /*return*/, new Promise(function (resolve, reject) {
		                            var onError = function (code, message) { return reject(new ServerError(code, message)); };
		                            targetRoom.onError.once(onError);
		                            targetRoom['onJoin'].once(function () {
		                                targetRoom.onError.remove(onError);
		                                resolve(targetRoom);
		                            });
		                        })];
		                });
		            });
		        };
		        Client.prototype.createMatchMakeRequest = function (method, roomName, options, rootSchema, reuseRoomInstance) {
		            if (options === void 0) { options = {}; }
		            return __awaiter(this, void 0, void 0, function () {
		                var response;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, this.http.post("matchmake/".concat(method, "/").concat(roomName), {
		                                headers: {
		                                    'Accept': 'application/json',
		                                    'Content-Type': 'application/json'
		                                },
		                                body: JSON.stringify(options)
		                            })];
		                        case 1:
		                            response = (_a.sent()).data;
		                            // FIXME: HTTP class is already handling this as ServerError.
		                            if (response.error) {
		                                throw new MatchMakeError(response.error, response.code);
		                            }
		                            // forward reconnection token during "reconnect" methods.
		                            if (method === "reconnect") {
		                                response.reconnectionToken = options.reconnectionToken;
		                            }
		                            return [4 /*yield*/, this.consumeSeatReservation(response, rootSchema, reuseRoomInstance)];
		                        case 2: return [2 /*return*/, _a.sent()];
		                    }
		                });
		            });
		        };
		        Client.prototype.createRoom = function (roomName, rootSchema) {
		            return new Room(roomName, rootSchema);
		        };
		        Client.prototype.buildEndpoint = function (room, options) {
		            if (options === void 0) { options = {}; }
		            var params = [];
		            // append provided options
		            for (var name_1 in options) {
		                if (!options.hasOwnProperty(name_1)) {
		                    continue;
		                }
		                params.push("".concat(name_1, "=").concat(options[name_1]));
		            }
		            var endpoint = (this.settings.secure)
		                ? "wss://"
		                : "ws://";
		            if (room.publicAddress) {
		                endpoint += "".concat(room.publicAddress);
		            }
		            else {
		                endpoint += "".concat(this.settings.hostname).concat(this.getEndpointPort()).concat(this.settings.pathname);
		            }
		            var endpointURL = "".concat(endpoint, "/").concat(room.processId, "/").concat(room.roomId, "?").concat(params.join('&'));
		            return (this.urlBuilder)
		                ? this.urlBuilder(new URL(endpointURL))
		                : endpointURL;
		        };
		        Client.prototype.getHttpEndpoint = function (segments) {
		            if (segments === void 0) { segments = ''; }
		            var path = segments.startsWith("/") ? segments : "/".concat(segments);
		            var endpointURL = "".concat((this.settings.secure) ? "https" : "http", "://").concat(this.settings.hostname).concat(this.getEndpointPort()).concat(this.settings.pathname).concat(path);
		            return (this.urlBuilder)
		                ? this.urlBuilder(new URL(endpointURL))
		                : endpointURL;
		        };
		        Client.prototype.getEndpointPort = function () {
		            return (this.settings.port !== 80 && this.settings.port !== 443)
		                ? ":".concat(this.settings.port)
		                : "";
		        };
		        return Client;
		    }());

registerSerializer('schema', SchemaSerializer);
		    registerSerializer('none', NoneSerializer);

exports.Auth = Auth;
		    exports.Client = Client;
		    exports.Room = Room;
		    exports.SchemaSerializer = SchemaSerializer;
		    exports.registerSerializer = registerSerializer;

Object.defineProperty(exports, '__esModule', { value: true });

}));
		
	} (colyseus, colyseus.exports));

var colyseusExports = colyseus.exports;

var umd = {exports: {}};

(function (module, exports) {
		(function (global, factory) {
		    factory(exports) ;
		})(commonjsGlobal, (function (exports) {
		    /******************************************************************************
		    Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
		    purpose with or without fee is hereby granted.

function __decorate(decorators, target, key, desc) {
		        var c = arguments.length, r = c < 3 ? target : desc, d;
		        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
		        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
		        return c > 3 && r && Object.defineProperty(target, key, r), r;
		    }

typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
		        var e = new Error(message);
		        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
		    };

// export const SWITCH_TO_STRUCTURE = 193; (easily collides with DELETE_AND_ADD + fieldIndex = 2)
		    var SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
		    var TYPE_ID = 213;
		    /**
		     * Encoding Schema field operations.
		     */
		    exports.OPERATION = void 0;
		    (function (OPERATION) {
		        // add new structure/primitive
		        OPERATION[OPERATION["ADD"] = 128] = "ADD";
		        // replace structure/primitive
		        OPERATION[OPERATION["REPLACE"] = 0] = "REPLACE";
		        // delete field
		        OPERATION[OPERATION["DELETE"] = 64] = "DELETE";
		        // DELETE field, followed by an ADD
		        OPERATION[OPERATION["DELETE_AND_ADD"] = 192] = "DELETE_AND_ADD";
		        // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
		        // touches are NOT encoded.
		        OPERATION[OPERATION["TOUCH"] = 1] = "TOUCH";
		        // MapSchema Operations
		        OPERATION[OPERATION["CLEAR"] = 10] = "CLEAR";
		    })(exports.OPERATION || (exports.OPERATION = {}));
		    // export enum OPERATION {
		    //     // add new structure/primitive
		    //     // (128)
		    //     ADD = 128, // 10000000,
		    //     // replace structure/primitive
		    //     REPLACE = 1,// 00000001
		    //     // delete field
		    //     DELETE = 192, // 11000000
		    //     // DELETE field, followed by an ADD
		    //     DELETE_AND_ADD = 224, // 11100000
		    //     // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
		    //     // touches are NOT encoded.
		    //     TOUCH = 0, // 00000000
		    //     // MapSchema Operations
		    //     CLEAR = 10,
		    // }

/**
		     * Copyright (c) 2018 Endel Dreyer
		     * Copyright (c) 2014 Ion Drive Software Ltd.
		     *
		     * Permission is hereby granted, free of charge, to any person obtaining a copy
		     * of this software and associated documentation files (the "Software"), to deal
		     * in the Software without restriction, including without limitation the rights
		     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		     * copies of the Software, and to permit persons to whom the Software is
		     * furnished to do so, subject to the following conditions:
		     *
		     * The above copyright notice and this permission notice shall be included in all
		     * copies or substantial portions of the Software.
		     *
		     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		     * SOFTWARE
		     */
		    /**
		     * msgpack implementation highly based on notepack.io
		     * https://github.com/darrachequesne/notepack
		     */
		    function utf8Length(str) {
		        var c = 0, length = 0;
		        for (var i = 0, l = str.length; i < l; i++) {
		            c = str.charCodeAt(i);
		            if (c < 0x80) {
		                length += 1;
		            }
		            else if (c < 0x800) {
		                length += 2;
		            }
		            else if (c < 0xd800 || c >= 0xe000) {
		                length += 3;
		            }
		            else {
		                i++;
		                length += 4;
		            }
		        }
		        return length;
		    }
		    function utf8Write(view, offset, str) {
		        var c = 0;
		        for (var i = 0, l = str.length; i < l; i++) {
		            c = str.charCodeAt(i);
		            if (c < 0x80) {
		                view[offset++] = c;
		            }
		            else if (c < 0x800) {
		                view[offset++] = 0xc0 | (c >> 6);
		                view[offset++] = 0x80 | (c & 0x3f);
		            }
		            else if (c < 0xd800 || c >= 0xe000) {
		                view[offset++] = 0xe0 | (c >> 12);
		                view[offset++] = 0x80 | (c >> 6 & 0x3f);
		                view[offset++] = 0x80 | (c & 0x3f);
		            }
		            else {
		                i++;
		                c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
		                view[offset++] = 0xf0 | (c >> 18);
		                view[offset++] = 0x80 | (c >> 12 & 0x3f);
		                view[offset++] = 0x80 | (c >> 6 & 0x3f);
		                view[offset++] = 0x80 | (c & 0x3f);
		            }
		        }
		    }
		    function int8$1(bytes, value) {
		        bytes.push(value & 255);
		    }
		    function uint8$1(bytes, value) {
		        bytes.push(value & 255);
		    }
		    function int16$1(bytes, value) {
		        bytes.push(value & 255);
		        bytes.push((value >> 8) & 255);
		    }
		    function uint16$1(bytes, value) {
		        bytes.push(value & 255);
		        bytes.push((value >> 8) & 255);
		    }
		    function int32$1(bytes, value) {
		        bytes.push(value & 255);
		        bytes.push((value >> 8) & 255);
		        bytes.push((value >> 16) & 255);
		        bytes.push((value >> 24) & 255);
		    }
		    function uint32$1(bytes, value) {
		        var b4 = value >> 24;
		        var b3 = value >> 16;
		        var b2 = value >> 8;
		        var b1 = value;
		        bytes.push(b1 & 255);
		        bytes.push(b2 & 255);
		        bytes.push(b3 & 255);
		        bytes.push(b4 & 255);
		    }
		    function int64$1(bytes, value) {
		        var high = Math.floor(value / Math.pow(2, 32));
		        var low = value >>> 0;
		        uint32$1(bytes, low);
		        uint32$1(bytes, high);
		    }
		    function uint64$1(bytes, value) {
		        var high = (value / Math.pow(2, 32)) >> 0;
		        var low = value >>> 0;
		        uint32$1(bytes, low);
		        uint32$1(bytes, high);
		    }
		    function float32$1(bytes, value) {
		        writeFloat32(bytes, value);
		    }
		    function float64$1(bytes, value) {
		        writeFloat64(bytes, value);
		    }
		    var _int32$1 = new Int32Array(2);
		    var _float32$1 = new Float32Array(_int32$1.buffer);
		    var _float64$1 = new Float64Array(_int32$1.buffer);
		    function writeFloat32(bytes, value) {
		        _float32$1[0] = value;
		        int32$1(bytes, _int32$1[0]);
		    }
		    function writeFloat64(bytes, value) {
		        _float64$1[0] = value;
		        int32$1(bytes, _int32$1[0 ]);
		        int32$1(bytes, _int32$1[1 ]);
		    }
		    function boolean$1(bytes, value) {
		        return uint8$1(bytes, value ? 1 : 0);
		    }
		    function string$1(bytes, value) {
		        // encode `null` strings as empty.
		        if (!value) {
		            value = "";
		        }
		        var length = utf8Length(value);
		        var size = 0;
		        // fixstr
		        if (length < 0x20) {
		            bytes.push(length | 0xa0);
		            size = 1;
		        }
		        // str 8
		        else if (length < 0x100) {
		            bytes.push(0xd9);
		            uint8$1(bytes, length);
		            size = 2;
		        }
		        // str 16
		        else if (length < 0x10000) {
		            bytes.push(0xda);
		            uint16$1(bytes, length);
		            size = 3;
		        }
		        // str 32
		        else if (length < 0x100000000) {
		            bytes.push(0xdb);
		            uint32$1(bytes, length);
		            size = 5;
		        }
		        else {
		            throw new Error('String too long');
		        }
		        utf8Write(bytes, bytes.length, value);
		        return size + length;
		    }
		    function number$1(bytes, value) {
		        if (isNaN(value)) {
		            return number$1(bytes, 0);
		        }
		        else if (!isFinite(value)) {
		            return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER);
		        }
		        else if (value !== (value | 0)) {
		            bytes.push(0xcb);
		            writeFloat64(bytes, value);
		            return 9;
		            // TODO: encode float 32?
		            // is it possible to differentiate between float32 / float64 here?
		            // // float 32
		            // bytes.push(0xca);
		            // writeFloat32(bytes, value);
		            // return 5;
		        }
		        if (value >= 0) {
		            // positive fixnum
		            if (value < 0x80) {
		                uint8$1(bytes, value);
		                return 1;
		            }
		            // uint 8
		            if (value < 0x100) {
		                bytes.push(0xcc);
		                uint8$1(bytes, value);
		                return 2;
		            }
		            // uint 16
		            if (value < 0x10000) {
		                bytes.push(0xcd);
		                uint16$1(bytes, value);
		                return 3;
		            }
		            // uint 32
		            if (value < 0x100000000) {
		                bytes.push(0xce);
		                uint32$1(bytes, value);
		                return 5;
		            }
		            // uint 64
		            bytes.push(0xcf);
		            uint64$1(bytes, value);
		            return 9;
		        }
		        else {
		            // negative fixnum
		            if (value >= -0x20) {
		                bytes.push(0xe0 | (value + 0x20));
		                return 1;
		            }
		            // int 8
		            if (value >= -0x80) {
		                bytes.push(0xd0);
		                int8$1(bytes, value);
		                return 2;
		            }
		            // int 16
		            if (value >= -0x8000) {
		                bytes.push(0xd1);
		                int16$1(bytes, value);
		                return 3;
		            }
		            // int 32
		            if (value >= -0x80000000) {
		                bytes.push(0xd2);
		                int32$1(bytes, value);
		                return 5;
		            }
		            // int 64
		            bytes.push(0xd3);
		            int64$1(bytes, value);
		            return 9;
		        }
		    }

var encode = /*#__PURE__*/Object.freeze({
		        __proto__: null,
		        boolean: boolean$1,
		        float32: float32$1,
		        float64: float64$1,
		        int16: int16$1,
		        int32: int32$1,
		        int64: int64$1,
		        int8: int8$1,
		        number: number$1,
		        string: string$1,
		        uint16: uint16$1,
		        uint32: uint32$1,
		        uint64: uint64$1,
		        uint8: uint8$1,
		        utf8Write: utf8Write,
		        writeFloat32: writeFloat32,
		        writeFloat64: writeFloat64
		    });

/**
		     * Copyright (c) 2018 Endel Dreyer
		     * Copyright (c) 2014 Ion Drive Software Ltd.
		     *
		     * Permission is hereby granted, free of charge, to any person obtaining a copy
		     * of this software and associated documentation files (the "Software"), to deal
		     * in the Software without restriction, including without limitation the rights
		     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		     * copies of the Software, and to permit persons to whom the Software is
		     * furnished to do so, subject to the following conditions:
		     *
		     * The above copyright notice and this permission notice shall be included in all
		     * copies or substantial portions of the Software.
		     *
		     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		     * SOFTWARE
		     */
		    function utf8Read(bytes, offset, length) {
		        var string = '', chr = 0;
		        for (var i = offset, end = offset + length; i < end; i++) {
		            var byte = bytes[i];
		            if ((byte & 0x80) === 0x00) {
		                string += String.fromCharCode(byte);
		                continue;
		            }
		            if ((byte & 0xe0) === 0xc0) {
		                string += String.fromCharCode(((byte & 0x1f) << 6) |
		                    (bytes[++i] & 0x3f));
		                continue;
		            }
		            if ((byte & 0xf0) === 0xe0) {
		                string += String.fromCharCode(((byte & 0x0f) << 12) |
		                    ((bytes[++i] & 0x3f) << 6) |
		                    ((bytes[++i] & 0x3f) << 0));
		                continue;
		            }
		            if ((byte & 0xf8) === 0xf0) {
		                chr = ((byte & 0x07) << 18) |
		                    ((bytes[++i] & 0x3f) << 12) |
		                    ((bytes[++i] & 0x3f) << 6) |
		                    ((bytes[++i] & 0x3f) << 0);
		                if (chr >= 0x010000) { // surrogate pair
		                    chr -= 0x010000;
		                    string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
		                }
		                else {
		                    string += String.fromCharCode(chr);
		                }
		                continue;
		            }
		            console.error('Invalid byte ' + byte.toString(16));
		            // (do not throw error to avoid server/client from crashing due to hack attemps)
		            // throw new Error('Invalid byte ' + byte.toString(16));
		        }
		        return string;
		    }
		    function int8(bytes, it) {
		        return uint8(bytes, it) << 24 >> 24;
		    }
		    function uint8(bytes, it) {
		        return bytes[it.offset++];
		    }
		    function int16(bytes, it) {
		        return uint16(bytes, it) << 16 >> 16;
		    }
		    function uint16(bytes, it) {
		        return bytes[it.offset++] | bytes[it.offset++] << 8;
		    }
		    function int32(bytes, it) {
		        return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
		    }
		    function uint32(bytes, it) {
		        return int32(bytes, it) >>> 0;
		    }
		    function float32(bytes, it) {
		        return readFloat32(bytes, it);
		    }
		    function float64(bytes, it) {
		        return readFloat64(bytes, it);
		    }
		    function int64(bytes, it) {
		        var low = uint32(bytes, it);
		        var high = int32(bytes, it) * Math.pow(2, 32);
		        return high + low;
		    }
		    function uint64(bytes, it) {
		        var low = uint32(bytes, it);
		        var high = uint32(bytes, it) * Math.pow(2, 32);
		        return high + low;
		    }
		    var _int32 = new Int32Array(2);
		    var _float32 = new Float32Array(_int32.buffer);
		    var _float64 = new Float64Array(_int32.buffer);
		    function readFloat32(bytes, it) {
		        _int32[0] = int32(bytes, it);
		        return _float32[0];
		    }
		    function readFloat64(bytes, it) {
		        _int32[0 ] = int32(bytes, it);
		        _int32[1 ] = int32(bytes, it);
		        return _float64[0];
		    }
		    function boolean(bytes, it) {
		        return uint8(bytes, it) > 0;
		    }
		    function string(bytes, it) {
		        var prefix = bytes[it.offset++];
		        var length;
		        if (prefix < 0xc0) {
		            // fixstr
		            length = prefix & 0x1f;
		        }
		        else if (prefix === 0xd9) {
		            length = uint8(bytes, it);
		        }
		        else if (prefix === 0xda) {
		            length = uint16(bytes, it);
		        }
		        else if (prefix === 0xdb) {
		            length = uint32(bytes, it);
		        }
		        var value = utf8Read(bytes, it.offset, length);
		        it.offset += length;
		        return value;
		    }
		    function stringCheck(bytes, it) {
		        var prefix = bytes[it.offset];
		        return (
		        // fixstr
		        (prefix < 0xc0 && prefix > 0xa0) ||
		            // str 8
		            prefix === 0xd9 ||
		            // str 16
		            prefix === 0xda ||
		            // str 32
		            prefix === 0xdb);
		    }
		    function number(bytes, it) {
		        var prefix = bytes[it.offset++];
		        if (prefix < 0x80) {
		            // positive fixint
		            return prefix;
		        }
		        else if (prefix === 0xca) {
		            // float 32
		            return readFloat32(bytes, it);
		        }
		        else if (prefix === 0xcb) {
		            // float 64
		            return readFloat64(bytes, it);
		        }
		        else if (prefix === 0xcc) {
		            // uint 8
		            return uint8(bytes, it);
		        }
		        else if (prefix === 0xcd) {
		            // uint 16
		            return uint16(bytes, it);
		        }
		        else if (prefix === 0xce) {
		            // uint 32
		            return uint32(bytes, it);
		        }
		        else if (prefix === 0xcf) {
		            // uint 64
		            return uint64(bytes, it);
		        }
		        else if (prefix === 0xd0) {
		            // int 8
		            return int8(bytes, it);
		        }
		        else if (prefix === 0xd1) {
		            // int 16
		            return int16(bytes, it);
		        }
		        else if (prefix === 0xd2) {
		            // int 32
		            return int32(bytes, it);
		        }
		        else if (prefix === 0xd3) {
		            // int 64
		            return int64(bytes, it);
		        }
		        else if (prefix > 0xdf) {
		            // negative fixint
		            return (0xff - prefix + 1) * -1;
		        }
		    }
		    function numberCheck(bytes, it) {
		        var prefix = bytes[it.offset];
		        // positive fixint - 0x00 - 0x7f
		        // float 32        - 0xca
		        // float 64        - 0xcb
		        // uint 8          - 0xcc
		        // uint 16         - 0xcd
		        // uint 32         - 0xce
		        // uint 64         - 0xcf
		        // int 8           - 0xd0
		        // int 16          - 0xd1
		        // int 32          - 0xd2
		        // int 64          - 0xd3
		        return (prefix < 0x80 ||
		            (prefix >= 0xca && prefix <= 0xd3));
		    }
		    function arrayCheck(bytes, it) {
		        return bytes[it.offset] < 0xa0;
		        // const prefix = bytes[it.offset] ;
		        // if (prefix < 0xa0) {
		        //   return prefix;
		        // // array
		        // } else if (prefix === 0xdc) {
		        //   it.offset += 2;
		        // } else if (0xdd) {
		        //   it.offset += 4;
		        // }
		        // return prefix;
		    }
		    function switchStructureCheck(bytes, it) {
		        return (
		        // previous byte should be `SWITCH_TO_STRUCTURE`
		        bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
		            // next byte should be a number
		            (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3)));
		    }

var decode = /*#__PURE__*/Object.freeze({
		        __proto__: null,
		        arrayCheck: arrayCheck,
		        boolean: boolean,
		        float32: float32,
		        float64: float64,
		        int16: int16,
		        int32: int32,
		        int64: int64,
		        int8: int8,
		        number: number,
		        numberCheck: numberCheck,
		        readFloat32: readFloat32,
		        readFloat64: readFloat64,
		        string: string,
		        stringCheck: stringCheck,
		        switchStructureCheck: switchStructureCheck,
		        uint16: uint16,
		        uint32: uint32,
		        uint64: uint64,
		        uint8: uint8
		    });

registerType("map", { constructor: MapSchema });
		    registerType("array", { constructor: ArraySchema });
		    registerType("set", { constructor: SetSchema });
		    registerType("collection", { constructor: CollectionSchema, });

exports.ArraySchema = ArraySchema;
		    exports.CollectionSchema = CollectionSchema;
		    exports.Context = Context;
		    exports.MapSchema = MapSchema;
		    exports.Reflection = Reflection;
		    exports.ReflectionField = ReflectionField;
		    exports.ReflectionType = ReflectionType;
		    exports.Schema = Schema;
		    exports.SchemaDefinition = SchemaDefinition;
		    exports.SetSchema = SetSchema;
		    exports.decode = decode;
		    exports.defineTypes = defineTypes;
		    exports.deprecated = deprecated;
		    exports.dumpChanges = dumpChanges;
		    exports.encode = encode;
		    exports.filter = filter;
		    exports.filterChildren = filterChildren;
		    exports.hasFilter = hasFilter;
		    exports.registerType = registerType;
		    exports.type = type;

})); 
	} (umd, umd.exports));

var umdExports = umd.exports;

var Protocol = {};

class SchemaSerializer extends EventTarget {
	    state;
	    setState(rawState) {
	        this.state.decode(rawState);
	        this.dispatchEvent(new CustomEvent('patch', { detail: null }));
	        this.dispatchEvent(new Event('load'));
	    }
	    getState() {
	        return this.state;
	    }
	    patch(patches) {
	        let res = this.state.decode(patches);
	        for (let change of res) {
	            if (change.field != 'gameTime') {
	                this.dispatchEvent(new CustomEvent('patch', { detail: res }));
	                break;
	            }
	        }
	    }
	    teardown() {
	        this.state?.['$changes']?.root.clearRefs();
	    }
	    handshake(bytes, it) {
	        if (this.state) {
	            const reflection = new umdExports.Reflection();
	            reflection.decode(bytes, it);
	        }
	        else {
	            // initialize reflected state from server
	            this.state = umdExports.Reflection.decode(bytes, it);
	        }
	        this.dispatchEvent(new CustomEvent('patch', { detail: null }));
	    }
	}
	const serializer = new SchemaSerializer();
	function onMessage(event) {
	    const bytes = Array.from(new Uint8Array(event.data));
	    const code = bytes[0];
	    if (code === colyseusExports.Protocol.JOIN_ROOM) {
	        let offset = 1;
	        const reconnectionToken = Protocol.utf8Read(bytes, offset);
	        offset += Protocol.utf8Length(reconnectionToken);
	        const serializerId = Protocol.utf8Read(bytes, offset);
	        offset += Protocol.utf8Length(serializerId);
	        console.log(reconnectionToken, serializerId, offset);
	        if (bytes.length > offset) {
	            serializer.handshake(bytes, { offset });
	        }
	    }
	    else if (code === colyseusExports.Protocol.ROOM_DATA_SCHEMA) ;
	    else if (code === colyseusExports.Protocol.ROOM_STATE) {
	        bytes.shift(); // drop `code` byte
	        serializer.setState(bytes);
	    }
	    else if (code === colyseusExports.Protocol.ROOM_STATE_PATCH) {
	        bytes.shift(); // drop `code` byte
	        serializer.patch(bytes);
	    }
	    else if (code === colyseusExports.Protocol.ROOM_DATA) {
	        const it = { offset: 1 };
	        const type = (umdExports.decode.stringCheck(bytes, it))
	            ? umdExports.decode.string(bytes, it)
	            : umdExports.decode.number(bytes, it);
	        const message = (bytes.length > it.offset)
	            ? decode_1(event.data, it.offset)
	            : undefined;
	        return { type, message };
	    }
	    else if (code === colyseusExports.Protocol.ROOM_DATA_BYTES) {
	        const it = { offset: 1 };
	        const type = (umdExports.decode.stringCheck(bytes, it))
	            ? umdExports.decode.string(bytes, it)
	            : umdExports.decode.number(bytes, it);
	        return { type, message: new Uint8Array(bytes.slice(it.offset)) };
	    }
	    return null;
	}

class SocketManager extends EventTarget {
	    socket = null;
	    transportType = writable("unknown");
	    blueboatRoomId = null;
	    setup() {
	        let manager = this;
	        // override the default WebSocket
	        class NewWebSocket extends WebSocket {
	            constructor(url, params) {
	                super(url, params);
	                if (!manager.socket) {
	                    manager.registerSocket(this);
	                }
	            }
	            send(data) {
	                manager.onSend(data);
	                super.send(data);
	            }
	        }
	        // override XMLHttpRequest to get the room id
	        let nativeXMLSend = XMLHttpRequest.prototype.send;
	        XMLHttpRequest.prototype.send = function () {
	            this.addEventListener('load', () => {
	                if (!this.responseURL.endsWith("/matchmaker/join"))
	                    return;
	                let response = JSON.parse(this.responseText);
	                manager.blueboatRoomId = response.roomId;
	                console.log("Got Blueboat Room Id: " + manager.blueboatRoomId);
	            });
	            nativeXMLSend.apply(this, arguments);
	        };
	        getUnsafeWindow().WebSocket = NewWebSocket;
	    }
	    registerSocket(socket) {
	        this.socket = socket;
	        // detect the transport type
	        if ('Phaser' in getUnsafeWindow()) {
	            this.transportType.set("colyseus");
	            this.addEventListener('colyseusMessage', (e) => {
	                if (e.detail.type != "DEVICES_STATES_CHANGES")
	                    return;
	                let changes = parseChangePacket(e.detail.message);
	                this.dispatchEvent(new CustomEvent('deviceChanges', {
	                    detail: changes
	                }));
	            });
	        }
	        else
	            this.transportType.set("blueboat");
	        // when we get a message, decode it and dispatch it
	        socket.addEventListener('message', (e) => {
	            let decoded;
	            if (get_store_value(this.transportType) == 'colyseus') {
	                decoded = onMessage(e);
	                if (!decoded)
	                    return;
	                this.dispatchEvent(new CustomEvent('colyseusMessage', {
	                    detail: decoded
	                }));
	            }
	            else {
	                decoded = blueboat.decode(e.data);
	                if (!decoded)
	                    return;
	                this.dispatchEvent(new CustomEvent('blueboatMessage', {
	                    detail: decoded
	                }));
	            }
	        });
	    }
	    onSend(data) {
	        // if we're already in a room, get the room id from the data
	        if (get_store_value(this.transportType) == "blueboat" && !this.blueboatRoomId) {
	            let decoded = blueboat.decode(data);
	            if (decoded.roomId)
	                this.blueboatRoomId = decoded.roomId;
	            if (decoded.room)
	                this.blueboatRoomId = decoded.room;
	            if (this.blueboatRoomId) {
	                console.log("Got Blueboat Room Id: " + this.blueboatRoomId);
	            }
	        }
	    }
	    sendMessage(channel, data) {
	        if (!this.socket)
	            return;
	        if (!this.blueboatRoomId && get_store_value(this.transportType) == "blueboat")
	            return;
	        let encoded;
	        if (get_store_value(this.transportType) == 'colyseus') {
	            let header = [colyseusExports.Protocol.ROOM_DATA];
	            let channelEncoded = encode_1(channel);
	            let packetEncoded = encode_1(data);
	            // combine the arraybuffers
	            encoded = new Uint8Array(channelEncoded.byteLength + packetEncoded.byteLength + header.length);
	            encoded.set(header);
	            encoded.set(new Uint8Array(channelEncoded), header.length);
	            encoded.set(new Uint8Array(packetEncoded), header.length + channelEncoded.byteLength);
	        }
	        else
	            encoded = blueboat.encode(channel, data, this.blueboatRoomId);
	        this.socket.send(encoded);
	    }
	}
	const socketManager = new SocketManager();

/* src\hud\Menu.svelte generated by Svelte v4.2.19 */

const { window: window_1$1 } = globals;

function create_fragment$E(ctx) {
		let div3;
		let div0;
		let t0;
		let t1;
		let button;
		let t2_value = (/*minimized*/ ctx[2] ? "+" : "-") + "";
		let t2;
		let t3;
		let div2;
		let div1;
		let current;
		let mounted;
		let dispose;
		const default_slot_template = /*#slots*/ ctx[11].default;
		const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[10], null);

return {
			c() {
				div3 = element("div");
				div0 = element("div");
				t0 = text(/*name*/ ctx[0]);
				t1 = space();
				button = element("button");
				t2 = text(t2_value);
				t3 = space();
				div2 = element("div");
				div1 = element("div");
				if (default_slot) default_slot.c();
				attr(button, "class", "minimize svelte-4jfbq8");
				attr(div0, "class", "header svelte-4jfbq8");
				attr(div1, "class", "groupContent open svelte-4jfbq8");
				attr(div2, "class", "children svelte-4jfbq8");
				attr(div3, "class", "menu svelte-4jfbq8");
				set_style(div3, "left", /*$coordSpring*/ ctx[3].x + "px");
				set_style(div3, "top", /*$coordSpring*/ ctx[3].y + "px");
				toggle_class(div3, "minimized", /*minimized*/ ctx[2]);
			},
			m(target, anchor) {
				insert(target, div3, anchor);
				append(div3, div0);
				append(div0, t0);
				append(div0, t1);
				append(div0, button);
				append(button, t2);
				append(div3, t3);
				append(div3, div2);
				append(div2, div1);

if (default_slot) {
					default_slot.m(div1, null);
				}

/*div3_binding*/ ctx[12](div3);
				current = true;

if (!mounted) {
					dispose = [
						listen(window_1$1, "mouseup", /*stopDrag*/ ctx[8]),
						listen(window_1$1, "mousemove", /*drag*/ ctx[7]),
						listen(window_1$1, "resize", /*onResize*/ ctx[5]),
						listen(button, "click", /*toggleMinimized*/ ctx[9]),
						listen(div3, "mousedown", /*startDrag*/ ctx[6])
					];

mounted = true;
				}
			},
			p(ctx, dirty) {
				if (!current || dirty[0] & /*name*/ 1) set_data(t0, /*name*/ ctx[0]);
				if ((!current || dirty[0] & /*minimized*/ 4) && t2_value !== (t2_value = (/*minimized*/ ctx[2] ? "+" : "-") + "")) set_data(t2, t2_value);

if (default_slot) {
					if (default_slot.p && (!current || dirty[0] & /*$$scope*/ 1024)) {
						update_slot_base(
							default_slot,
							default_slot_template,
							ctx,
							/*$$scope*/ ctx[10],
							!current
							? get_all_dirty_from_scope(/*$$scope*/ ctx[10])
							: get_slot_changes(default_slot_template, /*$$scope*/ ctx[10], dirty, null),
							null
						);
					}
				}

if (!current || dirty[0] & /*$coordSpring*/ 8) {
					set_style(div3, "left", /*$coordSpring*/ ctx[3].x + "px");
				}

if (!current || dirty[0] & /*$coordSpring*/ 8) {
					set_style(div3, "top", /*$coordSpring*/ ctx[3].y + "px");
				}

if (!current || dirty[0] & /*minimized*/ 4) {
					toggle_class(div3, "minimized", /*minimized*/ ctx[2]);
				}
			},
			i(local) {
				if (current) return;
				transition_in(default_slot, local);
				current = true;
			},
			o(local) {
				transition_out(default_slot, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(div3);
				}

if (default_slot) default_slot.d(detaching);
				/*div3_binding*/ ctx[12](null);
				mounted = false;
				run_all(dispose);
			}
		};
	}

function instance$x($$self, $$props, $$invalidate) {
		let $coordSpring;
		let { $$slots: slots = {}, $$scope } = $$props;
		let { name } = $$props;

// This whole file is a mess, but it's a mess that works*
		let transform = getMenuTransform(name);

let x = transform?.x ?? 50;
		let y = transform?.y ?? 50;
		let width = transform?.width ?? 200;
		let height = transform?.height ?? 200;
		let lastWidth = width;
		let lastHeight = height;
		let coordSpring = spring(moveInbounds(x, y), { stiffness: 0.1, damping: 0.5 });
		component_subscribe($$self, coordSpring, value => $$invalidate(3, $coordSpring = value));
		let coords = get_store_value(coordSpring);
		let returnX = coords.x;
		let returnY = coords.y;

function onResize() {
			let coords = get_store_value(coordSpring);
			coordSpring.set(moveInbounds(coords.x, coords.y));
		}

function moveInbounds(x, y) {
			if (x < 0) x = 0;
			if (y < 0) y = 0;
			if (x + lastWidth > window.innerWidth) x = window.innerWidth - lastWidth;
			if (y + lastHeight > window.innerHeight) y = window.innerHeight - lastHeight;
			return { x, y };
		}

let transitioning = false;

// move out of the way when the hud is hidden
		showHud.subscribe(v => {
			if (v) {
				coordSpring.set(moveInbounds(returnX, returnY));
				transitioning = false;
			} else {
				transitioning = true;
				let coords = get_store_value(coordSpring);

// move over the nearest edge
				let cX = coords.x + lastWidth / 2;

let cY = coords.y + lastHeight / 2;

let endX = cX < window.innerWidth / 2
				? -lastWidth
				: window.innerWidth;

let endY = cY < window.innerHeight / 2
				? -lastHeight
				: window.innerHeight;

if (Math.abs(endX - coords.x) < Math.abs(endY - coords.y)) {
					coordSpring.set({ x: endX, y: coords.y });
				} else {
					coordSpring.set({ x: coords.x, y: endY });
				}
			}
		});

let element;
		let minimized = transform?.minimized ?? false;
		let dragState = 'waiting';
		let startX, startY;
		let dragDistance;

function startDrag(event) {
			dragState = 'checking';
			const coords = get_store_value(coordSpring);
			startX = event.clientX - coords.x;
			startY = event.clientY - coords.y;
			dragDistance = 0;
		}

function saveTransform() {
			if (transitioning) return;
			let coords = get_store_value(coordSpring);

setMenuTransform(name, {
				x: coords.x,
				y: coords.y,
				width: lastWidth,
				height: lastHeight,
				minimized
			});
		}

const saveTransformDebounce = debounce$1(saveTransform, 100);
		coordSpring.subscribe(() => saveTransformDebounce());

function drag(event) {
			if (dragState == 'waiting') return;
			dragDistance += Math.abs(event.movementX) + Math.abs(event.movementY);

if (dragState == 'checking' && dragDistance > 5) {
				dragState = 'dragging';
				return;
			}

if (dragState == 'dragging') {
				let newX = event.clientX - startX;
				let newY = event.clientY - startY;
				returnX = newX;
				returnY = newY;
				coordSpring.set(moveInbounds(newX, newY));
				saveTransformDebounce();
			}
		}

function stopDrag() {
			dragState = 'waiting';
		}

let observer = new ResizeObserver(entries => {
				dragState = 'waiting';
				let entry = entries[0];

if (!minimized) {
					lastHeight = entry.contentRect.height;
				}

lastWidth = entry.contentRect.width;
				saveTransformDebounce();
			});

onMount(() => {
			observer.observe(element);
			$$invalidate(1, element.style.height = `${Math.max(height, 21)}px`, element);
			$$invalidate(1, element.style.width = `${Math.max(width, 150)}px`, element);
		});

onDestroy(() => {
			observer.disconnect();
		});

function toggleMinimized() {
			$$invalidate(2, minimized = !minimized);
			saveTransformDebounce();
		}

function div3_binding($$value) {
			binding_callbacks[$$value ? 'unshift' : 'push'](() => {
				element = $$value;
				$$invalidate(1, element);
			});
		}

$$self.$$set = $$props => {
			if ('name' in $$props) $$invalidate(0, name = $$props.name);
			if ('$$scope' in $$props) $$invalidate(10, $$scope = $$props.$$scope);
		};

return [
			name,
			element,
			minimized,
			$coordSpring,
			coordSpring,
			onResize,
			startDrag,
			drag,
			stopDrag,
			toggleMinimized,
			$$scope,
			slots,
			div3_binding
		];
	}

class Menu extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$x, create_fragment$E, safe_not_equal, { name: 0 }, add_css$f, [-1, -1]);
		}
	}

/* node_modules\svelte-material-icons\KeyboardOutline.svelte generated by Svelte v4.2.19 */

function create_if_block_1$5(ctx) {
		let desc_1;
		let t;

return {
			c() {
				desc_1 = svg_element("desc");
				t = text(/*desc*/ ctx[7]);
			},
			m(target, anchor) {
				insert(target, desc_1, anchor);
				append(desc_1, t);
			},
			p(ctx, dirty) {
				if (dirty & /*desc*/ 128) set_data(t, /*desc*/ ctx[7]);
			},
			d(detaching) {
				if (detaching) {
					detach(desc_1);
				}
			}
		};
	}

// (16:165) {#if title}
	function create_if_block$b(ctx) {
		let title_1;
		let t;

return {
			c() {
				title_1 = svg_element("title");
				t = text(/*title*/ ctx[6]);
			},
			m(target, anchor) {
				insert(target, title_1, anchor);
				append(title_1, t);
			},
			p(ctx, dirty) {
				if (dirty & /*title*/ 64) set_data(t, /*title*/ ctx[6]);
			},
			d(detaching) {
				if (detaching) {
					detach(title_1);
				}
			}
		};
	}

function create_fragment$D(ctx) {
		let svg;
		let if_block0_anchor;
		let path;
		let if_block0 = /*desc*/ ctx[7] && create_if_block_1$5(ctx);
		let if_block1 = /*title*/ ctx[6] && create_if_block$b(ctx);

return {
			c() {
				svg = svg_element("svg");
				if (if_block0) if_block0.c();
				if_block0_anchor = empty();
				if (if_block1) if_block1.c();
				path = svg_element("path");
				attr(path, "d", "M4,5A2,2 0 0,0 2,7V17A2,2 0 0,0 4,19H20A2,2 0 0,0 22,17V7A2,2 0 0,0 20,5H4M4,7H20V17H4V7M5,8V10H7V8H5M8,8V10H10V8H8M11,8V10H13V8H11M14,8V10H16V8H14M17,8V10H19V8H17M5,11V13H7V11H5M8,11V13H10V11H8M11,11V13H13V11H11M14,11V13H16V11H14M17,11V13H19V11H17M8,14V16H16V14H8Z");
				attr(path, "fill", /*color*/ ctx[2]);
				attr(svg, "viewBox", /*viewBox*/ ctx[3]);
				attr(svg, "width", /*width*/ ctx[0]);
				attr(svg, "height", /*height*/ ctx[1]);
				attr(svg, "class", /*className*/ ctx[8]);
				attr(svg, "aria-label", /*ariaLabel*/ ctx[4]);
				attr(svg, "aria-hidden", /*ariaHidden*/ ctx[5]);
			},
			m(target, anchor) {
				insert(target, svg, anchor);
				if (if_block0) if_block0.m(svg, null);
				append(svg, if_block0_anchor);
				if (if_block1) if_block1.m(svg, null);
				append(svg, path);
			},
			p(ctx, [dirty]) {
				if (/*desc*/ ctx[7]) {
					if (if_block0) {
						if_block0.p(ctx, dirty);
					} else {
						if_block0 = create_if_block_1$5(ctx);
						if_block0.c();
						if_block0.m(svg, if_block0_anchor);
					}
				} else if (if_block0) {
					if_block0.d(1);
					if_block0 = null;
				}

if (/*title*/ ctx[6]) {
					if (if_block1) {
						if_block1.p(ctx, dirty);
					} else {
						if_block1 = create_if_block$b(ctx);
						if_block1.c();
						if_block1.m(svg, path);
					}
				} else if (if_block1) {
					if_block1.d(1);
					if_block1 = null;
				}

if (dirty & /*color*/ 4) {
					attr(path, "fill", /*color*/ ctx[2]);
				}

if (dirty & /*viewBox*/ 8) {
					attr(svg, "viewBox", /*viewBox*/ ctx[3]);
				}

if (dirty & /*width*/ 1) {
					attr(svg, "width", /*width*/ ctx[0]);
				}

if (dirty & /*height*/ 2) {
					attr(svg, "height", /*height*/ ctx[1]);
				}

if (dirty & /*className*/ 256) {
					attr(svg, "class", /*className*/ ctx[8]);
				}

if (dirty & /*ariaLabel*/ 16) {
					attr(svg, "aria-label", /*ariaLabel*/ ctx[4]);
				}

if (dirty & /*ariaHidden*/ 32) {
					attr(svg, "aria-hidden", /*ariaHidden*/ ctx[5]);
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(svg);
				}

if (if_block0) if_block0.d();
				if (if_block1) if_block1.d();
			}
		};
	}

$$self.$$set = $$props => {
			if ('size' in $$props) $$invalidate(9, size = $$props.size);
			if ('width' in $$props) $$invalidate(0, width = $$props.width);
			if ('height' in $$props) $$invalidate(1, height = $$props.height);
			if ('color' in $$props) $$invalidate(2, color = $$props.color);
			if ('viewBox' in $$props) $$invalidate(3, viewBox = $$props.viewBox);
			if ('ariaLabel' in $$props) $$invalidate(4, ariaLabel = $$props.ariaLabel);
			if ('ariaHidden' in $$props) $$invalidate(5, ariaHidden = $$props.ariaHidden);
			if ('title' in $$props) $$invalidate(6, title = $$props.title);
			if ('desc' in $$props) $$invalidate(7, desc = $$props.desc);
			if ('class' in $$props) $$invalidate(8, className = $$props.class);
		};

return [
			width,
			height,
			color,
			viewBox,
			ariaLabel,
			ariaHidden,
			title,
			desc,
			className,
			size
		];
	}

class KeyboardOutline extends SvelteComponent {
		constructor(options) {
			super();

init(this, options, instance$w, create_fragment$D, safe_not_equal, {
				size: 9,
				width: 0,
				height: 1,
				color: 2,
				viewBox: 3,
				ariaLabel: 4,
				ariaHidden: 5,
				title: 6,
				desc: 7,
				class: 8
			});
		}
	}

class KeybindManager {
	    keysPressed = new Set();
	    keybinds = new Map();
	    constructor() {
	        window.addEventListener('keydown', (e) => {
	            this.keysPressed.add(e.key.toLowerCase());
	            // check if any keybinds are pressed
	            checkKeybinds: for (const [keys, callback] of this.keybinds) {
	                if (keys.size == 0)
	                    continue;
	                for (const key of keys) {
	                    if (!this.keysPressed.has(key)) {
	                        continue checkKeybinds;
	                    }
	                }
	                callback();
	            }
	        });
	        window.addEventListener('keyup', (e) => {
	            this.keysPressed.delete(e.key.toLowerCase());
	        });
	    }
	    addKeybind(keys, callback) {
	        this.keybinds.set(keys, callback);
	    }
	    removeKeybind(keys) {
	        this.keybinds.delete(keys);
	    }
	}
	const keybindManager = new KeybindManager();

/* src\hud\KeybindCreator.svelte generated by Svelte v4.2.19 */

// (49:8) {:else}
	function create_else_block_2(ctx) {
		let t;

return {
			c() {
				t = text("Re-record");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (47:39) 
	function create_if_block_3(ctx) {
		let t;

return {
			c() {
				t = text("Start recording");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (45:8) {#if recording}
	function create_if_block_2(ctx) {
		let t;

return {
			c() {
				t = text("Stop recording");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (60:8) {:else}
	function create_else_block_1$1(ctx) {
		let t_value = Array.from(/*keysDeref*/ ctx[0]).map(func).join(' + ') + "";
		let t;

return {
			c() {
				t = text(t_value);
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			p(ctx, dirty) {
				if (dirty & /*keysDeref*/ 1 && t_value !== (t_value = Array.from(/*keysDeref*/ ctx[0]).map(func).join(' + ') + "")) set_data(t, t_value);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (54:8) {#if keysDeref.size === 0}
	function create_if_block$a(ctx) {
		let if_block_anchor;

function select_block_type_2(ctx, dirty) {
			if (/*recording*/ ctx[1]) return create_if_block_1$4;
			return create_else_block$3;
		}

let current_block_type = select_block_type_2(ctx);
		let if_block = current_block_type(ctx);

return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_block.m(target, anchor);
				insert(target, if_block_anchor, anchor);
			},
			p(ctx, dirty) {
				if (current_block_type !== (current_block_type = select_block_type_2(ctx))) {
					if_block.d(1);
					if_block = current_block_type(ctx);

if (if_block) {
						if_block.c();
						if_block.m(if_block_anchor.parentNode, if_block_anchor);
					}
				}
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

if_block.d(detaching);
			}
		};
	}

// (57:12) {:else}
	function create_else_block$3(ctx) {
		let t;

return {
			c() {
				t = text("No hotkey set");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (55:12) {#if recording}
	function create_if_block_1$4(ctx) {
		let t;

return {
			c() {
				t = text("Press any keys");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

function create_fragment$C(ctx) {
		let dialog_1;
		let h2;
		let t1;
		let button0;
		let t2;
		let div0;
		let t3;
		let div1;
		let button1;
		let t4;
		let button1_disabled_value;
		let t5;
		let button2;
		let mounted;
		let dispose;

function select_block_type(ctx, dirty) {
			if (/*recording*/ ctx[1]) return create_if_block_2;
			if (/*keysDeref*/ ctx[0].size === 0) return create_if_block_3;
			return create_else_block_2;
		}

let current_block_type = select_block_type(ctx);
		let if_block0 = current_block_type(ctx);

function select_block_type_1(ctx, dirty) {
			if (/*keysDeref*/ ctx[0].size === 0) return create_if_block$a;
			return create_else_block_1$1;
		}

let current_block_type_1 = select_block_type_1(ctx);
		let if_block1 = current_block_type_1(ctx);

return {
			c() {
				dialog_1 = element("dialog");
				h2 = element("h2");
				h2.textContent = "Create Hotkey";
				t1 = space();
				button0 = element("button");
				if_block0.c();
				t2 = space();
				div0 = element("div");
				if_block1.c();
				t3 = space();
				div1 = element("div");
				button1 = element("button");
				t4 = text("Confirm");
				t5 = space();
				button2 = element("button");
				button2.textContent = "No hotkey";
				attr(h2, "class", "svelte-1j00okq");
				attr(button0, "class", "recordBtn svelte-1j00okq");
				attr(div0, "class", "hotkeyDisplay svelte-1j00okq");
				button1.disabled = button1_disabled_value = /*keysDeref*/ ctx[0].size === 0;
				attr(button1, "class", "confirm svelte-1j00okq");
				attr(button2, "class", "cancel svelte-1j00okq");
				attr(div1, "class", "completeContainer svelte-1j00okq");
				attr(dialog_1, "class", "svelte-1j00okq");
			},
			m(target, anchor) {
				insert(target, dialog_1, anchor);
				append(dialog_1, h2);
				append(dialog_1, t1);
				append(dialog_1, button0);
				if_block0.m(button0, null);
				append(dialog_1, t2);
				append(dialog_1, div0);
				if_block1.m(div0, null);
				append(dialog_1, t3);
				append(dialog_1, div1);
				append(div1, button1);
				append(button1, t4);
				append(div1, t5);
				append(div1, button2);
				/*dialog_1_binding*/ ctx[10](dialog_1);

if (!mounted) {
					dispose = [
						listen(window, "keydown", /*onKeydown*/ ctx[3]),
						listen(button0, "click", /*toggleRecording*/ ctx[4]),
						listen(button0, "keydown", prevent_default(/*keydown_handler*/ ctx[9])),
						listen(button1, "click", /*confirm*/ ctx[5]),
						listen(button2, "click", /*cancel*/ ctx[6]),
						listen(dialog_1, "mousedown", stop_propagation(/*mousedown_handler*/ ctx[8]))
					];

mounted = true;
				}
			},
			p(ctx, [dirty]) {
				if (current_block_type !== (current_block_type = select_block_type(ctx))) {
					if_block0.d(1);
					if_block0 = current_block_type(ctx);

if (if_block0) {
						if_block0.c();
						if_block0.m(button0, null);
					}
				}

if (current_block_type_1 === (current_block_type_1 = select_block_type_1(ctx)) && if_block1) {
					if_block1.p(ctx, dirty);
				} else {
					if_block1.d(1);
					if_block1 = current_block_type_1(ctx);

if (if_block1) {
						if_block1.c();
						if_block1.m(div0, null);
					}
				}

if (dirty & /*keysDeref*/ 1 && button1_disabled_value !== (button1_disabled_value = /*keysDeref*/ ctx[0].size === 0)) {
					button1.disabled = button1_disabled_value;
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(dialog_1);
				}

if_block0.d();
				if_block1.d();
				/*dialog_1_binding*/ ctx[10](null);
				mounted = false;
				run_all(dispose);
			}
		};
	}

const func = key => key === ' ' ? 'Space' : key;

function instance$v($$self, $$props, $$invalidate) {
		let { keys = new Set() } = $$props;
		let keysDeref = new Set(keys);

// $: keysDeref = new Set(keys);
		let recording = false;

let dialog;
		let dispatch = createEventDispatcher();

function onKeydown(event) {
			if (!recording) return;

if (event.key === 'Escape') {
				$$invalidate(1, recording = false);
				return;
			}

keysDeref.add(event.key.toLowerCase());
			$$invalidate(0, keysDeref);
		}

function toggleRecording() {
			$$invalidate(1, recording = !recording);

if (recording) {
				keysDeref.clear();
				$$invalidate(0, keysDeref);
			}
		}

function confirm() {
			dispatch('close', keysDeref);
		}

function cancel() {
			dispatch('close', new Set());
		}

onMount(() => {
			dialog.showModal();

dialog.addEventListener('close', () => {
				dispatch('close', new Set());
			});
		});

function mousedown_handler(event) {
			bubble.call(this, $$self, event);
		}

function keydown_handler(event) {
			bubble.call(this, $$self, event);
		}

function dialog_1_binding($$value) {
			binding_callbacks[$$value ? 'unshift' : 'push'](() => {
				dialog = $$value;
				$$invalidate(2, dialog);
			});
		}

$$self.$$set = $$props => {
			if ('keys' in $$props) $$invalidate(7, keys = $$props.keys);
		};

return [
			keysDeref,
			recording,
			dialog,
			onKeydown,
			toggleRecording,
			confirm,
			cancel,
			keys,
			mousedown_handler,
			keydown_handler,
			dialog_1_binding
		];
	}

class KeybindCreator extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$v, create_fragment$C, safe_not_equal, { keys: 7 }, add_css$e);
		}
	}

/* src\hud\components\Hotkey.svelte generated by Svelte v4.2.19 */

function add_css$d(target) {
		append_styles(target, "svelte-1tsrn0k", "button.svelte-1tsrn0k{background-color:transparent;border:none;height:30px;margin:0px;padding-right:0px}");
	}

// (28:0) {#if keybindCreatorOpen}
	function create_if_block$9(ctx) {
		let keybindcreator;
		let current;
		keybindcreator = new KeybindCreator({ props: { keys: /*keybind*/ ctx[1] } });
		keybindcreator.$on("close", /*onCreatorClose*/ ctx[2]);

return {
			c() {
				create_component(keybindcreator.$$.fragment);
			},
			m(target, anchor) {
				mount_component(keybindcreator, target, anchor);
				current = true;
			},
			p: noop,
			i(local) {
				if (current) return;
				transition_in(keybindcreator.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(keybindcreator.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(keybindcreator, detaching);
			}
		};
	}

function create_fragment$B(ctx) {
		let t;
		let button;
		let keyboardoutline;
		let current;
		let mounted;
		let dispose;
		let if_block = /*keybindCreatorOpen*/ ctx[0] && create_if_block$9(ctx);
		keyboardoutline = new KeyboardOutline({ props: { width: 30, height: 30 } });

return {
			c() {
				if (if_block) if_block.c();
				t = space();
				button = element("button");
				create_component(keyboardoutline.$$.fragment);
				attr(button, "class", "svelte-1tsrn0k");
			},
			m(target, anchor) {
				if (if_block) if_block.m(target, anchor);
				insert(target, t, anchor);
				insert(target, button, anchor);
				mount_component(keyboardoutline, button, null);
				current = true;

if (!mounted) {
					dispose = listen(button, "click", /*click_handler*/ ctx[4]);
					mounted = true;
				}
			},
			p(ctx, [dirty]) {
				if (/*keybindCreatorOpen*/ ctx[0]) {
					if (if_block) {
						if_block.p(ctx, dirty);

if (dirty & /*keybindCreatorOpen*/ 1) {
							transition_in(if_block, 1);
						}
					} else {
						if_block = create_if_block$9(ctx);
						if_block.c();
						transition_in(if_block, 1);
						if_block.m(t.parentNode, t);
					}
				} else if (if_block) {
					group_outros();

transition_out(if_block, 1, 1, () => {
						if_block = null;
					});

check_outros();
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				transition_in(keyboardoutline.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				transition_out(keyboardoutline.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t);
					detach(button);
				}

if (if_block) if_block.d(detaching);
				destroy_component(keyboardoutline);
				mounted = false;
				dispose();
			}
		};
	}

function instance$u($$self, $$props, $$invalidate) {
		let { hotkeyId } = $$props;
		let dispatch = createEventDispatcher();
		let keybindCreatorOpen = false;
		let keybind = new Set(getHotkey(hotkeyId) ?? []);

function onCreatorClose(result) {
			$$invalidate(0, keybindCreatorOpen = false);
			if (!result.detail) return;

// gotta keep the refrence
			keybind.clear();

for (let key of result.detail) {
				keybind.add(key);
			}

setHotkey(hotkeyId, Array.from(keybind));
		}

onMount(() => {
			keybindManager.addKeybind(keybind, () => {
				dispatch('trigger');
			});
		});

const click_handler = () => $$invalidate(0, keybindCreatorOpen = !keybindCreatorOpen);

$$self.$$set = $$props => {
			if ('hotkeyId' in $$props) $$invalidate(3, hotkeyId = $$props.hotkeyId);
		};

return [keybindCreatorOpen, keybind, onCreatorClose, hotkeyId, click_handler];
	}

class Hotkey extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$u, create_fragment$B, safe_not_equal, { hotkeyId: 3 }, add_css$d);
		}
	}

/* src\hud\components\Button.svelte generated by Svelte v4.2.19 */

// (25:4) {#if hotkeyId}
	function create_if_block$8(ctx) {
		let hotkey;
		let current;
		hotkey = new Hotkey({ props: { hotkeyId: /*hotkeyId*/ ctx[2] } });
		hotkey.$on("trigger", /*trigger*/ ctx[6]);

return {
			c() {
				create_component(hotkey.$$.fragment);
			},
			m(target, anchor) {
				mount_component(hotkey, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const hotkey_changes = {};
				if (dirty & /*hotkeyId*/ 4) hotkey_changes.hotkeyId = /*hotkeyId*/ ctx[2];
				hotkey.$set(hotkey_changes);
			},
			i(local) {
				if (current) return;
				transition_in(hotkey.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(hotkey.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(hotkey, detaching);
			}
		};
	}

function create_fragment$A(ctx) {
		let div;
		let button_1;
		let button_1_disabled_value;
		let button_1_title_value;
		let t;
		let current;
		let mounted;
		let dispose;
		const default_slot_template = /*#slots*/ ctx[8].default;
		const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[7], null);
		let if_block = /*hotkeyId*/ ctx[2] && create_if_block$8(ctx);

return {
			c() {
				div = element("div");
				button_1 = element("button");
				if (default_slot) default_slot.c();
				t = space();
				if (if_block) if_block.c();
				button_1.disabled = button_1_disabled_value = /*disabled*/ ctx[0] === true || /*disabled*/ ctx[0] === undefined;
				attr(button_1, "title", button_1_title_value = /*disabled*/ ctx[0] ? /*disabledMsg*/ ctx[1] : undefined);
				attr(button_1, "class", "svelte-o69qzc");
				toggle_class(button_1, "active", /*active*/ ctx[4]);
				attr(div, "class", "wrap svelte-o69qzc");
			},
			m(target, anchor) {
				insert(target, div, anchor);
				append(div, button_1);

if (default_slot) {
					default_slot.m(button_1, null);
				}

/*button_1_binding*/ ctx[10](button_1);
				append(div, t);
				if (if_block) if_block.m(div, null);
				current = true;

if (!mounted) {
					dispose = [
						listen(button_1, "click", /*onClick*/ ctx[5]),
						listen(button_1, "keydown", prevent_default(/*keydown_handler*/ ctx[9]))
					];

mounted = true;
				}
			},
			p(ctx, [dirty]) {
				if (default_slot) {
					if (default_slot.p && (!current || dirty & /*$$scope*/ 128)) {
						update_slot_base(
							default_slot,
							default_slot_template,
							ctx,
							/*$$scope*/ ctx[7],
							!current
							? get_all_dirty_from_scope(/*$$scope*/ ctx[7])
							: get_slot_changes(default_slot_template, /*$$scope*/ ctx[7], dirty, null),
							null
						);
					}
				}

if (!current || dirty & /*disabled*/ 1 && button_1_disabled_value !== (button_1_disabled_value = /*disabled*/ ctx[0] === true || /*disabled*/ ctx[0] === undefined)) {
					button_1.disabled = button_1_disabled_value;
				}

if (!current || dirty & /*disabled, disabledMsg*/ 3 && button_1_title_value !== (button_1_title_value = /*disabled*/ ctx[0] ? /*disabledMsg*/ ctx[1] : undefined)) {
					attr(button_1, "title", button_1_title_value);
				}

if (!current || dirty & /*active*/ 16) {
					toggle_class(button_1, "active", /*active*/ ctx[4]);
				}

if (/*hotkeyId*/ ctx[2]) {
					if (if_block) {
						if_block.p(ctx, dirty);

if (dirty & /*hotkeyId*/ 4) {
							transition_in(if_block, 1);
						}
					} else {
						if_block = create_if_block$8(ctx);
						if_block.c();
						transition_in(if_block, 1);
						if_block.m(div, null);
					}
				} else if (if_block) {
					group_outros();

transition_out(if_block, 1, 1, () => {
						if_block = null;
					});

check_outros();
				}
			},
			i(local) {
				if (current) return;
				transition_in(default_slot, local);
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(default_slot, local);
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(div);
				}

if (default_slot) default_slot.d(detaching);
				/*button_1_binding*/ ctx[10](null);
				if (if_block) if_block.d();
				mounted = false;
				run_all(dispose);
			}
		};
	}

function onClick() {
			dispatch("click");
		}

function trigger() {
			dispatch("click");
			$$invalidate(4, active = true);
			setTimeout(() => $$invalidate(4, active = false), 100);
		}

function keydown_handler(event) {
			bubble.call(this, $$self, event);
		}

function button_1_binding($$value) {
			binding_callbacks[$$value ? 'unshift' : 'push'](() => {
				button = $$value;
				$$invalidate(3, button);
			});
		}

$$self.$$set = $$props => {
			if ('disabled' in $$props) $$invalidate(0, disabled = $$props.disabled);
			if ('disabledMsg' in $$props) $$invalidate(1, disabledMsg = $$props.disabledMsg);
			if ('hotkeyId' in $$props) $$invalidate(2, hotkeyId = $$props.hotkeyId);
			if ('$$scope' in $$props) $$invalidate(7, $$scope = $$props.$$scope);
		};

return [
			disabled,
			disabledMsg,
			hotkeyId,
			button,
			active,
			onClick,
			trigger,
			$$scope,
			slots,
			keydown_handler,
			button_1_binding
		];
	}

class Button extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$t, create_fragment$A, safe_not_equal, { disabled: 0, disabledMsg: 1, hotkeyId: 2 }, add_css$c);
		}
	}

/* src\hud\Group.svelte generated by Svelte v4.2.19 */

// (40:0) <Button on:click={openGroup}>
	function create_default_slot_1$6(ctx) {
		let t;

return {
			c() {
				t = text(/*name*/ ctx[0]);
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			p(ctx, dirty) {
				if (dirty & /*name*/ 1) set_data(t, /*name*/ ctx[0]);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (45:4) <Button on:click={closeGroup}>
	function create_default_slot$l(ctx) {
		let t;

return {
			c() {
				t = text("Close");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

function create_fragment$z(ctx) {
		let button0;
		let t0;
		let div;
		let button1;
		let t1;
		let current;

button0 = new Button({
				props: {
					$$slots: { default: [create_default_slot_1$6] },
					$$scope: { ctx }
				}
			});

button0.$on("click", /*openGroup*/ ctx[2]);

button1 = new Button({
				props: {
					$$slots: { default: [create_default_slot$l] },
					$$scope: { ctx }
				}
			});

button1.$on("click", /*closeGroup*/ ctx[3]);
		const default_slot_template = /*#slots*/ ctx[4].default;
		const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[6], null);

return {
			c() {
				create_component(button0.$$.fragment);
				t0 = space();
				div = element("div");
				create_component(button1.$$.fragment);
				t1 = space();
				if (default_slot) default_slot.c();
				attr(div, "class", "groupContent svelte-151a7uw");
			},
			m(target, anchor) {
				mount_component(button0, target, anchor);
				insert(target, t0, anchor);
				insert(target, div, anchor);
				mount_component(button1, div, null);
				append(div, t1);

if (default_slot) {
					default_slot.m(div, null);
				}

/*div_binding*/ ctx[5](div);
				current = true;
			},
			p(ctx, [dirty]) {
				const button0_changes = {};

if (dirty & /*$$scope, name*/ 65) {
					button0_changes.$$scope = { dirty, ctx };
				}

button0.$set(button0_changes);
				const button1_changes = {};

if (dirty & /*$$scope*/ 64) {
					button1_changes.$$scope = { dirty, ctx };
				}

button1.$set(button1_changes);

if (default_slot) {
					if (default_slot.p && (!current || dirty & /*$$scope*/ 64)) {
						update_slot_base(
							default_slot,
							default_slot_template,
							ctx,
							/*$$scope*/ ctx[6],
							!current
							? get_all_dirty_from_scope(/*$$scope*/ ctx[6])
							: get_slot_changes(default_slot_template, /*$$scope*/ ctx[6], dirty, null),
							null
						);
					}
				}
			},
			i(local) {
				if (current) return;
				transition_in(button0.$$.fragment, local);
				transition_in(button1.$$.fragment, local);
				transition_in(default_slot, local);
				current = true;
			},
			o(local) {
				transition_out(button0.$$.fragment, local);
				transition_out(button1.$$.fragment, local);
				transition_out(default_slot, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(div);
				}

destroy_component(button0, detaching);
				destroy_component(button1);
				if (default_slot) default_slot.d(detaching);
				/*div_binding*/ ctx[5](null);
			}
		};
	}

function slide(el, direction, side) {
		el.style.animation = `slide-${direction}-${side} 0.2s ease-in-out forwards`;

if (direction == 'out') {
			el.classList.remove('open');

setTimeout(
				() => {
					el.style.display = 'none';
				},
				200
			);
		} else {
			el.style.display = 'flex';
			el.classList.add('open');
		}
	}

function instance$s($$self, $$props, $$invalidate) {
		let { $$slots: slots = {}, $$scope } = $$props;
		let { name } = $$props;
		let groupEl;
		let lastGroupEl;
		let parentMenu;

function openGroup() {
			// find the previously opened group
			lastGroupEl = parentMenu.querySelector('.groupContent.open');

// slide it out to the left
			if (lastGroupEl) slide(lastGroupEl, 'out', 'left');

slide(groupEl, 'in', 'right');
		}

function closeGroup() {
			slide(groupEl, 'out', 'right');
			if (lastGroupEl) slide(lastGroupEl, 'in', 'left');
		}

onMount(() => {
			parentMenu = findMatchingParent(groupEl, '.menu .children');
			parentMenu.appendChild(groupEl);
		});

function div_binding($$value) {
			binding_callbacks[$$value ? 'unshift' : 'push'](() => {
				groupEl = $$value;
				$$invalidate(1, groupEl);
			});
		}

$$self.$$set = $$props => {
			if ('name' in $$props) $$invalidate(0, name = $$props.name);
			if ('$$scope' in $$props) $$invalidate(6, $$scope = $$props.$$scope);
		};

return [name, groupEl, openGroup, closeGroup, slots, div_binding, $$scope];
	}

class Group extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$s, create_fragment$z, safe_not_equal, { name: 0 }, add_css$b);
		}
	}

/* src\hud\components\ColorPicker.svelte generated by Svelte v4.2.19 */

// (36:8) {#if allowOpacity}
	function create_if_block$7(ctx) {
		let div1;
		let div0;
		let t1;
		let input;
		let mounted;
		let dispose;

return {
			c() {
				div1 = element("div");
				div0 = element("div");
				div0.textContent = "Opacity";
				t1 = space();
				input = element("input");
				attr(input, "type", "range");
				attr(input, "min", /*minOpactiy*/ ctx[2]);
				attr(input, "max", "1");
				attr(input, "step", "0.01");
				attr(input, "class", "alphaInput svelte-qar3ci");
				attr(div1, "class", "opacityBlock svelte-qar3ci");
			},
			m(target, anchor) {
				insert(target, div1, anchor);
				append(div1, div0);
				append(div1, t1);
				append(div1, input);
				set_input_value(input, /*alphaVal*/ ctx[4]);

if (!mounted) {
					dispose = [
						listen(input, "change", /*input_change_input_handler*/ ctx[11]),
						listen(input, "input", /*input_change_input_handler*/ ctx[11]),
						listen(input, "input", /*onChange*/ ctx[6]),
						listen(input, "mousedown", stop_propagation(/*mousedown_handler*/ ctx[10]))
					];

mounted = true;
				}
			},
			p(ctx, dirty) {
				if (dirty & /*minOpactiy*/ 4) {
					attr(input, "min", /*minOpactiy*/ ctx[2]);
				}

if (dirty & /*alphaVal*/ 16) {
					set_input_value(input, /*alphaVal*/ ctx[4]);
				}
			},
			d(detaching) {
				if (detaching) {
					detach(div1);
				}

mounted = false;
				run_all(dispose);
			}
		};
	}

function create_fragment$y(ctx) {
		let div3;
		let div0;
		let t0;
		let t1;
		let div2;
		let t2;
		let input;
		let t3;
		let div1;
		let mounted;
		let dispose;
		let if_block = /*allowOpacity*/ ctx[1] && create_if_block$7(ctx);

return {
			c() {
				div3 = element("div");
				div0 = element("div");
				t0 = text(/*text*/ ctx[0]);
				t1 = space();
				div2 = element("div");
				if (if_block) if_block.c();
				t2 = space();
				input = element("input");
				t3 = space();
				div1 = element("div");
				attr(input, "type", "color");
				attr(input, "class", "colorInput svelte-qar3ci");
				attr(div1, "class", "preview svelte-qar3ci");
				set_style(div1, "background-color", /*displayColor*/ ctx[5]);
				attr(div2, "class", "inputs svelte-qar3ci");
				attr(div3, "class", "colorPicker svelte-qar3ci");
			},
			m(target, anchor) {
				insert(target, div3, anchor);
				append(div3, div0);
				append(div0, t0);
				append(div3, t1);
				append(div3, div2);
				if (if_block) if_block.m(div2, null);
				append(div2, t2);
				append(div2, input);
				set_input_value(input, /*colorVal*/ ctx[3]);
				append(div2, t3);
				append(div2, div1);

if (!mounted) {
					dispose = [
						listen(input, "input", /*input_input_handler*/ ctx[12]),
						listen(input, "input", /*onChange*/ ctx[6]),
						listen(input, "mousedown", stop_propagation(/*mousedown_handler_1*/ ctx[9]))
					];

mounted = true;
				}
			},
			p(ctx, [dirty]) {
				if (dirty & /*text*/ 1) set_data(t0, /*text*/ ctx[0]);

if (/*allowOpacity*/ ctx[1]) {
					if (if_block) {
						if_block.p(ctx, dirty);
					} else {
						if_block = create_if_block$7(ctx);
						if_block.c();
						if_block.m(div2, t2);
					}
				} else if (if_block) {
					if_block.d(1);
					if_block = null;
				}

if (dirty & /*colorVal*/ 8) {
					set_input_value(input, /*colorVal*/ ctx[3]);
				}

if (dirty & /*displayColor*/ 32) {
					set_style(div1, "background-color", /*displayColor*/ ctx[5]);
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(div3);
				}

if (if_block) if_block.d();
				mounted = false;
				run_all(dispose);
			}
		};
	}

function setVar(color) {
			setCssVar(bindValue, color);
		}

const setVarDebounce = debounce$1(setVar, 100);

function onChange() {
			let hexChannels = parseHex(colorVal);
			let newColor = `rgba(${hexChannels.r}, ${hexChannels.g}, ${hexChannels.b}, ${alphaVal})`;

if (bindValue) {
				setVarDebounce(newColor);
				document.documentElement.style.setProperty(`--${bindValue}`, newColor);
			}

$$invalidate(5, displayColor = newColor);
			if (color) $$invalidate(7, color = newColor);
		}

function mousedown_handler_1(event) {
			bubble.call(this, $$self, event);
		}

function mousedown_handler(event) {
			bubble.call(this, $$self, event);
		}

function input_change_input_handler() {
			alphaVal = to_number(this.value);
			$$invalidate(4, alphaVal);
		}

function input_input_handler() {
			colorVal = this.value;
			$$invalidate(3, colorVal);
		}

$$self.$$set = $$props => {
			if ('text' in $$props) $$invalidate(0, text = $$props.text);
			if ('color' in $$props) $$invalidate(7, color = $$props.color);
			if ('bindValue' in $$props) $$invalidate(8, bindValue = $$props.bindValue);
			if ('allowOpacity' in $$props) $$invalidate(1, allowOpacity = $$props.allowOpacity);
			if ('minOpactiy' in $$props) $$invalidate(2, minOpactiy = $$props.minOpactiy);
		};

return [
			text,
			allowOpacity,
			minOpactiy,
			colorVal,
			alphaVal,
			displayColor,
			onChange,
			color,
			bindValue,
			mousedown_handler_1,
			mousedown_handler,
			input_change_input_handler,
			input_input_handler
		];
	}

class ColorPicker extends SvelteComponent {
		constructor(options) {
			super();

init(
				this,
				options,
				instance$r,
				create_fragment$y,
				safe_not_equal,
				{
					text: 0,
					color: 7,
					bindValue: 8,
					allowOpacity: 1,
					minOpactiy: 2
				},
				add_css$a
			);
		}
	}

/* src\hud\ResetStyles.svelte generated by Svelte v4.2.19 */

function create_default_slot$k(ctx) {
		let t;

return {
			c() {
				t = text("Reset All Styles");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

function create_fragment$x(ctx) {
		let button;
		let current;

button = new Button({
				props: {
					$$slots: { default: [create_default_slot$k] },
					$$scope: { ctx }
				}
			});

button.$on("click", /*resetStyles*/ ctx[0]);

if (dirty & /*$$scope*/ 2) {
					button_changes.$$scope = { dirty, ctx };
				}

button.$set(button_changes);
			},
			i(local) {
				if (current) return;
				transition_in(button.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(button.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(button, detaching);
			}
		};
	}

function instance$q($$self) {
		function resetStyles() {
			let res = confirm("Are you sure you want to reset all styles?");
			if (!res) return;

for (let key in defaultCss) {
				document.documentElement.style.setProperty(`--${key}`, defaultCss[key]);
			}

setCssVars(defaultCss);
		}

return [resetStyles];
	}

class ResetStyles extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$q, create_fragment$x, safe_not_equal, {});
		}
	}

/* src\hud\components\ToggleButton.svelte generated by Svelte v4.2.19 */

function create_else_block$2(ctx) {
		let t;

return {
			c() {
				t = text(/*offText*/ ctx[2]);
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			p(ctx, dirty) {
				if (dirty & /*offText*/ 4) set_data(t, /*offText*/ ctx[2]);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (17:4) {#if enabled}
	function create_if_block$6(ctx) {
		let t;

return {
			c() {
				t = text(/*onText*/ ctx[1]);
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			p(ctx, dirty) {
				if (dirty & /*onText*/ 2) set_data(t, /*onText*/ ctx[1]);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (16:0) <Button on:click={onClick} {disabled} {disabledMsg} {hotkeyId}>
	function create_default_slot$j(ctx) {
		let if_block_anchor;

function select_block_type(ctx, dirty) {
			if (/*enabled*/ ctx[0]) return create_if_block$6;
			return create_else_block$2;
		}

let current_block_type = select_block_type(ctx);
		let if_block = current_block_type(ctx);

return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_block.m(target, anchor);
				insert(target, if_block_anchor, anchor);
			},
			p(ctx, dirty) {
				if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
					if_block.p(ctx, dirty);
				} else {
					if_block.d(1);
					if_block = current_block_type(ctx);

if (if_block) {
						if_block.c();
						if_block.m(if_block_anchor.parentNode, if_block_anchor);
					}
				}
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

if_block.d(detaching);
			}
		};
	}

function create_fragment$w(ctx) {
		let button;
		let current;

button = new Button({
				props: {
					disabled: /*disabled*/ ctx[3],
					disabledMsg: /*disabledMsg*/ ctx[4],
					hotkeyId: /*hotkeyId*/ ctx[5],
					$$slots: { default: [create_default_slot$j] },
					$$scope: { ctx }
				}
			});

button.$on("click", /*onClick*/ ctx[6]);

return {
			c() {
				create_component(button.$$.fragment);
			},
			m(target, anchor) {
				mount_component(button, target, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				const button_changes = {};
				if (dirty & /*disabled*/ 8) button_changes.disabled = /*disabled*/ ctx[3];
				if (dirty & /*disabledMsg*/ 16) button_changes.disabledMsg = /*disabledMsg*/ ctx[4];
				if (dirty & /*hotkeyId*/ 32) button_changes.hotkeyId = /*hotkeyId*/ ctx[5];

if (dirty & /*$$scope, onText, enabled, offText*/ 263) {
					button_changes.$$scope = { dirty, ctx };
				}

function onClick() {
			$$invalidate(0, enabled = !enabled);
			dispatch("click", enabled);
		}

$$self.$$set = $$props => {
			if ('onText' in $$props) $$invalidate(1, onText = $$props.onText);
			if ('offText' in $$props) $$invalidate(2, offText = $$props.offText);
			if ('enabled' in $$props) $$invalidate(0, enabled = $$props.enabled);
			if ('disabled' in $$props) $$invalidate(3, disabled = $$props.disabled);
			if ('disabledMsg' in $$props) $$invalidate(4, disabledMsg = $$props.disabledMsg);
			if ('hotkeyId' in $$props) $$invalidate(5, hotkeyId = $$props.hotkeyId);
		};

return [enabled, onText, offText, disabled, disabledMsg, hotkeyId, onClick];
	}

class ToggleButton extends SvelteComponent {
		constructor(options) {
			super();

init(this, options, instance$p, create_fragment$w, safe_not_equal, {
				onText: 1,
				offText: 2,
				enabled: 0,
				disabled: 3,
				disabledMsg: 4,
				hotkeyId: 5
			});
		}
	}

/* src\scripts\AutoAnswer.svelte generated by Svelte v4.2.19 */

function create_fragment$v(ctx) {
		let togglebutton;
		let current;

togglebutton = new ToggleButton({
				props: {
					disabled: !/*enabled*/ ctx[0],
					disabledMsg: "Questions haven't loaded yet",
					onText: "Stop auto answering",
					offText: "Start auto answering",
					enabled: false,
					hotkeyId: "autoAnswer"
				}
			});

togglebutton.$on("click", /*toggleAutoAnswer*/ ctx[2]);

return {
			c() {
				create_component(togglebutton.$$.fragment);
			},
			m(target, anchor) {
				mount_component(togglebutton, target, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				const togglebutton_changes = {};
				if (dirty & /*enabled*/ 1) togglebutton_changes.disabled = !/*enabled*/ ctx[0];
				togglebutton.$set(togglebutton_changes);
			},
			i(local) {
				if (current) return;
				transition_in(togglebutton.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(togglebutton.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(togglebutton, detaching);
			}
		};
	}

function instance$o($$self, $$props, $$invalidate) {
		let enabled;
		let $playerId;
		let $transportType;
		component_subscribe($$self, playerId, $$value => $$invalidate(10, $playerId = $$value));
		let { transportType } = socketManager;
		component_subscribe($$self, transportType, value => $$invalidate(8, $transportType = value));
		let questions = [];
		let answerDeviceId = null;
		let currentQuestionId = null;
		let questionIdList = [];
		let currentQuestionIndex = -1;

function answerQuestion() {
			if ($transportType === 'colyseus') {
				if (currentQuestionId == null) return;

// find the correct question
				let question = questions.find(q => q._id == currentQuestionId);

if (!question) return;

let packet = {
					key: 'answered',
					deviceId: answerDeviceId,
					data: {}
				};

// create a packet to send to the server
				if (question.type == 'text') {
					packet.data.answer = question.answers[0].text;
				} else {
					let correctAnswerId = question.answers.find(a => a.correct)._id;
					packet.data.answer = correctAnswerId;
				}

socketManager.sendMessage("MESSAGE_FOR_DEVICE", packet);
			} else {
				let questionId = questionIdList[currentQuestionIndex];
				let question = questions.find(q => q._id == questionId);
				if (!question) return;
				let answer;

if (question.type == 'mc') {
					answer = question.answers.find(a => a.correct)._id;
				} else {
					answer = question.answers[0].text;
				}

socketManager.sendMessage("QUESTION_ANSWERED", { answer, questionId });
			}
		}

let answerInterval; // should probably be a number but I don't care

function toggleAutoAnswer(event) {
			if (event.detail) {
				answerInterval = setInterval(answerQuestion, 1000);
			} else {
				clearInterval(answerInterval);
			}
		}

socketManager.addEventListener("deviceChanges", event => {
			for (let { id, data } of event.detail) {
				for (let key in data) {
					if (key == "GLOBAL_questions") {
						$$invalidate(3, questions = JSON.parse(data[key]));
						console.log("Got questions", questions);
						$$invalidate(4, answerDeviceId = id);
					}

if (key == `PLAYER_${$playerId}_currentQuestionId`) {
						$$invalidate(5, currentQuestionId = data[key]);
					}
				}
			}
		});

socketManager.addEventListener("blueboatMessage", event => {
			if (event.detail?.key != "STATE_UPDATE") return;

switch (event.detail.data.type) {
				case "GAME_QUESTIONS":
					$$invalidate(3, questions = event.detail.data.value);
					break;
				case "PLAYER_QUESTION_LIST":
					$$invalidate(6, questionIdList = event.detail.data.value.questionList);
					$$invalidate(7, currentQuestionIndex = event.detail.data.value.questionIndex);
					break;
				case "PLAYER_QUESTION_LIST_INDEX":
					$$invalidate(7, currentQuestionIndex = event.detail.data.value);
					break;
			}
		});

$$self.$$.update = () => {
			if ($$self.$$.dirty & /*$transportType, questions, currentQuestionId, answerDeviceId, questionIdList, currentQuestionIndex*/ 504) {
				$$invalidate(0, enabled = $transportType == "colyseus"
				? questions.length > 0 && currentQuestionId != null && answerDeviceId != null
				: questionIdList.length > 0 && questions.length > 0 && currentQuestionIndex != -1);
			}
		};

return [
			enabled,
			transportType,
			toggleAutoAnswer,
			questions,
			answerDeviceId,
			currentQuestionId,
			questionIdList,
			currentQuestionIndex,
			$transportType
		];
	}

class AutoAnswer extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$o, create_fragment$v, safe_not_equal, {});
		}
	}

/* src\scripts\2d\InstantUse.svelte generated by Svelte v4.2.19 */

function create_fragment$u(ctx) {
		let togglebutton;
		let updating_enabled;
		let current;

function togglebutton_enabled_binding(value) {
			/*togglebutton_enabled_binding*/ ctx[1](value);
		}

let togglebutton_props = {
			onText: "Stop instant use",
			offText: "Enable instant use",
			hotkeyId: "instantUse"
		};

if (/*enabled*/ ctx[0] !== void 0) {
			togglebutton_props.enabled = /*enabled*/ ctx[0];
		}

togglebutton = new ToggleButton({ props: togglebutton_props });
		binding_callbacks.push(() => bind(togglebutton, 'enabled', togglebutton_enabled_binding));

if (!updating_enabled && dirty & /*enabled*/ 1) {
					updating_enabled = true;
					togglebutton_changes.enabled = /*enabled*/ ctx[0];
					add_flush_callback(() => updating_enabled = false);
				}

togglebutton.$set(togglebutton_changes);
			},
			i(local) {
				if (current) return;
				transition_in(togglebutton.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(togglebutton.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(togglebutton, detaching);
			}
		};
	}

function instance$n($$self, $$props, $$invalidate) {
		let enabled = true;
		keybindManager.addKeybind(new Set(["enter"]), useNearest);

function useNearest() {
			if (!enabled) return;
			let win = getUnsafeWindow();
			let devices = win?.stores?.phaser?.scene?.worldManager?.devices?.devicesInView;
			let body = win?.stores?.phaser?.mainCharacter?.body;
			if (!devices || !body) return;
			let closest = null;
			let closestDistance = Infinity;

// Find the closest device with interactive zones
			for (let device of devices) {
				if (device.interactiveZones.zones.length == 0) continue;
				let distance = Math.sqrt(Math.pow(device.x - body.x, 2) + Math.pow(device.y - body.y, 2));

if (distance < closestDistance) {
					closest = device;
					closestDistance = distance;
				}
			}

if (!closest) return;
			closest?.interactiveZones?.onInteraction?.();
		}

function togglebutton_enabled_binding(value) {
			enabled = value;
			$$invalidate(0, enabled);
		}

return [enabled, togglebutton_enabled_binding];
	}

class InstantUse extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$n, create_fragment$u, safe_not_equal, {});
		}
	}

const knownSkins = ["dayOne", "echoAgent", "stripeDoubleGreen", "mustache", "vortexAgent", "grayGradient", "redNinja", "sprinklesRed", "redDeliciousApple", "sunny", "fadedBlueGradient", "glassHalfFull", "whiteAndBlueVerticalStripes", "polkaDotBlueAndYellow", "pinkPaste", "volcanoCracks", "mustachePink", "mountainAndSun", "camoTan", "redDinoCostume", "stripeDoubleRed", "coolRedBlueGradient", "pencilPack", "glyphsYellowBrown", "camoBlue", "purplePaste", "galaxy", "luchador", "fox", "pumpkin", "rockyWest", "mummy", "ghostCostume", "fifthBirthday", "corn", "feast", "pumpkinPie", "frostBuddy", "polkaDotWhiteAndRed", "festiveOnesieBlue", "festiveOnesieRed", "festiveOnesieGreen", "festiveOnesieTan", "gift", "hotChocolate", "snowman", "snowglobe", "mustacheSanta", "firework", "polkaDotFestiveReverse", "polkaDotFestive", "puzzleYellowPurple", "puzzleGreenBlue", "puzzleOrangeBlue", "puzzleGrayWhite", "puzzleRedGreen", "roses", "heart", "hamster", "leprechaun", "cellGold", "pirate", "constellationPurpleYellow", "constellationBlackGreen", "constellationBlackWhite", "constellationPinkGreen", "constellationYellowPink", "detective", "sketch", "astroHelmet", "mustacheBrown", "yinYang", "fisher", "coffee", "partyPineapple", "construction", "graduate", "graduateBlue", "stripeDoublePurple", "bananaSplit", "rainbowWave", "rockstar", "mountain", "tent", "goat", "daisy", "climber", "cookie", "zebra", "diamondRainbow", "circuitGreen", "circuitBlue", "circuitGray", "clock", "squiggles", "autumnTree", "crashTestDummy", "stripeDoubleYellow", "witch", "skeleton", "spiderWeb", "trickTreat", "calacaOne", "turkey", "farmer", "knight", "yellowCracksPurple", "arcticFox", "whistle", "penguinBlue", "goldenHotChocolate", "blastball", "blastballGimchester", "blastballKitcelona", "pufferJacket", "christmasTree", "rudolph", "snowball", "santaClaus", "causticWaterBlue", "causticWaterRed", "causticWaterGreen", "causticWaterCaribe", "causticWaterOcean", "causticWaterPurple", "taco", "gimKing", "sketchBlue", "clown", "camoGreen", "cellBlue", "burger", "sprinklesChocolate", "glyphsOrangeBlue", "frozenMummy", "evilPlantGreen", "evilPlantPink", "gamerGreen", "gamerPink", "gamerPurple", "gamerYellow", "sentryRobot", "8bit", "redDino", "calacaTwo", "calacaThree", "yarn", "racoon", "pilot", "shark", "redPanda", "marshmallow", "discoBall", "incognito", "dragon", "golden", "valenTime", "referee", "pilot", "sprinklesChocolate", "miningCart", "rainCloud", "watermelon", "terrainBlock", "floatingTube", "miner", "sproutingFlower", "luckyClover", "shark", "axolotlPink", "axolotlBlue", "axolotlYellow", "astroCaptain", "tuxedo", "blacksmith"];
	const knownTrails = ["origin_token", "fire_notes", "banana_peel", "rainbow_dots", "dust_particles", "bubble", "flowers", "metal_spring", "candy", "day_of_the_dead", "autumn_leaves", "corn", "hearts", "stars", "yin_yang", "puzzle_pieces", "taco", "blastball_phrases", "penguin_footprints", "blastball", "cupid_arrow", "birds", "mining_terrains", "beachball", "clovers", "easter_eggs"];

/* src\hud\components\InputWithSelect.svelte generated by Svelte v4.2.19 */

function get_each_context$4(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[4] = list[i];
		return child_ctx;
	}

// (11:8) {#each selectOptions as option}
	function create_each_block$4(ctx) {
		let option_1;
		let t_value = /*option*/ ctx[4] + "";
		let t;
		let option_1_value_value;

return {
			c() {
				option_1 = element("option");
				t = text(t_value);
				option_1.__value = option_1_value_value = /*option*/ ctx[4];
				set_input_value(option_1, option_1.__value);
			},
			m(target, anchor) {
				insert(target, option_1, anchor);
				append(option_1, t);
			},
			p(ctx, dirty) {
				if (dirty & /*selectOptions*/ 2 && t_value !== (t_value = /*option*/ ctx[4] + "")) set_data(t, t_value);

if (dirty & /*selectOptions*/ 2 && option_1_value_value !== (option_1_value_value = /*option*/ ctx[4])) {
					option_1.__value = option_1_value_value;
					set_input_value(option_1, option_1.__value);
				}
			},
			d(detaching) {
				if (detaching) {
					detach(option_1);
				}
			}
		};
	}

function create_fragment$t(ctx) {
		let div;
		let input;
		let t;
		let select;
		let mounted;
		let dispose;
		let each_value = ensure_array_like(/*selectOptions*/ ctx[1]);
		let each_blocks = [];

for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$4(get_each_context$4(ctx, each_value, i));
		}

return {
			c() {
				div = element("div");
				input = element("input");
				t = space();
				select = element("select");

for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

attr(input, "spellcheck", "false");
				attr(input, "class", "svelte-bgasye");
				attr(select, "class", "svelte-bgasye");
				attr(div, "class", "container svelte-bgasye");
			},
			m(target, anchor) {
				insert(target, div, anchor);
				append(div, input);
				set_input_value(input, /*value*/ ctx[0]);
				append(div, t);
				append(div, select);

for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(select, null);
					}
				}

if (!mounted) {
					dispose = [
						listen(input, "input", /*input_input_handler*/ ctx[3]),
						listen(select, "change", /*updateValue*/ ctx[2])
					];

mounted = true;
				}
			},
			p(ctx, [dirty]) {
				if (dirty & /*value*/ 1 && input.value !== /*value*/ ctx[0]) {
					set_input_value(input, /*value*/ ctx[0]);
				}

if (dirty & /*selectOptions*/ 2) {
					each_value = ensure_array_like(/*selectOptions*/ ctx[1]);
					let i;

for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$4(ctx, each_value, i);

if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
						} else {
							each_blocks[i] = create_each_block$4(child_ctx);
							each_blocks[i].c();
							each_blocks[i].m(select, null);
						}
					}

for (; i < each_blocks.length; i += 1) {
						each_blocks[i].d(1);
					}

each_blocks.length = each_value.length;
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(div);
				}

destroy_each(each_blocks, detaching);
				mounted = false;
				run_all(dispose);
			}
		};
	}

function instance$m($$self, $$props, $$invalidate) {
		let { selectOptions = [] } = $$props;
		let { value = "" } = $$props;

function updateValue(e) {
			$$invalidate(0, value = e.target.value);
		}

function input_input_handler() {
			value = this.value;
			$$invalidate(0, value);
		}

$$self.$$set = $$props => {
			if ('selectOptions' in $$props) $$invalidate(1, selectOptions = $$props.selectOptions);
			if ('value' in $$props) $$invalidate(0, value = $$props.value);
		};

return [value, selectOptions, updateValue, input_input_handler];
	}

class InputWithSelect extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$m, create_fragment$t, safe_not_equal, { selectOptions: 1, value: 0 }, add_css$9);
		}
	}

/* src\scripts\customization\CosmeticPicker.svelte generated by Svelte v4.2.19 */

// (54:4) <Button disabled={!gotSkinId} disabledMsg="Character hasn't loaded" on:click={apply}>
	function create_default_slot_1$5(ctx) {
		let t;

return {
			c() {
				t = text("Apply");
			},
			m(target, anchor) {
				insert(target, t, anchor);
			},
			d(detaching) {
				if (detaching) {
					detach(t);
				}
			}
		};
	}

// (42:0) <Group name="Cosmetic Picker">
	function create_default_slot$i(ctx) {
		let div0;
		let t1;
		let div1;
		let t3;
		let inputwithselect0;
		let updating_value;
		let t4;
		let div2;
		let t6;
		let inputwithselect1;
		let updating_value_1;
		let t7;
		let button;
		let current;

function inputwithselect0_value_binding(value) {
			/*inputwithselect0_value_binding*/ ctx[4](value);
		}

let inputwithselect0_props = { selectOptions: knownSkins };

if (/*skinId*/ ctx[0] !== void 0) {
			inputwithselect0_props.value = /*skinId*/ ctx[0];
		}

inputwithselect0 = new InputWithSelect({ props: inputwithselect0_props });
		binding_callbacks.push(() => bind(inputwithselect0, 'value', inputwithselect0_value_binding));

function inputwithselect1_value_binding(value) {
			/*inputwithselect1_value_binding*/ ctx[5](value);
		}

let inputwithselect1_props = { selectOptions: knownTrails };

if (/*trailId*/ ctx[1] !== void 0) {
			inputwithselect1_props.value = /*trailId*/ ctx[1];
		}

inputwithselect1 = new InputWithSelect({ props: inputwithselect1_props });
		binding_callbacks.push(() => bind(inputwithselect1, 'value', inputwithselect1_value_binding));

button = new Button({
				props: {
					disabled: !/*gotSkinId*/ ctx[2],
					disabledMsg: "Character hasn't loaded",
					$$slots: { default: [create_default_slot_1$5] },
					$$scope: { ctx }
				}
			});

button.$on("click", /*apply*/ ctx[3]);

return {
			c() {
				div0 = element("div");
				div0.textContent = "These only work client-side. Nobody else can see these cosmetics.";
				t1 = space();
				div1 = element("div");
				div1.textContent = "Skin ID";
				t3 = space();
				create_component(inputwithselect0.$$.fragment);
				t4 = space();
				div2 = element("div");
				div2.textContent = "Trail ID";
				t6 = space();
				create_component(inputwithselect1.$$.fragment);
				t7 = space();
				create_component(button.$$.fragment);
				attr(div0, "class", "disclaimer svelte-1ychv30");
				attr(div1, "class", "description svelte-1ychv30");
				attr(div2, "class", "description svelte-1ychv30");
			},
			m(target, anchor) {
				insert(target, div0, anchor);
				insert(target, t1, anchor);
				insert(target, div1, anchor);
				insert(target, t3, anchor);
				mount_component(inputwithselect0, target, anchor);
				insert(target, t4, anchor);
				insert(target, div2, anchor);
				insert(target, t6, anchor);
				mount_component(inputwithselect1, target, anchor);
				insert(target, t7, anchor);
				mount_component(button, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const inputwithselect0_changes = {};

if (!updating_value && dirty & /*skinId*/ 1) {
					updating_value = true;
					inputwithselect0_changes.value = /*skinId*/ ctx[0];
					add_flush_callback(() => updating_value = false);
				}

inputwithselect0.$set(inputwithselect0_changes);
				const inputwithselect1_changes = {};

if (!updating_value_1 && dirty & /*trailId*/ 2) {
					updating_value_1 = true;
					inputwithselect1_changes.value = /*trailId*/ ctx[1];
					add_flush_callback(() => updating_value_1 = false);
				}

inputwithselect1.$set(inputwithselect1_changes);
				const button_changes = {};
				if (dirty & /*gotSkinId*/ 4) button_changes.disabled = !/*gotSkinId*/ ctx[2];

if (dirty & /*$$scope*/ 256) {
					button_changes.$$scope = { dirty, ctx };
				}

button.$set(button_changes);
			},
			i(local) {
				if (current) return;
				transition_in(inputwithselect0.$$.fragment, local);
				transition_in(inputwithselect1.$$.fragment, local);
				transition_in(button.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(inputwithselect0.$$.fragment, local);
				transition_out(inputwithselect1.$$.fragment, local);
				transition_out(button.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(div0);
					detach(t1);
					detach(div1);
					detach(t3);
					detach(t4);
					detach(div2);
					detach(t6);
					detach(t7);
				}

destroy_component(inputwithselect0, detaching);
				destroy_component(inputwithselect1, detaching);
				destroy_component(button, detaching);
			}
		};
	}

function create_fragment$s(ctx) {
		let group;
		let current;

group = new Group({
				props: {
					name: "Cosmetic Picker",
					$$slots: { default: [create_default_slot$i] },
					$$scope: { ctx }
				}
			});

return {
			c() {
				create_component(group.$$.fragment);
			},
			m(target, anchor) {
				mount_component(group, target, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				const group_changes = {};

if (dirty & /*$$scope, gotSkinId, trailId, skinId*/ 263) {
					group_changes.$$scope = { dirty, ctx };
				}

group.$set(group_changes);
			},
			i(local) {
				if (current) return;
				transition_in(group.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(group.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				destroy_component(group, detaching);
			}
		};
	}

function instance$l($$self, $$props, $$invalidate) {
		let $playerId;
		component_subscribe($$self, playerId, $$value => $$invalidate(6, $playerId = $$value));
		let skinId = '';
		let trailId = '';
		let gotSkinId = false;

let checkInterval = setInterval(
			() => {
				let char = getUnsafeWindow()?.stores?.phaser?.scene?.characterManager?.characters?.get($playerId);

if (char) {
					$$invalidate(0, skinId = char.skin.skinId);
					$$invalidate(1, trailId = char.characterTrail.currentAppearanceId);
					$$invalidate(2, gotSkinId = true);
					clearInterval(checkInterval);
				}
			},
			500
		);

function apply() {
			let char = getUnsafeWindow()?.stores?.phaser?.scene?.characterManager?.characters?.get($playerId);
			if (!char) return;

if (skinId != "") {
				let setSkinId = skinId;
				if (!setSkinId.startsWith('character_')) setSkinId = 'character_' + setSkinId;
				char.skin.updateSkin({ id: setSkinId });
			}

if (trailId != "") {
				let setTrailId = trailId;
				if (!setTrailId.startsWith('trail_')) setTrailId = 'trail_' + setTrailId;
				char.characterTrail.updateAppearance(setTrailId);
			}
		}

onDestroy(() => {
			clearInterval(checkInterval);
		});

function inputwithselect0_value_binding(value) {
			skinId = value;
			$$invalidate(0, skinId);
		}

function inputwithselect1_value_binding(value) {
			trailId = value;
			$$invalidate(1, trailId);
		}

return [
			skinId,
			trailId,
			gotSkinId,
			apply,
			inputwithselect0_value_binding,
			inputwithselect1_value_binding
		];
	}

class CosmeticPicker extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$l, create_fragment$s, safe_not_equal, {}, add_css$8);
		}
	}

const defaultThemes = [
	    {
	        question: {
	            background: "rgba(48, 63, 159, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(119, 19, 34, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(168, 92, 21, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(13, 107, 51, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(7, 98, 150, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(108, 47, 0, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(158, 104, 42, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(181, 71, 48, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(138, 151, 72, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(241, 185, 48, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(0, 10, 18, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(38, 50, 56, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(55, 71, 79, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(69, 90, 100, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(84, 110, 122, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(13, 0, 25, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(34, 0, 68, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(51, 0, 102, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(62, 0, 124, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(79, 23, 135, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(0, 0, 99, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(40, 53, 147, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(7, 98, 150, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(2, 119, 189, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(21, 101, 192, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(76, 61, 51, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(56, 86, 69, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(66, 92, 73, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(65, 86, 65, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(76, 99, 73, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(127, 116, 150, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(244, 111, 90, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(237, 113, 45, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(122, 89, 106, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(232, 171, 60, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(255, 191, 209, 1)",
	            text: "rgba(67, 67, 67, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(255, 166, 158, 1)",
	                text: "rgba(91, 91, 91, 1)"
	            },
	            {
	                background: "rgba(252, 246, 191, 1)",
	                text: "rgba(91, 91, 91, 1)"
	            },
	            {
	                background: "rgba(208, 244, 222, 1)",
	                text: "rgba(91, 91, 91, 1)"
	            },
	            {
	                background: "rgba(147, 225, 216, 1)",
	                text: "rgba(91, 91, 91, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(156, 0, 34, 1)",
	            text: "rgba(255, 255, 255, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(0, 29, 59, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(255, 174, 82, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(254, 89, 99, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            },
	            {
	                background: "rgba(167, 28, 148, 1)",
	                text: "rgba(255, 255, 255, 1)"
	            }
	        ]
	    },
	    {
	        question: {
	            background: "rgba(0, 0, 0, 1)",
	            text: "rgba(255, 205, 43, 1)"
	        },
	        palette: [
	            {
	                background: "rgba(255, 205, 43, 1)",
	                text: "rgba(0, 0, 0, 1)"
	            },
	            {
	                background: "rgba(255, 199, 33, 1)",
	                text: "rgba(0, 0, 0, 1)"
	            },
	            {
	                background: "rgba(255, 209, 71, 1)",
	                text: "rgba(0, 0, 0, 1)"
	            },
	            {
	                background: "rgba(255, 205, 56, 1)",
	                text: "rgba(0, 0, 0, 1)"
	            }
	        ]
	    }
	];

/* node_modules\svelte-material-icons\Delete.svelte generated by Svelte v4.2.19 */

function create_if_block_1$3(ctx) {
		let desc_1;
		let t;

// (16:165) {#if title}
	function create_if_block$5(ctx) {
		let title_1;
		let t;

function create_fragment$r(ctx) {
		let svg;
		let if_block0_anchor;
		let path;
		let if_block0 = /*desc*/ ctx[7] && create_if_block_1$3(ctx);
		let if_block1 = /*title*/ ctx[6] && create_if_block$5(ctx);

return {
			c() {
				svg = svg_element("svg");
				if (if_block0) if_block0.c();
				if_block0_anchor = empty();
				if (if_block1) if_block1.c();
				path = svg_element("path");
				attr(path, "d", "M19,4H15.5L14.5,3H9.5L8.5,4H5V6H19M6,19A2,2 0 0,0 8,21H16A2,2 0 0,0 18,19V7H6V19Z");
				attr(path, "fill", /*color*/ ctx[2]);
				attr(svg, "viewBox", /*viewBox*/ ctx[3]);
				attr(svg, "width", /*width*/ ctx[0]);
				attr(svg, "height", /*height*/ ctx[1]);
				attr(svg, "class", /*className*/ ctx[8]);
				attr(svg, "aria-label", /*ariaLabel*/ ctx[4]);
				attr(svg, "aria-hidden", /*ariaHidden*/ ctx[5]);
			},
			m(target, anchor) {
				insert(target, svg, anchor);
				if (if_block0) if_block0.m(svg, null);
				append(svg, if_block0_anchor);
				if (if_block1) if_block1.m(svg, null);
				append(svg, path);
			},
			p(ctx, [dirty]) {
				if (/*desc*/ ctx[7]) {
					if (if_block0) {
						if_block0.p(ctx, dirty);
					} else {
						if_block0 = create_if_block_1$3(ctx);
						if_block0.c();
						if_block0.m(svg, if_block0_anchor);
					}
				} else if (if_block0) {
					if_block0.d(1);
					if_block0 = null;
				}

if (/*title*/ ctx[6]) {
					if (if_block1) {
						if_block1.p(ctx, dirty);
					} else {
						if_block1 = create_if_block$5(ctx);
						if_block1.c();
						if_block1.m(svg, path);
					}
				} else if (if_block1) {
					if_block1.d(1);
					if_block1 = null;
				}