(function (exports) {
	'use strict';

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

	function getAugmentedNamespace(n) {
	  if (n.__esModule) return n;
	  var f = n.default;
		if (typeof f == "function") {
			var a = function a () {
				if (this instanceof a) {
	        return Reflect.construct(f, arguments, this.constructor);
				}
				return f.apply(this, arguments);
			};
			a.prototype = f.prototype;
	  } else a = {};
	  Object.defineProperty(a, '__esModule', {value: true});
		Object.keys(n).forEach(function (k) {
			var d = Object.getOwnPropertyDescriptor(n, k);
			Object.defineProperty(a, k, d.get ? d : {
				enumerable: true,
				get: function () {
					return n[k];
				}
			});
		});
		return a;
	}

	var main$1 = {};

	var cjs$3 = {exports: {}};

	var url$1 = {};

	var cjs$2 = {};

	var socket$2 = {};

	var transports = {};

	var pollingXhr = {};

	var polling = {};

	var transport = {};

	var cjs$1 = {};

	var encodePacket_browser = {};

	var commons = {};

	Object.defineProperty(commons, "__esModule", { value: true });
	commons.ERROR_PACKET = commons.PACKET_TYPES_REVERSE = commons.PACKET_TYPES = void 0;
	const PACKET_TYPES = Object.create(null); // no Map = no polyfill
	commons.PACKET_TYPES = PACKET_TYPES;
	PACKET_TYPES["open"] = "0";
	PACKET_TYPES["close"] = "1";
	PACKET_TYPES["ping"] = "2";
	PACKET_TYPES["pong"] = "3";
	PACKET_TYPES["message"] = "4";
	PACKET_TYPES["upgrade"] = "5";
	PACKET_TYPES["noop"] = "6";
	const PACKET_TYPES_REVERSE = Object.create(null);
	commons.PACKET_TYPES_REVERSE = PACKET_TYPES_REVERSE;
	Object.keys(PACKET_TYPES).forEach((key) => {
	    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
	});
	const ERROR_PACKET = { type: "error", data: "parser error" };
	commons.ERROR_PACKET = ERROR_PACKET;

	Object.defineProperty(encodePacket_browser, "__esModule", { value: true });
	encodePacket_browser.encodePacket = void 0;
	encodePacket_browser.encodePacketToBinary = encodePacketToBinary;
	const commons_js_1$1 = commons;
	const withNativeBlob$1 = typeof Blob === "function" ||
	    (typeof Blob !== "undefined" &&
	        Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
	const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
	// ArrayBuffer.isView method is not defined in IE10
	const isView$1 = (obj) => {
	    return typeof ArrayBuffer.isView === "function"
	        ? ArrayBuffer.isView(obj)
	        : obj && obj.buffer instanceof ArrayBuffer;
	};
	const encodePacket = ({ type, data }, supportsBinary, callback) => {
	    if (withNativeBlob$1 && data instanceof Blob) {
	        if (supportsBinary) {
	            return callback(data);
	        }
	        else {
	            return encodeBlobAsBase64(data, callback);
	        }
	    }
	    else if (withNativeArrayBuffer$2 &&
	        (data instanceof ArrayBuffer || isView$1(data))) {
	        if (supportsBinary) {
	            return callback(data);
	        }
	        else {
	            return encodeBlobAsBase64(new Blob([data]), callback);
	        }
	    }
	    // plain string
	    return callback(commons_js_1$1.PACKET_TYPES[type] + (data || ""));
	};
	encodePacket_browser.encodePacket = encodePacket;
	const encodeBlobAsBase64 = (data, callback) => {
	    const fileReader = new FileReader();
	    fileReader.onload = function () {
	        const content = fileReader.result.split(",")[1];
	        callback("b" + (content || ""));
	    };
	    return fileReader.readAsDataURL(data);
	};
	function toArray$1(data) {
	    if (data instanceof Uint8Array) {
	        return data;
	    }
	    else if (data instanceof ArrayBuffer) {
	        return new Uint8Array(data);
	    }
	    else {
	        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
	    }
	}
	let TEXT_ENCODER;
	function encodePacketToBinary(packet, callback) {
	    if (withNativeBlob$1 && packet.data instanceof Blob) {
	        return packet.data.arrayBuffer().then(toArray$1).then(callback);
	    }
	    else if (withNativeArrayBuffer$2 &&
	        (packet.data instanceof ArrayBuffer || isView$1(packet.data))) {
	        return callback(toArray$1(packet.data));
	    }
	    encodePacket(packet, false, (encoded) => {
	        if (!TEXT_ENCODER) {
	            TEXT_ENCODER = new TextEncoder();
	        }
	        callback(TEXT_ENCODER.encode(encoded));
	    });
	}

	var decodePacket_browser = {};

	var base64Arraybuffer = {};

	Object.defineProperty(base64Arraybuffer, "__esModule", { value: true });
	base64Arraybuffer.decode = base64Arraybuffer.encode = void 0;
	// imported from https://github.com/socketio/base64-arraybuffer
	const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
	// Use a lookup table to find the index.
	const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
	for (let i = 0; i < chars.length; i++) {
	    lookup[chars.charCodeAt(i)] = i;
	}
	const encode$1 = (arraybuffer) => {
	    let bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';
	    for (i = 0; i < len; i += 3) {
	        base64 += chars[bytes[i] >> 2];
	        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
	        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
	        base64 += chars[bytes[i + 2] & 63];
	    }
	    if (len % 3 === 2) {
	        base64 = base64.substring(0, base64.length - 1) + '=';
	    }
	    else if (len % 3 === 1) {
	        base64 = base64.substring(0, base64.length - 2) + '==';
	    }
	    return base64;
	};
	base64Arraybuffer.encode = encode$1;
	const decode$1 = (base64) => {
	    let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
	    if (base64[base64.length - 1] === '=') {
	        bufferLength--;
	        if (base64[base64.length - 2] === '=') {
	            bufferLength--;
	        }
	    }
	    const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
	    for (i = 0; i < len; i += 4) {
	        encoded1 = lookup[base64.charCodeAt(i)];
	        encoded2 = lookup[base64.charCodeAt(i + 1)];
	        encoded3 = lookup[base64.charCodeAt(i + 2)];
	        encoded4 = lookup[base64.charCodeAt(i + 3)];
	        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
	        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
	        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
	    }
	    return arraybuffer;
	};
	base64Arraybuffer.decode = decode$1;

	Object.defineProperty(decodePacket_browser, "__esModule", { value: true });
	decodePacket_browser.decodePacket = void 0;
	const commons_js_1 = commons;
	const base64_arraybuffer_js_1 = base64Arraybuffer;
	const withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
	const decodePacket = (encodedPacket, binaryType) => {
	    if (typeof encodedPacket !== "string") {
	        return {
	            type: "message",
	            data: mapBinary(encodedPacket, binaryType),
	        };
	    }
	    const type = encodedPacket.charAt(0);
	    if (type === "b") {
	        return {
	            type: "message",
	            data: decodeBase64Packet(encodedPacket.substring(1), binaryType),
	        };
	    }
	    const packetType = commons_js_1.PACKET_TYPES_REVERSE[type];
	    if (!packetType) {
	        return commons_js_1.ERROR_PACKET;
	    }
	    return encodedPacket.length > 1
	        ? {
	            type: commons_js_1.PACKET_TYPES_REVERSE[type],
	            data: encodedPacket.substring(1),
	        }
	        : {
	            type: commons_js_1.PACKET_TYPES_REVERSE[type],
	        };
	};
	decodePacket_browser.decodePacket = decodePacket;
	const decodeBase64Packet = (data, binaryType) => {
	    if (withNativeArrayBuffer$1) {
	        const decoded = (0, base64_arraybuffer_js_1.decode)(data);
	        return mapBinary(decoded, binaryType);
	    }
	    else {
	        return { base64: true, data }; // fallback for old browsers
	    }
	};
	const mapBinary = (data, binaryType) => {
	    switch (binaryType) {
	        case "blob":
	            if (data instanceof Blob) {
	                // from WebSocket + binaryType "blob"
	                return data;
	            }
	            else {
	                // from HTTP long-polling or WebTransport
	                return new Blob([data]);
	            }
	        case "arraybuffer":
	        default:
	            if (data instanceof ArrayBuffer) {
	                // from HTTP long-polling (base64) or WebSocket + binaryType "arraybuffer"
	                return data;
	            }
	            else {
	                // from WebTransport (Uint8Array)
	                return data.buffer;
	            }
	    }
	};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.decodePayload = exports.decodePacket = exports.encodePayload = exports.encodePacket = exports.protocol = void 0;
		exports.createPacketEncoderStream = createPacketEncoderStream;
		exports.createPacketDecoderStream = createPacketDecoderStream;
		const encodePacket_js_1 = encodePacket_browser;
		Object.defineProperty(exports, "encodePacket", { enumerable: true, get: function () { return encodePacket_js_1.encodePacket; } });
		const decodePacket_js_1 = decodePacket_browser;
		Object.defineProperty(exports, "decodePacket", { enumerable: true, get: function () { return decodePacket_js_1.decodePacket; } });
		const commons_js_1 = commons;
		const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
		const encodePayload = (packets, callback) => {
		    // some packets may be added to the array while encoding, so the initial length must be saved
		    const length = packets.length;
		    const encodedPackets = new Array(length);
		    let count = 0;
		    packets.forEach((packet, i) => {
		        // force base64 encoding for binary packets
		        (0, encodePacket_js_1.encodePacket)(packet, false, (encodedPacket) => {
		            encodedPackets[i] = encodedPacket;
		            if (++count === length) {
		                callback(encodedPackets.join(SEPARATOR));
		            }
		        });
		    });
		};
		exports.encodePayload = encodePayload;
		const decodePayload = (encodedPayload, binaryType) => {
		    const encodedPackets = encodedPayload.split(SEPARATOR);
		    const packets = [];
		    for (let i = 0; i < encodedPackets.length; i++) {
		        const decodedPacket = (0, decodePacket_js_1.decodePacket)(encodedPackets[i], binaryType);
		        packets.push(decodedPacket);
		        if (decodedPacket.type === "error") {
		            break;
		        }
		    }
		    return packets;
		};
		exports.decodePayload = decodePayload;
		function createPacketEncoderStream() {
		    return new TransformStream({
		        transform(packet, controller) {
		            (0, encodePacket_js_1.encodePacketToBinary)(packet, (encodedPacket) => {
		                const payloadLength = encodedPacket.length;
		                let header;
		                // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length
		                if (payloadLength < 126) {
		                    header = new Uint8Array(1);
		                    new DataView(header.buffer).setUint8(0, payloadLength);
		                }
		                else if (payloadLength < 65536) {
		                    header = new Uint8Array(3);
		                    const view = new DataView(header.buffer);
		                    view.setUint8(0, 126);
		                    view.setUint16(1, payloadLength);
		                }
		                else {
		                    header = new Uint8Array(9);
		                    const view = new DataView(header.buffer);
		                    view.setUint8(0, 127);
		                    view.setBigUint64(1, BigInt(payloadLength));
		                }
		                // first bit indicates whether the payload is plain text (0) or binary (1)
		                if (packet.data && typeof packet.data !== "string") {
		                    header[0] |= 0x80;
		                }
		                controller.enqueue(header);
		                controller.enqueue(encodedPacket);
		            });
		        },
		    });
		}
		let TEXT_DECODER;
		function totalLength(chunks) {
		    return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
		}
		function concatChunks(chunks, size) {
		    if (chunks[0].length === size) {
		        return chunks.shift();
		    }
		    const buffer = new Uint8Array(size);
		    let j = 0;
		    for (let i = 0; i < size; i++) {
		        buffer[i] = chunks[0][j++];
		        if (j === chunks[0].length) {
		            chunks.shift();
		            j = 0;
		        }
		    }
		    if (chunks.length && j < chunks[0].length) {
		        chunks[0] = chunks[0].slice(j);
		    }
		    return buffer;
		}
		function createPacketDecoderStream(maxPayload, binaryType) {
		    if (!TEXT_DECODER) {
		        TEXT_DECODER = new TextDecoder();
		    }
		    const chunks = [];
		    let state = 0 /* State.READ_HEADER */;
		    let expectedLength = -1;
		    let isBinary = false;
		    return new TransformStream({
		        transform(chunk, controller) {
		            chunks.push(chunk);
		            while (true) {
		                if (state === 0 /* State.READ_HEADER */) {
		                    if (totalLength(chunks) < 1) {
		                        break;
		                    }
		                    const header = concatChunks(chunks, 1);
		                    isBinary = (header[0] & 0x80) === 0x80;
		                    expectedLength = header[0] & 0x7f;
		                    if (expectedLength < 126) {
		                        state = 3 /* State.READ_PAYLOAD */;
		                    }
		                    else if (expectedLength === 126) {
		                        state = 1 /* State.READ_EXTENDED_LENGTH_16 */;
		                    }
		                    else {
		                        state = 2 /* State.READ_EXTENDED_LENGTH_64 */;
		                    }
		                }
		                else if (state === 1 /* State.READ_EXTENDED_LENGTH_16 */) {
		                    if (totalLength(chunks) < 2) {
		                        break;
		                    }
		                    const headerArray = concatChunks(chunks, 2);
		                    expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
		                    state = 3 /* State.READ_PAYLOAD */;
		                }
		                else if (state === 2 /* State.READ_EXTENDED_LENGTH_64 */) {
		                    if (totalLength(chunks) < 8) {
		                        break;
		                    }
		                    const headerArray = concatChunks(chunks, 8);
		                    const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
		                    const n = view.getUint32(0);
		                    if (n > Math.pow(2, 53 - 32) - 1) {
		                        // the maximum safe integer in JavaScript is 2^53 - 1
		                        controller.enqueue(commons_js_1.ERROR_PACKET);
		                        break;
		                    }
		                    expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
		                    state = 3 /* State.READ_PAYLOAD */;
		                }
		                else {
		                    if (totalLength(chunks) < expectedLength) {
		                        break;
		                    }
		                    const data = concatChunks(chunks, expectedLength);
		                    controller.enqueue((0, decodePacket_js_1.decodePacket)(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
		                    state = 0 /* State.READ_HEADER */;
		                }
		                if (expectedLength === 0 || expectedLength > maxPayload) {
		                    controller.enqueue(commons_js_1.ERROR_PACKET);
		                    break;
		                }
		            }
		        },
		    });
		}
		exports.protocol = 4; 
	} (cjs$1));

	/**
	 * Initialize a new `Emitter`.
	 *
	 * @api public
	 */

	function Emitter(obj) {
	  if (obj) return mixin(obj);
	}

	/**
	 * Mixin the emitter properties.
	 *
	 * @param {Object} obj
	 * @return {Object}
	 * @api private
	 */

	function mixin(obj) {
	  for (var key in Emitter.prototype) {
	    obj[key] = Emitter.prototype[key];
	  }
	  return obj;
	}

	/**
	 * Listen on the given `event` with `fn`.
	 *
	 * @param {String} event
	 * @param {Function} fn
	 * @return {Emitter}
	 * @api public
	 */

	Emitter.prototype.on =
	Emitter.prototype.addEventListener = function(event, fn){
	  this._callbacks = this._callbacks || {};
	  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])
	    .push(fn);
	  return this;
	};

	/**
	 * Adds an `event` listener that will be invoked a single
	 * time then automatically removed.
	 *
	 * @param {String} event
	 * @param {Function} fn
	 * @return {Emitter}
	 * @api public
	 */

	Emitter.prototype.once = function(event, fn){
	  function on() {
	    this.off(event, on);
	    fn.apply(this, arguments);
	  }

	  on.fn = fn;
	  this.on(event, on);
	  return this;
	};

	/**
	 * Remove the given callback for `event` or all
	 * registered callbacks.
	 *
	 * @param {String} event
	 * @param {Function} fn
	 * @return {Emitter}
	 * @api public
	 */

	Emitter.prototype.off =
	Emitter.prototype.removeListener =
	Emitter.prototype.removeAllListeners =
	Emitter.prototype.removeEventListener = function(event, fn){
	  this._callbacks = this._callbacks || {};

	  // all
	  if (0 == arguments.length) {
	    this._callbacks = {};
	    return this;
	  }

	  // specific event
	  var callbacks = this._callbacks['$' + event];
	  if (!callbacks) return this;

	  // remove all handlers
	  if (1 == arguments.length) {
	    delete this._callbacks['$' + event];
	    return this;
	  }

	  // remove specific handler
	  var cb;
	  for (var i = 0; i < callbacks.length; i++) {
	    cb = callbacks[i];
	    if (cb === fn || cb.fn === fn) {
	      callbacks.splice(i, 1);
	      break;
	    }
	  }

	  // Remove event specific arrays for event types that no
	  // one is subscribed for to avoid memory leak.
	  if (callbacks.length === 0) {
	    delete this._callbacks['$' + event];
	  }

	  return this;
	};

	/**
	 * Emit `event` with the given args.
	 *
	 * @param {String} event
	 * @param {Mixed} ...
	 * @return {Emitter}
	 */

	Emitter.prototype.emit = function(event){
	  this._callbacks = this._callbacks || {};

	  var args = new Array(arguments.length - 1)
	    , callbacks = this._callbacks['$' + event];

	  for (var i = 1; i < arguments.length; i++) {
	    args[i - 1] = arguments[i];
	  }

	  if (callbacks) {
	    callbacks = callbacks.slice(0);
	    for (var i = 0, len = callbacks.length; i < len; ++i) {
	      callbacks[i].apply(this, args);
	    }
	  }

	  return this;
	};

	// alias used for reserved events (protected method)
	Emitter.prototype.emitReserved = Emitter.prototype.emit;

	/**
	 * Return array of callbacks for `event`.
	 *
	 * @param {String} event
	 * @return {Array}
	 * @api public
	 */

	Emitter.prototype.listeners = function(event){
	  this._callbacks = this._callbacks || {};
	  return this._callbacks['$' + event] || [];
	};

	/**
	 * Check if this emitter has `event` handlers.
	 *
	 * @param {String} event
	 * @return {Boolean}
	 * @api public
	 */

	Emitter.prototype.hasListeners = function(event){
	  return !! this.listeners(event).length;
	};

	var esm = /*#__PURE__*/Object.freeze({
		__proto__: null,
		Emitter: Emitter
	});

	var require$$5 = /*@__PURE__*/getAugmentedNamespace(esm);

	var util = {};

	var globals = {};

	Object.defineProperty(globals, "__esModule", { value: true });
	globals.defaultBinaryType = globals.globalThisShim = globals.nextTick = void 0;
	globals.createCookieJar = createCookieJar;
	globals.nextTick = (() => {
	    const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
	    if (isPromiseAvailable) {
	        return (cb) => Promise.resolve().then(cb);
	    }
	    else {
	        return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
	    }
	})();
	globals.globalThisShim = (() => {
	    if (typeof self !== "undefined") {
	        return self;
	    }
	    else if (typeof window !== "undefined") {
	        return window;
	    }
	    else {
	        return Function("return this")();
	    }
	})();
	globals.defaultBinaryType = "arraybuffer";
	function createCookieJar() { }

	Object.defineProperty(util, "__esModule", { value: true });
	util.pick = pick;
	util.installTimerFunctions = installTimerFunctions;
	util.byteLength = byteLength;
	util.randomString = randomString;
	const globals_node_js_1$4 = globals;
	function pick(obj, ...attr) {
	    return attr.reduce((acc, k) => {
	        if (obj.hasOwnProperty(k)) {
	            acc[k] = obj[k];
	        }
	        return acc;
	    }, {});
	}
	// Keep a reference to the real timeout functions so they can be used when overridden
	const NATIVE_SET_TIMEOUT = globals_node_js_1$4.globalThisShim.setTimeout;
	const NATIVE_CLEAR_TIMEOUT = globals_node_js_1$4.globalThisShim.clearTimeout;
	function installTimerFunctions(obj, opts) {
	    if (opts.useNativeTimers) {
	        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globals_node_js_1$4.globalThisShim);
	        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globals_node_js_1$4.globalThisShim);
	    }
	    else {
	        obj.setTimeoutFn = globals_node_js_1$4.globalThisShim.setTimeout.bind(globals_node_js_1$4.globalThisShim);
	        obj.clearTimeoutFn = globals_node_js_1$4.globalThisShim.clearTimeout.bind(globals_node_js_1$4.globalThisShim);
	    }
	}
	// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
	const BASE64_OVERHEAD = 1.33;
	// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
	function byteLength(obj) {
	    if (typeof obj === "string") {
	        return utf8Length(obj);
	    }
	    // arraybuffer or blob
	    return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
	}
	function utf8Length(str) {
	    let c = 0, length = 0;
	    for (let 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;
	}
	/**
	 * Generates a random 8-characters string.
	 */
	function randomString() {
	    return (Date.now().toString(36).substring(3) +
	        Math.random().toString(36).substring(2, 5));
	}

	var parseqs = {};

	// imported from https://github.com/galkn/querystring
	/**
	 * Compiles a querystring
	 * Returns string representation of the object
	 *
	 * @param {Object}
	 * @api private
	 */
	Object.defineProperty(parseqs, "__esModule", { value: true });
	parseqs.encode = encode;
	parseqs.decode = decode;
	function encode(obj) {
	    let str = '';
	    for (let i in obj) {
	        if (obj.hasOwnProperty(i)) {
	            if (str.length)
	                str += '&';
	            str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
	        }
	    }
	    return str;
	}
	/**
	 * Parses a simple querystring into an object
	 *
	 * @param {String} qs
	 * @api private
	 */
	function decode(qs) {
	    let qry = {};
	    let pairs = qs.split('&');
	    for (let i = 0, l = pairs.length; i < l; i++) {
	        let pair = pairs[i].split('=');
	        qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
	    }
	    return qry;
	}

	var browser = {exports: {}};

	/**
	 * Helpers.
	 */

	var ms;
	var hasRequiredMs;

	function requireMs () {
		if (hasRequiredMs) return ms;
		hasRequiredMs = 1;
		var s = 1000;
		var m = s * 60;
		var h = m * 60;
		var d = h * 24;
		var w = d * 7;
		var y = d * 365.25;

		/**
		 * Parse or format the given `val`.
		 *
		 * Options:
		 *
		 *  - `long` verbose formatting [false]
		 *
		 * @param {String|Number} val
		 * @param {Object} [options]
		 * @throws {Error} throw an error if val is not a non-empty string or a number
		 * @return {String|Number}
		 * @api public
		 */

		ms = function (val, options) {
		  options = options || {};
		  var type = typeof val;
		  if (type === 'string' && val.length > 0) {
		    return parse(val);
		  } else if (type === 'number' && isFinite(val)) {
		    return options.long ? fmtLong(val) : fmtShort(val);
		  }
		  throw new Error(
		    'val is not a non-empty string or a valid number. val=' +
		      JSON.stringify(val)
		  );
		};

		/**
		 * Parse the given `str` and return milliseconds.
		 *
		 * @param {String} str
		 * @return {Number}
		 * @api private
		 */

		function parse(str) {
		  str = String(str);
		  if (str.length > 100) {
		    return;
		  }
		  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
		    str
		  );
		  if (!match) {
		    return;
		  }
		  var n = parseFloat(match[1]);
		  var type = (match[2] || 'ms').toLowerCase();
		  switch (type) {
		    case 'years':
		    case 'year':
		    case 'yrs':
		    case 'yr':
		    case 'y':
		      return n * y;
		    case 'weeks':
		    case 'week':
		    case 'w':
		      return n * w;
		    case 'days':
		    case 'day':
		    case 'd':
		      return n * d;
		    case 'hours':
		    case 'hour':
		    case 'hrs':
		    case 'hr':
		    case 'h':
		      return n * h;
		    case 'minutes':
		    case 'minute':
		    case 'mins':
		    case 'min':
		    case 'm':
		      return n * m;
		    case 'seconds':
		    case 'second':
		    case 'secs':
		    case 'sec':
		    case 's':
		      return n * s;
		    case 'milliseconds':
		    case 'millisecond':
		    case 'msecs':
		    case 'msec':
		    case 'ms':
		      return n;
		    default:
		      return undefined;
		  }
		}

		/**
		 * Short format for `ms`.
		 *
		 * @param {Number} ms
		 * @return {String}
		 * @api private
		 */

		function fmtShort(ms) {
		  var msAbs = Math.abs(ms);
		  if (msAbs >= d) {
		    return Math.round(ms / d) + 'd';
		  }
		  if (msAbs >= h) {
		    return Math.round(ms / h) + 'h';
		  }
		  if (msAbs >= m) {
		    return Math.round(ms / m) + 'm';
		  }
		  if (msAbs >= s) {
		    return Math.round(ms / s) + 's';
		  }
		  return ms + 'ms';
		}

		/**
		 * Long format for `ms`.
		 *
		 * @param {Number} ms
		 * @return {String}
		 * @api private
		 */

		function fmtLong(ms) {
		  var msAbs = Math.abs(ms);
		  if (msAbs >= d) {
		    return plural(ms, msAbs, d, 'day');
		  }
		  if (msAbs >= h) {
		    return plural(ms, msAbs, h, 'hour');
		  }
		  if (msAbs >= m) {
		    return plural(ms, msAbs, m, 'minute');
		  }
		  if (msAbs >= s) {
		    return plural(ms, msAbs, s, 'second');
		  }
		  return ms + ' ms';
		}

		/**
		 * Pluralization helper.
		 */

		function plural(ms, msAbs, n, name) {
		  var isPlural = msAbs >= n * 1.5;
		  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
		}
		return ms;
	}

	/**
	 * This is the common logic for both the Node.js and web browser
	 * implementations of `debug()`.
	 */

	function setup(env) {
		createDebug.debug = createDebug;
		createDebug.default = createDebug;
		createDebug.coerce = coerce;
		createDebug.disable = disable;
		createDebug.enable = enable;
		createDebug.enabled = enabled;
		createDebug.humanize = requireMs();
		createDebug.destroy = destroy;

		Object.keys(env).forEach(key => {
			createDebug[key] = env[key];
		});

		/**
		* The currently active debug mode names, and names to skip.
		*/

		createDebug.names = [];
		createDebug.skips = [];

		/**
		* Map of special "%n" handling functions, for the debug "format" argument.
		*
		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
		*/
		createDebug.formatters = {};

		/**
		* Selects a color for a debug namespace
		* @param {String} namespace The namespace string for the debug instance to be colored
		* @return {Number|String} An ANSI color code for the given namespace
		* @api private
		*/
		function selectColor(namespace) {
			let hash = 0;

			for (let i = 0; i < namespace.length; i++) {
				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
				hash |= 0; // Convert to 32bit integer
			}

			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
		}
		createDebug.selectColor = selectColor;

		/**
		* Create a debugger with the given `namespace`.
		*
		* @param {String} namespace
		* @return {Function}
		* @api public
		*/
		function createDebug(namespace) {
			let prevTime;
			let enableOverride = null;
			let namespacesCache;
			let enabledCache;

			function debug(...args) {
				// Disabled?
				if (!debug.enabled) {
					return;
				}

				const self = debug;

				// Set `diff` timestamp
				const curr = Number(new Date());
				const ms = curr - (prevTime || curr);
				self.diff = ms;
				self.prev = prevTime;
				self.curr = curr;
				prevTime = curr;

				args[0] = createDebug.coerce(args[0]);

				if (typeof args[0] !== 'string') {
					// Anything else let's inspect with %O
					args.unshift('%O');
				}

				// Apply any `formatters` transformations
				let index = 0;
				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
					// If we encounter an escaped % then don't increase the array index
					if (match === '%%') {
						return '%';
					}
					index++;
					const formatter = createDebug.formatters[format];
					if (typeof formatter === 'function') {
						const val = args[index];
						match = formatter.call(self, val);

						// Now we need to remove `args[index]` since it's inlined in the `format`
						args.splice(index, 1);
						index--;
					}
					return match;
				});

				// Apply env-specific formatting (colors, etc.)
				createDebug.formatArgs.call(self, args);

				const logFn = self.log || createDebug.log;
				logFn.apply(self, args);
			}

			debug.namespace = namespace;
			debug.useColors = createDebug.useColors();
			debug.color = createDebug.selectColor(namespace);
			debug.extend = extend;
			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.

			Object.defineProperty(debug, 'enabled', {
				enumerable: true,
				configurable: false,
				get: () => {
					if (enableOverride !== null) {
						return enableOverride;
					}
					if (namespacesCache !== createDebug.namespaces) {
						namespacesCache = createDebug.namespaces;
						enabledCache = createDebug.enabled(namespace);
					}

					return enabledCache;
				},
				set: v => {
					enableOverride = v;
				}
			});

			// Env-specific initialization logic for debug instances
			if (typeof createDebug.init === 'function') {
				createDebug.init(debug);
			}

			return debug;
		}

		function extend(namespace, delimiter) {
			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
			newDebug.log = this.log;
			return newDebug;
		}

		/**
		* Enables a debug mode by namespaces. This can include modes
		* separated by a colon and wildcards.
		*
		* @param {String} namespaces
		* @api public
		*/
		function enable(namespaces) {
			createDebug.save(namespaces);
			createDebug.namespaces = namespaces;

			createDebug.names = [];
			createDebug.skips = [];

			const split = (typeof namespaces === 'string' ? namespaces : '')
				.trim()
				.replace(/\s+/g, ',')
				.split(',')
				.filter(Boolean);

			for (const ns of split) {
				if (ns[0] === '-') {
					createDebug.skips.push(ns.slice(1));
				} else {
					createDebug.names.push(ns);
				}
			}
		}

		/**
		 * Checks if the given string matches a namespace template, honoring
		 * asterisks as wildcards.
		 *
		 * @param {String} search
		 * @param {String} template
		 * @return {Boolean}
		 */
		function matchesTemplate(search, template) {
			let searchIndex = 0;
			let templateIndex = 0;
			let starIndex = -1;
			let matchIndex = 0;

			while (searchIndex < search.length) {
				if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) {
					// Match character or proceed with wildcard
					if (template[templateIndex] === '*') {
						starIndex = templateIndex;
						matchIndex = searchIndex;
						templateIndex++; // Skip the '*'
					} else {
						searchIndex++;
						templateIndex++;
					}
				} else if (starIndex !== -1) { // eslint-disable-line no-negated-condition
					// Backtrack to the last '*' and try to match more characters
					templateIndex = starIndex + 1;
					matchIndex++;
					searchIndex = matchIndex;
				} else {
					return false; // No match
				}
			}

			// Handle trailing '*' in template
			while (templateIndex < template.length && template[templateIndex] === '*') {
				templateIndex++;
			}

			return templateIndex === template.length;
		}

		/**
		* Disable debug output.
		*
		* @return {String} namespaces
		* @api public
		*/
		function disable() {
			const namespaces = [
				...createDebug.names,
				...createDebug.skips.map(namespace => '-' + namespace)
			].join(',');
			createDebug.enable('');
			return namespaces;
		}

		/**
		* Returns true if the given mode name is enabled, false otherwise.
		*
		* @param {String} name
		* @return {Boolean}
		* @api public
		*/
		function enabled(name) {
			for (const skip of createDebug.skips) {
				if (matchesTemplate(name, skip)) {
					return false;
				}
			}

			for (const ns of createDebug.names) {
				if (matchesTemplate(name, ns)) {
					return true;
				}
			}

			return false;
		}

		/**
		* Coerce `val`.
		*
		* @param {Mixed} val
		* @return {Mixed}
		* @api private
		*/
		function coerce(val) {
			if (val instanceof Error) {
				return val.stack || val.message;
			}
			return val;
		}

		/**
		* XXX DO NOT USE. This is a temporary stub function.
		* XXX It WILL be removed in the next major release.
		*/
		function destroy() {
			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
		}

		createDebug.enable(createDebug.load());

		return createDebug;
	}

	var common = setup;

	/* eslint-env browser */
	browser.exports;

	(function (module, exports) {
		/**
		 * This is the web browser implementation of `debug()`.
		 */

		exports.formatArgs = formatArgs;
		exports.save = save;
		exports.load = load;
		exports.useColors = useColors;
		exports.storage = localstorage();
		exports.destroy = (() => {
			let warned = false;

			return () => {
				if (!warned) {
					warned = true;
					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
				}
			};
		})();

		/**
		 * Colors.
		 */

		exports.colors = [
			'#0000CC',
			'#0000FF',
			'#0033CC',
			'#0033FF',
			'#0066CC',
			'#0066FF',
			'#0099CC',
			'#0099FF',
			'#00CC00',
			'#00CC33',
			'#00CC66',
			'#00CC99',
			'#00CCCC',
			'#00CCFF',
			'#3300CC',
			'#3300FF',
			'#3333CC',
			'#3333FF',
			'#3366CC',
			'#3366FF',
			'#3399CC',
			'#3399FF',
			'#33CC00',
			'#33CC33',
			'#33CC66',
			'#33CC99',
			'#33CCCC',
			'#33CCFF',
			'#6600CC',
			'#6600FF',
			'#6633CC',
			'#6633FF',
			'#66CC00',
			'#66CC33',
			'#9900CC',
			'#9900FF',
			'#9933CC',
			'#9933FF',
			'#99CC00',
			'#99CC33',
			'#CC0000',
			'#CC0033',
			'#CC0066',
			'#CC0099',
			'#CC00CC',
			'#CC00FF',
			'#CC3300',
			'#CC3333',
			'#CC3366',
			'#CC3399',
			'#CC33CC',
			'#CC33FF',
			'#CC6600',
			'#CC6633',
			'#CC9900',
			'#CC9933',
			'#CCCC00',
			'#CCCC33',
			'#FF0000',
			'#FF0033',
			'#FF0066',
			'#FF0099',
			'#FF00CC',
			'#FF00FF',
			'#FF3300',
			'#FF3333',
			'#FF3366',
			'#FF3399',
			'#FF33CC',
			'#FF33FF',
			'#FF6600',
			'#FF6633',
			'#FF9900',
			'#FF9933',
			'#FFCC00',
			'#FFCC33'
		];

		/**
		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
		 * and the Firebug extension (any Firefox version) are known
		 * to support "%c" CSS customizations.
		 *
		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
		 */

		// eslint-disable-next-line complexity
		function useColors() {
			// NB: In an Electron preload script, document will be defined but not fully
			// initialized. Since we know we're in Chrome, we'll just detect this case
			// explicitly
			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
				return true;
			}

			// Internet Explorer and Edge do not support colors.
			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
				return false;
			}

			let m;

			// Is webkit? http://stackoverflow.com/a/16459606/376773
			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
			// eslint-disable-next-line no-return-assign
			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
				// Is firebug? http://stackoverflow.com/a/398120/376773
				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
				// Is firefox >= v31?
				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
				// Double check webkit in userAgent just in case we are in a worker
				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
		}

		/**
		 * Colorize log arguments if enabled.
		 *
		 * @api public
		 */

		function formatArgs(args) {
			args[0] = (this.useColors ? '%c' : '') +
				this.namespace +
				(this.useColors ? ' %c' : ' ') +
				args[0] +
				(this.useColors ? '%c ' : ' ') +
				'+' + module.exports.humanize(this.diff);

			if (!this.useColors) {
				return;
			}

			const c = 'color: ' + this.color;
			args.splice(1, 0, c, 'color: inherit');

			// The final "%c" is somewhat tricky, because there could be other
			// arguments passed either before or after the %c, so we need to
			// figure out the correct index to insert the CSS into
			let index = 0;
			let lastC = 0;
			args[0].replace(/%[a-zA-Z%]/g, match => {
				if (match === '%%') {
					return;
				}
				index++;
				if (match === '%c') {
					// We only are interested in the *last* %c
					// (the user may have provided their own)
					lastC = index;
				}
			});

			args.splice(lastC, 0, c);
		}

		/**
		 * Invokes `console.debug()` when available.
		 * No-op when `console.debug` is not a "function".
		 * If `console.debug` is not available, falls back
		 * to `console.log`.
		 *
		 * @api public
		 */
		exports.log = console.debug || console.log || (() => {});

		/**
		 * Save `namespaces`.
		 *
		 * @param {String} namespaces
		 * @api private
		 */
		function save(namespaces) {
			try {
				if (namespaces) {
					exports.storage.setItem('debug', namespaces);
				} else {
					exports.storage.removeItem('debug');
				}
			} catch (error) {
				// Swallow
				// XXX (@Qix-) should we be logging these?
			}
		}

		/**
		 * Load `namespaces`.
		 *
		 * @return {String} returns the previously persisted debug modes
		 * @api private
		 */
		function load() {
			let r;
			try {
				r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
			} catch (error) {
				// Swallow
				// XXX (@Qix-) should we be logging these?
			}

			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
			if (!r && typeof process !== 'undefined' && 'env' in process) {
				r = process.env.DEBUG;
			}

			return r;
		}

		/**
		 * Localstorage attempts to return the localstorage.
		 *
		 * This is necessary because safari throws
		 * when a user disables cookies/localstorage
		 * and you attempt to access it.
		 *
		 * @return {LocalStorage}
		 * @api private
		 */

		function localstorage() {
			try {
				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
				// The Browser also has localStorage in the global context.
				return localStorage;
			} catch (error) {
				// Swallow
				// XXX (@Qix-) should we be logging these?
			}
		}

		module.exports = common(exports);

		const {formatters} = module.exports;

		/**
		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
		 */

		formatters.j = function (v) {
			try {
				return JSON.stringify(v);
			} catch (error) {
				return '[UnexpectedJSONParseError]: ' + error.message;
			}
		}; 
	} (browser, browser.exports));

	var browserExports = browser.exports;

	var __importDefault$8 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(transport, "__esModule", { value: true });
	transport.Transport = transport.TransportError = void 0;
	const engine_io_parser_1$4 = cjs$1;
	const component_emitter_1$5 = require$$5;
	const util_js_1$4 = util;
	const parseqs_js_1$1 = parseqs;
	const debug_1$9 = __importDefault$8(browserExports); // debug()
	const debug$9 = (0, debug_1$9.default)("engine.io-client:transport"); // debug()
	class TransportError extends Error {
	    constructor(reason, description, context) {
	        super(reason);
	        this.description = description;
	        this.context = context;
	        this.type = "TransportError";
	    }
	}
	transport.TransportError = TransportError;
	class Transport extends component_emitter_1$5.Emitter {
	    /**
	     * Transport abstract constructor.
	     *
	     * @param {Object} opts - options
	     * @protected
	     */
	    constructor(opts) {
	        super();
	        this.writable = false;
	        (0, util_js_1$4.installTimerFunctions)(this, opts);
	        this.opts = opts;
	        this.query = opts.query;
	        this.socket = opts.socket;
	        this.supportsBinary = !opts.forceBase64;
	    }
	    /**
	     * Emits an error.
	     *
	     * @param {String} reason
	     * @param description
	     * @param context - the error context
	     * @return {Transport} for chaining
	     * @protected
	     */
	    onError(reason, description, context) {
	        super.emitReserved("error", new TransportError(reason, description, context));
	        return this;
	    }
	    /**
	     * Opens the transport.
	     */
	    open() {
	        this.readyState = "opening";
	        this.doOpen();
	        return this;
	    }
	    /**
	     * Closes the transport.
	     */
	    close() {
	        if (this.readyState === "opening" || this.readyState === "open") {
	            this.doClose();
	            this.onClose();
	        }
	        return this;
	    }
	    /**
	     * Sends multiple packets.
	     *
	     * @param {Array} packets
	     */
	    send(packets) {
	        if (this.readyState === "open") {
	            this.write(packets);
	        }
	        else {
	            // this might happen if the transport was silently closed in the beforeunload event handler
	            debug$9("transport is not open, discarding packets");
	        }
	    }
	    /**
	     * Called upon open
	     *
	     * @protected
	     */
	    onOpen() {
	        this.readyState = "open";
	        this.writable = true;
	        super.emitReserved("open");
	    }
	    /**
	     * Called with data.
	     *
	     * @param {String} data
	     * @protected
	     */
	    onData(data) {
	        const packet = (0, engine_io_parser_1$4.decodePacket)(data, this.socket.binaryType);
	        this.onPacket(packet);
	    }
	    /**
	     * Called with a decoded packet.
	     *
	     * @protected
	     */
	    onPacket(packet) {
	        super.emitReserved("packet", packet);
	    }
	    /**
	     * Called upon close.
	     *
	     * @protected
	     */
	    onClose(details) {
	        this.readyState = "closed";
	        super.emitReserved("close", details);
	    }
	    /**
	     * Pauses the transport, in order not to lose packets during an upgrade.
	     *
	     * @param onPause
	     */
	    pause(onPause) { }
	    createUri(schema, query = {}) {
	        return (schema +
	            "://" +
	            this._hostname() +
	            this._port() +
	            this.opts.path +
	            this._query(query));
	    }
	    _hostname() {
	        const hostname = this.opts.hostname;
	        return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
	    }
	    _port() {
	        if (this.opts.port &&
	            ((this.opts.secure && Number(this.opts.port) !== 443) ||
	                (!this.opts.secure && Number(this.opts.port) !== 80))) {
	            return ":" + this.opts.port;
	        }
	        else {
	            return "";
	        }
	    }
	    _query(query) {
	        const encodedQuery = (0, parseqs_js_1$1.encode)(query);
	        return encodedQuery.length ? "?" + encodedQuery : "";
	    }
	}
	transport.Transport = Transport;

	var __importDefault$7 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(polling, "__esModule", { value: true });
	polling.Polling = void 0;
	const transport_js_1$2 = transport;
	const util_js_1$3 = util;
	const engine_io_parser_1$3 = cjs$1;
	const debug_1$8 = __importDefault$7(browserExports); // debug()
	const debug$8 = (0, debug_1$8.default)("engine.io-client:polling"); // debug()
	class Polling extends transport_js_1$2.Transport {
	    constructor() {
	        super(...arguments);
	        this._polling = false;
	    }
	    get name() {
	        return "polling";
	    }
	    /**
	     * Opens the socket (triggers polling). We write a PING message to determine
	     * when the transport is open.
	     *
	     * @protected
	     */
	    doOpen() {
	        this._poll();
	    }
	    /**
	     * Pauses polling.
	     *
	     * @param {Function} onPause - callback upon buffers are flushed and transport is paused
	     * @package
	     */
	    pause(onPause) {
	        this.readyState = "pausing";
	        const pause = () => {
	            debug$8("paused");
	            this.readyState = "paused";
	            onPause();
	        };
	        if (this._polling || !this.writable) {
	            let total = 0;
	            if (this._polling) {
	                debug$8("we are currently polling - waiting to pause");
	                total++;
	                this.once("pollComplete", function () {
	                    debug$8("pre-pause polling complete");
	                    --total || pause();
	                });
	            }
	            if (!this.writable) {
	                debug$8("we are currently writing - waiting to pause");
	                total++;
	                this.once("drain", function () {
	                    debug$8("pre-pause writing complete");
	                    --total || pause();
	                });
	            }
	        }
	        else {
	            pause();
	        }
	    }
	    /**
	     * Starts polling cycle.
	     *
	     * @private
	     */
	    _poll() {
	        debug$8("polling");
	        this._polling = true;
	        this.doPoll();
	        this.emitReserved("poll");
	    }
	    /**
	     * Overloads onData to detect payloads.
	     *
	     * @protected
	     */
	    onData(data) {
	        debug$8("polling got data %s", data);
	        const callback = (packet) => {
	            // if its the first message we consider the transport open
	            if ("opening" === this.readyState && packet.type === "open") {
	                this.onOpen();
	            }
	            // if its a close packet, we close the ongoing requests
	            if ("close" === packet.type) {
	                this.onClose({ description: "transport closed by the server" });
	                return false;
	            }
	            // otherwise bypass onData and handle the message
	            this.onPacket(packet);
	        };
	        // decode payload
	        (0, engine_io_parser_1$3.decodePayload)(data, this.socket.binaryType).forEach(callback);
	        // if an event did not trigger closing
	        if ("closed" !== this.readyState) {
	            // if we got data we're not polling
	            this._polling = false;
	            this.emitReserved("pollComplete");
	            if ("open" === this.readyState) {
	                this._poll();
	            }
	            else {
	                debug$8('ignoring poll - transport state "%s"', this.readyState);
	            }
	        }
	    }
	    /**
	     * For polling, send a close packet.
	     *
	     * @protected
	     */
	    doClose() {
	        const close = () => {
	            debug$8("writing close packet");
	            this.write([{ type: "close" }]);
	        };
	        if ("open" === this.readyState) {
	            debug$8("transport open - closing");
	            close();
	        }
	        else {
	            // in case we're trying to close while
	            // handshaking is in progress (GH-164)
	            debug$8("transport not open - deferring close");
	            this.once("open", close);
	        }
	    }
	    /**
	     * Writes a packets payload.
	     *
	     * @param {Array} packets - data packets
	     * @protected
	     */
	    write(packets) {
	        this.writable = false;
	        (0, engine_io_parser_1$3.encodePayload)(packets, (data) => {
	            this.doWrite(data, () => {
	                this.writable = true;
	                this.emitReserved("drain");
	            });
	        });
	    }
	    /**
	     * Generates uri for connection.
	     *
	     * @private
	     */
	    uri() {
	        const schema = this.opts.secure ? "https" : "http";
	        const query = this.query || {};
	        // cache busting is forced
	        if (false !== this.opts.timestampRequests) {
	            query[this.opts.timestampParam] = (0, util_js_1$3.randomString)();
	        }
	        if (!this.supportsBinary && !query.sid) {
	            query.b64 = 1;
	        }
	        return this.createUri(schema, query);
	    }
	}
	polling.Polling = Polling;

	var hasCors = {};

	Object.defineProperty(hasCors, "__esModule", { value: true });
	hasCors.hasCORS = void 0;
	// imported from https://github.com/component/has-cors
	let value = false;
	try {
	    value = typeof XMLHttpRequest !== 'undefined' &&
	        'withCredentials' in new XMLHttpRequest();
	}
	catch (err) {
	    // if XMLHttp support is disabled in IE then it will throw
	    // when trying to create
	}
	hasCors.hasCORS = value;

	var __importDefault$6 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(pollingXhr, "__esModule", { value: true });
	pollingXhr.XHR = pollingXhr.Request = pollingXhr.BaseXHR = void 0;
	const polling_js_1$1 = polling;
	const component_emitter_1$4 = require$$5;
	const util_js_1$2 = util;
	const globals_node_js_1$3 = globals;
	const has_cors_js_1 = hasCors;
	const debug_1$7 = __importDefault$6(browserExports); // debug()
	const debug$7 = (0, debug_1$7.default)("engine.io-client:polling"); // debug()
	function empty() { }
	class BaseXHR extends polling_js_1$1.Polling {
	    /**
	     * XHR Polling constructor.
	     *
	     * @param {Object} opts
	     * @package
	     */
	    constructor(opts) {
	        super(opts);
	        if (typeof location !== "undefined") {
	            const isSSL = "https:" === location.protocol;
	            let port = location.port;
	            // some user agents have empty `location.port`
	            if (!port) {
	                port = isSSL ? "443" : "80";
	            }
	            this.xd =
	                (typeof location !== "undefined" &&
	                    opts.hostname !== location.hostname) ||
	                    port !== opts.port;
	        }
	    }
	    /**
	     * Sends data.
	     *
	     * @param {String} data to send.
	     * @param {Function} called upon flush.
	     * @private
	     */
	    doWrite(data, fn) {
	        const req = this.request({
	            method: "POST",
	            data: data,
	        });
	        req.on("success", fn);
	        req.on("error", (xhrStatus, context) => {
	            this.onError("xhr post error", xhrStatus, context);
	        });
	    }
	    /**
	     * Starts a poll cycle.
	     *
	     * @private
	     */
	    doPoll() {
	        debug$7("xhr poll");
	        const req = this.request();
	        req.on("data", this.onData.bind(this));
	        req.on("error", (xhrStatus, context) => {
	            this.onError("xhr poll error", xhrStatus, context);
	        });
	        this.pollXhr = req;
	    }
	}
	pollingXhr.BaseXHR = BaseXHR;
	class Request extends component_emitter_1$4.Emitter {
	    /**
	     * Request constructor
	     *
	     * @param {Object} options
	     * @package
	     */
	    constructor(createRequest, uri, opts) {
	        super();
	        this.createRequest = createRequest;
	        (0, util_js_1$2.installTimerFunctions)(this, opts);
	        this._opts = opts;
	        this._method = opts.method || "GET";
	        this._uri = uri;
	        this._data = undefined !== opts.data ? opts.data : null;
	        this._create();
	    }
	    /**
	     * Creates the XHR object and sends the request.
	     *
	     * @private
	     */
	    _create() {
	        var _a;
	        const opts = (0, util_js_1$2.pick)(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
	        opts.xdomain = !!this._opts.xd;
	        const xhr = (this._xhr = this.createRequest(opts));
	        try {
	            debug$7("xhr open %s: %s", this._method, this._uri);
	            xhr.open(this._method, this._uri, true);
	            try {
	                if (this._opts.extraHeaders) {
	                    // @ts-ignore
	                    xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
	                    for (let i in this._opts.extraHeaders) {
	                        if (this._opts.extraHeaders.hasOwnProperty(i)) {
	                            xhr.setRequestHeader(i, this._opts.extraHeaders[i]);
	                        }
	                    }
	                }
	            }
	            catch (e) { }
	            if ("POST" === this._method) {
	                try {
	                    xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
	                }
	                catch (e) { }
	            }
	            try {
	                xhr.setRequestHeader("Accept", "*/*");
	            }
	            catch (e) { }
	            (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
	            // ie6 check
	            if ("withCredentials" in xhr) {
	                xhr.withCredentials = this._opts.withCredentials;
	            }
	            if (this._opts.requestTimeout) {
	                xhr.timeout = this._opts.requestTimeout;
	            }
	            xhr.onreadystatechange = () => {
	                var _a;
	                if (xhr.readyState === 3) {
	                    (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(
	                    // @ts-ignore
	                    xhr.getResponseHeader("set-cookie"));
	                }
	                if (4 !== xhr.readyState)
	                    return;
	                if (200 === xhr.status || 1223 === xhr.status) {
	                    this._onLoad();
	                }
	                else {
	                    // make sure the `error` event handler that's user-set
	                    // does not throw in the same tick and gets caught here
	                    this.setTimeoutFn(() => {
	                        this._onError(typeof xhr.status === "number" ? xhr.status : 0);
	                    }, 0);
	                }
	            };
	            debug$7("xhr data %s", this._data);
	            xhr.send(this._data);
	        }
	        catch (e) {
	            // Need to defer since .create() is called directly from the constructor
	            // and thus the 'error' event can only be only bound *after* this exception
	            // occurs.  Therefore, also, we cannot throw here at all.
	            this.setTimeoutFn(() => {
	                this._onError(e);
	            }, 0);
	            return;
	        }
	        if (typeof document !== "undefined") {
	            this._index = Request.requestsCount++;
	            Request.requests[this._index] = this;
	        }
	    }
	    /**
	     * Called upon error.
	     *
	     * @private
	     */
	    _onError(err) {
	        this.emitReserved("error", err, this._xhr);
	        this._cleanup(true);
	    }
	    /**
	     * Cleans up house.
	     *
	     * @private
	     */
	    _cleanup(fromError) {
	        if ("undefined" === typeof this._xhr || null === this._xhr) {
	            return;
	        }
	        this._xhr.onreadystatechange = empty;
	        if (fromError) {
	            try {
	                this._xhr.abort();
	            }
	            catch (e) { }
	        }
	        if (typeof document !== "undefined") {
	            delete Request.requests[this._index];
	        }
	        this._xhr = null;
	    }
	    /**
	     * Called upon load.
	     *
	     * @private
	     */
	    _onLoad() {
	        const data = this._xhr.responseText;
	        if (data !== null) {
	            this.emitReserved("data", data);
	            this.emitReserved("success");
	            this._cleanup();
	        }
	    }
	    /**
	     * Aborts the request.
	     *
	     * @package
	     */
	    abort() {
	        this._cleanup();
	    }
	}
	pollingXhr.Request = Request;
	Request.requestsCount = 0;
	Request.requests = {};
	/**
	 * Aborts pending requests when unloading the window. This is needed to prevent
	 * memory leaks (e.g. when using IE) and to ensure that no spurious error is
	 * emitted.
	 */
	if (typeof document !== "undefined") {
	    // @ts-ignore
	    if (typeof attachEvent === "function") {
	        // @ts-ignore
	        attachEvent("onunload", unloadHandler);
	    }
	    else if (typeof addEventListener === "function") {
	        const terminationEvent = "onpagehide" in globals_node_js_1$3.globalThisShim ? "pagehide" : "unload";
	        addEventListener(terminationEvent, unloadHandler, false);
	    }
	}
	function unloadHandler() {
	    for (let i in Request.requests) {
	        if (Request.requests.hasOwnProperty(i)) {
	            Request.requests[i].abort();
	        }
	    }
	}
	const hasXHR2 = (function () {
	    const xhr = newRequest({
	        xdomain: false,
	    });
	    return xhr && xhr.responseType !== null;
	})();
	/**
	 * HTTP long-polling based on the built-in `XMLHttpRequest` object.
	 *
	 * Usage: browser
	 *
	 * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
	 */
	class XHR extends BaseXHR {
	    constructor(opts) {
	        super(opts);
	        const forceBase64 = opts && opts.forceBase64;
	        this.supportsBinary = hasXHR2 && !forceBase64;
	    }
	    request(opts = {}) {
	        Object.assign(opts, { xd: this.xd }, this.opts);
	        return new Request(newRequest, this.uri(), opts);
	    }
	}
	pollingXhr.XHR = XHR;
	function newRequest(opts) {
	    const xdomain = opts.xdomain;
	    // XMLHttpRequest can be disabled on IE
	    try {
	        if ("undefined" !== typeof XMLHttpRequest && (!xdomain || has_cors_js_1.hasCORS)) {
	            return new XMLHttpRequest();
	        }
	    }
	    catch (e) { }
	    if (!xdomain) {
	        try {
	            return new globals_node_js_1$3.globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
	        }
	        catch (e) { }
	    }
	}

	var websocket = {};

	var __importDefault$5 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(websocket, "__esModule", { value: true });
	websocket.WS = websocket.BaseWS = void 0;
	const transport_js_1$1 = transport;
	const util_js_1$1 = util;
	const engine_io_parser_1$2 = cjs$1;
	const globals_node_js_1$2 = globals;
	const debug_1$6 = __importDefault$5(browserExports); // debug()
	const debug$6 = (0, debug_1$6.default)("engine.io-client:websocket"); // debug()
	// detect ReactNative environment
	const isReactNative = typeof navigator !== "undefined" &&
	    typeof navigator.product === "string" &&
	    navigator.product.toLowerCase() === "reactnative";
	class BaseWS extends transport_js_1$1.Transport {
	    get name() {
	        return "websocket";
	    }
	    doOpen() {
	        const uri = this.uri();
	        const protocols = this.opts.protocols;
	        // React Native only supports the 'headers' option, and will print a warning if anything else is passed
	        const opts = isReactNative
	            ? {}
	            : (0, util_js_1$1.pick)(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
	        if (this.opts.extraHeaders) {
	            opts.headers = this.opts.extraHeaders;
	        }
	        try {
	            this.ws = this.createSocket(uri, protocols, opts);
	        }
	        catch (err) {
	            return this.emitReserved("error", err);
	        }
	        this.ws.binaryType = this.socket.binaryType;
	        this.addEventListeners();
	    }
	    /**
	     * Adds event listeners to the socket
	     *
	     * @private
	     */
	    addEventListeners() {
	        this.ws.onopen = () => {
	            if (this.opts.autoUnref) {
	                this.ws._socket.unref();
	            }
	            this.onOpen();
	        };
	        this.ws.onclose = (closeEvent) => this.onClose({
	            description: "websocket connection closed",
	            context: closeEvent,
	        });
	        this.ws.onmessage = (ev) => this.onData(ev.data);
	        this.ws.onerror = (e) => this.onError("websocket error", e);
	    }
	    write(packets) {
	        this.writable = false;
	        // encodePacket efficient as it uses WS framing
	        // no need for encodePayload
	        for (let i = 0; i < packets.length; i++) {
	            const packet = packets[i];
	            const lastPacket = i === packets.length - 1;
	            (0, engine_io_parser_1$2.encodePacket)(packet, this.supportsBinary, (data) => {
	                // Sometimes the websocket has already been closed but the browser didn't
	                // have a chance of informing us about it yet, in that case send will
	                // throw an error
	                try {
	                    this.doWrite(packet, data);
	                }
	                catch (e) {
	                    debug$6("websocket closed before onclose event");
	                }
	                if (lastPacket) {
	                    // fake drain
	                    // defer to next tick to allow Socket to clear writeBuffer
	                    (0, globals_node_js_1$2.nextTick)(() => {
	                        this.writable = true;
	                        this.emitReserved("drain");
	                    }, this.setTimeoutFn);
	                }
	            });
	        }
	    }
	    doClose() {
	        if (typeof this.ws !== "undefined") {
	            this.ws.onerror = () => { };
	            this.ws.close();
	            this.ws = null;
	        }
	    }
	    /**
	     * Generates uri for connection.
	     *
	     * @private
	     */
	    uri() {
	        const schema = this.opts.secure ? "wss" : "ws";
	        const query = this.query || {};
	        // append timestamp to URI
	        if (this.opts.timestampRequests) {
	            query[this.opts.timestampParam] = (0, util_js_1$1.randomString)();
	        }
	        // communicate binary support capabilities
	        if (!this.supportsBinary) {
	            query.b64 = 1;
	        }
	        return this.createUri(schema, query);
	    }
	}
	websocket.BaseWS = BaseWS;
	const WebSocketCtor = globals_node_js_1$2.globalThisShim.WebSocket || globals_node_js_1$2.globalThisShim.MozWebSocket;
	/**
	 * WebSocket transport based on the built-in `WebSocket` object.
	 *
	 * Usage: browser, Node.js (since v21), Deno, Bun
	 *
	 * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
	 * @see https://caniuse.com/mdn-api_websocket
	 * @see https://nodejs.org/api/globals.html#websocket
	 */
	class WS extends BaseWS {
	    createSocket(uri, protocols, opts) {
	        return !isReactNative
	            ? protocols
	                ? new WebSocketCtor(uri, protocols)
	                : new WebSocketCtor(uri)
	            : new WebSocketCtor(uri, protocols, opts);
	    }
	    doWrite(_packet, data) {
	        this.ws.send(data);
	    }
	}
	websocket.WS = WS;

	var webtransport = {};

	var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(webtransport, "__esModule", { value: true });
	webtransport.WT = void 0;
	const transport_js_1 = transport;
	const globals_node_js_1$1 = globals;
	const engine_io_parser_1$1 = cjs$1;
	const debug_1$5 = __importDefault$4(browserExports); // debug()
	const debug$5 = (0, debug_1$5.default)("engine.io-client:webtransport"); // debug()
	/**
	 * WebTransport transport based on the built-in `WebTransport` object.
	 *
	 * Usage: browser, Node.js (with the `@fails-components/webtransport` package)
	 *
	 * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
	 * @see https://caniuse.com/webtransport
	 */
	class WT extends transport_js_1.Transport {
	    get name() {
	        return "webtransport";
	    }
	    doOpen() {
	        try {
	            // @ts-ignore
	            this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
	        }
	        catch (err) {
	            return this.emitReserved("error", err);
	        }
	        this._transport.closed
	            .then(() => {
	            debug$5("transport closed gracefully");
	            this.onClose();
	        })
	            .catch((err) => {
	            debug$5("transport closed due to %s", err);
	            this.onError("webtransport error", err);
	        });
	        // note: we could have used async/await, but that would require some additional polyfills
	        this._transport.ready.then(() => {
	            this._transport.createBidirectionalStream().then((stream) => {
	                const decoderStream = (0, engine_io_parser_1$1.createPacketDecoderStream)(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
	                const reader = stream.readable.pipeThrough(decoderStream).getReader();
	                const encoderStream = (0, engine_io_parser_1$1.createPacketEncoderStream)();
	                encoderStream.readable.pipeTo(stream.writable);
	                this._writer = encoderStream.writable.getWriter();
	                const read = () => {
	                    reader
	                        .read()
	                        .then(({ done, value }) => {
	                        if (done) {
	                            debug$5("session is closed");
	                            return;
	                        }
	                        debug$5("received chunk: %o", value);
	                        this.onPacket(value);
	                        read();
	                    })
	                        .catch((err) => {
	                        debug$5("an error occurred while reading: %s", err);
	                    });
	                };
	                read();
	                const packet = { type: "open" };
	                if (this.query.sid) {
	                    packet.data = `{"sid":"${this.query.sid}"}`;
	                }
	                this._writer.write(packet).then(() => this.onOpen());
	            });
	        });
	    }
	    write(packets) {
	        this.writable = false;
	        for (let i = 0; i < packets.length; i++) {
	            const packet = packets[i];
	            const lastPacket = i === packets.length - 1;
	            this._writer.write(packet).then(() => {
	                if (lastPacket) {
	                    (0, globals_node_js_1$1.nextTick)(() => {
	                        this.writable = true;
	                        this.emitReserved("drain");
	                    }, this.setTimeoutFn);
	                }
	            });
	        }
	    }
	    doClose() {
	        var _a;
	        (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close();
	    }
	}
	webtransport.WT = WT;

	Object.defineProperty(transports, "__esModule", { value: true });
	transports.transports = void 0;
	const polling_xhr_node_js_1 = pollingXhr;
	const websocket_node_js_1 = websocket;
	const webtransport_js_1 = webtransport;
	transports.transports = {
	    websocket: websocket_node_js_1.WS,
	    webtransport: webtransport_js_1.WT,
	    polling: polling_xhr_node_js_1.XHR,
	};

	var parseuri = {};

	Object.defineProperty(parseuri, "__esModule", { value: true });
	parseuri.parse = parse;
	// imported from https://github.com/galkn/parseuri
	/**
	 * Parses a URI
	 *
	 * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
	 *
	 * See:
	 * - https://developer.mozilla.org/en-US/docs/Web/API/URL
	 * - https://caniuse.com/url
	 * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
	 *
	 * History of the parse() method:
	 * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
	 * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
	 * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
	 *
	 * @author Steven Levithan <stevenlevithan.com> (MIT license)
	 * @api private
	 */
	const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
	const parts = [
	    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
	];
	function parse(str) {
	    if (str.length > 8000) {
	        throw "URI too long";
	    }
	    const src = str, b = str.indexOf('['), e = str.indexOf(']');
	    if (b != -1 && e != -1) {
	        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
	    }
	    let m = re.exec(str || ''), uri = {}, i = 14;
	    while (i--) {
	        uri[parts[i]] = m[i] || '';
	    }
	    if (b != -1 && e != -1) {
	        uri.source = src;
	        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
	        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
	        uri.ipv6uri = true;
	    }
	    uri.pathNames = pathNames(uri, uri['path']);
	    uri.queryKey = queryKey(uri, uri['query']);
	    return uri;
	}
	function pathNames(obj, path) {
	    const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
	    if (path.slice(0, 1) == '/' || path.length === 0) {
	        names.splice(0, 1);
	    }
	    if (path.slice(-1) == '/') {
	        names.splice(names.length - 1, 1);
	    }
	    return names;
	}
	function queryKey(uri, query) {
	    const data = {};
	    query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
	        if ($1) {
	            data[$1] = $2;
	        }
	    });
	    return data;
	}

	var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(socket$2, "__esModule", { value: true });
	socket$2.Socket = socket$2.SocketWithUpgrade = socket$2.SocketWithoutUpgrade = void 0;
	const index_js_1 = transports;
	const util_js_1 = util;
	const parseqs_js_1 = parseqs;
	const parseuri_js_1 = parseuri;
	const component_emitter_1$3 = require$$5;
	const engine_io_parser_1 = cjs$1;
	const globals_node_js_1 = globals;
	const debug_1$4 = __importDefault$3(browserExports); // debug()
	const debug$4 = (0, debug_1$4.default)("engine.io-client:socket"); // debug()
	const withEventListeners = typeof addEventListener === "function" &&
	    typeof removeEventListener === "function";
	const OFFLINE_EVENT_LISTENERS = [];
	if (withEventListeners) {
	    // within a ServiceWorker, any event handler for the 'offline' event must be added on the initial evaluation of the
	    // script, so we create one single event listener here which will forward the event to the socket instances
	    addEventListener("offline", () => {
	        debug$4("closing %d connection(s) because the network was lost", OFFLINE_EVENT_LISTENERS.length);
	        OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
	    }, false);
	}
	/**
	 * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
	 * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
	 *
	 * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
	 * successfully establishes the connection.
	 *
	 * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
	 *
	 * @example
	 * import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
	 *
	 * const socket = new SocketWithoutUpgrade({
	 *   transports: [WebSocket]
	 * });
	 *
	 * socket.on("open", () => {
	 *   socket.send("hello");
	 * });
	 *
	 * @see SocketWithUpgrade
	 * @see Socket
	 */
	class SocketWithoutUpgrade extends component_emitter_1$3.Emitter {
	    /**
	     * Socket constructor.
	     *
	     * @param {String|Object} uri - uri or options
	     * @param {Object} opts - options
	     */
	    constructor(uri, opts) {
	        super();
	        this.binaryType = globals_node_js_1.defaultBinaryType;
	        this.writeBuffer = [];
	        this._prevBufferLen = 0;
	        this._pingInterval = -1;
	        this._pingTimeout = -1;
	        this._maxPayload = -1;
	        /**
	         * The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the
	         * callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.
	         */
	        this._pingTimeoutTime = Infinity;
	        if (uri && "object" === typeof uri) {
	            opts = uri;
	            uri = null;
	        }
	        if (uri) {
	            const parsedUri = (0, parseuri_js_1.parse)(uri);
	            opts.hostname = parsedUri.host;
	            opts.secure =
	                parsedUri.protocol === "https" || parsedUri.protocol === "wss";
	            opts.port = parsedUri.port;
	            if (parsedUri.query)
	                opts.query = parsedUri.query;
	        }
	        else if (opts.host) {
	            opts.hostname = (0, parseuri_js_1.parse)(opts.host).host;
	        }
	        (0, util_js_1.installTimerFunctions)(this, opts);
	        this.secure =
	            null != opts.secure
	                ? opts.secure
	                : typeof location !== "undefined" && "https:" === location.protocol;
	        if (opts.hostname && !opts.port) {
	            // if no port is specified manually, use the protocol default
	            opts.port = this.secure ? "443" : "80";
	        }
	        this.hostname =
	            opts.hostname ||
	                (typeof location !== "undefined" ? location.hostname : "localhost");
	        this.port =
	            opts.port ||
	                (typeof location !== "undefined" && location.port
	                    ? location.port
	                    : this.secure
	                        ? "443"
	                        : "80");
	        this.transports = [];
	        this._transportsByName = {};
	        opts.transports.forEach((t) => {
	            const transportName = t.prototype.name;
	            this.transports.push(transportName);
	            this._transportsByName[transportName] = t;
	        });
	        this.opts = Object.assign({
	            path: "/engine.io",
	            agent: false,
	            withCredentials: false,
	            upgrade: true,
	            timestampParam: "t",
	            rememberUpgrade: false,
	            addTrailingSlash: true,
	            rejectUnauthorized: true,
	            perMessageDeflate: {
	                threshold: 1024,
	            },
	            transportOptions: {},
	            closeOnBeforeunload: false,
	        }, opts);
	        this.opts.path =
	            this.opts.path.replace(/\/$/, "") +
	                (this.opts.addTrailingSlash ? "/" : "");
	        if (typeof this.opts.query === "string") {
	            this.opts.query = (0, parseqs_js_1.decode)(this.opts.query);
	        }
	        if (withEventListeners) {
	            if (this.opts.closeOnBeforeunload) {
	                // Firefox closes the connection when the "beforeunload" event is emitted but not Chrome. This event listener
	                // ensures every browser behaves the same (no "disconnect" event at the Socket.IO level when the page is
	                // closed/reloaded)
	                this._beforeunloadEventListener = () => {
	                    if (this.transport) {
	                        // silently close the transport
	                        this.transport.removeAllListeners();
	                        this.transport.close();
	                    }
	                };
	                addEventListener("beforeunload", this._beforeunloadEventListener, false);
	            }
	            if (this.hostname !== "localhost") {
	                debug$4("adding listener for the 'offline' event");
	                this._offlineEventListener = () => {
	                    this._onClose("transport close", {
	                        description: "network connection lost",
	                    });
	                };
	                OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
	            }
	        }
	        if (this.opts.withCredentials) {
	            this._cookieJar = (0, globals_node_js_1.createCookieJar)();
	        }
	        this._open();
	    }
	    /**
	     * Creates transport of the given type.
	     *
	     * @param {String} name - transport name
	     * @return {Transport}
	     * @private
	     */
	    createTransport(name) {
	        debug$4('creating transport "%s"', name);
	        const query = Object.assign({}, this.opts.query);
	        // append engine.io protocol identifier
	        query.EIO = engine_io_parser_1.protocol;
	        // transport name
	        query.transport = name;
	        // session id if we already have one
	        if (this.id)
	            query.sid = this.id;
	        const opts = Object.assign({}, this.opts, {
	            query,
	            socket: this,
	            hostname: this.hostname,
	            secure: this.secure,
	            port: this.port,
	        }, this.opts.transportOptions[name]);
	        debug$4("options: %j", opts);
	        return new this._transportsByName[name](opts);
	    }
	    /**
	     * Initializes transport to use and starts probe.
	     *
	     * @private
	     */
	    _open() {
	        if (this.transports.length === 0) {
	            // Emit error on next tick so it can be listened to
	            this.setTimeoutFn(() => {
	                this.emitReserved("error", "No transports available");
	            }, 0);
	            return;
	        }
	        const transportName = this.opts.rememberUpgrade &&
	            SocketWithoutUpgrade.priorWebsocketSuccess &&
	            this.transports.indexOf("websocket") !== -1
	            ? "websocket"
	            : this.transports[0];
	        this.readyState = "opening";
	        const transport = this.createTransport(transportName);
	        transport.open();
	        this.setTransport(transport);
	    }
	    /**
	     * Sets the current transport. Disables the existing one (if any).
	     *
	     * @private
	     */
	    setTransport(transport) {
	        debug$4("setting transport %s", transport.name);
	        if (this.transport) {
	            debug$4("clearing existing transport %s", this.transport.name);
	            this.transport.removeAllListeners();
	        }
	        // set up transport
	        this.transport = transport;
	        // set up transport listeners
	        transport
	            .on("drain", this._onDrain.bind(this))
	            .on("packet", this._onPacket.bind(this))
	            .on("error", this._onError.bind(this))
	            .on("close", (reason) => this._onClose("transport close", reason));
	    }
	    /**
	     * Called when connection is deemed open.
	     *
	     * @private
	     */
	    onOpen() {
	        debug$4("socket open");
	        this.readyState = "open";
	        SocketWithoutUpgrade.priorWebsocketSuccess =
	            "websocket" === this.transport.name;
	        this.emitReserved("open");
	        this.flush();
	    }
	    /**
	     * Handles a packet.
	     *
	     * @private
	     */
	    _onPacket(packet) {
	        if ("opening" === this.readyState ||
	            "open" === this.readyState ||
	            "closing" === this.readyState) {
	            debug$4('socket receive: type "%s", data "%s"', packet.type, packet.data);
	            this.emitReserved("packet", packet);
	            // Socket is live - any packet counts
	            this.emitReserved("heartbeat");
	            switch (packet.type) {
	                case "open":
	                    this.onHandshake(JSON.parse(packet.data));
	                    break;
	                case "ping":
	                    this._sendPacket("pong");
	                    this.emitReserved("ping");
	                    this.emitReserved("pong");
	                    this._resetPingTimeout();
	                    break;
	                case "error":
	                    const err = new Error("server error");
	                    // @ts-ignore
	                    err.code = packet.data;
	                    this._onError(err);
	                    break;
	                case "message":
	                    this.emitReserved("data", packet.data);
	                    this.emitReserved("message", packet.data);
	                    break;
	            }
	        }
	        else {
	            debug$4('packet received with socket readyState "%s"', this.readyState);
	        }
	    }
	    /**
	     * Called upon handshake completion.
	     *
	     * @param {Object} data - handshake obj
	     * @private
	     */
	    onHandshake(data) {
	        this.emitReserved("handshake", data);
	        this.id = data.sid;
	        this.transport.query.sid = data.sid;
	        this._pingInterval = data.pingInterval;
	        this._pingTimeout = data.pingTimeout;
	        this._maxPayload = data.maxPayload;
	        this.onOpen();
	        // In case open handler closes socket
	        if ("closed" === this.readyState)
	            return;
	        this._resetPingTimeout();
	    }
	    /**
	     * Sets and resets ping timeout timer based on server pings.
	     *
	     * @private
	     */
	    _resetPingTimeout() {
	        this.clearTimeoutFn(this._pingTimeoutTimer);
	        const delay = this._pingInterval + this._pingTimeout;
	        this._pingTimeoutTime = Date.now() + delay;
	        this._pingTimeoutTimer = this.setTimeoutFn(() => {
	            this._onClose("ping timeout");
	        }, delay);
	        if (this.opts.autoUnref) {
	            this._pingTimeoutTimer.unref();
	        }
	    }
	    /**
	     * Called on `drain` event
	     *
	     * @private
	     */
	    _onDrain() {
	        this.writeBuffer.splice(0, this._prevBufferLen);
	        // setting prevBufferLen = 0 is very important
	        // for example, when upgrading, upgrade packet is sent over,
	        // and a nonzero prevBufferLen could cause problems on `drain`
	        this._prevBufferLen = 0;
	        if (0 === this.writeBuffer.length) {
	            this.emitReserved("drain");
	        }
	        else {
	            this.flush();
	        }
	    }
	    /**
	     * Flush write buffers.
	     *
	     * @private
	     */
	    flush() {
	        if ("closed" !== this.readyState &&
	            this.transport.writable &&
	            !this.upgrading &&
	            this.writeBuffer.length) {
	            const packets = this._getWritablePackets();
	            debug$4("flushing %d packets in socket", packets.length);
	            this.transport.send(packets);
	            // keep track of current length of writeBuffer
	            // splice writeBuffer and callbackBuffer on `drain`
	            this._prevBufferLen = packets.length;
	            this.emitReserved("flush");
	        }
	    }
	    /**
	     * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
	     * long-polling)
	     *
	     * @private
	     */
	    _getWritablePackets() {
	        const shouldCheckPayloadSize = this._maxPayload &&
	            this.transport.name === "polling" &&
	            this.writeBuffer.length > 1;
	        if (!shouldCheckPayloadSize) {
	            return this.writeBuffer;
	        }
	        let payloadSize = 1; // first packet type
	        for (let i = 0; i < this.writeBuffer.length; i++) {
	            const data = this.writeBuffer[i].data;
	            if (data) {
	                payloadSize += (0, util_js_1.byteLength)(data);
	            }
	            if (i > 0 && payloadSize > this._maxPayload) {
	                debug$4("only send %d out of %d packets", i, this.writeBuffer.length);
	                return this.writeBuffer.slice(0, i);
	            }
	            payloadSize += 2; // separator + packet type
	        }
	        debug$4("payload size is %d (max: %d)", payloadSize, this._maxPayload);
	        return this.writeBuffer;
	    }
	    /**
	     * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
	     *
	     * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
	     * `write()` method then the message would not be buffered by the Socket.IO client.
	     *
	     * @return {boolean}
	     * @private
	     */
	    /* private */ _hasPingExpired() {
	        if (!this._pingTimeoutTime)
	            return true;
	        const hasExpired = Date.now() > this._pingTimeoutTime;
	        if (hasExpired) {
	            debug$4("throttled timer detected, scheduling connection close");
	            this._pingTimeoutTime = 0;
	            (0, globals_node_js_1.nextTick)(() => {
	                this._onClose("ping timeout");
	            }, this.setTimeoutFn);
	        }
	        return hasExpired;
	    }
	    /**
	     * Sends a message.
	     *
	     * @param {String} msg - message.
	     * @param {Object} options.
	     * @param {Function} fn - callback function.
	     * @return {Socket} for chaining.
	     */
	    write(msg, options, fn) {
	        this._sendPacket("message", msg, options, fn);
	        return this;
	    }
	    /**
	     * Sends a message. Alias of {@link Socket#write}.
	     *
	     * @param {String} msg - message.
	     * @param {Object} options.
	     * @param {Function} fn - callback function.
	     * @return {Socket} for chaining.
	     */
	    send(msg, options, fn) {
	        this._sendPacket("message", msg, options, fn);
	        return this;
	    }
	    /**
	     * Sends a packet.
	     *
	     * @param {String} type: packet type.
	     * @param {String} data.
	     * @param {Object} options.
	     * @param {Function} fn - callback function.
	     * @private
	     */
	    _sendPacket(type, data, options, fn) {
	        if ("function" === typeof data) {
	            fn = data;
	            data = undefined;
	        }
	        if ("function" === typeof options) {
	            fn = options;
	            options = null;
	        }
	        if ("closing" === this.readyState || "closed" === this.readyState) {
	            return;
	        }
	        options = options || {};
	        options.compress = false !== options.compress;
	        const packet = {
	            type: type,
	            data: data,
	            options: options,
	        };
	        this.emitReserved("packetCreate", packet);
	        this.writeBuffer.push(packet);
	        if (fn)
	            this.once("flush", fn);
	        this.flush();
	    }
	    /**
	     * Closes the connection.
	     */
	    close() {
	        const close = () => {
	            this._onClose("forced close");
	            debug$4("socket closing - telling transport to close");
	            this.transport.close();
	        };
	        const cleanupAndClose = () => {
	            this.off("upgrade", cleanupAndClose);
	            this.off("upgradeError", cleanupAndClose);
	            close();
	        };
	        const waitForUpgrade = () => {
	            // wait for upgrade to finish since we can't send packets while pausing a transport
	            this.once("upgrade", cleanupAndClose);
	            this.once("upgradeError", cleanupAndClose);
	        };
	        if ("opening" === this.readyState || "open" === this.readyState) {
	            this.readyState = "closing";
	            if (this.writeBuffer.length) {
	                this.once("drain", () => {
	                    if (this.upgrading) {
	                        waitForUpgrade();
	                    }
	                    else {
	                        close();
	                    }
	                });
	            }
	            else if (this.upgrading) {
	                waitForUpgrade();
	            }
	            else {
	                close();
	            }
	        }
	        return this;
	    }
	    /**
	     * Called upon transport error
	     *
	     * @private
	     */
	    _onError(err) {
	        debug$4("socket error %j", err);
	        SocketWithoutUpgrade.priorWebsocketSuccess = false;
	        if (this.opts.tryAllTransports &&
	            this.transports.length > 1 &&
	            this.readyState === "opening") {
	            debug$4("trying next transport");
	            this.transports.shift();
	            return this._open();
	        }
	        this.emitReserved("error", err);
	        this._onClose("transport error", err);
	    }
	    /**
	     * Called upon transport close.
	     *
	     * @private
	     */
	    _onClose(reason, description) {
	        if ("opening" === this.readyState ||
	            "open" === this.readyState ||
	            "closing" === this.readyState) {
	            debug$4('socket close with reason: "%s"', reason);
	            // clear timers
	            this.clearTimeoutFn(this._pingTimeoutTimer);
	            // stop event from firing again for transport
	            this.transport.removeAllListeners("close");
	            // ensure transport won't stay open
	            this.transport.close();
	            // ignore further transport communication
	            this.transport.removeAllListeners();
	            if (withEventListeners) {
	                if (this._beforeunloadEventListener) {
	                    removeEventListener("beforeunload", this._beforeunloadEventListener, false);
	                }
	                if (this._offlineEventListener) {
	                    const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
	                    if (i !== -1) {
	                        debug$4("removing listener for the 'offline' event");
	                        OFFLINE_EVENT_LISTENERS.splice(i, 1);
	                    }
	                }
	            }
	            // set ready state
	            this.readyState = "closed";
	            // clear session id
	            this.id = null;
	            // emit close event
	            this.emitReserved("close", reason, description);
	            // clean buffers after, so users can still
	            // grab the buffers on `close` event
	            this.writeBuffer = [];
	            this._prevBufferLen = 0;
	        }
	    }
	}
	socket$2.SocketWithoutUpgrade = SocketWithoutUpgrade;
	SocketWithoutUpgrade.protocol = engine_io_parser_1.protocol;
	/**
	 * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
	 * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
	 *
	 * This class comes with an upgrade mechanism, which means that once the connection is established with the first
	 * low-level transport, it will try to upgrade to a better transport.
	 *
	 * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
	 *
	 * @example
	 * import { SocketWithUpgrade, WebSocket } from "engine.io-client";
	 *
	 * const socket = new SocketWithUpgrade({
	 *   transports: [WebSocket]
	 * });
	 *
	 * socket.on("open", () => {
	 *   socket.send("hello");
	 * });
	 *
	 * @see SocketWithoutUpgrade
	 * @see Socket
	 */
	class SocketWithUpgrade extends SocketWithoutUpgrade {
	    constructor() {
	        super(...arguments);
	        this._upgrades = [];
	    }
	    onOpen() {
	        super.onOpen();
	        if ("open" === this.readyState && this.opts.upgrade) {
	            debug$4("starting upgrade probes");
	            for (let i = 0; i < this._upgrades.length; i++) {
	                this._probe(this._upgrades[i]);
	            }
	        }
	    }
	    /**
	     * Probes a transport.
	     *
	     * @param {String} name - transport name
	     * @private
	     */
	    _probe(name) {
	        debug$4('probing transport "%s"', name);
	        let transport = this.createTransport(name);
	        let failed = false;
	        SocketWithoutUpgrade.priorWebsocketSuccess = false;
	        const onTransportOpen = () => {
	            if (failed)
	                return;
	            debug$4('probe transport "%s" opened', name);
	            transport.send([{ type: "ping", data: "probe" }]);
	            transport.once("packet", (msg) => {
	                if (failed)
	                    return;
	                if ("pong" === msg.type && "probe" === msg.data) {
	                    debug$4('probe transport "%s" pong', name);
	                    this.upgrading = true;
	                    this.emitReserved("upgrading", transport);
	                    if (!transport)
	                        return;
	                    SocketWithoutUpgrade.priorWebsocketSuccess =
	                        "websocket" === transport.name;
	                    debug$4('pausing current transport "%s"', this.transport.name);
	                    this.transport.pause(() => {
	                        if (failed)
	                            return;
	                        if ("closed" === this.readyState)
	                            return;
	                        debug$4("changing transport and sending upgrade packet");
	                        cleanup();
	                        this.setTransport(transport);
	                        transport.send([{ type: "upgrade" }]);
	                        this.emitReserved("upgrade", transport);
	                        transport = null;
	                        this.upgrading = false;
	                        this.flush();
	                    });
	                }
	                else {
	                    debug$4('probe transport "%s" failed', name);
	                    const err = new Error("probe error");
	                    // @ts-ignore
	                    err.transport = transport.name;
	                    this.emitReserved("upgradeError", err);
	                }
	            });
	        };
	        function freezeTransport() {
	            if (failed)
	                return;
	            // Any callback called by transport should be ignored since now
	            failed = true;
	            cleanup();
	            transport.close();
	            transport = null;
	        }
	        // Handle any error that happens while probing
	        const onerror = (err) => {
	            const error = new Error("probe error: " + err);
	            // @ts-ignore
	            error.transport = transport.name;
	            freezeTransport();
	            debug$4('probe transport "%s" failed because of error: %s', name, err);
	            this.emitReserved("upgradeError", error);
	        };
	        function onTransportClose() {
	            onerror("transport closed");
	        }
	        // When the socket is closed while we're probing
	        function onclose() {
	            onerror("socket closed");
	        }
	        // When the socket is upgraded while we're probing
	        function onupgrade(to) {
	            if (transport && to.name !== transport.name) {
	                debug$4('"%s" works - aborting "%s"', to.name, transport.name);
	                freezeTransport();
	            }
	        }
	        // Remove all listeners on the transport and on self
	        const cleanup = () => {
	            transport.removeListener("open", onTransportOpen);
	            transport.removeListener("error", onerror);
	            transport.removeListener("close", onTransportClose);
	            this.off("close", onclose);
	            this.off("upgrading", onupgrade);
	        };
	        transport.once("open", onTransportOpen);
	        transport.once("error", onerror);
	        transport.once("close", onTransportClose);
	        this.once("close", onclose);
	        this.once("upgrading", onupgrade);
	        if (this._upgrades.indexOf("webtransport") !== -1 &&
	            name !== "webtransport") {
	            // favor WebTransport
	            this.setTimeoutFn(() => {
	                if (!failed) {
	                    transport.open();
	                }
	            }, 200);
	        }
	        else {
	            transport.open();
	        }
	    }
	    onHandshake(data) {
	        this._upgrades = this._filterUpgrades(data.upgrades);
	        super.onHandshake(data);
	    }
	    /**
	     * Filters upgrades, returning only those matching client transports.
	     *
	     * @param {Array} upgrades - server upgrades
	     * @private
	     */
	    _filterUpgrades(upgrades) {
	        const filteredUpgrades = [];
	        for (let i = 0; i < upgrades.length; i++) {
	            if (~this.transports.indexOf(upgrades[i]))
	                filteredUpgrades.push(upgrades[i]);
	        }
	        return filteredUpgrades;
	    }
	}
	socket$2.SocketWithUpgrade = SocketWithUpgrade;
	/**
	 * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
	 * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
	 *
	 * This class comes with an upgrade mechanism, which means that once the connection is established with the first
	 * low-level transport, it will try to upgrade to a better transport.
	 *
	 * @example
	 * import { Socket } from "engine.io-client";
	 *
	 * const socket = new Socket();
	 *
	 * socket.on("open", () => {
	 *   socket.send("hello");
	 * });
	 *
	 * @see SocketWithoutUpgrade
	 * @see SocketWithUpgrade
	 */
	class Socket$1 extends SocketWithUpgrade {
	    constructor(uri, opts = {}) {
	        const o = typeof uri === "object" ? uri : opts;
	        if (!o.transports ||
	            (o.transports && typeof o.transports[0] === "string")) {
	            o.transports = (o.transports || ["polling", "websocket", "webtransport"])
	                .map((transportName) => index_js_1.transports[transportName])
	                .filter((t) => !!t);
	        }
	        super(uri, o);
	    }
	}
	socket$2.Socket = Socket$1;

	var pollingFetch = {};

	Object.defineProperty(pollingFetch, "__esModule", { value: true });
	pollingFetch.Fetch = void 0;
	const polling_js_1 = polling;
	/**
	 * HTTP long-polling based on the built-in `fetch()` method.
	 *
	 * Usage: browser, Node.js (since v18), Deno, Bun
	 *
	 * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch
	 * @see https://caniuse.com/fetch
	 * @see https://nodejs.org/api/globals.html#fetch
	 */
	class Fetch extends polling_js_1.Polling {
	    doPoll() {
	        this._fetch()
	            .then((res) => {
	            if (!res.ok) {
	                return this.onError("fetch read error", res.status, res);
	            }
	            res.text().then((data) => this.onData(data));
	        })
	            .catch((err) => {
	            this.onError("fetch read error", err);
	        });
	    }
	    doWrite(data, callback) {
	        this._fetch(data)
	            .then((res) => {
	            if (!res.ok) {
	                return this.onError("fetch write error", res.status, res);
	            }
	            callback();
	        })
	            .catch((err) => {
	            this.onError("fetch write error", err);
	        });
	    }
	    _fetch(data) {
	        var _a;
	        const isPost = data !== undefined;
	        const headers = new Headers(this.opts.extraHeaders);
	        if (isPost) {
	            headers.set("content-type", "text/plain;charset=UTF-8");
	        }
	        (_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.appendCookies(headers);
	        return fetch(this.uri(), {
	            method: isPost ? "POST" : "GET",
	            body: isPost ? data : null,
	            headers,
	            credentials: this.opts.withCredentials ? "include" : "omit",
	        }).then((res) => {
	            var _a;
	            // @ts-ignore getSetCookie() was added in Node.js v19.7.0
	            (_a = this.socket._cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(res.headers.getSetCookie());
	            return res;
	        });
	    }
	}
	pollingFetch.Fetch = Fetch;

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.WebTransport = exports.WebSocket = exports.NodeWebSocket = exports.XHR = exports.NodeXHR = exports.Fetch = exports.nextTick = exports.parse = exports.installTimerFunctions = exports.transports = exports.TransportError = exports.Transport = exports.protocol = exports.SocketWithUpgrade = exports.SocketWithoutUpgrade = exports.Socket = void 0;
		const socket_js_1 = socket$2;
		Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_js_1.Socket; } });
		var socket_js_2 = socket$2;
		Object.defineProperty(exports, "SocketWithoutUpgrade", { enumerable: true, get: function () { return socket_js_2.SocketWithoutUpgrade; } });
		Object.defineProperty(exports, "SocketWithUpgrade", { enumerable: true, get: function () { return socket_js_2.SocketWithUpgrade; } });
		exports.protocol = socket_js_1.Socket.protocol;
		var transport_js_1 = transport;
		Object.defineProperty(exports, "Transport", { enumerable: true, get: function () { return transport_js_1.Transport; } });
		Object.defineProperty(exports, "TransportError", { enumerable: true, get: function () { return transport_js_1.TransportError; } });
		var index_js_1 = transports;
		Object.defineProperty(exports, "transports", { enumerable: true, get: function () { return index_js_1.transports; } });
		var util_js_1 = util;
		Object.defineProperty(exports, "installTimerFunctions", { enumerable: true, get: function () { return util_js_1.installTimerFunctions; } });
		var parseuri_js_1 = parseuri;
		Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parseuri_js_1.parse; } });
		var globals_node_js_1 = globals;
		Object.defineProperty(exports, "nextTick", { enumerable: true, get: function () { return globals_node_js_1.nextTick; } });
		var polling_fetch_js_1 = pollingFetch;
		Object.defineProperty(exports, "Fetch", { enumerable: true, get: function () { return polling_fetch_js_1.Fetch; } });
		var polling_xhr_node_js_1 = pollingXhr;
		Object.defineProperty(exports, "NodeXHR", { enumerable: true, get: function () { return polling_xhr_node_js_1.XHR; } });
		var polling_xhr_js_1 = pollingXhr;
		Object.defineProperty(exports, "XHR", { enumerable: true, get: function () { return polling_xhr_js_1.XHR; } });
		var websocket_node_js_1 = websocket;
		Object.defineProperty(exports, "NodeWebSocket", { enumerable: true, get: function () { return websocket_node_js_1.WS; } });
		var websocket_js_1 = websocket;
		Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return websocket_js_1.WS; } });
		var webtransport_js_1 = webtransport;
		Object.defineProperty(exports, "WebTransport", { enumerable: true, get: function () { return webtransport_js_1.WT; } }); 
	} (cjs$2));

	var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(url$1, "__esModule", { value: true });
	url$1.url = url;
	const engine_io_client_1$1 = cjs$2;
	const debug_1$3 = __importDefault$2(browserExports); // debug()
	const debug$3 = (0, debug_1$3.default)("socket.io-client:url"); // debug()
	/**
	 * URL parser.
	 *
	 * @param uri - url
	 * @param path - the request path of the connection
	 * @param loc - An object meant to mimic window.location.
	 *        Defaults to window.location.
	 * @public
	 */
	function url(uri, path = "", loc) {
	    let obj = uri;
	    // default to window.location
	    loc = loc || (typeof location !== "undefined" && location);
	    if (null == uri)
	        uri = loc.protocol + "//" + loc.host;
	    // relative path support
	    if (typeof uri === "string") {
	        if ("/" === uri.charAt(0)) {
	            if ("/" === uri.charAt(1)) {
	                uri = loc.protocol + uri;
	            }
	            else {
	                uri = loc.host + uri;
	            }
	        }
	        if (!/^(https?|wss?):\/\//.test(uri)) {
	            debug$3("protocol-less url %s", uri);
	            if ("undefined" !== typeof loc) {
	                uri = loc.protocol + "//" + uri;
	            }
	            else {
	                uri = "https://" + uri;
	            }
	        }
	        // parse
	        debug$3("parse %s", uri);
	        obj = (0, engine_io_client_1$1.parse)(uri);
	    }
	    // make sure we treat `localhost:80` and `localhost` equally
	    if (!obj.port) {
	        if (/^(http|ws)$/.test(obj.protocol)) {
	            obj.port = "80";
	        }
	        else if (/^(http|ws)s$/.test(obj.protocol)) {
	            obj.port = "443";
	        }
	    }
	    obj.path = obj.path || "/";
	    const ipv6 = obj.host.indexOf(":") !== -1;
	    const host = ipv6 ? "[" + obj.host + "]" : obj.host;
	    // define unique id
	    obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
	    // define href
	    obj.href =
	        obj.protocol +
	            "://" +
	            host +
	            (loc && loc.port === obj.port ? "" : ":" + obj.port);
	    return obj;
	}

	var manager = {};

	var socket$1 = {};

	var cjs = {};

	var binary = {};

	var isBinary$1 = {};

	Object.defineProperty(isBinary$1, "__esModule", { value: true });
	isBinary$1.isBinary = isBinary;
	isBinary$1.hasBinary = hasBinary;
	const withNativeArrayBuffer = typeof ArrayBuffer === "function";
	const isView = (obj) => {
	    return typeof ArrayBuffer.isView === "function"
	        ? ArrayBuffer.isView(obj)
	        : obj.buffer instanceof ArrayBuffer;
	};
	const toString = Object.prototype.toString;
	const withNativeBlob = typeof Blob === "function" ||
	    (typeof Blob !== "undefined" &&
	        toString.call(Blob) === "[object BlobConstructor]");
	const withNativeFile = typeof File === "function" ||
	    (typeof File !== "undefined" &&
	        toString.call(File) === "[object FileConstructor]");
	/**
	 * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
	 *
	 * @private
	 */
	function isBinary(obj) {
	    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||
	        (withNativeBlob && obj instanceof Blob) ||
	        (withNativeFile && obj instanceof File));
	}
	function hasBinary(obj, toJSON) {
	    if (!obj || typeof obj !== "object") {
	        return false;
	    }
	    if (Array.isArray(obj)) {
	        for (let i = 0, l = obj.length; i < l; i++) {
	            if (hasBinary(obj[i])) {
	                return true;
	            }
	        }
	        return false;
	    }
	    if (isBinary(obj)) {
	        return true;
	    }
	    if (obj.toJSON &&
	        typeof obj.toJSON === "function" &&
	        arguments.length === 1) {
	        return hasBinary(obj.toJSON(), true);
	    }
	    for (const key in obj) {
	        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
	            return true;
	        }
	    }
	    return false;
	}

	Object.defineProperty(binary, "__esModule", { value: true });
	binary.deconstructPacket = deconstructPacket;
	binary.reconstructPacket = reconstructPacket;
	const is_binary_js_1$1 = isBinary$1;
	/**
	 * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
	 *
	 * @param {Object} packet - socket.io event packet
	 * @return {Object} with deconstructed packet and list of buffers
	 * @public
	 */
	function deconstructPacket(packet) {
	    const buffers = [];
	    const packetData = packet.data;
	    const pack = packet;
	    pack.data = _deconstructPacket(packetData, buffers);
	    pack.attachments = buffers.length; // number of binary 'attachments'
	    return { packet: pack, buffers: buffers };
	}
	function _deconstructPacket(data, buffers) {
	    if (!data)
	        return data;
	    if ((0, is_binary_js_1$1.isBinary)(data)) {
	        const placeholder = { _placeholder: true, num: buffers.length };
	        buffers.push(data);
	        return placeholder;
	    }
	    else if (Array.isArray(data)) {
	        const newData = new Array(data.length);
	        for (let i = 0; i < data.length; i++) {
	            newData[i] = _deconstructPacket(data[i], buffers);
	        }
	        return newData;
	    }
	    else if (typeof data === "object" && !(data instanceof Date)) {
	        const newData = {};
	        for (const key in data) {
	            if (Object.prototype.hasOwnProperty.call(data, key)) {
	                newData[key] = _deconstructPacket(data[key], buffers);
	            }
	        }
	        return newData;
	    }
	    return data;
	}
	/**
	 * Reconstructs a binary packet from its placeholder packet and buffers
	 *
	 * @param {Object} packet - event packet with placeholders
	 * @param {Array} buffers - binary buffers to put in placeholder positions
	 * @return {Object} reconstructed packet
	 * @public
	 */
	function reconstructPacket(packet, buffers) {
	    packet.data = _reconstructPacket(packet.data, buffers);
	    delete packet.attachments; // no longer useful
	    return packet;
	}
	function _reconstructPacket(data, buffers) {
	    if (!data)
	        return data;
	    if (data && data._placeholder === true) {
	        const isIndexValid = typeof data.num === "number" &&
	            data.num >= 0 &&
	            data.num < buffers.length;
	        if (isIndexValid) {
	            return buffers[data.num]; // appropriate buffer (should be natural order anyway)
	        }
	        else {
	            throw new Error("illegal attachments");
	        }
	    }
	    else if (Array.isArray(data)) {
	        for (let i = 0; i < data.length; i++) {
	            data[i] = _reconstructPacket(data[i], buffers);
	        }
	    }
	    else if (typeof data === "object") {
	        for (const key in data) {
	            if (Object.prototype.hasOwnProperty.call(data, key)) {
	                data[key] = _reconstructPacket(data[key], buffers);
	            }
	        }
	    }
	    return data;
	}

	Object.defineProperty(cjs, "__esModule", { value: true });
	cjs.Decoder = cjs.Encoder = cjs.PacketType = cjs.protocol = void 0;
	cjs.isPacketValid = isPacketValid;
	const component_emitter_1$2 = require$$5;
	const binary_js_1 = binary;
	const is_binary_js_1 = isBinary$1;
	const debug_1$2 = browserExports; // debug()
	const debug$2 = (0, debug_1$2.default)("socket.io-parser"); // debug()
	/**
	 * These strings must not be used as event names, as they have a special meaning.
	 */
	const RESERVED_EVENTS$1 = [
	    "connect", // used on the client side
	    "connect_error", // used on the client side
	    "disconnect", // used on both sides
	    "disconnecting", // used on the server side
	    "newListener", // used by the Node.js EventEmitter
	    "removeListener", // used by the Node.js EventEmitter
	];
	/**
	 * Protocol version.
	 *
	 * @public
	 */
	cjs.protocol = 5;
	var PacketType;
	(function (PacketType) {
	    PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
	    PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
	    PacketType[PacketType["EVENT"] = 2] = "EVENT";
	    PacketType[PacketType["ACK"] = 3] = "ACK";
	    PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
	    PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
	    PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
	})(PacketType || (cjs.PacketType = PacketType = {}));
	/**
	 * A socket.io Encoder instance
	 */
	class Encoder {
	    /**
	     * Encoder constructor
	     *
	     * @param {function} replacer - custom replacer to pass down to JSON.parse
	     */
	    constructor(replacer) {
	        this.replacer = replacer;
	    }
	    /**
	     * Encode a packet as a single string if non-binary, or as a
	     * buffer sequence, depending on packet type.
	     *
	     * @param {Object} obj - packet object
	     */
	    encode(obj) {
	        debug$2("encoding packet %j", obj);
	        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
	            if ((0, is_binary_js_1.hasBinary)(obj)) {
	                return this.encodeAsBinary({
	                    type: obj.type === PacketType.EVENT
	                        ? PacketType.BINARY_EVENT
	                        : PacketType.BINARY_ACK,
	                    nsp: obj.nsp,
	                    data: obj.data,
	                    id: obj.id,
	                });
	            }
	        }
	        return [this.encodeAsString(obj)];
	    }
	    /**
	     * Encode packet as string.
	     */
	    encodeAsString(obj) {
	        // first is type
	        let str = "" + obj.type;
	        // attachments if we have them
	        if (obj.type === PacketType.BINARY_EVENT ||
	            obj.type === PacketType.BINARY_ACK) {
	            str += obj.attachments + "-";
	        }
	        // if we have a namespace other than `/`
	        // we append it followed by a comma `,`
	        if (obj.nsp && "/" !== obj.nsp) {
	            str += obj.nsp + ",";
	        }
	        // immediately followed by the id
	        if (null != obj.id) {
	            str += obj.id;
	        }
	        // json data
	        if (null != obj.data) {
	            str += JSON.stringify(obj.data, this.replacer);
	        }
	        debug$2("encoded %j as %s", obj, str);
	        return str;
	    }
	    /**
	     * Encode packet as 'buffer sequence' by removing blobs, and
	     * deconstructing packet into object with placeholders and
	     * a list of buffers.
	     */
	    encodeAsBinary(obj) {
	        const deconstruction = (0, binary_js_1.deconstructPacket)(obj);
	        const pack = this.encodeAsString(deconstruction.packet);
	        const buffers = deconstruction.buffers;
	        buffers.unshift(pack); // add packet info to beginning of data list
	        return buffers; // write all the buffers
	    }
	}
	cjs.Encoder = Encoder;
	/**
	 * A socket.io Decoder instance
	 *
	 * @return {Object} decoder
	 */
	class Decoder extends component_emitter_1$2.Emitter {
	    /**
	     * Decoder constructor
	     *
	     * @param {function} reviver - custom reviver to pass down to JSON.stringify
	     */
	    constructor(reviver) {
	        super();
	        this.reviver = reviver;
	    }
	    /**
	     * Decodes an encoded packet string into packet JSON.
	     *
	     * @param {String} obj - encoded packet
	     */
	    add(obj) {
	        let packet;
	        if (typeof obj === "string") {
	            if (this.reconstructor) {
	                throw new Error("got plaintext data when reconstructing a packet");
	            }
	            packet = this.decodeString(obj);
	            const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
	            if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
	                packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
	                // binary packet's json
	                this.reconstructor = new BinaryReconstructor(packet);
	                // no attachments, labeled binary but no binary data to follow
	                if (packet.attachments === 0) {
	                    super.emitReserved("decoded", packet);
	                }
	            }
	            else {
	                // non-binary full packet
	                super.emitReserved("decoded", packet);
	            }
	        }
	        else if ((0, is_binary_js_1.isBinary)(obj) || obj.base64) {
	            // raw binary data
	            if (!this.reconstructor) {
	                throw new Error("got binary data when not reconstructing a packet");
	            }
	            else {
	                packet = this.reconstructor.takeBinaryData(obj);
	                if (packet) {
	                    // received final buffer
	                    this.reconstructor = null;
	                    super.emitReserved("decoded", packet);
	                }
	            }
	        }
	        else {
	            throw new Error("Unknown type: " + obj);
	        }
	    }
	    /**
	     * Decode a packet String (JSON data)
	     *
	     * @param {String} str
	     * @return {Object} packet
	     */
	    decodeString(str) {
	        let i = 0;
	        // look up type
	        const p = {
	            type: Number(str.charAt(0)),
	        };
	        if (PacketType[p.type] === undefined) {
	            throw new Error("unknown packet type " + p.type);
	        }
	        // look up attachments if type binary
	        if (p.type === PacketType.BINARY_EVENT ||
	            p.type === PacketType.BINARY_ACK) {
	            const start = i + 1;
	            while (str.charAt(++i) !== "-" && i != str.length) { }
	            const buf = str.substring(start, i);
	            if (buf != Number(buf) || str.charAt(i) !== "-") {
	                throw new Error("Illegal attachments");
	            }
	            p.attachments = Number(buf);
	        }
	        // look up namespace (if any)
	        if ("/" === str.charAt(i + 1)) {
	            const start = i + 1;
	            while (++i) {
	                const c = str.charAt(i);
	                if ("," === c)
	                    break;
	                if (i === str.length)
	                    break;
	            }
	            p.nsp = str.substring(start, i);
	        }
	        else {
	            p.nsp = "/";
	        }
	        // look up id
	        const next = str.charAt(i + 1);
	        if ("" !== next && Number(next) == next) {
	            const start = i + 1;
	            while (++i) {
	                const c = str.charAt(i);
	                if (null == c || Number(c) != c) {
	                    --i;
	                    break;
	                }
	                if (i === str.length)
	                    break;
	            }
	            p.id = Number(str.substring(start, i + 1));
	        }
	        // look up json data
	        if (str.charAt(++i)) {
	            const payload = this.tryParse(str.substr(i));
	            if (Decoder.isPayloadValid(p.type, payload)) {
	                p.data = payload;
	            }
	            else {
	                throw new Error("invalid payload");
	            }
	        }
	        debug$2("decoded %s as %j", str, p);
	        return p;
	    }
	    tryParse(str) {
	        try {
	            return JSON.parse(str, this.reviver);
	        }
	        catch (e) {
	            return false;
	        }
	    }
	    static isPayloadValid(type, payload) {
	        switch (type) {
	            case PacketType.CONNECT:
	                return isObject(payload);
	            case PacketType.DISCONNECT:
	                return payload === undefined;
	            case PacketType.CONNECT_ERROR:
	                return typeof payload === "string" || isObject(payload);
	            case PacketType.EVENT:
	            case PacketType.BINARY_EVENT:
	                return (Array.isArray(payload) &&
	                    (typeof payload[0] === "number" ||
	                        (typeof payload[0] === "string" &&
	                            RESERVED_EVENTS$1.indexOf(payload[0]) === -1)));
	            case PacketType.ACK:
	            case PacketType.BINARY_ACK:
	                return Array.isArray(payload);
	        }
	    }
	    /**
	     * Deallocates a parser's resources
	     */
	    destroy() {
	        if (this.reconstructor) {
	            this.reconstructor.finishedReconstruction();
	            this.reconstructor = null;
	        }
	    }
	}
	cjs.Decoder = Decoder;
	/**
	 * A manager of a binary event's 'buffer sequence'. Should
	 * be constructed whenever a packet of type BINARY_EVENT is
	 * decoded.
	 *
	 * @param {Object} packet
	 * @return {BinaryReconstructor} initialized reconstructor
	 */
	class BinaryReconstructor {
	    constructor(packet) {
	        this.packet = packet;
	        this.buffers = [];
	        this.reconPack = packet;
	    }
	    /**
	     * Method to be called when binary data received from connection
	     * after a BINARY_EVENT packet.
	     *
	     * @param {Buffer | ArrayBuffer} binData - the raw binary data received
	     * @return {null | Object} returns null if more binary data is expected or
	     *   a reconstructed packet object if all buffers have been received.
	     */
	    takeBinaryData(binData) {
	        this.buffers.push(binData);
	        if (this.buffers.length === this.reconPack.attachments) {
	            // done with buffer list
	            const packet = (0, binary_js_1.reconstructPacket)(this.reconPack, this.buffers);
	            this.finishedReconstruction();
	            return packet;
	        }
	        return null;
	    }
	    /**
	     * Cleans up binary packet reconstruction variables.
	     */
	    finishedReconstruction() {
	        this.reconPack = null;
	        this.buffers = [];
	    }
	}
	function isNamespaceValid(nsp) {
	    return typeof nsp === "string";
	}
	// see https://caniuse.com/mdn-javascript_builtins_number_isinteger
	const isInteger = Number.isInteger ||
	    function (value) {
	        return (typeof value === "number" &&
	            isFinite(value) &&
	            Math.floor(value) === value);
	    };
	function isAckIdValid(id) {
	    return id === undefined || isInteger(id);
	}
	// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript
	function isObject(value) {
	    return Object.prototype.toString.call(value) === "[object Object]";
	}
	function isDataValid(type, payload) {
	    switch (type) {
	        case PacketType.CONNECT:
	            return payload === undefined || isObject(payload);
	        case PacketType.DISCONNECT:
	            return payload === undefined;
	        case PacketType.EVENT:
	            return (Array.isArray(payload) &&
	                (typeof payload[0] === "number" ||
	                    (typeof payload[0] === "string" &&
	                        RESERVED_EVENTS$1.indexOf(payload[0]) === -1)));
	        case PacketType.ACK:
	            return Array.isArray(payload);
	        case PacketType.CONNECT_ERROR:
	            return typeof payload === "string" || isObject(payload);
	        default:
	            return false;
	    }
	}
	function isPacketValid(packet) {
	    return (isNamespaceValid(packet.nsp) &&
	        isAckIdValid(packet.id) &&
	        isDataValid(packet.type, packet.data));
	}

	var on$1 = {};

	Object.defineProperty(on$1, "__esModule", { value: true });
	on$1.on = on;
	function on(obj, ev, fn) {
	    obj.on(ev, fn);
	    return function subDestroy() {
	        obj.off(ev, fn);
	    };
	}

	var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(socket$1, "__esModule", { value: true });
	socket$1.Socket = void 0;
	const socket_io_parser_1 = cjs;
	const on_js_1$1 = on$1;
	const component_emitter_1$1 = require$$5;
	const debug_1$1 = __importDefault$1(browserExports); // debug()
	const debug$1 = (0, debug_1$1.default)("socket.io-client:socket"); // debug()
	/**
	 * Internal events.
	 * These events can't be emitted by the user.
	 */
	const RESERVED_EVENTS = Object.freeze({
	    connect: 1,
	    connect_error: 1,
	    disconnect: 1,
	    disconnecting: 1,
	    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
	    newListener: 1,
	    removeListener: 1,
	});
	/**
	 * A Socket is the fundamental class for interacting with the server.
	 *
	 * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
	 *
	 * @example
	 * const socket = io();
	 *
	 * socket.on("connect", () => {
	 *   console.log("connected");
	 * });
	 *
	 * // send an event to the server
	 * socket.emit("foo", "bar");
	 *
	 * socket.on("foobar", () => {
	 *   // an event was received from the server
	 * });
	 *
	 * // upon disconnection
	 * socket.on("disconnect", (reason) => {
	 *   console.log(`disconnected due to ${reason}`);
	 * });
	 */
	class Socket extends component_emitter_1$1.Emitter {
	    /**
	     * `Socket` constructor.
	     */
	    constructor(io, nsp, opts) {
	        super();
	        /**
	         * Whether the socket is currently connected to the server.
	         *
	         * @example
	         * const socket = io();
	         *
	         * socket.on("connect", () => {
	         *   console.log(socket.connected); // true
	         * });
	         *
	         * socket.on("disconnect", () => {
	         *   console.log(socket.connected); // false
	         * });
	         */
	        this.connected = false;
	        /**
	         * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
	         * be transmitted by the server.
	         */
	        this.recovered = false;
	        /**
	         * Buffer for packets received before the CONNECT packet
	         */
	        this.receiveBuffer = [];
	        /**
	         * Buffer for packets that will be sent once the socket is connected
	         */
	        this.sendBuffer = [];
	        /**
	         * The queue of packets to be sent with retry in case of failure.
	         *
	         * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.
	         * @private
	         */
	        this._queue = [];
	        /**
	         * A sequence to generate the ID of the {@link QueuedPacket}.
	         * @private
	         */
	        this._queueSeq = 0;
	        this.ids = 0;
	        /**
	         * A map containing acknowledgement handlers.
	         *
	         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:
	         *
	         * - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
	         * - `socket.timeout(5000).emit("test", (err, value) => { ... })`
	         * - `const value = await socket.emitWithAck("test")`
	         *
	         * From those that don't:
	         *
	         * - `socket.emit("test", (value) => { ... });`
	         *
	         * In the first case, the handlers will be called with an error when:
	         *
	         * - the timeout is reached
	         * - the socket gets disconnected
	         *
	         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
	         * an acknowledgement from the server.
	         *
	         * @private
	         */
	        this.acks = {};
	        this.flags = {};
	        this.io = io;
	        this.nsp = nsp;
	        if (opts && opts.auth) {
	            this.auth = opts.auth;
	        }
	        this._opts = Object.assign({}, opts);
	        if (this.io._autoConnect)
	            this.open();
	    }
	    /**
	     * Whether the socket is currently disconnected
	     *
	     * @example
	     * const socket = io();
	     *
	     * socket.on("connect", () => {
	     *   console.log(socket.disconnected); // false
	     * });
	     *
	     * socket.on("disconnect", () => {
	     *   console.log(socket.disconnected); // true
	     * });
	     */
	    get disconnected() {
	        return !this.connected;
	    }
	    /**
	     * Subscribe to open, close and packet events
	     *
	     * @private
	     */
	    subEvents() {
	        if (this.subs)
	            return;
	        const io = this.io;
	        this.subs = [
	            (0, on_js_1$1.on)(io, "open", this.onopen.bind(this)),
	            (0, on_js_1$1.on)(io, "packet", this.onpacket.bind(this)),
	            (0, on_js_1$1.on)(io, "error", this.onerror.bind(this)),
	            (0, on_js_1$1.on)(io, "close", this.onclose.bind(this)),
	        ];
	    }
	    /**
	     * Whether the Socket will try to reconnect when its Manager connects or reconnects.
	     *
	     * @example
	     * const socket = io();
	     *
	     * console.log(socket.active); // true
	     *
	     * socket.on("disconnect", (reason) => {
	     *   if (reason === "io server disconnect") {
	     *     // the disconnection was initiated by the server, you need to manually reconnect
	     *     console.log(socket.active); // false
	     *   }
	     *   // else the socket will automatically try to reconnect
	     *   console.log(socket.active); // true
	     * });
	     */
	    get active() {
	        return !!this.subs;
	    }
	    /**
	     * "Opens" the socket.
	     *
	     * @example
	     * const socket = io({
	     *   autoConnect: false
	     * });
	     *
	     * socket.connect();
	     */
	    connect() {
	        if (this.connected)
	            return this;
	        this.subEvents();
	        if (!this.io["_reconnecting"])
	            this.io.open(); // ensure open
	        if ("open" === this.io._readyState)
	            this.onopen();
	        return this;
	    }
	    /**
	     * Alias for {@link connect()}.
	     */
	    open() {
	        return this.connect();
	    }
	    /**
	     * Sends a `message` event.
	     *
	     * This method mimics the WebSocket.send() method.
	     *
	     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
	     *
	     * @example
	     * socket.send("hello");
	     *
	     * // this is equivalent to
	     * socket.emit("message", "hello");
	     *
	     * @return self
	     */
	    send(...args) {
	        args.unshift("message");
	        this.emit.apply(this, args);
	        return this;
	    }
	    /**
	     * Override `emit`.
	     * If the event is in `events`, it's emitted normally.
	     *
	     * @example
	     * socket.emit("hello", "world");
	     *
	     * // all serializable datastructures are supported (no need to call JSON.stringify)
	     * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
	     *
	     * // with an acknowledgement from the server
	     * socket.emit("hello", "world", (val) => {
	     *   // ...
	     * });
	     *
	     * @return self
	     */
	    emit(ev, ...args) {
	        var _a, _b, _c;
	        if (RESERVED_EVENTS.hasOwnProperty(ev)) {
	            throw new Error('"' + ev.toString() + '" is a reserved event name');
	        }
	        args.unshift(ev);
	        if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
	            this._addToQueue(args);
	            return this;
	        }
	        const packet = {
	            type: socket_io_parser_1.PacketType.EVENT,
	            data: args,
	        };
	        packet.options = {};
	        packet.options.compress = this.flags.compress !== false;
	        // event ack callback
	        if ("function" === typeof args[args.length - 1]) {
	            const id = this.ids++;
	            debug$1("emitting packet with ack id %d", id);
	            const ack = args.pop();
	            this._registerAckCallback(id, ack);
	            packet.id = id;
	        }
	        const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
	        const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
	        const discardPacket = this.flags.volatile && !isTransportWritable;
	        if (discardPacket) {
	            debug$1("discard packet as the transport is not currently writable");
	        }
	        else if (isConnected) {
	            this.notifyOutgoingListeners(packet);
	            this.packet(packet);
	        }
	        else {
	            this.sendBuffer.push(packet);
	        }
	        this.flags = {};
	        return this;
	    }
	    /**
	     * @private
	     */
	    _registerAckCallback(id, ack) {
	        var _a;
	        const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
	        if (timeout === undefined) {
	            this.acks[id] = ack;
	            return;
	        }
	        // @ts-ignore
	        const timer = this.io.setTimeoutFn(() => {
	            delete this.acks[id];
	            for (let i = 0; i < this.sendBuffer.length; i++) {
	                if (this.sendBuffer[i].id === id) {
	                    debug$1("removing packet with ack id %d from the buffer", id);
	                    this.sendBuffer.splice(i, 1);
	                }
	            }
	            debug$1("event with ack id %d has timed out after %d ms", id, timeout);
	            ack.call(this, new Error("operation has timed out"));
	        }, timeout);
	        const fn = (...args) => {
	            // @ts-ignore
	            this.io.clearTimeoutFn(timer);
	            ack.apply(this, args);
	        };
	        fn.withError = true;
	        this.acks[id] = fn;
	    }
	    /**
	     * Emits an event and waits for an acknowledgement
	     *
	     * @example
	     * // without timeout
	     * const response = await socket.emitWithAck("hello", "world");
	     *
	     * // with a specific timeout
	     * try {
	     *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
	     * } catch (err) {
	     *   // the server did not acknowledge the event in the given delay
	     * }
	     *
	     * @return a Promise that will be fulfilled when the server acknowledges the event
	     */
	    emitWithAck(ev, ...args) {
	        return new Promise((resolve, reject) => {
	            const fn = (arg1, arg2) => {
	                return arg1 ? reject(arg1) : resolve(arg2);
	            };
	            fn.withError = true;
	            args.push(fn);
	            this.emit(ev, ...args);
	        });
	    }
	    /**
	     * Add the packet to the queue.
	     * @param args
	     * @private
	     */
	    _addToQueue(args) {
	        let ack;
	        if (typeof args[args.length - 1] === "function") {
	            ack = args.pop();
	        }
	        const packet = {
	            id: this._queueSeq++,
	            tryCount: 0,
	            pending: false,
	            args,
	            flags: Object.assign({ fromQueue: true }, this.flags),
	        };
	        args.push((err, ...responseArgs) => {
	            if (packet !== this._queue[0]) {
	                return debug$1("packet [%d] already acknowledged", packet.id);
	            }
	            const hasError = err !== null;
	            if (hasError) {
	                if (packet.tryCount > this._opts.retries) {
	                    debug$1("packet [%d] is discarded after %d tries", packet.id, packet.tryCount);
	                    this._queue.shift();
	                    if (ack) {
	                        ack(err);
	                    }
	                }
	            }
	            else {
	                debug$1("packet [%d] was successfully sent", packet.id);
	                this._queue.shift();
	                if (ack) {
	                    ack(null, ...responseArgs);
	                }
	            }
	            packet.pending = false;
	            return this._drainQueue();
	        });
	        this._queue.push(packet);
	        this._drainQueue();
	    }
	    /**
	     * Send the first packet of the queue, and wait for an acknowledgement from the server.
	     * @param force - whether to resend a packet that has not been acknowledged yet
	     *
	     * @private
	     */
	    _drainQueue(force = false) {
	        debug$1("draining queue");
	        if (!this.connected || this._queue.length === 0) {
	            return;
	        }
	        const packet = this._queue[0];
	        if (packet.pending && !force) {
	            debug$1("packet [%d] has already been sent and is waiting for an ack", packet.id);
	            return;
	        }
	        packet.pending = true;
	        packet.tryCount++;
	        debug$1("sending packet [%d] (try n°%d)", packet.id, packet.tryCount);
	        this.flags = packet.flags;
	        this.emit.apply(this, packet.args);
	    }
	    /**
	     * Sends a packet.
	     *
	     * @param packet
	     * @private
	     */
	    packet(packet) {
	        packet.nsp = this.nsp;
	        this.io._packet(packet);
	    }
	    /**
	     * Called upon engine `open`.
	     *
	     * @private
	     */
	    onopen() {
	        debug$1("transport is open - connecting");
	        if (typeof this.auth == "function") {
	            this.auth((data) => {
	                this._sendConnectPacket(data);
	            });
	        }
	        else {
	            this._sendConnectPacket(this.auth);
	        }
	    }
	    /**
	     * Sends a CONNECT packet to initiate the Socket.IO session.
	     *
	     * @param data
	     * @private
	     */
	    _sendConnectPacket(data) {
	        this.packet({
	            type: socket_io_parser_1.PacketType.CONNECT,
	            data: this._pid
	                ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
	                : data,
	        });
	    }
	    /**
	     * Called upon engine or manager `error`.
	     *
	     * @param err
	     * @private
	     */
	    onerror(err) {
	        if (!this.connected) {
	            this.emitReserved("connect_error", err);
	        }
	    }
	    /**
	     * Called upon engine `close`.
	     *
	     * @param reason
	     * @param description
	     * @private
	     */
	    onclose(reason, description) {
	        debug$1("close (%s)", reason);
	        this.connected = false;
	        delete this.id;
	        this.emitReserved("disconnect", reason, description);
	        this._clearAcks();
	    }
	    /**
	     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
	     * the server.
	     *
	     * @private
	     */
	    _clearAcks() {
	        Object.keys(this.acks).forEach((id) => {
	            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
	            if (!isBuffered) {
	                // note: handlers that do not accept an error as first argument are ignored here
	                const ack = this.acks[id];
	                delete this.acks[id];
	                if (ack.withError) {
	                    ack.call(this, new Error("socket has been disconnected"));
	                }
	            }
	        });
	    }
	    /**
	     * Called with socket packet.
	     *
	     * @param packet
	     * @private
	     */
	    onpacket(packet) {
	        const sameNamespace = packet.nsp === this.nsp;
	        if (!sameNamespace)
	            return;
	        switch (packet.type) {
	            case socket_io_parser_1.PacketType.CONNECT:
	                if (packet.data && packet.data.sid) {
	                    this.onconnect(packet.data.sid, packet.data.pid);
	                }
	                else {
	                    this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
	                }
	                break;
	            case socket_io_parser_1.PacketType.EVENT:
	            case socket_io_parser_1.PacketType.BINARY_EVENT:
	                this.onevent(packet);
	                break;
	            case socket_io_parser_1.PacketType.ACK:
	            case socket_io_parser_1.PacketType.BINARY_ACK:
	                this.onack(packet);
	                break;
	            case socket_io_parser_1.PacketType.DISCONNECT:
	                this.ondisconnect();
	                break;
	            case socket_io_parser_1.PacketType.CONNECT_ERROR:
	                this.destroy();
	                const err = new Error(packet.data.message);
	                // @ts-ignore
	                err.data = packet.data.data;
	                this.emitReserved("connect_error", err);
	                break;
	        }
	    }
	    /**
	     * Called upon a server event.
	     *
	     * @param packet
	     * @private
	     */
	    onevent(packet) {
	        const args = packet.data || [];
	        debug$1("emitting event %j", args);
	        if (null != packet.id) {
	            debug$1("attaching ack callback to event");
	            args.push(this.ack(packet.id));
	        }
	        if (this.connected) {
	            this.emitEvent(args);
	        }
	        else {
	            this.receiveBuffer.push(Object.freeze(args));
	        }
	    }
	    emitEvent(args) {
	        if (this._anyListeners && this._anyListeners.length) {
	            const listeners = this._anyListeners.slice();
	            for (const listener of listeners) {
	                listener.apply(this, args);
	            }
	        }
	        super.emit.apply(this, args);
	        if (this._pid && args.length && typeof args[args.length - 1] === "string") {
	            this._lastOffset = args[args.length - 1];
	        }
	    }
	    /**
	     * Produces an ack callback to emit with an event.
	     *
	     * @private
	     */
	    ack(id) {
	        const self = this;
	        let sent = false;
	        return function (...args) {
	            // prevent double callbacks
	            if (sent)
	                return;
	            sent = true;
	            debug$1("sending ack %j", args);
	            self.packet({
	                type: socket_io_parser_1.PacketType.ACK,
	                id: id,
	                data: args,
	            });
	        };
	    }
	    /**
	     * Called upon a server acknowledgement.
	     *
	     * @param packet
	     * @private
	     */
	    onack(packet) {
	        const ack = this.acks[packet.id];
	        if (typeof ack !== "function") {
	            debug$1("bad ack %s", packet.id);
	            return;
	        }
	        delete this.acks[packet.id];
	        debug$1("calling ack %s with %j", packet.id, packet.data);
	        // @ts-ignore FIXME ack is incorrectly inferred as 'never'
	        if (ack.withError) {
	            packet.data.unshift(null);
	        }
	        // @ts-ignore
	        ack.apply(this, packet.data);
	    }
	    /**
	     * Called upon server connect.
	     *
	     * @private
	     */
	    onconnect(id, pid) {
	        debug$1("socket connected with id %s", id);
	        this.id = id;
	        this.recovered = pid && this._pid === pid;
	        this._pid = pid; // defined only if connection state recovery is enabled
	        this.connected = true;
	        this.emitBuffered();
	        this._drainQueue(true);
	        this.emitReserved("connect");
	    }
	    /**
	     * Emit buffered events (received and emitted).
	     *
	     * @private
	     */
	    emitBuffered() {
	        this.receiveBuffer.forEach((args) => this.emitEvent(args));
	        this.receiveBuffer = [];
	        this.sendBuffer.forEach((packet) => {
	            this.notifyOutgoingListeners(packet);
	            this.packet(packet);
	        });
	        this.sendBuffer = [];
	    }
	    /**
	     * Called upon server disconnect.
	     *
	     * @private
	     */
	    ondisconnect() {
	        debug$1("server disconnect (%s)", this.nsp);
	        this.destroy();
	        this.onclose("io server disconnect");
	    }
	    /**
	     * Called upon forced client/server side disconnections,
	     * this method ensures the manager stops tracking us and
	     * that reconnections don't get triggered for this.
	     *
	     * @private
	     */
	    destroy() {
	        if (this.subs) {
	            // clean subscriptions to avoid reconnections
	            this.subs.forEach((subDestroy) => subDestroy());
	            this.subs = undefined;
	        }
	        this.io["_destroy"](this);
	    }
	    /**
	     * Disconnects the socket manually. In that case, the socket will not try to reconnect.
	     *
	     * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
	     *
	     * @example
	     * const socket = io();
	     *
	     * socket.on("disconnect", (reason) => {
	     *   // console.log(reason); prints "io client disconnect"
	     * });
	     *
	     * socket.disconnect();
	     *
	     * @return self
	     */
	    disconnect() {
	        if (this.connected) {
	            debug$1("performing disconnect (%s)", this.nsp);
	            this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });
	        }
	        // remove socket from pool
	        this.destroy();
	        if (this.connected) {
	            // fire events
	            this.onclose("io client disconnect");
	        }
	        return this;
	    }
	    /**
	     * Alias for {@link disconnect()}.
	     *
	     * @return self
	     */
	    close() {
	        return this.disconnect();
	    }
	    /**
	     * Sets the compress flag.
	     *
	     * @example
	     * socket.compress(false).emit("hello");
	     *
	     * @param compress - if `true`, compresses the sending data
	     * @return self
	     */
	    compress(compress) {
	        this.flags.compress = compress;
	        return this;
	    }
	    /**
	     * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
	     * ready to send messages.
	     *
	     * @example
	     * socket.volatile.emit("hello"); // the server may or may not receive it
	     *
	     * @returns self
	     */
	    get volatile() {
	        this.flags.volatile = true;
	        return this;
	    }
	    /**
	     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
	     * given number of milliseconds have elapsed without an acknowledgement from the server:
	     *
	     * @example
	     * socket.timeout(5000).emit("my-event", (err) => {
	     *   if (err) {
	     *     // the server did not acknowledge the event in the given delay
	     *   }
	     * });
	     *
	     * @returns self
	     */
	    timeout(timeout) {
	        this.flags.timeout = timeout;
	        return this;
	    }
	    /**
	     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
	     * callback.
	     *
	     * @example
	     * socket.onAny((event, ...args) => {
	     *   console.log(`got ${event}`);
	     * });
	     *
	     * @param listener
	     */
	    onAny(listener) {
	        this._anyListeners = this._anyListeners || [];
	        this._anyListeners.push(listener);
	        return this;
	    }
	    /**
	     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
	     * callback. The listener is added to the beginning of the listeners array.
	     *
	     * @example
	     * socket.prependAny((event, ...args) => {
	     *   console.log(`got event ${event}`);
	     * });
	     *
	     * @param listener
	     */
	    prependAny(listener) {
	        this._anyListeners = this._anyListeners || [];
	        this._anyListeners.unshift(listener);
	        return this;
	    }
	    /**
	     * Removes the listener that will be fired when any event is emitted.
	     *
	     * @example
	     * const catchAllListener = (event, ...args) => {
	     *   console.log(`got event ${event}`);
	     * }
	     *
	     * socket.onAny(catchAllListener);
	     *
	     * // remove a specific listener
	     * socket.offAny(catchAllListener);
	     *
	     * // or remove all listeners
	     * socket.offAny();
	     *
	     * @param listener
	     */
	    offAny(listener) {
	        if (!this._anyListeners) {
	            return this;
	        }
	        if (listener) {
	            const listeners = this._anyListeners;
	            for (let i = 0; i < listeners.length; i++) {
	                if (listener === listeners[i]) {
	                    listeners.splice(i, 1);
	                    return this;
	                }
	            }
	        }
	        else {
	            this._anyListeners = [];
	        }
	        return this;
	    }
	    /**
	     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
	     * e.g. to remove listeners.
	     */
	    listenersAny() {
	        return this._anyListeners || [];
	    }
	    /**
	     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
	     * callback.
	     *
	     * Note: acknowledgements sent to the server are not included.
	     *
	     * @example
	     * socket.onAnyOutgoing((event, ...args) => {
	     *   console.log(`sent event ${event}`);
	     * });
	     *
	     * @param listener
	     */
	    onAnyOutgoing(listener) {
	        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
	        this._anyOutgoingListeners.push(listener);
	        return this;
	    }
	    /**
	     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
	     * callback. The listener is added to the beginning of the listeners array.
	     *
	     * Note: acknowledgements sent to the server are not included.
	     *
	     * @example
	     * socket.prependAnyOutgoing((event, ...args) => {
	     *   console.log(`sent event ${event}`);
	     * });
	     *
	     * @param listener
	     */
	    prependAnyOutgoing(listener) {
	        this._anyOutgoingListeners = this._anyOutgoingListeners || [];
	        this._anyOutgoingListeners.unshift(listener);
	        return this;
	    }
	    /**
	     * Removes the listener that will be fired when any event is emitted.
	     *
	     * @example
	     * const catchAllListener = (event, ...args) => {
	     *   console.log(`sent event ${event}`);
	     * }
	     *
	     * socket.onAnyOutgoing(catchAllListener);
	     *
	     * // remove a specific listener
	     * socket.offAnyOutgoing(catchAllListener);
	     *
	     * // or remove all listeners
	     * socket.offAnyOutgoing();
	     *
	     * @param [listener] - the catch-all listener (optional)
	     */
	    offAnyOutgoing(listener) {
	        if (!this._anyOutgoingListeners) {
	            return this;
	        }
	        if (listener) {
	            const listeners = this._anyOutgoingListeners;
	            for (let i = 0; i < listeners.length; i++) {
	                if (listener === listeners[i]) {
	                    listeners.splice(i, 1);
	                    return this;
	                }
	            }
	        }
	        else {
	            this._anyOutgoingListeners = [];
	        }
	        return this;
	    }
	    /**
	     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
	     * e.g. to remove listeners.
	     */
	    listenersAnyOutgoing() {
	        return this._anyOutgoingListeners || [];
	    }
	    /**
	     * Notify the listeners for each packet sent
	     *
	     * @param packet
	     *
	     * @private
	     */
	    notifyOutgoingListeners(packet) {
	        if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
	            const listeners = this._anyOutgoingListeners.slice();
	            for (const listener of listeners) {
	                listener.apply(this, packet.data);
	            }
	        }
	    }
	}
	socket$1.Socket = Socket;

	var backo2 = {};

	/**
	 * Initialize backoff timer with `opts`.
	 *
	 * - `min` initial timeout in milliseconds [100]
	 * - `max` max timeout [10000]
	 * - `jitter` [0]
	 * - `factor` [2]
	 *
	 * @param {Object} opts
	 * @api public
	 */
	Object.defineProperty(backo2, "__esModule", { value: true });
	backo2.Backoff = Backoff;
	function Backoff(opts) {
	    opts = opts || {};
	    this.ms = opts.min || 100;
	    this.max = opts.max || 10000;
	    this.factor = opts.factor || 2;
	    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
	    this.attempts = 0;
	}
	/**
	 * Return the backoff duration.
	 *
	 * @return {Number}
	 * @api public
	 */
	Backoff.prototype.duration = function () {
	    var ms = this.ms * Math.pow(this.factor, this.attempts++);
	    if (this.jitter) {
	        var rand = Math.random();
	        var deviation = Math.floor(rand * this.jitter * ms);
	        ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
	    }
	    return Math.min(ms, this.max) | 0;
	};
	/**
	 * Reset the number of attempts.
	 *
	 * @api public
	 */
	Backoff.prototype.reset = function () {
	    this.attempts = 0;
	};
	/**
	 * Set the minimum duration
	 *
	 * @api public
	 */
	Backoff.prototype.setMin = function (min) {
	    this.ms = min;
	};
	/**
	 * Set the maximum duration
	 *
	 * @api public
	 */
	Backoff.prototype.setMax = function (max) {
	    this.max = max;
	};
	/**
	 * Set the jitter
	 *
	 * @api public
	 */
	Backoff.prototype.setJitter = function (jitter) {
	    this.jitter = jitter;
	};

	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    var desc = Object.getOwnPropertyDescriptor(m, k);
	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
	      desc = { enumerable: true, get: function() { return m[k]; } };
	    }
	    Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    o[k2] = m[k];
	}));
	var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
	    Object.defineProperty(o, "default", { enumerable: true, value: v });
	}) : function(o, v) {
	    o["default"] = v;
	});
	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
	    if (mod && mod.__esModule) return mod;
	    var result = {};
	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
	    __setModuleDefault(result, mod);
	    return result;
	};
	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(manager, "__esModule", { value: true });
	manager.Manager = void 0;
	const engine_io_client_1 = cjs$2;
	const socket_js_1 = socket$1;
	const parser = __importStar(cjs);
	const on_js_1 = on$1;
	const backo2_js_1 = backo2;
	const component_emitter_1 = require$$5;
	const debug_1 = __importDefault(browserExports); // debug()
	const debug = (0, debug_1.default)("socket.io-client:manager"); // debug()
	class Manager$1 extends component_emitter_1.Emitter {
	    constructor(uri, opts) {
	        var _a;
	        super();
	        this.nsps = {};
	        this.subs = [];
	        if (uri && "object" === typeof uri) {
	            opts = uri;
	            uri = undefined;
	        }
	        opts = opts || {};
	        opts.path = opts.path || "/socket.io";
	        this.opts = opts;
	        (0, engine_io_client_1.installTimerFunctions)(this, opts);
	        this.reconnection(opts.reconnection !== false);
	        this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
	        this.reconnectionDelay(opts.reconnectionDelay || 1000);
	        this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
	        this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
	        this.backoff = new backo2_js_1.Backoff({
	            min: this.reconnectionDelay(),
	            max: this.reconnectionDelayMax(),
	            jitter: this.randomizationFactor(),
	        });
	        this.timeout(null == opts.timeout ? 20000 : opts.timeout);
	        this._readyState = "closed";
	        this.uri = uri;
	        const _parser = opts.parser || parser;
	        this.encoder = new _parser.Encoder();
	        this.decoder = new _parser.Decoder();
	        this._autoConnect = opts.autoConnect !== false;
	        if (this._autoConnect)
	            this.open();
	    }
	    reconnection(v) {
	        if (!arguments.length)
	            return this._reconnection;
	        this._reconnection = !!v;
	        if (!v) {
	            this.skipReconnect = true;
	        }
	        return this;
	    }
	    reconnectionAttempts(v) {
	        if (v === undefined)
	            return this._reconnectionAttempts;
	        this._reconnectionAttempts = v;
	        return this;
	    }
	    reconnectionDelay(v) {
	        var _a;
	        if (v === undefined)
	            return this._reconnectionDelay;
	        this._reconnectionDelay = v;
	        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
	        return this;
	    }
	    randomizationFactor(v) {
	        var _a;
	        if (v === undefined)
	            return this._randomizationFactor;
	        this._randomizationFactor = v;
	        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
	        return this;
	    }
	    reconnectionDelayMax(v) {
	        var _a;
	        if (v === undefined)
	            return this._reconnectionDelayMax;
	        this._reconnectionDelayMax = v;
	        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
	        return this;
	    }
	    timeout(v) {
	        if (!arguments.length)
	            return this._timeout;
	        this._timeout = v;
	        return this;
	    }
	    /**
	     * Starts trying to reconnect if reconnection is enabled and we have not
	     * started reconnecting yet
	     *
	     * @private
	     */
	    maybeReconnectOnOpen() {
	        // Only try to reconnect if it's the first time we're connecting
	        if (!this._reconnecting &&
	            this._reconnection &&
	            this.backoff.attempts === 0) {
	            // keeps reconnection from firing twice for the same reconnection loop
	            this.reconnect();
	        }
	    }
	    /**
	     * Sets the current transport `socket`.
	     *
	     * @param {Function} fn - optional, callback
	     * @return self
	     * @public
	     */
	    open(fn) {
	        debug("readyState %s", this._readyState);
	        if (~this._readyState.indexOf("open"))
	            return this;
	        debug("opening %s", this.uri);
	        this.engine = new engine_io_client_1.Socket(this.uri, this.opts);
	        const socket = this.engine;
	        const self = this;
	        this._readyState = "opening";
	        this.skipReconnect = false;
	        // emit `open`
	        const openSubDestroy = (0, on_js_1.on)(socket, "open", function () {
	            self.onopen();
	            fn && fn();
	        });
	        const onError = (err) => {
	            debug("error");
	            this.cleanup();
	            this._readyState = "closed";
	            this.emitReserved("error", err);
	            if (fn) {
	                fn(err);
	            }
	            else {
	                // Only do this if there is no fn to handle the error
	                this.maybeReconnectOnOpen();
	            }
	        };
	        // emit `error`
	        const errorSub = (0, on_js_1.on)(socket, "error", onError);
	        if (false !== this._timeout) {
	            const timeout = this._timeout;
	            debug("connect attempt will timeout after %d", timeout);
	            // set timer
	            const timer = this.setTimeoutFn(() => {
	                debug("connect attempt timed out after %d", timeout);
	                openSubDestroy();
	                onError(new Error("timeout"));
	                socket.close();
	            }, timeout);
	            if (this.opts.autoUnref) {
	                timer.unref();
	            }
	            this.subs.push(() => {
	                this.clearTimeoutFn(timer);
	            });
	        }
	        this.subs.push(openSubDestroy);
	        this.subs.push(errorSub);
	        return this;
	    }
	    /**
	     * Alias for open()
	     *
	     * @return self
	     * @public
	     */
	    connect(fn) {
	        return this.open(fn);
	    }
	    /**
	     * Called upon transport open.
	     *
	     * @private
	     */
	    onopen() {
	        debug("open");
	        // clear old subs
	        this.cleanup();
	        // mark as open
	        this._readyState = "open";
	        this.emitReserved("open");
	        // add new subs
	        const socket = this.engine;
	        this.subs.push((0, on_js_1.on)(socket, "ping", this.onping.bind(this)), (0, on_js_1.on)(socket, "data", this.ondata.bind(this)), (0, on_js_1.on)(socket, "error", this.onerror.bind(this)), (0, on_js_1.on)(socket, "close", this.onclose.bind(this)), 
	        // @ts-ignore
	        (0, on_js_1.on)(this.decoder, "decoded", this.ondecoded.bind(this)));
	    }
	    /**
	     * Called upon a ping.
	     *
	     * @private
	     */
	    onping() {
	        this.emitReserved("ping");
	    }
	    /**
	     * Called with data.
	     *
	     * @private
	     */
	    ondata(data) {
	        try {
	            this.decoder.add(data);
	        }
	        catch (e) {
	            this.onclose("parse error", e);
	        }
	    }
	    /**
	     * Called when parser fully decodes a packet.
	     *
	     * @private
	     */
	    ondecoded(packet) {
	        // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
	        (0, engine_io_client_1.nextTick)(() => {
	            this.emitReserved("packet", packet);
	        }, this.setTimeoutFn);
	    }
	    /**
	     * Called upon socket error.
	     *
	     * @private
	     */
	    onerror(err) {
	        debug("error", err);
	        this.emitReserved("error", err);
	    }
	    /**
	     * Creates a new socket for the given `nsp`.
	     *
	     * @return {Socket}
	     * @public
	     */
	    socket(nsp, opts) {
	        let socket = this.nsps[nsp];
	        if (!socket) {
	            socket = new socket_js_1.Socket(this, nsp, opts);
	            this.nsps[nsp] = socket;
	        }
	        else if (this._autoConnect && !socket.active) {
	            socket.connect();
	        }
	        return socket;
	    }
	    /**
	     * Called upon a socket close.
	     *
	     * @param socket
	     * @private
	     */
	    _destroy(socket) {
	        const nsps = Object.keys(this.nsps);
	        for (const nsp of nsps) {
	            const socket = this.nsps[nsp];
	            if (socket.active) {
	                debug("socket %s is still active, skipping close", nsp);
	                return;
	            }
	        }
	        this._close();
	    }
	    /**
	     * Writes a packet.
	     *
	     * @param packet
	     * @private
	     */
	    _packet(packet) {
	        debug("writing packet %j", packet);
	        const encodedPackets = this.encoder.encode(packet);
	        for (let i = 0; i < encodedPackets.length; i++) {
	            this.engine.write(encodedPackets[i], packet.options);
	        }
	    }
	    /**
	     * Clean up transport subscriptions and packet buffer.
	     *
	     * @private
	     */
	    cleanup() {
	        debug("cleanup");
	        this.subs.forEach((subDestroy) => subDestroy());
	        this.subs.length = 0;
	        this.decoder.destroy();
	    }
	    /**
	     * Close the current socket.
	     *
	     * @private
	     */
	    _close() {
	        debug("disconnect");
	        this.skipReconnect = true;
	        this._reconnecting = false;
	        this.onclose("forced close");
	    }
	    /**
	     * Alias for close()
	     *
	     * @private
	     */
	    disconnect() {
	        return this._close();
	    }
	    /**
	     * Called when:
	     *
	     * - the low-level engine is closed
	     * - the parser encountered a badly formatted packet
	     * - all sockets are disconnected
	     *
	     * @private
	     */
	    onclose(reason, description) {
	        var _a;
	        debug("closed due to %s", reason);
	        this.cleanup();
	        (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();
	        this.backoff.reset();
	        this._readyState = "closed";
	        this.emitReserved("close", reason, description);
	        if (this._reconnection && !this.skipReconnect) {
	            this.reconnect();
	        }
	    }
	    /**
	     * Attempt a reconnection.
	     *
	     * @private
	     */
	    reconnect() {
	        if (this._reconnecting || this.skipReconnect)
	            return this;
	        const self = this;
	        if (this.backoff.attempts >= this._reconnectionAttempts) {
	            debug("reconnect failed");
	            this.backoff.reset();
	            this.emitReserved("reconnect_failed");
	            this._reconnecting = false;
	        }
	        else {
	            const delay = this.backoff.duration();
	            debug("will wait %dms before reconnect attempt", delay);
	            this._reconnecting = true;
	            const timer = this.setTimeoutFn(() => {
	                if (self.skipReconnect)
	                    return;
	                debug("attempting reconnect");
	                this.emitReserved("reconnect_attempt", self.backoff.attempts);
	                // check again for the case socket closed in above events
	                if (self.skipReconnect)
	                    return;
	                self.open((err) => {
	                    if (err) {
	                        debug("reconnect attempt error");
	                        self._reconnecting = false;
	                        self.reconnect();
	                        this.emitReserved("reconnect_error", err);
	                    }
	                    else {
	                        debug("reconnect success");
	                        self.onreconnect();
	                    }
	                });
	            }, delay);
	            if (this.opts.autoUnref) {
	                timer.unref();
	            }
	            this.subs.push(() => {
	                this.clearTimeoutFn(timer);
	            });
	        }
	    }
	    /**
	     * Called upon successful reconnect.
	     *
	     * @private
	     */
	    onreconnect() {
	        const attempt = this.backoff.attempts;
	        this._reconnecting = false;
	        this.backoff.reset();
	        this.emitReserved("reconnect", attempt);
	    }
	}
	manager.Manager = Manager$1;

	cjs$3.exports;

	(function (module, exports) {
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.WebTransport = exports.WebSocket = exports.NodeWebSocket = exports.XHR = exports.NodeXHR = exports.Fetch = exports.Socket = exports.Manager = exports.protocol = void 0;
		exports.io = lookup;
		exports.connect = lookup;
		exports.default = lookup;
		const url_js_1 = url$1;
		const manager_js_1 = manager;
		Object.defineProperty(exports, "Manager", { enumerable: true, get: function () { return manager_js_1.Manager; } });
		const socket_js_1 = socket$1;
		Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_js_1.Socket; } });
		const debug_1 = __importDefault(browserExports); // debug()
		const debug = (0, debug_1.default)("socket.io-client"); // debug()
		/**
		 * Managers cache.
		 */
		const cache = {};
		function lookup(uri, opts) {
		    if (typeof uri === "object") {
		        opts = uri;
		        uri = undefined;
		    }
		    opts = opts || {};
		    const parsed = (0, url_js_1.url)(uri, opts.path || "/socket.io");
		    const source = parsed.source;
		    const id = parsed.id;
		    const path = parsed.path;
		    const sameNamespace = cache[id] && path in cache[id]["nsps"];
		    const newConnection = opts.forceNew ||
		        opts["force new connection"] ||
		        false === opts.multiplex ||
		        sameNamespace;
		    let io;
		    if (newConnection) {
		        debug("ignoring socket cache for %s", source);
		        io = new manager_js_1.Manager(source, opts);
		    }
		    else {
		        if (!cache[id]) {
		            debug("new io instance for %s", source);
		            cache[id] = new manager_js_1.Manager(source, opts);
		        }
		        io = cache[id];
		    }
		    if (parsed.query && !opts.query) {
		        opts.query = parsed.queryKey;
		    }
		    return io.socket(parsed.path, opts);
		}
		// so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
		// namespace (e.g. `io.connect(...)`), for backward compatibility
		Object.assign(lookup, {
		    Manager: manager_js_1.Manager,
		    Socket: socket_js_1.Socket,
		    io: lookup,
		    connect: lookup,
		});
		/**
		 * Protocol version.
		 *
		 * @public
		 */
		var socket_io_parser_1 = cjs;
		Object.defineProperty(exports, "protocol", { enumerable: true, get: function () { return socket_io_parser_1.protocol; } });
		var engine_io_client_1 = cjs$2;
		Object.defineProperty(exports, "Fetch", { enumerable: true, get: function () { return engine_io_client_1.Fetch; } });
		Object.defineProperty(exports, "NodeXHR", { enumerable: true, get: function () { return engine_io_client_1.NodeXHR; } });
		Object.defineProperty(exports, "XHR", { enumerable: true, get: function () { return engine_io_client_1.XHR; } });
		Object.defineProperty(exports, "NodeWebSocket", { enumerable: true, get: function () { return engine_io_client_1.NodeWebSocket; } });
		Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return engine_io_client_1.WebSocket; } });
		Object.defineProperty(exports, "WebTransport", { enumerable: true, get: function () { return engine_io_client_1.WebTransport; } });

		module.exports = lookup; 
	} (cjs$3, cjs$3.exports));

	var cjsExports = cjs$3.exports;

	var menu = {};

	Object.defineProperty(menu, "__esModule", { value: true });
	menu.Menu = void 0;
	var Menu = /** @class */ (function () {
	    function Menu() {
	        this.menuContainer = document.querySelector('.ntsh_menubar');
	        this.tabContainer = document.querySelector('.ntsh_tabs');
	        this.registerListeners();
	        if (window.location.search.includes('advanced'))
	            this.selectTab('advanced');
	    }
	    Menu.prototype.selectTab = function (tabId) {
	        this.menuContainer
	            .querySelectorAll('.ntsh_menubar-item')
	            .forEach(function (item) {
	            if (item.getAttribute('tabid') === tabId) {
	                item.classList.add('selected');
	            }
	            else {
	                item.classList.remove('selected');
	            }
	        });
	        this.tabContainer.querySelectorAll('.ntsh_tab').forEach(function (tab) {
	            if (tab.getAttribute('tabid') === tabId) {
	                tab.classList.add('visible');
	            }
	            else {
	                tab.classList.remove('visible');
	            }
	        });
	    };
	    Menu.prototype.registerListeners = function () {
	        var _this = this;
	        this.menuContainer
	            .querySelectorAll('.ntsh_menubar-item')
	            .forEach(function (item) {
	            item.addEventListener('click', function () {
	                var itemId = item.getAttribute('tabid');
	                _this.selectTab(itemId);
	            });
	        });
	    };
	    return Menu;
	}());
	menu.Menu = Menu;

	var checklist = {};

	var Index = {};

	var name = "morphux";
	var version = "2025.11.5";
	var description = "Standardized Morphix UX framework.";
	var main = "dist/Index.js";
	var types = "dist/index.d.ts";
	var scripts = {
		build: "sass scss/index.scss style.css && tsc && npm run bundle",
		"watch-ts": "tsc -w",
		"watch-scss": "sass scss/index.scss style.css -w",
		"watch-rollup": "rollup -c --watch",
		bundle: "npm run bundle-ts && npm run bundle-defenitions",
		"bundle-ts": "rollup --config rollup.config.js",
		"bundle-defenitions": "dts-bundle-generator dist/index.d.ts -o bundle.d.ts --no-check"
	};
	var author = "";
	var license = "ISC";
	var dependencies = {
		"@egjs/hammerjs": "^2.0.17",
		"@rollup/plugin-commonjs": "^25.0.7",
		"@rollup/plugin-json": "^6.1.0",
		"@rollup/plugin-node-resolve": "^15.1.0",
		"@types/node": "^20.12.8",
		"material-symbols": "^0.17.4",
		rollup: "^2.79.1",
		"rollup-plugin-terser": "^7.0.2",
		sortablejs: "^1.2.1"
	};
	var devDependencies = {
		"@types/sortablejs": "^1.15.8",
		"dts-bundle-generator": "^9.5.1"
	};
	var require$$0$1 = {
		name: name,
		version: version,
		description: description,
		main: main,
		types: types,
		scripts: scripts,
		author: author,
		license: license,
		dependencies: dependencies,
		devDependencies: devDependencies
	};

	var Morph_Components = {};

	var Component_Button = {};

	var CE = {};

	Object.defineProperty(CE, "__esModule", { value: true });
	CE.ce = ce;
	function ce(tagName, classList, attributes, innerText, innerHTML, style) {
	    var _a;
	    var element = document.createElement(tagName);
	    if (classList)
	        if (typeof classList == 'string')
	            element.classList.add(classList);
	        else
	            (_a = element.classList).add.apply(_a, classList);
	    if (attributes)
	        for (var key in attributes)
	            if (element[key] != undefined)
	                element[key] = attributes[key];
	            else
	                element.setAttribute(key, String(attributes[key]));
	    if (innerText)
	        element.innerText = innerText;
	    if (innerHTML)
	        element.innerHTML = innerHTML;
	    if (style != undefined)
	        for (var key in style)
	            element.style[key] = style[key];
	    return element;
	}

	var baseComponent = {};

	Object.defineProperty(baseComponent, "__esModule", { value: true });
	baseComponent.MUXComponent = void 0;
	var MUXComponent = /** @class */ (function () {
	    function MUXComponent() {
	        this._events = {};
	    }
	    MUXComponent.prototype.callEvent = function (event) {
	        var _a;
	        var args = [];
	        for (var _i = 1; _i < arguments.length; _i++) {
	            args[_i - 1] = arguments[_i];
	        }
	        if (this._events[event] != undefined) {
	            (_a = this._events)[event].apply(_a, args);
	        }
	    };
	    MUXComponent.prototype.on = function (event, callback) {
	        this._events[event] = callback;
	    };
	    MUXComponent.prototype.destroy = function () {
	        this.container.remove();
	    };
	    return MUXComponent;
	}());
	baseComponent.MUXComponent = MUXComponent;

	var __extends$9 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Button, "__esModule", { value: true });
	Component_Button.ComponentButton = void 0;
	var CE_1$9 = CE;
	var baseComponent_1$9 = baseComponent;
	var ComponentButton = /** @class */ (function (_super) {
	    __extends$9(ComponentButton, _super);
	    function ComponentButton(options) {
	        var _a, _b;
	        var _this = _super.call(this) || this;
	        _this.mode = 'normal';
	        _this.mode = (_a = options === null || options === void 0 ? void 0 : options.mode) !== null && _a !== void 0 ? _a : 'normal';
	        var target = (_b = options === null || options === void 0 ? void 0 : options.target) !== null && _b !== void 0 ? _b : '';
	        _this.container = (0, CE_1$9.ce)(typeof target === 'string' ? 'a' : 'div', [
	            'mux_button',
	            "mux_".concat(_this.mode),
	        ]);
	        if ((options === null || options === void 0 ? void 0 : options.materialIcon) != undefined)
	            _this.container.append((0, CE_1$9.ce)('span', 'material-symbols-outlined', null, options.materialIcon));
	        _this.container.appendChild((0, CE_1$9.ce)('span', ['mux_text', 'mux_normal'], null, options.content));
	        _this.container.onclick = function (e) {
	            e.preventDefault();
	            if (_this.mode == 'disabled')
	                return;
	            if (typeof target === 'function')
	                target();
	            else {
	                if ((options === null || options === void 0 ? void 0 : options.openInNewTab) == true)
	                    window.open(target, '_blank');
	                else
	                    window.location.href = target;
	            }
	        };
	        if (typeof target === 'string')
	            _this.container.setAttribute('href', target);
	        return _this;
	    }
	    ComponentButton.prototype.updateContent = function (content) {
	        this.container.innerHTML = content;
	    };
	    ComponentButton.prototype.updateMode = function (mode) {
	        this.mode = mode;
	        this.container.classList.remove('mux_normal');
	        this.container.classList.remove('mux_highlight');
	        this.container.classList.remove('mux_secondary');
	        this.container.classList.remove('mux_disabled');
	        this.container.classList.add("mux_".concat(mode));
	    };
	    return ComponentButton;
	}(baseComponent_1$9.MUXComponent));
	Component_Button.ComponentButton = ComponentButton;

	var Component_Cards = {};

	var TextHighlighter = {};

	Object.defineProperty(TextHighlighter, "__esModule", { value: true });
	TextHighlighter.generateTextHighlights = generateTextHighlights;
	function generateTextHighlights(originalText, additionalClassnames) {
	    var _a;
	    if (additionalClassnames === void 0) { additionalClassnames = []; }
	    var div = document.createElement('div');
	    (_a = div.classList).add.apply(_a, additionalClassnames);
	    var remainingStr = originalText;
	    var regex = /\<(.*?)\>/;
	    while (remainingStr.length) {
	        var match = regex.exec(remainingStr);
	        if (match) {
	            var normalText = remainingStr.substring(0, match.index);
	            if (normalText) {
	                var normalSpan = document.createElement('span');
	                normalSpan.className = 'normal';
	                normalSpan.textContent = normalText;
	                div.appendChild(normalSpan);
	            }
	            var highlightSpan = document.createElement('span');
	            highlightSpan.className = 'highlight';
	            highlightSpan.textContent = match[1];
	            div.appendChild(highlightSpan);
	            remainingStr = remainingStr.substring(match.index + match[0].length);
	        }
	        else {
	            var normalSpan = document.createElement('span');
	            normalSpan.className = 'normal';
	            normalSpan.textContent = remainingStr;
	            div.appendChild(normalSpan);
	            break;
	        }
	    }
	    return div;
	}

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

	/**!
	 * Sortable
	 * @author	RubaXa   <trash@rubaxa.org>
	 * @license MIT
	 */
	Sortable$2.exports;

	(function (module) {
		(function (factory) {

			{
				module.exports = factory();
			}
		})(function () {

			var dragEl,
				ghostEl,
				cloneEl,
				rootEl,
				nextEl,

				scrollEl,
				scrollParentEl,

				lastEl,
				lastCSS,

				oldIndex,
				newIndex,

				activeGroup,
				autoScroll = {},

				tapEvt,
				touchEvt,

				/** @const */
				RSPACE = /\s+/g,

				expando = 'Sortable' + (new Date).getTime(),

				win = window,
				document = win.document,
				parseInt = win.parseInt,

				supportDraggable = !!('draggable' in document.createElement('div')),

				_silent = false,

				abs = Math.abs,
				slice = [].slice,

				touchDragOverListeners = [],

				_autoScroll = _throttle(function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
					// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
					if (rootEl && options.scroll) {
						var el,
							rect,
							sens = options.scrollSensitivity,
							speed = options.scrollSpeed,

							x = evt.clientX,
							y = evt.clientY,

							winWidth = window.innerWidth,
							winHeight = window.innerHeight,

							vx,
							vy
						;

						// Delect scrollEl
						if (scrollParentEl !== rootEl) {
							scrollEl = options.scroll;
							scrollParentEl = rootEl;

							if (scrollEl === true) {
								scrollEl = rootEl;

								do {
									if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
										(scrollEl.offsetHeight < scrollEl.scrollHeight)
									) {
										break;
									}
									/* jshint boss:true */
								} while (scrollEl = scrollEl.parentNode);
							}
						}

						if (scrollEl) {
							el = scrollEl;
							rect = scrollEl.getBoundingClientRect();
							vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
							vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens);
						}


						if (!(vx || vy)) {
							vx = (winWidth - x <= sens) - (x <= sens);
							vy = (winHeight - y <= sens) - (y <= sens);

							/* jshint expr:true */
							(vx || vy) && (el = win);
						}


						if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
							autoScroll.el = el;
							autoScroll.vx = vx;
							autoScroll.vy = vy;

							clearInterval(autoScroll.pid);

							if (el) {
								autoScroll.pid = setInterval(function () {
									if (el === win) {
										win.scrollTo(win.pageXOffset + vx * speed, win.pageYOffset + vy * speed);
									} else {
										vy && (el.scrollTop += vy * speed);
										vx && (el.scrollLeft += vx * speed);
									}
								}, 24);
							}
						}
					}
				}, 30)
			;



			/**
			 * @class  Sortable
			 * @param  {HTMLElement}  el
			 * @param  {Object}       [options]
			 */
			function Sortable(el, options) {
				this.el = el; // root element
				this.options = options = _extend({}, options);


				// Export instance
				el[expando] = this;


				// Default options
				var defaults = {
					group: Math.random(),
					sort: true,
					disabled: false,
					store: null,
					handle: null,
					scroll: true,
					scrollSensitivity: 30,
					scrollSpeed: 10,
					draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
					ghostClass: 'sortable-ghost',
					ignore: 'a, img',
					filter: null,
					animation: 0,
					setData: function (dataTransfer, dragEl) {
						dataTransfer.setData('Text', dragEl.textContent);
					},
					dropBubble: false,
					dragoverBubble: false,
					dataIdAttr: 'data-id',
					delay: 0
				};


				// Set default options
				for (var name in defaults) {
					!(name in options) && (options[name] = defaults[name]);
				}


				var group = options.group;

				if (!group || typeof group != 'object') {
					group = options.group = { name: group };
				}


				['pull', 'put'].forEach(function (key) {
					if (!(key in group)) {
						group[key] = true;
					}
				});


				options.groups = ' ' + group.name + (group.put.join ? ' ' + group.put.join(' ') : '') + ' ';


				// Bind all private methods
				for (var fn in this) {
					if (fn.charAt(0) === '_') {
						this[fn] = _bind(this, this[fn]);
					}
				}


				// Bind events
				_on(el, 'mousedown', this._onTapStart);
				_on(el, 'touchstart', this._onTapStart);

				_on(el, 'dragover', this);
				_on(el, 'dragenter', this);

				touchDragOverListeners.push(this._onDragOver);

				// Restore sorting
				options.store && this.sort(options.store.get(this));
			}


			Sortable.prototype = /** @lends Sortable.prototype */ {
				constructor: Sortable,

				_onTapStart: function (/** Event|TouchEvent */evt) {
					var _this = this,
						el = this.el,
						options = this.options,
						type = evt.type,
						touch = evt.touches && evt.touches[0],
						target = (touch || evt).target,
						originalTarget = target,
						filter = options.filter;


					if (type === 'mousedown' && evt.button !== 0 || options.disabled) {
						return; // only left button or enabled
					}

					target = _closest(target, options.draggable, el);

					if (!target) {
						return;
					}

					// get the index of the dragged element within its parent
					oldIndex = _index(target);

					// Check filter
					if (typeof filter === 'function') {
						if (filter.call(this, evt, target, this)) {
							_dispatchEvent(_this, originalTarget, 'filter', target, el, oldIndex);
							evt.preventDefault();
							return; // cancel dnd
						}
					}
					else if (filter) {
						filter = filter.split(',').some(function (criteria) {
							criteria = _closest(originalTarget, criteria.trim(), el);

							if (criteria) {
								_dispatchEvent(_this, criteria, 'filter', target, el, oldIndex);
								return true;
							}
						});

						if (filter) {
							evt.preventDefault();
							return; // cancel dnd
						}
					}


					if (options.handle && !_closest(originalTarget, options.handle, el)) {
						return;
					}


					// Prepare `dragstart`
					this._prepareDragStart(evt, touch, target);
				},

				_prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target) {
					var _this = this,
						el = _this.el,
						options = _this.options,
						ownerDocument = el.ownerDocument,
						dragStartFn;

					if (target && !dragEl && (target.parentNode === el)) {
						tapEvt = evt;

						rootEl = el;
						dragEl = target;
						nextEl = dragEl.nextSibling;
						activeGroup = options.group;

						dragStartFn = function () {
							// Delayed drag has been triggered
							// we can re-enable the events: touchmove/mousemove
							_this._disableDelayedDrag();

							// Make the element draggable
							dragEl.draggable = true;

							// Disable "draggable"
							options.ignore.split(',').forEach(function (criteria) {
								_find(dragEl, criteria.trim(), _disableDraggable);
							});

							// Bind the events: dragstart/dragend
							_this._triggerDragStart(touch);
						};

						_on(ownerDocument, 'mouseup', _this._onDrop);
						_on(ownerDocument, 'touchend', _this._onDrop);
						_on(ownerDocument, 'touchcancel', _this._onDrop);

						if (options.delay) {
							// If the user moves the pointer before the delay has been reached:
							// disable the delayed drag
							_on(ownerDocument, 'mousemove', _this._disableDelayedDrag);
							_on(ownerDocument, 'touchmove', _this._disableDelayedDrag);

							_this._dragStartTimer = setTimeout(dragStartFn, options.delay);
						} else {
							dragStartFn();
						}
					}
				},

				_disableDelayedDrag: function () {
					var ownerDocument = this.el.ownerDocument;

					clearTimeout(this._dragStartTimer);

					_off(ownerDocument, 'mousemove', this._disableDelayedDrag);
					_off(ownerDocument, 'touchmove', this._disableDelayedDrag);
				},

				_triggerDragStart: function (/** Touch */touch) {
					if (touch) {
						// Touch device support
						tapEvt = {
							target: dragEl,
							clientX: touch.clientX,
							clientY: touch.clientY
						};

						this._onDragStart(tapEvt, 'touch');
					}
					else if (!supportDraggable) {
						this._onDragStart(tapEvt, true);
					}
					else {
						_on(dragEl, 'dragend', this);
						_on(rootEl, 'dragstart', this._onDragStart);
					}

					try {
						if (document.selection) {
							document.selection.empty();
						} else {
							window.getSelection().removeAllRanges();
						}
					} catch (err) {
					}
				},

				_dragStarted: function () {
					if (rootEl && dragEl) {
						// Apply effect
						_toggleClass(dragEl, this.options.ghostClass, true);

						Sortable.active = this;

						// Drag start event
						_dispatchEvent(this, rootEl, 'start', dragEl, rootEl, oldIndex);
					}
				},

				_emulateDragOver: function () {
					if (touchEvt) {
						_css(ghostEl, 'display', 'none');

						var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY),
							parent = target,
							groupName = ' ' + this.options.group.name + '',
							i = touchDragOverListeners.length;

						if (parent) {
							do {
								if (parent[expando] && parent[expando].options.groups.indexOf(groupName) > -1) {
									while (i--) {
										touchDragOverListeners[i]({
											clientX: touchEvt.clientX,
											clientY: touchEvt.clientY,
											target: target,
											rootEl: parent
										});
									}

									break;
								}

								target = parent; // store last element
							}
							/* jshint boss:true */
							while (parent = parent.parentNode);
						}

						_css(ghostEl, 'display', '');
					}
				},


				_onTouchMove: function (/**TouchEvent*/evt) {
					if (tapEvt) {
						var touch = evt.touches ? evt.touches[0] : evt,
							dx = touch.clientX - tapEvt.clientX,
							dy = touch.clientY - tapEvt.clientY,
							translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';

						touchEvt = touch;

						_css(ghostEl, 'webkitTransform', translate3d);
						_css(ghostEl, 'mozTransform', translate3d);
						_css(ghostEl, 'msTransform', translate3d);
						_css(ghostEl, 'transform', translate3d);

						evt.preventDefault();
					}
				},


				_onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
					var dataTransfer = evt.dataTransfer,
						options = this.options;

					this._offUpEvents();

					if (activeGroup.pull == 'clone') {
						cloneEl = dragEl.cloneNode(true);
						_css(cloneEl, 'display', 'none');
						rootEl.insertBefore(cloneEl, dragEl);
					}

					if (useFallback) {
						var rect = dragEl.getBoundingClientRect(),
							css = _css(dragEl),
							ghostRect;

						ghostEl = dragEl.cloneNode(true);

						_css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
						_css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
						_css(ghostEl, 'width', rect.width);
						_css(ghostEl, 'height', rect.height);
						_css(ghostEl, 'opacity', '0.8');
						_css(ghostEl, 'position', 'fixed');
						_css(ghostEl, 'zIndex', '100000');

						rootEl.appendChild(ghostEl);

						// Fixing dimensions.
						ghostRect = ghostEl.getBoundingClientRect();
						_css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
						_css(ghostEl, 'height', rect.height * 2 - ghostRect.height);

						if (useFallback === 'touch') {
							// Bind touch events
							_on(document, 'touchmove', this._onTouchMove);
							_on(document, 'touchend', this._onDrop);
							_on(document, 'touchcancel', this._onDrop);
						} else {
							// Old brwoser
							_on(document, 'mousemove', this._onTouchMove);
							_on(document, 'mouseup', this._onDrop);
						}

						this._loopId = setInterval(this._emulateDragOver, 150);
					}
					else {
						if (dataTransfer) {
							dataTransfer.effectAllowed = 'move';
							options.setData && options.setData.call(this, dataTransfer, dragEl);
						}

						_on(document, 'drop', this);
					}

					setTimeout(this._dragStarted, 0);
				},

				_onDragOver: function (/**Event*/evt) {
					var el = this.el,
						target,
						dragRect,
						revert,
						options = this.options,
						group = options.group,
						groupPut = group.put,
						isOwner = (activeGroup === group),
						canSort = options.sort;

					if (evt.preventDefault !== void 0) {
						evt.preventDefault();
						!options.dragoverBubble && evt.stopPropagation();
					}

					if (activeGroup && !options.disabled &&
						(isOwner
							? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
							: activeGroup.pull && groupPut && (
								(activeGroup.name === group.name) || // by Name
								(groupPut.indexOf && ~groupPut.indexOf(activeGroup.name)) // by Array
							)
						) &&
						(evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
					) {
						// Smart auto-scrolling
						_autoScroll(evt, options, this.el);

						if (_silent) {
							return;
						}

						target = _closest(evt.target, options.draggable, el);
						dragRect = dragEl.getBoundingClientRect();


						if (revert) {
							_cloneHide(true);

							if (cloneEl || nextEl) {
								rootEl.insertBefore(dragEl, cloneEl || nextEl);
							}
							else if (!canSort) {
								rootEl.appendChild(dragEl);
							}

							return;
						}


						if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
							(el === evt.target) && (target = _ghostInBottom(el, evt))
						) {
							if (target) {
								if (target.animated) {
									return;
								}
								targetRect = target.getBoundingClientRect();
							}

							_cloneHide(isOwner);

							if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect) !== false) {
								el.appendChild(dragEl);
								this._animate(dragRect, dragEl);
								target && this._animate(targetRect, target);
							}
						}
						else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
							if (lastEl !== target) {
								lastEl = target;
								lastCSS = _css(target);
							}


							var targetRect = target.getBoundingClientRect(),
								width = targetRect.right - targetRect.left,
								height = targetRect.bottom - targetRect.top,
								floating = /left|right|inline/.test(lastCSS.cssFloat + lastCSS.display),
								isWide = (target.offsetWidth > dragEl.offsetWidth),
								isLong = (target.offsetHeight > dragEl.offsetHeight),
								halfway = (floating ? (evt.clientX - targetRect.left) / width : (evt.clientY - targetRect.top) / height) > 0.5,
								nextSibling = target.nextElementSibling,
								moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect),
								after
							;

							if (moveVector !== false) {
								_silent = true;
								setTimeout(_unsilent, 30);

								_cloneHide(isOwner);

								if (moveVector === 1 || moveVector === -1) {
									after = (moveVector === 1);
								}
								else if (floating) {
									after = (target.previousElementSibling === dragEl) && !isWide || halfway && isWide;
								} else {
									after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
								}

								if (after && !nextSibling) {
									el.appendChild(dragEl);
								} else {
									target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
								}

								this._animate(dragRect, dragEl);
								this._animate(targetRect, target);
							}
						}
					}
				},

				_animate: function (prevRect, target) {
					var ms = this.options.animation;

					if (ms) {
						var currentRect = target.getBoundingClientRect();

						_css(target, 'transition', 'none');
						_css(target, 'transform', 'translate3d('
							+ (prevRect.left - currentRect.left) + 'px,'
							+ (prevRect.top - currentRect.top) + 'px,0)'
						);

						target.offsetWidth; // repaint

						_css(target, 'transition', 'all ' + ms + 'ms');
						_css(target, 'transform', 'translate3d(0,0,0)');

						clearTimeout(target.animated);
						target.animated = setTimeout(function () {
							_css(target, 'transition', '');
							_css(target, 'transform', '');
							target.animated = false;
						}, ms);
					}
				},

				_offUpEvents: function () {
					var ownerDocument = this.el.ownerDocument;

					_off(document, 'touchmove', this._onTouchMove);
					_off(ownerDocument, 'mouseup', this._onDrop);
					_off(ownerDocument, 'touchend', this._onDrop);
					_off(ownerDocument, 'touchcancel', this._onDrop);
				},

				_onDrop: function (/**Event*/evt) {
					var el = this.el,
						options = this.options;

					clearInterval(this._loopId);
					clearInterval(autoScroll.pid);
					clearTimeout(this._dragStartTimer);

					// Unbind events
					_off(document, 'drop', this);
					_off(document, 'mousemove', this._onTouchMove);
					_off(el, 'dragstart', this._onDragStart);

					this._offUpEvents();

					if (evt) {
						evt.preventDefault();
						!options.dropBubble && evt.stopPropagation();

						ghostEl && ghostEl.parentNode.removeChild(ghostEl);

						if (dragEl) {
							_off(dragEl, 'dragend', this);

							_disableDraggable(dragEl);
							_toggleClass(dragEl, this.options.ghostClass, false);

							if (rootEl !== dragEl.parentNode) {
								newIndex = _index(dragEl);

								// drag from one list and drop into another
								_dispatchEvent(null, dragEl.parentNode, 'sort', dragEl, rootEl, oldIndex, newIndex);
								_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);

								// Add event
								_dispatchEvent(null, dragEl.parentNode, 'add', dragEl, rootEl, oldIndex, newIndex);

								// Remove event
								_dispatchEvent(this, rootEl, 'remove', dragEl, rootEl, oldIndex, newIndex);
							}
							else {
								// Remove clone
								cloneEl && cloneEl.parentNode.removeChild(cloneEl);

								if (dragEl.nextSibling !== nextEl) {
									// Get the index of the dragged element within its parent
									newIndex = _index(dragEl);

									// drag & drop within the same list
									_dispatchEvent(this, rootEl, 'update', dragEl, rootEl, oldIndex, newIndex);
									_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);
								}
							}

							if (Sortable.active) {
								// Drag end event
								_dispatchEvent(this, rootEl, 'end', dragEl, rootEl, oldIndex, newIndex);

								// Save sorting
								this.save();
							}
						}

						// Nulling
						rootEl =
						dragEl =
						ghostEl =
						nextEl =
						cloneEl =

						scrollEl =
						scrollParentEl =

						tapEvt =
						touchEvt =

						lastEl =
						lastCSS =

						activeGroup =
						Sortable.active = null;
					}
				},


				handleEvent: function (/**Event*/evt) {
					var type = evt.type;

					if (type === 'dragover' || type === 'dragenter') {
						if (dragEl) {
							this._onDragOver(evt);
							_globalDragOver(evt);
						}
					}
					else if (type === 'drop' || type === 'dragend') {
						this._onDrop(evt);
					}
				},


				/**
				 * Serializes the item into an array of string.
				 * @returns {String[]}
				 */
				toArray: function () {
					var order = [],
						el,
						children = this.el.children,
						i = 0,
						n = children.length,
						options = this.options;

					for (; i < n; i++) {
						el = children[i];
						if (_closest(el, options.draggable, this.el)) {
							order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
						}
					}

					return order;
				},


				/**
				 * Sorts the elements according to the array.
				 * @param  {String[]}  order  order of the items
				 */
				sort: function (order) {
					var items = {}, rootEl = this.el;

					this.toArray().forEach(function (id, i) {
						var el = rootEl.children[i];

						if (_closest(el, this.options.draggable, rootEl)) {
							items[id] = el;
						}
					}, this);

					order.forEach(function (id) {
						if (items[id]) {
							rootEl.removeChild(items[id]);
							rootEl.appendChild(items[id]);
						}
					});
				},


				/**
				 * Save the current sorting
				 */
				save: function () {
					var store = this.options.store;
					store && store.set(this);
				},


				/**
				 * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
				 * @param   {HTMLElement}  el
				 * @param   {String}       [selector]  default: `options.draggable`
				 * @returns {HTMLElement|null}
				 */
				closest: function (el, selector) {
					return _closest(el, selector || this.options.draggable, this.el);
				},


				/**
				 * Set/get option
				 * @param   {string} name
				 * @param   {*}      [value]
				 * @returns {*}
				 */
				option: function (name, value) {
					var options = this.options;

					if (value === void 0) {
						return options[name];
					} else {
						options[name] = value;
					}
				},


				/**
				 * Destroy
				 */
				destroy: function () {
					var el = this.el;

					el[expando] = null;

					_off(el, 'mousedown', this._onTapStart);
					_off(el, 'touchstart', this._onTapStart);

					_off(el, 'dragover', this);
					_off(el, 'dragenter', this);

					// Remove draggable attributes
					Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
						el.removeAttribute('draggable');
					});

					touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);

					this._onDrop();

					this.el = el = null;
				}
			};


			function _cloneHide(state) {
				if (cloneEl && (cloneEl.state !== state)) {
					_css(cloneEl, 'display', state ? 'none' : '');
					!state && cloneEl.state && rootEl.insertBefore(cloneEl, dragEl);
					cloneEl.state = state;
				}
			}


			function _bind(ctx, fn) {
				var args = slice.call(arguments, 2);
				return	fn.bind ? fn.bind.apply(fn, [ctx].concat(args)) : function () {
					return fn.apply(ctx, args.concat(slice.call(arguments)));
				};
			}


			function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
				if (el) {
					ctx = ctx || document;
					selector = selector.split('.');

					var tag = selector.shift().toUpperCase(),
						re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g');

					do {
						if (
							(tag === '>*' && el.parentNode === ctx) || (
								(tag === '' || el.nodeName.toUpperCase() == tag) &&
								(!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
							)
						) {
							return el;
						}
					}
					while (el !== ctx && (el = el.parentNode));
				}

				return null;
			}


			function _globalDragOver(/**Event*/evt) {
				evt.dataTransfer.dropEffect = 'move';
				evt.preventDefault();
			}


			function _on(el, event, fn) {
				el.addEventListener(event, fn, false);
			}


			function _off(el, event, fn) {
				el.removeEventListener(event, fn, false);
			}


			function _toggleClass(el, name, state) {
				if (el) {
					if (el.classList) {
						el.classList[state ? 'add' : 'remove'](name);
					}
					else {
						var className = (' ' + el.className + ' ').replace(RSPACE, ' ').replace(' ' + name + ' ', ' ');
						el.className = (className + (state ? ' ' + name : '')).replace(RSPACE, ' ');
					}
				}
			}


			function _css(el, prop, val) {
				var style = el && el.style;

				if (style) {
					if (val === void 0) {
						if (document.defaultView && document.defaultView.getComputedStyle) {
							val = document.defaultView.getComputedStyle(el, '');
						}
						else if (el.currentStyle) {
							val = el.currentStyle;
						}

						return prop === void 0 ? val : val[prop];
					}
					else {
						if (!(prop in style)) {
							prop = '-webkit-' + prop;
						}

						style[prop] = val + (typeof val === 'string' ? '' : 'px');
					}
				}
			}


			function _find(ctx, tagName, iterator) {
				if (ctx) {
					var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;

					if (iterator) {
						for (; i < n; i++) {
							iterator(list[i], i);
						}
					}

					return list;
				}

				return [];
			}



			function _dispatchEvent(sortable, rootEl, name, targetEl, fromEl, startIndex, newIndex) {
				var evt = document.createEvent('Event'),
					options = (sortable || rootEl[expando]).options,
					onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);

				evt.initEvent(name, true, true);

				evt.to = rootEl;
				evt.from = fromEl || rootEl;
				evt.item = targetEl || rootEl;
				evt.clone = cloneEl;

				evt.oldIndex = startIndex;
				evt.newIndex = newIndex;

				rootEl.dispatchEvent(evt);

				if (options[onName]) {
					options[onName].call(sortable, evt);
				}
			}


			function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect) {
				var evt,
					sortable = fromEl[expando],
					onMoveFn = sortable.options.onMove,
					retVal;

				if (onMoveFn) {
					evt = document.createEvent('Event');
					evt.initEvent('move', true, true);

					evt.to = toEl;
					evt.from = fromEl;
					evt.dragged = dragEl;
					evt.draggedRect = dragRect;
					evt.related = targetEl || toEl;
					evt.relatedRect = targetRect || toEl.getBoundingClientRect();

					retVal = onMoveFn.call(sortable, evt);
				}

				return retVal;
			}


			function _disableDraggable(el) {
				el.draggable = false;
			}


			function _unsilent() {
				_silent = false;
			}


			/** @returns {HTMLElement|false} */
			function _ghostInBottom(el, evt) {
				var lastEl = el.lastElementChild,
					rect = lastEl.getBoundingClientRect();

				return (evt.clientY - (rect.top + rect.height) > 5) && lastEl; // min delta
			}


			/**
			 * Generate id
			 * @param   {HTMLElement} el
			 * @returns {String}
			 * @private
			 */
			function _generateId(el) {
				var str = el.tagName + el.className + el.src + el.href + el.textContent,
					i = str.length,
					sum = 0;

				while (i--) {
					sum += str.charCodeAt(i);
				}

				return sum.toString(36);
			}

			/**
			 * Returns the index of an element within its parent
			 * @param el
			 * @returns {number}
			 * @private
			 */
			function _index(/**HTMLElement*/el) {
				var index = 0;
				while (el && (el = el.previousElementSibling)) {
					if (el.nodeName.toUpperCase() !== 'TEMPLATE') {
						index++;
					}
				}
				return index;
			}

			function _throttle(callback, ms) {
				var args, _this;

				return function () {
					if (args === void 0) {
						args = arguments;
						_this = this;

						setTimeout(function () {
							if (args.length === 1) {
								callback.call(_this, args[0]);
							} else {
								callback.apply(_this, args);
							}

							args = void 0;
						}, ms);
					}
				};
			}

			function _extend(dst, src) {
				if (dst && src) {
					for (var key in src) {
						if (src.hasOwnProperty(key)) {
							dst[key] = src[key];
						}
					}
				}

				return dst;
			}


			// Export utils
			Sortable.utils = {
				on: _on,
				off: _off,
				css: _css,
				find: _find,
				bind: _bind,
				is: function (el, selector) {
					return !!_closest(el, selector, el);
				},
				extend: _extend,
				throttle: _throttle,
				closest: _closest,
				toggleClass: _toggleClass,
				index: _index
			};


			Sortable.version = '1.2.1';


			/**
			 * Create sortable instance
			 * @param {HTMLElement}  el
			 * @param {Object}      [options]
			 */
			Sortable.create = function (el, options) {
				return new Sortable(el, options);
			};

			// Export
			return Sortable;
		}); 
	} (Sortable$2));

	var SortableExports = Sortable$2.exports;

	var __extends$8 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Cards, "__esModule", { value: true });
	Component_Cards.ComponentCards = void 0;
	var CE_1$8 = CE;
	var TextHighlighter_1 = TextHighlighter;
	var baseComponent_1$8 = baseComponent;
	var Sortable$1 = SortableExports;
	var ComponentCards = /** @class */ (function (_super) {
	    __extends$8(ComponentCards, _super);
	    function ComponentCards(options) {
	        var _a, _b;
	        var _this = _super.call(this) || this;
	        _this.entries = {};
	        _this.container = (0, CE_1$8.ce)('div', 'mux_cards');
	        if (options.onePerRow === true)
	            _this.container.classList.add('mux_cards-oneperrow');
	        if (options.dragable !== false)
	            _this.sortable = new Sortable$1(_this.container, {
	                ghostClass: 'mux_cards-item-dragging',
	                onStart: function () {
	                    _this.container.classList.add('mux_cards-dragging');
	                },
	                onEnd: function (evt) {
	                    _this.container.classList.remove('mux_cards-dragging');
	                    _this.callEvent('orderUpdated', _this.getOrder());
	                },
	            });
	        _this.highlightText = (_a = options === null || options === void 0 ? void 0 : options.highlightText) !== null && _a !== void 0 ? _a : false;
	        _this.setItems((_b = options === null || options === void 0 ? void 0 : options.items) !== null && _b !== void 0 ? _b : []);
	        return _this;
	    }
	    ComponentCards.prototype.setItems = function (items) {
	        var _this = this;
	        this.container.innerHTML = '';
	        this.entries = {};
	        items.forEach(function (item) { return _this.addItem(item); });
	    };
	    ComponentCards.prototype.addItem = function (item) {
	        var _this = this;
	        var _a, _b;
	        var element = (0, CE_1$8.ce)(item.href != undefined ? 'a' : 'div', 'mux_cards-item', {
	            uid: item.uniqueIdentifier,
	        });
	        if (item.href != undefined)
	            element.href = item.href;
	        if (item.click != undefined)
	            element.onclick = function () { return item.click(); };
	        if (item.tooltip != undefined)
	            element.title = item.title;
	        if (item.enabled == false)
	            element.classList.add('mux_cards-item-disabled');
	        if (item.uniqueIdentifier != undefined)
	            this.entries[item.uniqueIdentifier] = element;
	        if (item.thumbnail != null) {
	            var thumbnailType = (_a = item.thumbnailType) !== null && _a !== void 0 ? _a : 'image';
	            if (thumbnailType == 'image') {
	                element.appendChild((0, CE_1$8.ce)('img', 'mux_cards-item-thumbnail', {
	                    src: item.thumbnail,
	                }));
	            }
	            else if (thumbnailType == 'frame') {
	                var ratio = (_b = item.thumbnailWidthRatio) !== null && _b !== void 0 ? _b : 1;
	                var frame = (0, CE_1$8.ce)('iframe', 'mux_cards-item-thumbnail', {
	                    scrolling: 'no',
	                    src: item.thumbnail,
	                });
	                element.appendChild(frame);
	                var scaleClock = setInterval(function () {
	                    if (element == null ||
	                        element.parentElement == null ||
	                        frame == null)
	                        return clearInterval(scaleClock);
	                    frame.style.width = "".concat(frame.clientHeight * ratio, "px");
	                }, 100);
	            }
	        }
	        var info = (0, CE_1$8.ce)('div', 'mux_cards-item-info');
	        info.appendChild(this.highlightText
	            ? (0, TextHighlighter_1.generateTextHighlights)(item.title, [
	                'mux_header',
	                'mux_small',
	            ])
	            : (0, CE_1$8.ce)('div', ['mux_header', 'mux_small'], null, item.title));
	        if (item.sublines != undefined && item.sublines.length > 0)
	            item.sublines.forEach(function (subline) {
	                if (subline != null)
	                    info.appendChild(_this.highlightText
	                        ? (0, TextHighlighter_1.generateTextHighlights)(subline, [
	                            'mux_text',
	                            'mux_small',
	                        ])
	                        : (0, CE_1$8.ce)('div', ['mux_text', 'mux_small'], null, subline));
	            });
	        element.appendChild(info);
	        if (item.actions != undefined && item.actions.length > 0) {
	            var buttons = (0, CE_1$8.ce)('div', 'mux_cards-item-buttons');
	            item.actions.forEach(function (action) {
	                var buttonelem = (0, CE_1$8.ce)(action.href != undefined ? 'a' : 'div', 'mux_cards-item-button');
	                if (action.href != undefined)
	                    buttonelem.href = action.href;
	                if (action.click != undefined)
	                    buttonelem.onclick = function (e) {
	                        e.preventDefault();
	                        e.stopPropagation();
	                        e.stopImmediatePropagation();
	                        action.click();
	                    };
	                if (action.tooltip != undefined)
	                    buttonelem.title = action.tooltip;
	                buttonelem.appendChild((0, CE_1$8.ce)('span', 'material-symbols-outlined', null, action.materialIcon));
	                buttons.appendChild(buttonelem);
	            });
	            element.appendChild(buttons);
	        }
	        this.container.appendChild(element);
	    };
	    ComponentCards.prototype.removeItem = function (uniqueIdentifier) {
	        if (this.entries[uniqueIdentifier] != undefined) {
	            this.entries[uniqueIdentifier].parentElement.removeChild(this.entries[uniqueIdentifier]);
	            delete this.entries[uniqueIdentifier];
	        }
	    };
	    ComponentCards.prototype.hasItem = function (uniqueIdentifier) {
	        return this.entries[uniqueIdentifier] != undefined;
	    };
	    ComponentCards.prototype.clear = function () {
	        this.container.innerHTML = '';
	        this.entries = {};
	    };
	    ComponentCards.prototype.updateItemTitle = function (uniqueIdentifier, newTitle) {
	        if (this.entries[uniqueIdentifier] == undefined)
	            return;
	        var existingHeader = this.entries[uniqueIdentifier].querySelector('.mux_header');
	        var container = existingHeader.parentElement;
	        container.insertBefore(this.highlightText
	            ? (0, TextHighlighter_1.generateTextHighlights)(newTitle, ['mux_header', 'mux_small'])
	            : (0, CE_1$8.ce)('div', ['mux_header', 'mux_small'], null, newTitle), existingHeader);
	        container.removeChild(existingHeader);
	    };
	    ComponentCards.prototype.updateSublines = function (uniqueIdentifier, newSublines) {
	        var _this = this;
	        if (this.entries[uniqueIdentifier] == undefined)
	            return;
	        var info = this.entries[uniqueIdentifier].querySelector('.mux_cards-item-info');
	        info.querySelectorAll('.mux_text.mux_small').forEach(function (existingSubline) {
	            return existingSubline.parentElement.removeChild(existingSubline);
	        });
	        if (newSublines != undefined && newSublines.length > 0)
	            newSublines.forEach(function (subline) {
	                info.appendChild(_this.highlightText
	                    ? (0, TextHighlighter_1.generateTextHighlights)(subline, [
	                        'mux_text',
	                        'mux_small',
	                    ])
	                    : (0, CE_1$8.ce)('div', ['mux_text', 'mux_small'], null, subline));
	            });
	    };
	    ComponentCards.prototype.updateThumbnail = function (uniqueIdentifier, thumbnailSrc) {
	        if (this.entries[uniqueIdentifier] == undefined)
	            return;
	        var thumbnail = this.entries[uniqueIdentifier].querySelector('.mux_cards-item-thumbnail');
	        thumbnail.src = thumbnailSrc;
	    };
	    ComponentCards.prototype.getOrder = function () {
	        var order = [];
	        this.container
	            .querySelectorAll('.mux_cards-item')
	            .forEach(function (item) { return order.push(item.getAttribute('uid')); });
	        return order;
	    };
	    return ComponentCards;
	}(baseComponent_1$8.MUXComponent));
	Component_Cards.ComponentCards = ComponentCards;

	var Component_ContextMenu = {};

	var Morph_Keys = {};

	var KeyBinderBase$1 = {};

	var KeyBinderOverwrite$1 = {};

	var __spreadArray$1 = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
	    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
	        if (ar || !(i in from)) {
	            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
	            ar[i] = from[i];
	        }
	    }
	    return to.concat(ar || Array.prototype.slice.call(from));
	};
	Object.defineProperty(KeyBinderOverwrite$1, "__esModule", { value: true });
	KeyBinderOverwrite$1.KeyBinderOverwrite = void 0;
	var KeyBinderOverwrite = /** @class */ (function () {
	    function KeyBinderOverwrite(id, KeyBinder) {
	        this.binds = {};
	        this.id = id;
	        this._KeyBinder = KeyBinder;
	    }
	    KeyBinderOverwrite.prototype.log = function () {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i] = arguments[_i];
	        }
	        if (window.location.search.includes('debug'))
	            console.log.apply(console, __spreadArray$1(['[KeyBinder]'], args, false));
	    };
	    KeyBinderOverwrite.prototype.close = function () {
	        this._KeyBinder.closeOverwrite(this.id);
	    };
	    KeyBinderOverwrite.prototype.bind = function (key, callback, settings) {
	        if (settings == undefined)
	            settings = {};
	        var query = this._KeyBinder.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
	        if (this.binds[query] != undefined)
	            return this.log("Unable to bind key query '".concat(query, "' in overwrite because it already has a bind"));
	        if ((settings === null || settings === void 0 ? void 0 : settings.disableInElementsWithTags) != undefined)
	            settings.disableInElementsWithTags =
	                settings.disableInElementsWithTags.map(function (tagname) {
	                    return tagname.toUpperCase();
	                });
	        this.binds[query] = { callback: callback, key: key, settings: settings };
	    };
	    return KeyBinderOverwrite;
	}());
	KeyBinderOverwrite$1.KeyBinderOverwrite = KeyBinderOverwrite;

	var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
	    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
	        if (ar || !(i in from)) {
	            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
	            ar[i] = from[i];
	        }
	    }
	    return to.concat(ar || Array.prototype.slice.call(from));
	};
	Object.defineProperty(KeyBinderBase$1, "__esModule", { value: true });
	KeyBinderBase$1.KeyBinderBase = void 0;
	var KeyBinderOverwrite_1 = KeyBinderOverwrite$1;
	var KeyBinderBase = /** @class */ (function () {
	    function KeyBinderBase() {
	        this.binds = {};
	        this.overwrites = [];
	        this.log('Preparing KeyBinder');
	        this.registerListeners();
	    }
	    KeyBinderBase.prototype.log = function () {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i] = arguments[_i];
	        }
	        if (window.location.search.includes('debug'))
	            console.log.apply(console, __spreadArray(['[KeyBinder]'], args, false));
	    };
	    KeyBinderBase.prototype.multiBind = function (keys, callback, settings) {
	        for (var i = 0; i < keys.length; i++)
	            this.bind(keys[i], callback, settings);
	    };
	    KeyBinderBase.prototype.bind = function (key, callback, settings) {
	        if (settings == undefined)
	            settings = {};
	        var query = this.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
	        if (this.binds[query] != undefined)
	            return this.log("Unable to bind key query '".concat(query, "' because it already has a bind"));
	        if ((settings === null || settings === void 0 ? void 0 : settings.disableInElementsWithTags) != undefined)
	            settings.disableInElementsWithTags =
	                settings.disableInElementsWithTags.map(function (tagname) {
	                    return tagname.toUpperCase();
	                });
	        this.binds[query] = { callback: callback, key: key, settings: settings };
	    };
	    KeyBinderBase.prototype.unbind = function (key, settings) {
	        if (settings == undefined)
	            settings = {};
	        var query = this.createKeyQuery(key, settings.controlKey, settings.shiftKey, settings.altKey);
	        if (this.binds[query] == undefined)
	            return this.log("Unable to unbind key query '".concat(query, "' because it has no bind"));
	    };
	    KeyBinderBase.prototype.createOverwrite = function () {
	        var id = this.generateOverwriteId();
	        var overwrite = new KeyBinderOverwrite_1.KeyBinderOverwrite(id, this);
	        this.overwrites.push(overwrite);
	        this.log("Overwrite with id '".concat(id, "' was created"));
	        return overwrite;
	    };
	    KeyBinderBase.prototype.closeOverwrite = function (id) {
	        for (var i = 0; i < this.overwrites.length; i++)
	            if (this.overwrites[i].id == id) {
	                this.overwrites.splice(i, 1);
	                this.log("Overwrite with id '".concat(id, "' was closed"));
	                return;
	            }
	    };
	    KeyBinderBase.prototype.createKeyQuery = function (key, ctrlKey, shiftKey, altKey) {
	        if (ctrlKey === void 0) { ctrlKey = false; }
	        if (shiftKey === void 0) { shiftKey = false; }
	        if (altKey === void 0) { altKey = false; }
	        var queryParts = [key.toLowerCase()];
	        if (ctrlKey)
	            queryParts.push('ctrl');
	        if (shiftKey)
	            queryParts.push('shft');
	        if (altKey)
	            queryParts.push('alt');
	        return queryParts.join(':');
	    };
	    KeyBinderBase.prototype.getAllBinds = function () {
	        return Array.from(new Set(this.overwrites
	            .map(function (overwrite) { return Object.keys(overwrite.binds); })
	            .concat(Object.keys(this.binds))
	            .flat()));
	    };
	    KeyBinderBase.prototype.getBindsOverview = function () {
	        return Object.values(this.binds).map(function (_a) {
	            var key = _a.key, settings = _a.settings;
	            var combo = [];
	            if (settings === null || settings === void 0 ? void 0 : settings.controlKey)
	                combo.push('Ctrl');
	            if (settings === null || settings === void 0 ? void 0 : settings.shiftKey)
	                combo.push('Shift');
	            if (settings === null || settings === void 0 ? void 0 : settings.altKey)
	                combo.push('Alt');
	            combo.push(key.length < 3 ? key.toUpperCase() : key);
	            return [combo.join('+'), settings === null || settings === void 0 ? void 0 : settings.name];
	        });
	    };
	    KeyBinderBase.prototype.generateOverwriteId = function () {
	        while (true) {
	            var id = (Math.random() + 1).toString(36).substring(7);
	            if (!this.overwriteIdExists(id))
	                return id;
	        }
	    };
	    KeyBinderBase.prototype.overwriteIdExists = function (id) {
	        for (var i = 0; i < this.overwrites.length; i++)
	            if (this.overwrites[i].id == id)
	                return true;
	        return false;
	    };
	    KeyBinderBase.prototype.registerListeners = function () {
	        var _this = this;
	        window.addEventListener('keydown', function (e) {
	            var _a;
	            var query = _this.createKeyQuery(e.key, e.ctrlKey || e.metaKey, e.shiftKey, e.altKey);
	            if (window.location.search.includes('keydebug'))
	                _this.log("Got keypress: ".concat(query));
	            var binds = _this.binds;
	            if (_this.overwrites.length > 0) {
	                binds = _this.overwrites[_this.overwrites.length - 1].binds;
	            }
	            if (binds[query] == undefined)
	                return;
	            var bind = binds[query];
	            if (((_a = bind === null || bind === void 0 ? void 0 : bind.settings) === null || _a === void 0 ? void 0 : _a.disableInElementsWithTags) != undefined &&
	                bind.settings.disableInElementsWithTags.includes(document.activeElement.tagName))
	                return;
	            e.preventDefault();
	            bind.callback();
	        });
	    };
	    return KeyBinderBase;
	}());
	KeyBinderBase$1.KeyBinderBase = KeyBinderBase;

	Object.defineProperty(Morph_Keys, "__esModule", { value: true });
	Morph_Keys.MorphKey = void 0;
	var KeyBinderBase_1 = KeyBinderBase$1;
	Morph_Keys.MorphKey = new KeyBinderBase_1.KeyBinderBase();

	var __extends$7 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_ContextMenu, "__esModule", { value: true });
	Component_ContextMenu.ComponentContextMenu = void 0;
	var Morph_Keys_1 = Morph_Keys;
	var CE_1$7 = CE;
	var baseComponent_1$7 = baseComponent;
	var ComponentContextMenu = /** @class */ (function (_super) {
	    __extends$7(ComponentContextMenu, _super);
	    function ComponentContextMenu(options) {
	        var _a, _b;
	        var _this = _super.call(this) || this;
	        _this.open = true;
	        _this.container = (0, CE_1$7.ce)('div', 'mux_contextmenu');
	        if ((options === null || options === void 0 ? void 0 : options.width) != undefined) {
	            _this.container.style.minWidth = "".concat(options.width, "px");
	            _this.container.style.width = "".concat(options.width, "px");
	        }
	        var align = (_a = options === null || options === void 0 ? void 0 : options.align) !== null && _a !== void 0 ? _a : 'center';
	        if ((options === null || options === void 0 ? void 0 : options.materialIconColor) != undefined)
	            _this.container.style.setProperty('--mux-contextmenu-iconcolor', options.materialIconColor);
	        _this.setItems((_b = options === null || options === void 0 ? void 0 : options.items) !== null && _b !== void 0 ? _b : [], options === null || options === void 0 ? void 0 : options.selected);
	        var parentContainer = document.body;
	        parentContainer.appendChild(_this.container);
	        _this.container.style.top = "".concat(options.y - parentContainer.getBoundingClientRect().top, "px");
	        var left = options.x;
	        var maxLeft = document.body.clientWidth - _this.container.clientWidth - 20;
	        var minLeft = 10;
	        if (align == 'center') {
	            left -= _this.container.clientWidth / 2;
	            _this.container.style.transformOrigin = 'top center';
	        }
	        else if (align == 'left') {
	            _this.container.style.transformOrigin = 'top left';
	        }
	        else if (align == 'right') {
	            left -= _this.container.clientWidth;
	            _this.container.style.transformOrigin = 'top right';
	        }
	        left = Math.min(left, maxLeft);
	        left = Math.max(left, minLeft);
	        var maxHeight = document.body.clientHeight - options.y - 20;
	        _this.container.style.left = "".concat(left, "px");
	        _this.container.style.transitionDuration = '.2s';
	        _this.container.style.transform = 'scale(1)';
	        _this.container.style.opacity = '1';
	        _this.container.style.maxHeight = "".concat(maxHeight, "px");
	        if ((options === null || options === void 0 ? void 0 : options.highlightedItem) != undefined &&
	            _this.container.querySelector("[uid=\"".concat(options.highlightedItem, "\"]")) != null) {
	            var selected = _this.container.querySelector("[uid=\"".concat(options.highlightedItem, "\"]"));
	            selected.classList.add('mux_contextmenu-item-selected');
	            setTimeout(function () {
	                selected.scrollIntoView();
	            }, 100);
	        }
	        if ((options === null || options === void 0 ? void 0 : options.selected) != undefined &&
	            _this.container.querySelector("[uid=\"".concat(options.selected, "\"]")) != null) {
	            var selected = _this.container.querySelector("[uid=\"".concat(options.selected, "\"]"));
	            setTimeout(function () {
	                selected.scrollIntoView({
	                    block: 'center',
	                    inline: 'center',
	                });
	            }, 100);
	        }
	        var delay = function (duration, callback) {
	            setTimeout(function () {
	                callback();
	            }, duration);
	        };
	        _this.handleClick = function (e) {
	            var _a, _b;
	            if (e.target == undefined)
	                return delay(100, function () { return _this.close('outside'); });
	            var target = e.target;
	            if (target.classList.length == 0)
	                return delay(100, function () { return _this.close('outsideclick'); });
	            if (!target.classList[0].startsWith('mux_contextmenu') &&
	                !((_b = (_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.classList[0]) === null || _b === void 0 ? void 0 : _b.startsWith('mux_contextmenu')))
	                return delay(100, function () { return _this.close('outsideparentclick'); });
	        };
	        setTimeout(function () {
	            window.addEventListener('click', _this.handleClick);
	            window.addEventListener('mousedown', _this.handleClick);
	            window.addEventListener('touchstart', _this.handleClick);
	        }, 100);
	        _this.overwrite = Morph_Keys_1.MorphKey.createOverwrite();
	        if ((options === null || options === void 0 ? void 0 : options.highlightedItem) == undefined) {
	            _this.overwrite.bind('ArrowUp', function () {
	                var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
	                if (selected == null) {
	                    var elements = _this.container.querySelectorAll('.mux_contextmenu-item');
	                    if (elements.length > 0) {
	                        var first = elements[elements.length - 1];
	                        first.classList.add('mux_contextmenu-item-selected');
	                        first.scrollIntoView();
	                    }
	                }
	                else {
	                    var previous = selected.previousElementSibling;
	                    if (previous != null) {
	                        selected.classList.remove('mux_contextmenu-item-selected');
	                        previous.classList.add('mux_contextmenu-item-selected');
	                        previous.scrollIntoView();
	                    }
	                }
	            });
	            _this.overwrite.bind('ArrowDown', function () {
	                var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
	                if (selected == null) {
	                    var elements = _this.container.querySelectorAll('.mux_contextmenu-item');
	                    if (elements.length > 0) {
	                        var first = elements[0];
	                        first.classList.add('mux_contextmenu-item-selected');
	                        first.scrollIntoView();
	                    }
	                }
	                else {
	                    var next = selected.nextElementSibling;
	                    if (next != null) {
	                        selected.classList.remove('mux_contextmenu-item-selected');
	                        next.classList.add('mux_contextmenu-item-selected');
	                        next.scrollIntoView();
	                    }
	                }
	            });
	        }
	        _this.overwrite.bind('Enter', function () {
	            var selected = _this.container.querySelector('.mux_contextmenu-item-selected');
	            if (selected != null) {
	                selected.click();
	            }
	        });
	        _this.overwrite.bind('Escape', function () {
	            _this.close('escape');
	        });
	        return _this;
	    }
	    ComponentContextMenu.prototype.close = function (origin, byClick) {
	        var _this = this;
	        if (origin === void 0) { origin = 'integrator?'; }
	        if (byClick === void 0) { byClick = false; }
	        this.overwrite.close();
	        this.open = false;
	        this.killSubContexts();
	        window.removeEventListener('click', this.handleClick);
	        window.removeEventListener('mousedown', this.handleClick);
	        window.removeEventListener('touchstart', this.handleClick);
	        this.callEvent('close', byClick, origin);
	        this.container.style.transform = 'scale(0)';
	        this.container.style.opacity = '0';
	        setTimeout(function () {
	            _this.destroy();
	        }, 200);
	    };
	    ComponentContextMenu.prototype.enable = function (uniqueIdentifier) {
	        if (this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"))) {
	            var element = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
	            element.classList.remove('mux_contextmenu-item-disabled');
	        }
	    };
	    ComponentContextMenu.prototype.disable = function (uniqueIdentifier) {
	        if (this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"))) {
	            var element = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
	            element.classList.add('mux_contextmenu-item-disabled');
	        }
	    };
	    ComponentContextMenu.prototype.isOpen = function () {
	        return this.open;
	    };
	    ComponentContextMenu.prototype.setItems = function (items, selectedId) {
	        var _this = this;
	        this.container.innerHTML = '';
	        items.forEach(function (item) {
	            return _this.addItem(item, selectedId != null && selectedId == item.uniqueIdentifier);
	        });
	    };
	    ComponentContextMenu.prototype.addItem = function (item, selected) {
	        var _this = this;
	        var _a, _b, _c;
	        if (selected === void 0) { selected = false; }
	        switch (item.type) {
	            case 'separator':
	                var separator = (0, CE_1$7.ce)('div', 'mux_contextmenu-separator');
	                if (item.text != undefined && item.text.trim().length > 0)
	                    separator.appendChild((0, CE_1$7.ce)('span', null, null, item.text));
	                this.container.appendChild(separator);
	                break;
	            case 'normal':
	                var element = (0, CE_1$7.ce)(item.href != undefined ? 'a' : 'div', 'mux_contextmenu-item');
	                if (selected)
	                    element.classList.add('mux_contextmenu-item-selected');
	                var itemId = (_a = item.uniqueIdentifier) !== null && _a !== void 0 ? _a : (Math.random() + 1).toString(36).substring(7);
	                if (item.href != undefined)
	                    element.setAttribute('href', item.href);
	                if (item.tooltip != undefined)
	                    element.title = item.tooltip;
	                if (item.uniqueIdentifier != undefined) {
	                    element.setAttribute('uid', item.uniqueIdentifier);
	                }
	                if (item.enabled == false)
	                    element.classList.add('mux_contextmenu-item-disabled');
	                var textContent = (0, CE_1$7.ce)('div', 'mux_contextmenu-item-content');
	                element.appendChild(textContent);
	                var itemContent = (0, CE_1$7.ce)('div', ['mux_text', 'mux_small'], null, (_b = item.text) !== null && _b !== void 0 ? _b : '');
	                if (item.customFontSize != undefined)
	                    itemContent.style.fontSize = "".concat(item.customFontSize, "px");
	                textContent.appendChild(itemContent);
	                if (item.children == undefined && item.shortcut != undefined)
	                    textContent.appendChild((0, CE_1$7.ce)('div', [
	                        'mux_contextmenu-shortcut',
	                        'mux_text',
	                        'mux_tiny',
	                    ], null, (_c = item.shortcut) !== null && _c !== void 0 ? _c : ''));
	                if (item.children != undefined && item.children.length > 0) {
	                    textContent.appendChild((0, CE_1$7.ce)('span', [
	                        'material-symbols-outlined',
	                        'mux_contextmenu-item-arrow',
	                    ], null, 'keyboard_arrow_right'));
	                }
	                if (item.materialIcon != undefined) {
	                    var materialIcon = (0, CE_1$7.ce)('span', [
	                        'mux_contextmenu-item-materialicon',
	                        'material-symbols-outlined',
	                    ], null, item.materialIcon);
	                    if (item.materialIconTransform != undefined)
	                        materialIcon.style.transform =
	                            item.materialIconTransform;
	                    element.appendChild(materialIcon);
	                }
	                else if (item.icon != undefined)
	                    element.appendChild((0, CE_1$7.ce)('img', 'mux_contextmenu-item-icon', {
	                        src: item.icon,
	                    }));
	                element.onmousemove = function () {
	                    if (_this.subContextParent == itemId)
	                        return;
	                    _this.killSubContexts();
	                    if (item.children != undefined &&
	                        item.children.length > 0) {
	                        var bounds = element.getBoundingClientRect();
	                        _this.subContextParent = itemId;
	                        _this.subContext = new ComponentContextMenu({
	                            items: item.children,
	                            x: bounds.x + bounds.width + 1,
	                            y: bounds.y,
	                            align: 'left',
	                        });
	                        _this.subContext.on('close', function (byClick) {
	                            if (byClick)
	                                _this.close('parentkillchildhover', true);
	                        });
	                    }
	                };
	                if (item.click != undefined && item.href == undefined) {
	                    element.onclick = function () {
	                        if (item.stayOpenOnClick != true) {
	                            _this.close('itemclick', true);
	                            _this.killSubContexts();
	                        }
	                        item.click();
	                    };
	                }
	                this.container.appendChild(element);
	                break;
	        }
	    };
	    ComponentContextMenu.prototype.killSubContexts = function () {
	        if (this.subContext != null) {
	            this.subContext.close('parentkillchild');
	            this.subContext = null;
	        }
	        this.subContextParent = null;
	    };
	    return ComponentContextMenu;
	}(baseComponent_1$7.MUXComponent));
	Component_ContextMenu.ComponentContextMenu = ComponentContextMenu;

	var Component_Dialog = {};

	var hasRequiredComponent_Dialog;

	function requireComponent_Dialog () {
		if (hasRequiredComponent_Dialog) return Component_Dialog;
		hasRequiredComponent_Dialog = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Dialog, "__esModule", { value: true });
		Component_Dialog.ComponentDialog = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var ComponentDialog = /** @class */ (function (_super) {
		    __extends(ComponentDialog, _super);
		    function ComponentDialog(options) {
		        var _a, _b, _c, _d, _e, _f, _g, _h;
		        var _this = _super.call(this) || this;
		        var width = (_a = options === null || options === void 0 ? void 0 : options.width) !== null && _a !== void 0 ? _a : 'small';
		        var height = (_b = options === null || options === void 0 ? void 0 : options.height) !== null && _b !== void 0 ? _b : 'auto';
		        _this.container = (0, CE_1.ce)('div', 'mux_dialogcontainer');
		        _this.dialog = (0, CE_1.ce)('div', 'mux_dialog');
		        _this.dialog.classList.add("mux_w-".concat(width), "mux_h-".concat(height));
		        var openDialogs = document.querySelectorAll(".mux_dialog.mux_w-".concat(width, ".mux_h-").concat(height)).length;
		        _this.dialog.style.marginLeft = "".concat(openDialogs * 30, "px");
		        _this.dialog.style.marginTop = "".concat(openDialogs * 30, "px");
		        _this.container.append(_this.dialog);
		        var titlebar = (0, CE_1.ce)('div', 'mux_dialog-titlebar');
		        titlebar.appendChild((0, CE_1.ce)('div', ['mux_dialog-title', 'mux_header'], null, options.title));
		        var titlesettings = (0, CE_1.ce)('div', 'mux_dialog-titlesettings');
		        titlebar.appendChild(titlesettings);
		        _this.titlebar = titlesettings;
		        if ((options === null || options === void 0 ? void 0 : options.closeable) !== false) {
		            var close = (0, CE_1.ce)('div', 'mux_dialog-close');
		            close.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'close'));
		            close.onclick = function () {
		                _this.callEvent('close', new CloseEvent(_this));
		            };
		            titlebar.appendChild(close);
		        }
		        _this.dialog.appendChild(titlebar);
		        _this.content = (0, CE_1.ce)('div', 'mux_dialog-content');
		        _this.dialog.appendChild(_this.content);
		        var okButtonVisible = (_c = options === null || options === void 0 ? void 0 : options.okButtonVisible) !== null && _c !== void 0 ? _c : true;
		        var cancelButtonVisible = (_d = options === null || options === void 0 ? void 0 : options.cancelButtonVisible) !== null && _d !== void 0 ? _d : true;
		        if (okButtonVisible || cancelButtonVisible) {
		            var actionbar = (0, CE_1.ce)('div', 'mux_dialog-actionbar');
		            var buttons = (0, CE_1.ce)('div', 'mux_dialog-buttons');
		            if (cancelButtonVisible) {
		                var cancelButtonEnabled = (_e = options === null || options === void 0 ? void 0 : options.cancelButtonEnabled) !== null && _e !== void 0 ? _e : true;
		                _this.cancelButton = new Index_1.MorphComponent.Button({
		                    content: (_f = options === null || options === void 0 ? void 0 : options.cancelButtonText) !== null && _f !== void 0 ? _f : 'Cancel',
		                    mode: cancelButtonEnabled ? 'normal' : 'disabled',
		                    target: function () {
		                        _this.callEvent('cancel', new CloseEvent(_this));
		                    },
		                });
		                buttons.appendChild(_this.cancelButton.container);
		            }
		            if (okButtonVisible) {
		                var okButtonEnabled = (_g = options === null || options === void 0 ? void 0 : options.okButtonEnabled) !== null && _g !== void 0 ? _g : true;
		                _this.okButton = new Index_1.MorphComponent.Button({
		                    content: (_h = options === null || options === void 0 ? void 0 : options.okButtonText) !== null && _h !== void 0 ? _h : 'OK',
		                    mode: okButtonEnabled ? 'highlight' : 'disabled',
		                    target: function () {
		                        _this.callEvent('ok', new CloseEvent(_this));
		                    },
		                });
		                buttons.appendChild(_this.okButton.container);
		            }
		            actionbar.appendChild(buttons);
		            _this.dialog.appendChild(actionbar);
		        }
		        else
		            _this.content.classList.add('mux_dialog-content-nobuttons');
		        document.body.appendChild(_this.container);
		        setTimeout(function () {
		            _this.container.style.opacity = '1';
		            _this.dialog.style.opacity = '1';
		            _this.dialog.style.transform = 'scale(1)';
		        }, 20);
		        _this.keyOverwrite = Index_1.MorphKey.createOverwrite();
		        _this.keyOverwrite.bind('Escape', function () {
		            _this.callEvent('cancel', new CloseEvent(_this));
		        });
		        _this.keyOverwrite.bind('Enter', function () {
		            _this.callEvent('ok', new CloseEvent(_this));
		        });
		        return _this;
		    }
		    ComponentDialog.prototype.close = function () {
		        var _this = this;
		        this.dialog.style.transitionTimingFunction = 'ease-out';
		        this.dialog.style.transform = 'scale(0.8)';
		        this.dialog.style.opacity = '0';
		        this.container.style.opacity = '0';
		        this.container.style.pointerEvents = 'none';
		        this.keyOverwrite.close();
		        setTimeout(function () {
		            _this.destroy();
		        }, 200);
		    };
		    ComponentDialog.prototype.setOkButtonMode = function (mode) {
		        this.okButton.updateMode(mode);
		    };
		    ComponentDialog.prototype.setCancelButtonMode = function (mode) {
		        this.cancelButton.updateMode(mode);
		    };
		    return ComponentDialog;
		}(baseComponent_1.MUXComponent));
		Component_Dialog.ComponentDialog = ComponentDialog;
		var CloseEvent = /** @class */ (function () {
		    function DialogCloseEvent(origin) {
		        var _this = this;
		        this.origin = origin;
		        this.autoCloseInterval = setTimeout(function () {
		            _this.close();
		        }, 50);
		    }
		    DialogCloseEvent.prototype.preventClose = function () {
		        clearInterval(this.autoCloseInterval);
		    };
		    DialogCloseEvent.prototype.close = function () {
		        clearInterval(this.autoCloseInterval);
		        this.origin.close();
		    };
		    return DialogCloseEvent;
		}());
		
		return Component_Dialog;
	}

	var Component_Group = {};

	var __extends$6 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Group, "__esModule", { value: true });
	Component_Group.ComponentGroup = void 0;
	var CE_1$6 = CE;
	var baseComponent_1$6 = baseComponent;
	var ComponentGroup = /** @class */ (function (_super) {
	    __extends$6(ComponentGroup, _super);
	    function ComponentGroup(options) {
	        var _a, _b, _c;
	        var _this = _super.call(this) || this;
	        _this.container = (0, CE_1$6.ce)('div', ['mux_group', 'mux_group-open']);
	        var closeable = (_a = options === null || options === void 0 ? void 0 : options.closeable) !== null && _a !== void 0 ? _a : false;
	        if ((options === null || options === void 0 ? void 0 : options.open) == false && closeable) {
	            _this.container.classList.remove('mux_group-open');
	        }
	        var header = (0, CE_1$6.ce)('div', 'mux_group-header');
	        if ((options === null || options === void 0 ? void 0 : options.materialIcon) != undefined)
	            header.appendChild((0, CE_1$6.ce)('span', 'material-symbols-outlined', null, options.materialIcon));
	        _this.title = (0, CE_1$6.ce)('div', ['mux_header', 'mux_small'], null, (_b = options === null || options === void 0 ? void 0 : options.title) !== null && _b !== void 0 ? _b : '');
	        _this.subTitle = (0, CE_1$6.ce)('div', ['mux_text', 'mux_small'], null, (_c = options === null || options === void 0 ? void 0 : options.subTitle) !== null && _c !== void 0 ? _c : '');
	        header.append(_this.title, _this.subTitle);
	        if ((options === null || options === void 0 ? void 0 : options.actions) != undefined && options.actions.length > 0) {
	            var actions = (0, CE_1$6.ce)('div', 'mux_group-actions');
	            options.actions.forEach(function (action) {
	                var element = (0, CE_1$6.ce)('div', 'mux_group-iconbutton');
	                element.appendChild((0, CE_1$6.ce)('span', 'material-symbols-outlined', null, action.materialIcon));
	                element.onclick = function (e) {
	                    e.stopPropagation();
	                    action.click();
	                };
	                actions.appendChild(element);
	            });
	            header.appendChild(actions);
	        }
	        if (closeable) {
	            var foldIcon = (0, CE_1$6.ce)('span', ['material-symbols-outlined', 'mux_group-fold'], null, 'keyboard_arrow_right');
	            header.appendChild(foldIcon);
	            header.onclick = function () {
	                if (_this.container.classList.contains('mux_group-open'))
	                    _this.container.classList.remove('mux_group-open');
	                else
	                    _this.container.classList.add('mux_group-open');
	                _this.callEvent('openState', _this.container.classList.contains('mux_group-open'));
	            };
	        }
	        _this.container.appendChild(header);
	        _this.content = (0, CE_1$6.ce)('div', 'mux_group-content');
	        var contentwrapper = (0, CE_1$6.ce)('div', 'mux_group-contentwrapper');
	        contentwrapper.appendChild(_this.content);
	        _this.container.appendChild(contentwrapper);
	        return _this;
	    }
	    ComponentGroup.prototype.setTitle = function (title) {
	        this.title.innerText = title !== null && title !== void 0 ? title : '';
	    };
	    ComponentGroup.prototype.setSubTitle = function (subTitle) {
	        this.subTitle.innerText = subTitle !== null && subTitle !== void 0 ? subTitle : '';
	    };
	    return ComponentGroup;
	}(baseComponent_1$6.MUXComponent));
	Component_Group.ComponentGroup = ComponentGroup;

	var Component_Header = {};

	var __extends$5 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Header, "__esModule", { value: true });
	Component_Header.ComponentHeader = void 0;
	var CE_1$5 = CE;
	var baseComponent_1$5 = baseComponent;
	var ComponentHeader = /** @class */ (function (_super) {
	    __extends$5(ComponentHeader, _super);
	    function ComponentHeader(options) {
	        var _a;
	        var _this = _super.call(this) || this;
	        var size = (_a = options === null || options === void 0 ? void 0 : options.size) !== null && _a !== void 0 ? _a : 'normal';
	        _this.container = (0, CE_1$5.ce)('div', ['mux_header', "mux_".concat(size)], null, options === null || options === void 0 ? void 0 : options.content);
	        return _this;
	    }
	    ComponentHeader.prototype.update = function (content) {
	        this.container.innerHTML = content;
	    };
	    return ComponentHeader;
	}(baseComponent_1$5.MUXComponent));
	Component_Header.ComponentHeader = ComponentHeader;

	var Component_IconGrid = {};

	var __extends$4 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_IconGrid, "__esModule", { value: true });
	Component_IconGrid.ComponentIconGrid = void 0;
	var CE_1$4 = CE;
	var baseComponent_1$4 = baseComponent;
	var Sortable = SortableExports;
	var ComponentIconGrid = /** @class */ (function (_super) {
	    __extends$4(ComponentIconGrid, _super);
	    function ComponentIconGrid(options) {
	        var _a;
	        var _this = _super.call(this) || this;
	        _this.container = (0, CE_1$4.ce)('div', 'mux_icongrid');
	        if ((options === null || options === void 0 ? void 0 : options.sortable) === true) {
	            _this.sortable = new Sortable(_this.container, {
	                ghostClass: 'mux_icongrid-item-dragging',
	                onStart: function () {
	                    _this.container.classList.add('mux_icongrid-dragging');
	                },
	                onEnd: function (evt) {
	                    _this.container.classList.remove('mux_icongrid-dragging');
	                    _this.callEvent('orderUpdated', _this.getOrder());
	                },
	            });
	        }
	        _this.setItems((_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : []);
	        return _this;
	    }
	    ComponentIconGrid.prototype.setItems = function (items) {
	        var _this = this;
	        this.container.innerHTML = '';
	        items.forEach(function (item) { return _this.addItem(item); });
	    };
	    ComponentIconGrid.prototype.addItem = function (item) {
	        var element = (0, CE_1$4.ce)('div', 'mux_icongrid-item');
	        if (item.uniqueIdentifier != undefined)
	            element.setAttribute('uid', item.uniqueIdentifier);
	        if (!item.enabled)
	            element.classList.add('mux_icongrid-item-disabled');
	        if (item.click != undefined)
	            element.onclick = item.click;
	        if (item.materialIcon != undefined)
	            element.appendChild((0, CE_1$4.ce)('span', ['mux_icongrid-item-icon', 'material-symbols-outline'], null, item.materialIcon));
	        else if (item.icon != undefined)
	            element.appendChild((0, CE_1$4.ce)('img', 'mux_icongrid-item-icon', { src: item.icon }));
	        element.appendChild((0, CE_1$4.ce)('div', ['mux_text', 'mux_small'], null, item.text));
	        this.container.appendChild(element);
	    };
	    ComponentIconGrid.prototype.getOrder = function () {
	        return Array.from(this.container.querySelectorAll('.mux_icongrid-item')).map(function (item) { return item.getAttribute('uid'); });
	    };
	    ComponentIconGrid.prototype.enable = function (uniqueIdentifier) {
	        var item = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
	        if (item != undefined)
	            item.classList.remove('mux_icongrid-item-disabled');
	    };
	    ComponentIconGrid.prototype.disable = function (uniqueIdentifier) {
	        var item = this.container.querySelector("[uid=\"".concat(uniqueIdentifier, "\"]"));
	        if (item != undefined)
	            item.classList.add('mux_icongrid-item-disabled');
	    };
	    return ComponentIconGrid;
	}(baseComponent_1$4.MUXComponent));
	Component_IconGrid.ComponentIconGrid = ComponentIconGrid;

	var Component_ImageViewer = {};

	/*! Hammer.JS - v2.0.17-rc - 2019-12-16
	 * http://naver.github.io/egjs
	 *
	 * Forked By Naver egjs
	 * Copyright (c) hammerjs
	 * Licensed under the MIT license */
	function _extends() {
	  _extends = Object.assign || function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];

	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }

	    return target;
	  };

	  return _extends.apply(this, arguments);
	}

	function _inheritsLoose(subClass, superClass) {
	  subClass.prototype = Object.create(superClass.prototype);
	  subClass.prototype.constructor = subClass;
	  subClass.__proto__ = superClass;
	}

	function _assertThisInitialized(self) {
	  if (self === void 0) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }

	  return self;
	}

	/**
	 * @private
	 * extend object.
	 * means that properties in dest will be overwritten by the ones in src.
	 * @param {Object} target
	 * @param {...Object} objects_to_assign
	 * @returns {Object} target
	 */
	var assign;

	if (typeof Object.assign !== 'function') {
	  assign = function assign(target) {
	    if (target === undefined || target === null) {
	      throw new TypeError('Cannot convert undefined or null to object');
	    }

	    var output = Object(target);

	    for (var index = 1; index < arguments.length; index++) {
	      var source = arguments[index];

	      if (source !== undefined && source !== null) {
	        for (var nextKey in source) {
	          if (source.hasOwnProperty(nextKey)) {
	            output[nextKey] = source[nextKey];
	          }
	        }
	      }
	    }

	    return output;
	  };
	} else {
	  assign = Object.assign;
	}

	var assign$1 = assign;

	var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
	var TEST_ELEMENT = typeof document === "undefined" ? {
	  style: {}
	} : document.createElement('div');
	var TYPE_FUNCTION = 'function';
	var round = Math.round,
	    abs = Math.abs;
	var now = Date.now;

	/**
	 * @private
	 * get the prefixed property
	 * @param {Object} obj
	 * @param {String} property
	 * @returns {String|Undefined} prefixed
	 */

	function prefixed(obj, property) {
	  var prefix;
	  var prop;
	  var camelProp = property[0].toUpperCase() + property.slice(1);
	  var i = 0;

	  while (i < VENDOR_PREFIXES.length) {
	    prefix = VENDOR_PREFIXES[i];
	    prop = prefix ? prefix + camelProp : property;

	    if (prop in obj) {
	      return prop;
	    }

	    i++;
	  }

	  return undefined;
	}

	/* eslint-disable no-new-func, no-nested-ternary */
	var win;

	if (typeof window === "undefined") {
	  // window is undefined in node.js
	  win = {};
	} else {
	  win = window;
	}

	var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
	var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
	function getTouchActionProps() {
	  if (!NATIVE_TOUCH_ACTION) {
	    return false;
	  }

	  var touchMap = {};
	  var cssSupports = win.CSS && win.CSS.supports;
	  ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function (val) {
	    // If css.supports is not supported but there is native touch-action assume it supports
	    // all values. This is the case for IE 10 and 11.
	    return touchMap[val] = cssSupports ? win.CSS.supports('touch-action', val) : true;
	  });
	  return touchMap;
	}

	var TOUCH_ACTION_COMPUTE = 'compute';
	var TOUCH_ACTION_AUTO = 'auto';
	var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented

	var TOUCH_ACTION_NONE = 'none';
	var TOUCH_ACTION_PAN_X = 'pan-x';
	var TOUCH_ACTION_PAN_Y = 'pan-y';
	var TOUCH_ACTION_MAP = getTouchActionProps();

	var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
	var SUPPORT_TOUCH = 'ontouchstart' in win;
	var SUPPORT_POINTER_EVENTS = prefixed(win, 'PointerEvent') !== undefined;
	var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
	var INPUT_TYPE_TOUCH = 'touch';
	var INPUT_TYPE_PEN = 'pen';
	var INPUT_TYPE_MOUSE = 'mouse';
	var INPUT_TYPE_KINECT = 'kinect';
	var COMPUTE_INTERVAL = 25;
	var INPUT_START = 1;
	var INPUT_MOVE = 2;
	var INPUT_END = 4;
	var INPUT_CANCEL = 8;
	var DIRECTION_NONE = 1;
	var DIRECTION_LEFT = 2;
	var DIRECTION_RIGHT = 4;
	var DIRECTION_UP = 8;
	var DIRECTION_DOWN = 16;
	var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
	var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
	var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
	var PROPS_XY = ['x', 'y'];
	var PROPS_CLIENT_XY = ['clientX', 'clientY'];

	/**
	 * @private
	 * walk objects and arrays
	 * @param {Object} obj
	 * @param {Function} iterator
	 * @param {Object} context
	 */
	function each(obj, iterator, context) {
	  var i;

	  if (!obj) {
	    return;
	  }

	  if (obj.forEach) {
	    obj.forEach(iterator, context);
	  } else if (obj.length !== undefined) {
	    i = 0;

	    while (i < obj.length) {
	      iterator.call(context, obj[i], i, obj);
	      i++;
	    }
	  } else {
	    for (i in obj) {
	      obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
	    }
	  }
	}

	/**
	 * @private
	 * let a boolean value also be a function that must return a boolean
	 * this first item in args will be used as the context
	 * @param {Boolean|Function} val
	 * @param {Array} [args]
	 * @returns {Boolean}
	 */

	function boolOrFn(val, args) {
	  if (typeof val === TYPE_FUNCTION) {
	    return val.apply(args ? args[0] || undefined : undefined, args);
	  }

	  return val;
	}

	/**
	 * @private
	 * small indexOf wrapper
	 * @param {String} str
	 * @param {String} find
	 * @returns {Boolean} found
	 */
	function inStr(str, find) {
	  return str.indexOf(find) > -1;
	}

	/**
	 * @private
	 * when the touchActions are collected they are not a valid value, so we need to clean things up. *
	 * @param {String} actions
	 * @returns {*}
	 */

	function cleanTouchActions(actions) {
	  // none
	  if (inStr(actions, TOUCH_ACTION_NONE)) {
	    return TOUCH_ACTION_NONE;
	  }

	  var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
	  var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y); // if both pan-x and pan-y are set (different recognizers
	  // for different directions, e.g. horizontal pan but vertical swipe?)
	  // we need none (as otherwise with pan-x pan-y combined none of these
	  // recognizers will work, since the browser would handle all panning

	  if (hasPanX && hasPanY) {
	    return TOUCH_ACTION_NONE;
	  } // pan-x OR pan-y


	  if (hasPanX || hasPanY) {
	    return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
	  } // manipulation


	  if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
	    return TOUCH_ACTION_MANIPULATION;
	  }

	  return TOUCH_ACTION_AUTO;
	}

	/**
	 * @private
	 * Touch Action
	 * sets the touchAction property or uses the js alternative
	 * @param {Manager} manager
	 * @param {String} value
	 * @constructor
	 */

	var TouchAction =
	/*#__PURE__*/
	function () {
	  function TouchAction(manager, value) {
	    this.manager = manager;
	    this.set(value);
	  }
	  /**
	   * @private
	   * set the touchAction value on the element or enable the polyfill
	   * @param {String} value
	   */


	  var _proto = TouchAction.prototype;

	  _proto.set = function set(value) {
	    // find out the touch-action by the event handlers
	    if (value === TOUCH_ACTION_COMPUTE) {
	      value = this.compute();
	    }

	    if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
	      this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
	    }

	    this.actions = value.toLowerCase().trim();
	  };
	  /**
	   * @private
	   * just re-set the touchAction value
	   */


	  _proto.update = function update() {
	    this.set(this.manager.options.touchAction);
	  };
	  /**
	   * @private
	   * compute the value for the touchAction property based on the recognizer's settings
	   * @returns {String} value
	   */


	  _proto.compute = function compute() {
	    var actions = [];
	    each(this.manager.recognizers, function (recognizer) {
	      if (boolOrFn(recognizer.options.enable, [recognizer])) {
	        actions = actions.concat(recognizer.getTouchAction());
	      }
	    });
	    return cleanTouchActions(actions.join(' '));
	  };
	  /**
	   * @private
	   * this method is called on each input cycle and provides the preventing of the browser behavior
	   * @param {Object} input
	   */


	  _proto.preventDefaults = function preventDefaults(input) {
	    var srcEvent = input.srcEvent;
	    var direction = input.offsetDirection; // if the touch action did prevented once this session

	    if (this.manager.session.prevented) {
	      srcEvent.preventDefault();
	      return;
	    }

	    var actions = this.actions;
	    var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
	    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
	    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];

	    if (hasNone) {
	      // do not prevent defaults if this is a tap gesture
	      var isTapPointer = input.pointers.length === 1;
	      var isTapMovement = input.distance < 2;
	      var isTapTouchTime = input.deltaTime < 250;

	      if (isTapPointer && isTapMovement && isTapTouchTime) {
	        return;
	      }
	    }

	    if (hasPanX && hasPanY) {
	      // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
	      return;
	    }

	    if (hasNone || hasPanY && direction & DIRECTION_HORIZONTAL || hasPanX && direction & DIRECTION_VERTICAL) {
	      return this.preventSrc(srcEvent);
	    }
	  };
	  /**
	   * @private
	   * call preventDefault to prevent the browser's default behavior (scrolling in most cases)
	   * @param {Object} srcEvent
	   */


	  _proto.preventSrc = function preventSrc(srcEvent) {
	    this.manager.session.prevented = true;
	    srcEvent.preventDefault();
	  };

	  return TouchAction;
	}();

	/**
	 * @private
	 * find if a node is in the given parent
	 * @method hasParent
	 * @param {HTMLElement} node
	 * @param {HTMLElement} parent
	 * @return {Boolean} found
	 */
	function hasParent(node, parent) {
	  while (node) {
	    if (node === parent) {
	      return true;
	    }

	    node = node.parentNode;
	  }

	  return false;
	}

	/**
	 * @private
	 * get the center of all the pointers
	 * @param {Array} pointers
	 * @return {Object} center contains `x` and `y` properties
	 */

	function getCenter(pointers) {
	  var pointersLength = pointers.length; // no need to loop when only one touch

	  if (pointersLength === 1) {
	    return {
	      x: round(pointers[0].clientX),
	      y: round(pointers[0].clientY)
	    };
	  }

	  var x = 0;
	  var y = 0;
	  var i = 0;

	  while (i < pointersLength) {
	    x += pointers[i].clientX;
	    y += pointers[i].clientY;
	    i++;
	  }

	  return {
	    x: round(x / pointersLength),
	    y: round(y / pointersLength)
	  };
	}

	/**
	 * @private
	 * create a simple clone from the input used for storage of firstInput and firstMultiple
	 * @param {Object} input
	 * @returns {Object} clonedInputData
	 */

	function simpleCloneInputData(input) {
	  // make a simple copy of the pointers because we will get a reference if we don't
	  // we only need clientXY for the calculations
	  var pointers = [];
	  var i = 0;

	  while (i < input.pointers.length) {
	    pointers[i] = {
	      clientX: round(input.pointers[i].clientX),
	      clientY: round(input.pointers[i].clientY)
	    };
	    i++;
	  }

	  return {
	    timeStamp: now(),
	    pointers: pointers,
	    center: getCenter(pointers),
	    deltaX: input.deltaX,
	    deltaY: input.deltaY
	  };
	}

	/**
	 * @private
	 * calculate the absolute distance between two points
	 * @param {Object} p1 {x, y}
	 * @param {Object} p2 {x, y}
	 * @param {Array} [props] containing x and y keys
	 * @return {Number} distance
	 */

	function getDistance(p1, p2, props) {
	  if (!props) {
	    props = PROPS_XY;
	  }

	  var x = p2[props[0]] - p1[props[0]];
	  var y = p2[props[1]] - p1[props[1]];
	  return Math.sqrt(x * x + y * y);
	}

	/**
	 * @private
	 * calculate the angle between two coordinates
	 * @param {Object} p1
	 * @param {Object} p2
	 * @param {Array} [props] containing x and y keys
	 * @return {Number} angle
	 */

	function getAngle(p1, p2, props) {
	  if (!props) {
	    props = PROPS_XY;
	  }

	  var x = p2[props[0]] - p1[props[0]];
	  var y = p2[props[1]] - p1[props[1]];
	  return Math.atan2(y, x) * 180 / Math.PI;
	}

	/**
	 * @private
	 * get the direction between two points
	 * @param {Number} x
	 * @param {Number} y
	 * @return {Number} direction
	 */

	function getDirection(x, y) {
	  if (x === y) {
	    return DIRECTION_NONE;
	  }

	  if (abs(x) >= abs(y)) {
	    return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
	  }

	  return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
	}

	function computeDeltaXY(session, input) {
	  var center = input.center; // let { offsetDelta:offset = {}, prevDelta = {}, prevInput = {} } = session;
	  // jscs throwing error on defalut destructured values and without defaults tests fail

	  var offset = session.offsetDelta || {};
	  var prevDelta = session.prevDelta || {};
	  var prevInput = session.prevInput || {};

	  if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
	    prevDelta = session.prevDelta = {
	      x: prevInput.deltaX || 0,
	      y: prevInput.deltaY || 0
	    };
	    offset = session.offsetDelta = {
	      x: center.x,
	      y: center.y
	    };
	  }

	  input.deltaX = prevDelta.x + (center.x - offset.x);
	  input.deltaY = prevDelta.y + (center.y - offset.y);
	}

	/**
	 * @private
	 * calculate the velocity between two points. unit is in px per ms.
	 * @param {Number} deltaTime
	 * @param {Number} x
	 * @param {Number} y
	 * @return {Object} velocity `x` and `y`
	 */
	function getVelocity(deltaTime, x, y) {
	  return {
	    x: x / deltaTime || 0,
	    y: y / deltaTime || 0
	  };
	}

	/**
	 * @private
	 * calculate the scale factor between two pointersets
	 * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
	 * @param {Array} start array of pointers
	 * @param {Array} end array of pointers
	 * @return {Number} scale
	 */

	function getScale(start, end) {
	  return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
	}

	/**
	 * @private
	 * calculate the rotation degrees between two pointersets
	 * @param {Array} start array of pointers
	 * @param {Array} end array of pointers
	 * @return {Number} rotation
	 */

	function getRotation(start, end) {
	  return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
	}

	/**
	 * @private
	 * velocity is calculated every x ms
	 * @param {Object} session
	 * @param {Object} input
	 */

	function computeIntervalInputData(session, input) {
	  var last = session.lastInterval || input;
	  var deltaTime = input.timeStamp - last.timeStamp;
	  var velocity;
	  var velocityX;
	  var velocityY;
	  var direction;

	  if (input.eventType !== INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
	    var deltaX = input.deltaX - last.deltaX;
	    var deltaY = input.deltaY - last.deltaY;
	    var v = getVelocity(deltaTime, deltaX, deltaY);
	    velocityX = v.x;
	    velocityY = v.y;
	    velocity = abs(v.x) > abs(v.y) ? v.x : v.y;
	    direction = getDirection(deltaX, deltaY);
	    session.lastInterval = input;
	  } else {
	    // use latest velocity info if it doesn't overtake a minimum period
	    velocity = last.velocity;
	    velocityX = last.velocityX;
	    velocityY = last.velocityY;
	    direction = last.direction;
	  }

	  input.velocity = velocity;
	  input.velocityX = velocityX;
	  input.velocityY = velocityY;
	  input.direction = direction;
	}

	/**
	* @private
	 * extend the data with some usable properties like scale, rotate, velocity etc
	 * @param {Object} manager
	 * @param {Object} input
	 */

	function computeInputData(manager, input) {
	  var session = manager.session;
	  var pointers = input.pointers;
	  var pointersLength = pointers.length; // store the first input to calculate the distance and direction

	  if (!session.firstInput) {
	    session.firstInput = simpleCloneInputData(input);
	  } // to compute scale and rotation we need to store the multiple touches


	  if (pointersLength > 1 && !session.firstMultiple) {
	    session.firstMultiple = simpleCloneInputData(input);
	  } else if (pointersLength === 1) {
	    session.firstMultiple = false;
	  }

	  var firstInput = session.firstInput,
	      firstMultiple = session.firstMultiple;
	  var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
	  var center = input.center = getCenter(pointers);
	  input.timeStamp = now();
	  input.deltaTime = input.timeStamp - firstInput.timeStamp;
	  input.angle = getAngle(offsetCenter, center);
	  input.distance = getDistance(offsetCenter, center);
	  computeDeltaXY(session, input);
	  input.offsetDirection = getDirection(input.deltaX, input.deltaY);
	  var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
	  input.overallVelocityX = overallVelocity.x;
	  input.overallVelocityY = overallVelocity.y;
	  input.overallVelocity = abs(overallVelocity.x) > abs(overallVelocity.y) ? overallVelocity.x : overallVelocity.y;
	  input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
	  input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
	  input.maxPointers = !session.prevInput ? input.pointers.length : input.pointers.length > session.prevInput.maxPointers ? input.pointers.length : session.prevInput.maxPointers;
	  computeIntervalInputData(session, input); // find the correct target

	  var target = manager.element;
	  var srcEvent = input.srcEvent;
	  var srcEventTarget;

	  if (srcEvent.composedPath) {
	    srcEventTarget = srcEvent.composedPath()[0];
	  } else if (srcEvent.path) {
	    srcEventTarget = srcEvent.path[0];
	  } else {
	    srcEventTarget = srcEvent.target;
	  }

	  if (hasParent(srcEventTarget, target)) {
	    target = srcEventTarget;
	  }

	  input.target = target;
	}

	/**
	 * @private
	 * handle input events
	 * @param {Manager} manager
	 * @param {String} eventType
	 * @param {Object} input
	 */

	function inputHandler(manager, eventType, input) {
	  var pointersLen = input.pointers.length;
	  var changedPointersLen = input.changedPointers.length;
	  var isFirst = eventType & INPUT_START && pointersLen - changedPointersLen === 0;
	  var isFinal = eventType & (INPUT_END | INPUT_CANCEL) && pointersLen - changedPointersLen === 0;
	  input.isFirst = !!isFirst;
	  input.isFinal = !!isFinal;

	  if (isFirst) {
	    manager.session = {};
	  } // source event is the normalized value of the domEvents
	  // like 'touchstart, mouseup, pointerdown'


	  input.eventType = eventType; // compute scale, rotation etc

	  computeInputData(manager, input); // emit secret event

	  manager.emit('hammer.input', input);
	  manager.recognize(input);
	  manager.session.prevInput = input;
	}

	/**
	 * @private
	 * split string on whitespace
	 * @param {String} str
	 * @returns {Array} words
	 */
	function splitStr(str) {
	  return str.trim().split(/\s+/g);
	}

	/**
	 * @private
	 * addEventListener with multiple events at once
	 * @param {EventTarget} target
	 * @param {String} types
	 * @param {Function} handler
	 */

	function addEventListeners(target, types, handler) {
	  each(splitStr(types), function (type) {
	    target.addEventListener(type, handler, false);
	  });
	}

	/**
	 * @private
	 * removeEventListener with multiple events at once
	 * @param {EventTarget} target
	 * @param {String} types
	 * @param {Function} handler
	 */

	function removeEventListeners(target, types, handler) {
	  each(splitStr(types), function (type) {
	    target.removeEventListener(type, handler, false);
	  });
	}

	/**
	 * @private
	 * get the window object of an element
	 * @param {HTMLElement} element
	 * @returns {DocumentView|Window}
	 */
	function getWindowForElement(element) {
	  var doc = element.ownerDocument || element;
	  return doc.defaultView || doc.parentWindow || window;
	}

	/**
	 * @private
	 * create new input type manager
	 * @param {Manager} manager
	 * @param {Function} callback
	 * @returns {Input}
	 * @constructor
	 */

	var Input =
	/*#__PURE__*/
	function () {
	  function Input(manager, callback) {
	    var self = this;
	    this.manager = manager;
	    this.callback = callback;
	    this.element = manager.element;
	    this.target = manager.options.inputTarget; // smaller wrapper around the handler, for the scope and the enabled state of the manager,
	    // so when disabled the input events are completely bypassed.

	    this.domHandler = function (ev) {
	      if (boolOrFn(manager.options.enable, [manager])) {
	        self.handler(ev);
	      }
	    };

	    this.init();
	  }
	  /**
	   * @private
	   * should handle the inputEvent data and trigger the callback
	   * @virtual
	   */


	  var _proto = Input.prototype;

	  _proto.handler = function handler() {};
	  /**
	   * @private
	   * bind the events
	   */


	  _proto.init = function init() {
	    this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
	    this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
	    this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
	  };
	  /**
	   * @private
	   * unbind the events
	   */


	  _proto.destroy = function destroy() {
	    this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
	    this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
	    this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
	  };

	  return Input;
	}();

	/**
	 * @private
	 * find if a array contains the object using indexOf or a simple polyFill
	 * @param {Array} src
	 * @param {String} find
	 * @param {String} [findByKey]
	 * @return {Boolean|Number} false when not found, or the index
	 */
	function inArray(src, find, findByKey) {
	  if (src.indexOf && !findByKey) {
	    return src.indexOf(find);
	  } else {
	    var i = 0;

	    while (i < src.length) {
	      if (findByKey && src[i][findByKey] == find || !findByKey && src[i] === find) {
	        // do not use === here, test fails
	        return i;
	      }

	      i++;
	    }

	    return -1;
	  }
	}

	var POINTER_INPUT_MAP = {
	  pointerdown: INPUT_START,
	  pointermove: INPUT_MOVE,
	  pointerup: INPUT_END,
	  pointercancel: INPUT_CANCEL,
	  pointerout: INPUT_CANCEL
	}; // in IE10 the pointer types is defined as an enum

	var IE10_POINTER_TYPE_ENUM = {
	  2: INPUT_TYPE_TOUCH,
	  3: INPUT_TYPE_PEN,
	  4: INPUT_TYPE_MOUSE,
	  5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816

	};
	var POINTER_ELEMENT_EVENTS = 'pointerdown';
	var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel'; // IE10 has prefixed support, and case-sensitive

	if (win.MSPointerEvent && !win.PointerEvent) {
	  POINTER_ELEMENT_EVENTS = 'MSPointerDown';
	  POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
	}
	/**
	 * @private
	 * Pointer events input
	 * @constructor
	 * @extends Input
	 */


	var PointerEventInput =
	/*#__PURE__*/
	function (_Input) {
	  _inheritsLoose(PointerEventInput, _Input);

	  function PointerEventInput() {
	    var _this;

	    var proto = PointerEventInput.prototype;
	    proto.evEl = POINTER_ELEMENT_EVENTS;
	    proto.evWin = POINTER_WINDOW_EVENTS;
	    _this = _Input.apply(this, arguments) || this;
	    _this.store = _this.manager.session.pointerEvents = [];
	    return _this;
	  }
	  /**
	   * @private
	   * handle mouse events
	   * @param {Object} ev
	   */


	  var _proto = PointerEventInput.prototype;

	  _proto.handler = function handler(ev) {
	    var store = this.store;
	    var removePointer = false;
	    var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
	    var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
	    var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
	    var isTouch = pointerType === INPUT_TYPE_TOUCH; // get index of the event in the store

	    var storeIndex = inArray(store, ev.pointerId, 'pointerId'); // start and mouse must be down

	    if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
	      if (storeIndex < 0) {
	        store.push(ev);
	        storeIndex = store.length - 1;
	      }
	    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
	      removePointer = true;
	    } // it not found, so the pointer hasn't been down (so it's probably a hover)


	    if (storeIndex < 0) {
	      return;
	    } // update the event in the store


	    store[storeIndex] = ev;
	    this.callback(this.manager, eventType, {
	      pointers: store,
	      changedPointers: [ev],
	      pointerType: pointerType,
	      srcEvent: ev
	    });

	    if (removePointer) {
	      // remove from the store
	      store.splice(storeIndex, 1);
	    }
	  };

	  return PointerEventInput;
	}(Input);

	/**
	 * @private
	 * convert array-like objects to real arrays
	 * @param {Object} obj
	 * @returns {Array}
	 */
	function toArray(obj) {
	  return Array.prototype.slice.call(obj, 0);
	}

	/**
	 * @private
	 * unique array with objects based on a key (like 'id') or just by the array's value
	 * @param {Array} src [{id:1},{id:2},{id:1}]
	 * @param {String} [key]
	 * @param {Boolean} [sort=False]
	 * @returns {Array} [{id:1},{id:2}]
	 */

	function uniqueArray(src, key, sort) {
	  var results = [];
	  var values = [];
	  var i = 0;

	  while (i < src.length) {
	    var val = key ? src[i][key] : src[i];

	    if (inArray(values, val) < 0) {
	      results.push(src[i]);
	    }

	    values[i] = val;
	    i++;
	  }

	  if (sort) {
	    if (!key) {
	      results = results.sort();
	    } else {
	      results = results.sort(function (a, b) {
	        return a[key] > b[key];
	      });
	    }
	  }

	  return results;
	}

	var TOUCH_INPUT_MAP = {
	  touchstart: INPUT_START,
	  touchmove: INPUT_MOVE,
	  touchend: INPUT_END,
	  touchcancel: INPUT_CANCEL
	};
	var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
	/**
	 * @private
	 * Multi-user touch events input
	 * @constructor
	 * @extends Input
	 */

	var TouchInput =
	/*#__PURE__*/
	function (_Input) {
	  _inheritsLoose(TouchInput, _Input);

	  function TouchInput() {
	    var _this;

	    TouchInput.prototype.evTarget = TOUCH_TARGET_EVENTS;
	    _this = _Input.apply(this, arguments) || this;
	    _this.targetIds = {}; // this.evTarget = TOUCH_TARGET_EVENTS;

	    return _this;
	  }

	  var _proto = TouchInput.prototype;

	  _proto.handler = function handler(ev) {
	    var type = TOUCH_INPUT_MAP[ev.type];
	    var touches = getTouches.call(this, ev, type);

	    if (!touches) {
	      return;
	    }

	    this.callback(this.manager, type, {
	      pointers: touches[0],
	      changedPointers: touches[1],
	      pointerType: INPUT_TYPE_TOUCH,
	      srcEvent: ev
	    });
	  };

	  return TouchInput;
	}(Input);

	function getTouches(ev, type) {
	  var allTouches = toArray(ev.touches);
	  var targetIds = this.targetIds; // when there is only one touch, the process can be simplified

	  if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
	    targetIds[allTouches[0].identifier] = true;
	    return [allTouches, allTouches];
	  }

	  var i;
	  var targetTouches;
	  var changedTouches = toArray(ev.changedTouches);
	  var changedTargetTouches = [];
	  var target = this.target; // get target touches from touches

	  targetTouches = allTouches.filter(function (touch) {
	    return hasParent(touch.target, target);
	  }); // collect touches

	  if (type === INPUT_START) {
	    i = 0;

	    while (i < targetTouches.length) {
	      targetIds[targetTouches[i].identifier] = true;
	      i++;
	    }
	  } // filter changed touches to only contain touches that exist in the collected target ids


	  i = 0;

	  while (i < changedTouches.length) {
	    if (targetIds[changedTouches[i].identifier]) {
	      changedTargetTouches.push(changedTouches[i]);
	    } // cleanup removed touches


	    if (type & (INPUT_END | INPUT_CANCEL)) {
	      delete targetIds[changedTouches[i].identifier];
	    }

	    i++;
	  }

	  if (!changedTargetTouches.length) {
	    return;
	  }

	  return [// merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
	  uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true), changedTargetTouches];
	}

	var MOUSE_INPUT_MAP = {
	  mousedown: INPUT_START,
	  mousemove: INPUT_MOVE,
	  mouseup: INPUT_END
	};
	var MOUSE_ELEMENT_EVENTS = 'mousedown';
	var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
	/**
	 * @private
	 * Mouse events input
	 * @constructor
	 * @extends Input
	 */

	var MouseInput =
	/*#__PURE__*/
	function (_Input) {
	  _inheritsLoose(MouseInput, _Input);

	  function MouseInput() {
	    var _this;

	    var proto = MouseInput.prototype;
	    proto.evEl = MOUSE_ELEMENT_EVENTS;
	    proto.evWin = MOUSE_WINDOW_EVENTS;
	    _this = _Input.apply(this, arguments) || this;
	    _this.pressed = false; // mousedown state

	    return _this;
	  }
	  /**
	   * @private
	   * handle mouse events
	   * @param {Object} ev
	   */


	  var _proto = MouseInput.prototype;

	  _proto.handler = function handler(ev) {
	    var eventType = MOUSE_INPUT_MAP[ev.type]; // on start we want to have the left mouse button down

	    if (eventType & INPUT_START && ev.button === 0) {
	      this.pressed = true;
	    }

	    if (eventType & INPUT_MOVE && ev.which !== 1) {
	      eventType = INPUT_END;
	    } // mouse must be down


	    if (!this.pressed) {
	      return;
	    }

	    if (eventType & INPUT_END) {
	      this.pressed = false;
	    }

	    this.callback(this.manager, eventType, {
	      pointers: [ev],
	      changedPointers: [ev],
	      pointerType: INPUT_TYPE_MOUSE,
	      srcEvent: ev
	    });
	  };

	  return MouseInput;
	}(Input);

	/**
	 * @private
	 * Combined touch and mouse input
	 *
	 * Touch has a higher priority then mouse, and while touching no mouse events are allowed.
	 * This because touch devices also emit mouse events while doing a touch.
	 *
	 * @constructor
	 * @extends Input
	 */

	var DEDUP_TIMEOUT = 2500;
	var DEDUP_DISTANCE = 25;

	function setLastTouch(eventData) {
	  var _eventData$changedPoi = eventData.changedPointers,
	      touch = _eventData$changedPoi[0];

	  if (touch.identifier === this.primaryTouch) {
	    var lastTouch = {
	      x: touch.clientX,
	      y: touch.clientY
	    };
	    var lts = this.lastTouches;
	    this.lastTouches.push(lastTouch);

	    var removeLastTouch = function removeLastTouch() {
	      var i = lts.indexOf(lastTouch);

	      if (i > -1) {
	        lts.splice(i, 1);
	      }
	    };

	    setTimeout(removeLastTouch, DEDUP_TIMEOUT);
	  }
	}

	function recordTouches(eventType, eventData) {
	  if (eventType & INPUT_START) {
	    this.primaryTouch = eventData.changedPointers[0].identifier;
	    setLastTouch.call(this, eventData);
	  } else if (eventType & (INPUT_END | INPUT_CANCEL)) {
	    setLastTouch.call(this, eventData);
	  }
	}

	function isSyntheticEvent(eventData) {
	  var x = eventData.srcEvent.clientX;
	  var y = eventData.srcEvent.clientY;

	  for (var i = 0; i < this.lastTouches.length; i++) {
	    var t = this.lastTouches[i];
	    var dx = Math.abs(x - t.x);
	    var dy = Math.abs(y - t.y);

	    if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
	      return true;
	    }
	  }

	  return false;
	}

	var TouchMouseInput =
	/*#__PURE__*/
	function () {
	  var TouchMouseInput =
	  /*#__PURE__*/
	  function (_Input) {
	    _inheritsLoose(TouchMouseInput, _Input);

	    function TouchMouseInput(_manager, callback) {
	      var _this;

	      _this = _Input.call(this, _manager, callback) || this;

	      _this.handler = function (manager, inputEvent, inputData) {
	        var isTouch = inputData.pointerType === INPUT_TYPE_TOUCH;
	        var isMouse = inputData.pointerType === INPUT_TYPE_MOUSE;

	        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
	          return;
	        } // when we're in a touch event, record touches to  de-dupe synthetic mouse event


	        if (isTouch) {
	          recordTouches.call(_assertThisInitialized(_assertThisInitialized(_this)), inputEvent, inputData);
	        } else if (isMouse && isSyntheticEvent.call(_assertThisInitialized(_assertThisInitialized(_this)), inputData)) {
	          return;
	        }

	        _this.callback(manager, inputEvent, inputData);
	      };

	      _this.touch = new TouchInput(_this.manager, _this.handler);
	      _this.mouse = new MouseInput(_this.manager, _this.handler);
	      _this.primaryTouch = null;
	      _this.lastTouches = [];
	      return _this;
	    }
	    /**
	     * @private
	     * handle mouse and touch events
	     * @param {Hammer} manager
	     * @param {String} inputEvent
	     * @param {Object} inputData
	     */


	    var _proto = TouchMouseInput.prototype;

	    /**
	     * @private
	     * remove the event listeners
	     */
	    _proto.destroy = function destroy() {
	      this.touch.destroy();
	      this.mouse.destroy();
	    };

	    return TouchMouseInput;
	  }(Input);

	  return TouchMouseInput;
	}();

	/**
	 * @private
	 * create new input type manager
	 * called by the Manager constructor
	 * @param {Hammer} manager
	 * @returns {Input}
	 */

	function createInputInstance(manager) {
	  var Type; // let inputClass = manager.options.inputClass;

	  var inputClass = manager.options.inputClass;

	  if (inputClass) {
	    Type = inputClass;
	  } else if (SUPPORT_POINTER_EVENTS) {
	    Type = PointerEventInput;
	  } else if (SUPPORT_ONLY_TOUCH) {
	    Type = TouchInput;
	  } else if (!SUPPORT_TOUCH) {
	    Type = MouseInput;
	  } else {
	    Type = TouchMouseInput;
	  }

	  return new Type(manager, inputHandler);
	}

	/**
	 * @private
	 * if the argument is an array, we want to execute the fn on each entry
	 * if it aint an array we don't want to do a thing.
	 * this is used by all the methods that accept a single and array argument.
	 * @param {*|Array} arg
	 * @param {String} fn
	 * @param {Object} [context]
	 * @returns {Boolean}
	 */

	function invokeArrayArg(arg, fn, context) {
	  if (Array.isArray(arg)) {
	    each(arg, context[fn], context);
	    return true;
	  }

	  return false;
	}

	var STATE_POSSIBLE = 1;
	var STATE_BEGAN = 2;
	var STATE_CHANGED = 4;
	var STATE_ENDED = 8;
	var STATE_RECOGNIZED = STATE_ENDED;
	var STATE_CANCELLED = 16;
	var STATE_FAILED = 32;

	/**
	 * @private
	 * get a unique id
	 * @returns {number} uniqueId
	 */
	var _uniqueId = 1;
	function uniqueId() {
	  return _uniqueId++;
	}

	/**
	 * @private
	 * get a recognizer by name if it is bound to a manager
	 * @param {Recognizer|String} otherRecognizer
	 * @param {Recognizer} recognizer
	 * @returns {Recognizer}
	 */
	function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
	  var manager = recognizer.manager;

	  if (manager) {
	    return manager.get(otherRecognizer);
	  }

	  return otherRecognizer;
	}

	/**
	 * @private
	 * get a usable string, used as event postfix
	 * @param {constant} state
	 * @returns {String} state
	 */

	function stateStr(state) {
	  if (state & STATE_CANCELLED) {
	    return 'cancel';
	  } else if (state & STATE_ENDED) {
	    return 'end';
	  } else if (state & STATE_CHANGED) {
	    return 'move';
	  } else if (state & STATE_BEGAN) {
	    return 'start';
	  }

	  return '';
	}

	/**
	 * @private
	 * Recognizer flow explained; *
	 * All recognizers have the initial state of POSSIBLE when a input session starts.
	 * The definition of a input session is from the first input until the last input, with all it's movement in it. *
	 * Example session for mouse-input: mousedown -> mousemove -> mouseup
	 *
	 * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
	 * which determines with state it should be.
	 *
	 * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
	 * POSSIBLE to give it another change on the next cycle.
	 *
	 *               Possible
	 *                  |
	 *            +-----+---------------+
	 *            |                     |
	 *      +-----+-----+               |
	 *      |           |               |
	 *   Failed      Cancelled          |
	 *                          +-------+------+
	 *                          |              |
	 *                      Recognized       Began
	 *                                         |
	 *                                      Changed
	 *                                         |
	 *                                  Ended/Recognized
	 */

	/**
	 * @private
	 * Recognizer
	 * Every recognizer needs to extend from this class.
	 * @constructor
	 * @param {Object} options
	 */

	var Recognizer =
	/*#__PURE__*/
	function () {
	  function Recognizer(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    this.options = _extends({
	      enable: true
	    }, options);
	    this.id = uniqueId();
	    this.manager = null; // default is enable true

	    this.state = STATE_POSSIBLE;
	    this.simultaneous = {};
	    this.requireFail = [];
	  }
	  /**
	   * @private
	   * set options
	   * @param {Object} options
	   * @return {Recognizer}
	   */


	  var _proto = Recognizer.prototype;

	  _proto.set = function set(options) {
	    assign$1(this.options, options); // also update the touchAction, in case something changed about the directions/enabled state

	    this.manager && this.manager.touchAction.update();
	    return this;
	  };
	  /**
	   * @private
	   * recognize simultaneous with an other recognizer.
	   * @param {Recognizer} otherRecognizer
	   * @returns {Recognizer} this
	   */


	  _proto.recognizeWith = function recognizeWith(otherRecognizer) {
	    if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
	      return this;
	    }

	    var simultaneous = this.simultaneous;
	    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);

	    if (!simultaneous[otherRecognizer.id]) {
	      simultaneous[otherRecognizer.id] = otherRecognizer;
	      otherRecognizer.recognizeWith(this);
	    }

	    return this;
	  };
	  /**
	   * @private
	   * drop the simultaneous link. it doesnt remove the link on the other recognizer.
	   * @param {Recognizer} otherRecognizer
	   * @returns {Recognizer} this
	   */


	  _proto.dropRecognizeWith = function dropRecognizeWith(otherRecognizer) {
	    if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
	      return this;
	    }

	    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
	    delete this.simultaneous[otherRecognizer.id];
	    return this;
	  };
	  /**
	   * @private
	   * recognizer can only run when an other is failing
	   * @param {Recognizer} otherRecognizer
	   * @returns {Recognizer} this
	   */


	  _proto.requireFailure = function requireFailure(otherRecognizer) {
	    if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
	      return this;
	    }

	    var requireFail = this.requireFail;
	    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);

	    if (inArray(requireFail, otherRecognizer) === -1) {
	      requireFail.push(otherRecognizer);
	      otherRecognizer.requireFailure(this);
	    }

	    return this;
	  };
	  /**
	   * @private
	   * drop the requireFailure link. it does not remove the link on the other recognizer.
	   * @param {Recognizer} otherRecognizer
	   * @returns {Recognizer} this
	   */


	  _proto.dropRequireFailure = function dropRequireFailure(otherRecognizer) {
	    if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
	      return this;
	    }

	    otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
	    var index = inArray(this.requireFail, otherRecognizer);

	    if (index > -1) {
	      this.requireFail.splice(index, 1);
	    }

	    return this;
	  };
	  /**
	   * @private
	   * has require failures boolean
	   * @returns {boolean}
	   */


	  _proto.hasRequireFailures = function hasRequireFailures() {
	    return this.requireFail.length > 0;
	  };
	  /**
	   * @private
	   * if the recognizer can recognize simultaneous with an other recognizer
	   * @param {Recognizer} otherRecognizer
	   * @returns {Boolean}
	   */


	  _proto.canRecognizeWith = function canRecognizeWith(otherRecognizer) {
	    return !!this.simultaneous[otherRecognizer.id];
	  };
	  /**
	   * @private
	   * You should use `tryEmit` instead of `emit` directly to check
	   * that all the needed recognizers has failed before emitting.
	   * @param {Object} input
	   */


	  _proto.emit = function emit(input) {
	    var self = this;
	    var state = this.state;

	    function emit(event) {
	      self.manager.emit(event, input);
	    } // 'panstart' and 'panmove'


	    if (state < STATE_ENDED) {
	      emit(self.options.event + stateStr(state));
	    }

	    emit(self.options.event); // simple 'eventName' events

	    if (input.additionalEvent) {
	      // additional event(panleft, panright, pinchin, pinchout...)
	      emit(input.additionalEvent);
	    } // panend and pancancel


	    if (state >= STATE_ENDED) {
	      emit(self.options.event + stateStr(state));
	    }
	  };
	  /**
	   * @private
	   * Check that all the require failure recognizers has failed,
	   * if true, it emits a gesture event,
	   * otherwise, setup the state to FAILED.
	   * @param {Object} input
	   */


	  _proto.tryEmit = function tryEmit(input) {
	    if (this.canEmit()) {
	      return this.emit(input);
	    } // it's failing anyway


	    this.state = STATE_FAILED;
	  };
	  /**
	   * @private
	   * can we emit?
	   * @returns {boolean}
	   */


	  _proto.canEmit = function canEmit() {
	    var i = 0;

	    while (i < this.requireFail.length) {
	      if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
	        return false;
	      }

	      i++;
	    }

	    return true;
	  };
	  /**
	   * @private
	   * update the recognizer
	   * @param {Object} inputData
	   */


	  _proto.recognize = function recognize(inputData) {
	    // make a new copy of the inputData
	    // so we can change the inputData without messing up the other recognizers
	    var inputDataClone = assign$1({}, inputData); // is is enabled and allow recognizing?

	    if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
	      this.reset();
	      this.state = STATE_FAILED;
	      return;
	    } // reset when we've reached the end


	    if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
	      this.state = STATE_POSSIBLE;
	    }

	    this.state = this.process(inputDataClone); // the recognizer has recognized a gesture
	    // so trigger an event

	    if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
	      this.tryEmit(inputDataClone);
	    }
	  };
	  /**
	   * @private
	   * return the state of the recognizer
	   * the actual recognizing happens in this method
	   * @virtual
	   * @param {Object} inputData
	   * @returns {constant} STATE
	   */

	  /* jshint ignore:start */


	  _proto.process = function process(inputData) {};
	  /* jshint ignore:end */

	  /**
	   * @private
	   * return the preferred touch-action
	   * @virtual
	   * @returns {Array}
	   */


	  _proto.getTouchAction = function getTouchAction() {};
	  /**
	   * @private
	   * called when the gesture isn't allowed to recognize
	   * like when another is being recognized or it is disabled
	   * @virtual
	   */


	  _proto.reset = function reset() {};

	  return Recognizer;
	}();

	/**
	 * @private
	 * A tap is recognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
	 * between the given interval and position. The delay option can be used to recognize multi-taps without firing
	 * a single tap.
	 *
	 * The eventData from the emitted event contains the property `tapCount`, which contains the amount of
	 * multi-taps being recognized.
	 * @constructor
	 * @extends Recognizer
	 */

	var TapRecognizer =
	/*#__PURE__*/
	function (_Recognizer) {
	  _inheritsLoose(TapRecognizer, _Recognizer);

	  function TapRecognizer(options) {
	    var _this;

	    if (options === void 0) {
	      options = {};
	    }

	    _this = _Recognizer.call(this, _extends({
	      event: 'tap',
	      pointers: 1,
	      taps: 1,
	      interval: 300,
	      // max time between the multi-tap taps
	      time: 250,
	      // max time of the pointer to be down (like finger on the screen)
	      threshold: 9,
	      // a minimal movement is ok, but keep it low
	      posThreshold: 10
	    }, options)) || this; // previous time and center,
	    // used for tap counting

	    _this.pTime = false;
	    _this.pCenter = false;
	    _this._timer = null;
	    _this._input = null;
	    _this.count = 0;
	    return _this;
	  }

	  var _proto = TapRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    return [TOUCH_ACTION_MANIPULATION];
	  };

	  _proto.process = function process(input) {
	    var _this2 = this;

	    var options = this.options;
	    var validPointers = input.pointers.length === options.pointers;
	    var validMovement = input.distance < options.threshold;
	    var validTouchTime = input.deltaTime < options.time;
	    this.reset();

	    if (input.eventType & INPUT_START && this.count === 0) {
	      return this.failTimeout();
	    } // we only allow little movement
	    // and we've reached an end event, so a tap is possible


	    if (validMovement && validTouchTime && validPointers) {
	      if (input.eventType !== INPUT_END) {
	        return this.failTimeout();
	      }

	      var validInterval = this.pTime ? input.timeStamp - this.pTime < options.interval : true;
	      var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
	      this.pTime = input.timeStamp;
	      this.pCenter = input.center;

	      if (!validMultiTap || !validInterval) {
	        this.count = 1;
	      } else {
	        this.count += 1;
	      }

	      this._input = input; // if tap count matches we have recognized it,
	      // else it has began recognizing...

	      var tapCount = this.count % options.taps;

	      if (tapCount === 0) {
	        // no failing requirements, immediately trigger the tap event
	        // or wait as long as the multitap interval to trigger
	        if (!this.hasRequireFailures()) {
	          return STATE_RECOGNIZED;
	        } else {
	          this._timer = setTimeout(function () {
	            _this2.state = STATE_RECOGNIZED;

	            _this2.tryEmit();
	          }, options.interval);
	          return STATE_BEGAN;
	        }
	      }
	    }

	    return STATE_FAILED;
	  };

	  _proto.failTimeout = function failTimeout() {
	    var _this3 = this;

	    this._timer = setTimeout(function () {
	      _this3.state = STATE_FAILED;
	    }, this.options.interval);
	    return STATE_FAILED;
	  };

	  _proto.reset = function reset() {
	    clearTimeout(this._timer);
	  };

	  _proto.emit = function emit() {
	    if (this.state === STATE_RECOGNIZED) {
	      this._input.tapCount = this.count;
	      this.manager.emit(this.options.event, this._input);
	    }
	  };

	  return TapRecognizer;
	}(Recognizer);

	/**
	 * @private
	 * This recognizer is just used as a base for the simple attribute recognizers.
	 * @constructor
	 * @extends Recognizer
	 */

	var AttrRecognizer =
	/*#__PURE__*/
	function (_Recognizer) {
	  _inheritsLoose(AttrRecognizer, _Recognizer);

	  function AttrRecognizer(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return _Recognizer.call(this, _extends({
	      pointers: 1
	    }, options)) || this;
	  }
	  /**
	   * @private
	   * Used to check if it the recognizer receives valid input, like input.distance > 10.
	   * @memberof AttrRecognizer
	   * @param {Object} input
	   * @returns {Boolean} recognized
	   */


	  var _proto = AttrRecognizer.prototype;

	  _proto.attrTest = function attrTest(input) {
	    var optionPointers = this.options.pointers;
	    return optionPointers === 0 || input.pointers.length === optionPointers;
	  };
	  /**
	   * @private
	   * Process the input and return the state for the recognizer
	   * @memberof AttrRecognizer
	   * @param {Object} input
	   * @returns {*} State
	   */


	  _proto.process = function process(input) {
	    var state = this.state;
	    var eventType = input.eventType;
	    var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
	    var isValid = this.attrTest(input); // on cancel input and we've recognized before, return STATE_CANCELLED

	    if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
	      return state | STATE_CANCELLED;
	    } else if (isRecognized || isValid) {
	      if (eventType & INPUT_END) {
	        return state | STATE_ENDED;
	      } else if (!(state & STATE_BEGAN)) {
	        return STATE_BEGAN;
	      }

	      return state | STATE_CHANGED;
	    }

	    return STATE_FAILED;
	  };

	  return AttrRecognizer;
	}(Recognizer);

	/**
	 * @private
	 * direction cons to string
	 * @param {constant} direction
	 * @returns {String}
	 */

	function directionStr(direction) {
	  if (direction === DIRECTION_DOWN) {
	    return 'down';
	  } else if (direction === DIRECTION_UP) {
	    return 'up';
	  } else if (direction === DIRECTION_LEFT) {
	    return 'left';
	  } else if (direction === DIRECTION_RIGHT) {
	    return 'right';
	  }

	  return '';
	}

	/**
	 * @private
	 * Pan
	 * Recognized when the pointer is down and moved in the allowed direction.
	 * @constructor
	 * @extends AttrRecognizer
	 */

	var PanRecognizer =
	/*#__PURE__*/
	function (_AttrRecognizer) {
	  _inheritsLoose(PanRecognizer, _AttrRecognizer);

	  function PanRecognizer(options) {
	    var _this;

	    if (options === void 0) {
	      options = {};
	    }

	    _this = _AttrRecognizer.call(this, _extends({
	      event: 'pan',
	      threshold: 10,
	      pointers: 1,
	      direction: DIRECTION_ALL
	    }, options)) || this;
	    _this.pX = null;
	    _this.pY = null;
	    return _this;
	  }

	  var _proto = PanRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    var direction = this.options.direction;
	    var actions = [];

	    if (direction & DIRECTION_HORIZONTAL) {
	      actions.push(TOUCH_ACTION_PAN_Y);
	    }

	    if (direction & DIRECTION_VERTICAL) {
	      actions.push(TOUCH_ACTION_PAN_X);
	    }

	    return actions;
	  };

	  _proto.directionTest = function directionTest(input) {
	    var options = this.options;
	    var hasMoved = true;
	    var distance = input.distance;
	    var direction = input.direction;
	    var x = input.deltaX;
	    var y = input.deltaY; // lock to axis?

	    if (!(direction & options.direction)) {
	      if (options.direction & DIRECTION_HORIZONTAL) {
	        direction = x === 0 ? DIRECTION_NONE : x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
	        hasMoved = x !== this.pX;
	        distance = Math.abs(input.deltaX);
	      } else {
	        direction = y === 0 ? DIRECTION_NONE : y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
	        hasMoved = y !== this.pY;
	        distance = Math.abs(input.deltaY);
	      }
	    }

	    input.direction = direction;
	    return hasMoved && distance > options.threshold && direction & options.direction;
	  };

	  _proto.attrTest = function attrTest(input) {
	    return AttrRecognizer.prototype.attrTest.call(this, input) && ( // replace with a super call
	    this.state & STATE_BEGAN || !(this.state & STATE_BEGAN) && this.directionTest(input));
	  };

	  _proto.emit = function emit(input) {
	    this.pX = input.deltaX;
	    this.pY = input.deltaY;
	    var direction = directionStr(input.direction);

	    if (direction) {
	      input.additionalEvent = this.options.event + direction;
	    }

	    _AttrRecognizer.prototype.emit.call(this, input);
	  };

	  return PanRecognizer;
	}(AttrRecognizer);

	/**
	 * @private
	 * Swipe
	 * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
	 * @constructor
	 * @extends AttrRecognizer
	 */

	var SwipeRecognizer =
	/*#__PURE__*/
	function (_AttrRecognizer) {
	  _inheritsLoose(SwipeRecognizer, _AttrRecognizer);

	  function SwipeRecognizer(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return _AttrRecognizer.call(this, _extends({
	      event: 'swipe',
	      threshold: 10,
	      velocity: 0.3,
	      direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
	      pointers: 1
	    }, options)) || this;
	  }

	  var _proto = SwipeRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    return PanRecognizer.prototype.getTouchAction.call(this);
	  };

	  _proto.attrTest = function attrTest(input) {
	    var direction = this.options.direction;
	    var velocity;

	    if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
	      velocity = input.overallVelocity;
	    } else if (direction & DIRECTION_HORIZONTAL) {
	      velocity = input.overallVelocityX;
	    } else if (direction & DIRECTION_VERTICAL) {
	      velocity = input.overallVelocityY;
	    }

	    return _AttrRecognizer.prototype.attrTest.call(this, input) && direction & input.offsetDirection && input.distance > this.options.threshold && input.maxPointers === this.options.pointers && abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
	  };

	  _proto.emit = function emit(input) {
	    var direction = directionStr(input.offsetDirection);

	    if (direction) {
	      this.manager.emit(this.options.event + direction, input);
	    }

	    this.manager.emit(this.options.event, input);
	  };

	  return SwipeRecognizer;
	}(AttrRecognizer);

	/**
	 * @private
	 * Pinch
	 * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
	 * @constructor
	 * @extends AttrRecognizer
	 */

	var PinchRecognizer =
	/*#__PURE__*/
	function (_AttrRecognizer) {
	  _inheritsLoose(PinchRecognizer, _AttrRecognizer);

	  function PinchRecognizer(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return _AttrRecognizer.call(this, _extends({
	      event: 'pinch',
	      threshold: 0,
	      pointers: 2
	    }, options)) || this;
	  }

	  var _proto = PinchRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    return [TOUCH_ACTION_NONE];
	  };

	  _proto.attrTest = function attrTest(input) {
	    return _AttrRecognizer.prototype.attrTest.call(this, input) && (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
	  };

	  _proto.emit = function emit(input) {
	    if (input.scale !== 1) {
	      var inOut = input.scale < 1 ? 'in' : 'out';
	      input.additionalEvent = this.options.event + inOut;
	    }

	    _AttrRecognizer.prototype.emit.call(this, input);
	  };

	  return PinchRecognizer;
	}(AttrRecognizer);

	/**
	 * @private
	 * Rotate
	 * Recognized when two or more pointer are moving in a circular motion.
	 * @constructor
	 * @extends AttrRecognizer
	 */

	var RotateRecognizer =
	/*#__PURE__*/
	function (_AttrRecognizer) {
	  _inheritsLoose(RotateRecognizer, _AttrRecognizer);

	  function RotateRecognizer(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return _AttrRecognizer.call(this, _extends({
	      event: 'rotate',
	      threshold: 0,
	      pointers: 2
	    }, options)) || this;
	  }

	  var _proto = RotateRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    return [TOUCH_ACTION_NONE];
	  };

	  _proto.attrTest = function attrTest(input) {
	    return _AttrRecognizer.prototype.attrTest.call(this, input) && (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
	  };

	  return RotateRecognizer;
	}(AttrRecognizer);

	/**
	 * @private
	 * Press
	 * Recognized when the pointer is down for x ms without any movement.
	 * @constructor
	 * @extends Recognizer
	 */

	var PressRecognizer =
	/*#__PURE__*/
	function (_Recognizer) {
	  _inheritsLoose(PressRecognizer, _Recognizer);

	  function PressRecognizer(options) {
	    var _this;

	    if (options === void 0) {
	      options = {};
	    }

	    _this = _Recognizer.call(this, _extends({
	      event: 'press',
	      pointers: 1,
	      time: 251,
	      // minimal time of the pointer to be pressed
	      threshold: 9
	    }, options)) || this;
	    _this._timer = null;
	    _this._input = null;
	    return _this;
	  }

	  var _proto = PressRecognizer.prototype;

	  _proto.getTouchAction = function getTouchAction() {
	    return [TOUCH_ACTION_AUTO];
	  };

	  _proto.process = function process(input) {
	    var _this2 = this;

	    var options = this.options;
	    var validPointers = input.pointers.length === options.pointers;
	    var validMovement = input.distance < options.threshold;
	    var validTime = input.deltaTime > options.time;
	    this._input = input; // we only allow little movement
	    // and we've reached an end event, so a tap is possible

	    if (!validMovement || !validPointers || input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime) {
	      this.reset();
	    } else if (input.eventType & INPUT_START) {
	      this.reset();
	      this._timer = setTimeout(function () {
	        _this2.state = STATE_RECOGNIZED;

	        _this2.tryEmit();
	      }, options.time);
	    } else if (input.eventType & INPUT_END) {
	      return STATE_RECOGNIZED;
	    }

	    return STATE_FAILED;
	  };

	  _proto.reset = function reset() {
	    clearTimeout(this._timer);
	  };

	  _proto.emit = function emit(input) {
	    if (this.state !== STATE_RECOGNIZED) {
	      return;
	    }

	    if (input && input.eventType & INPUT_END) {
	      this.manager.emit(this.options.event + "up", input);
	    } else {
	      this._input.timeStamp = now();
	      this.manager.emit(this.options.event, this._input);
	    }
	  };

	  return PressRecognizer;
	}(Recognizer);

	var defaults = {
	  /**
	   * @private
	   * set if DOM events are being triggered.
	   * But this is slower and unused by simple implementations, so disabled by default.
	   * @type {Boolean}
	   * @default false
	   */
	  domEvents: false,

	  /**
	   * @private
	   * The value for the touchAction property/fallback.
	   * When set to `compute` it will magically set the correct value based on the added recognizers.
	   * @type {String}
	   * @default compute
	   */
	  touchAction: TOUCH_ACTION_COMPUTE,

	  /**
	   * @private
	   * @type {Boolean}
	   * @default true
	   */
	  enable: true,

	  /**
	   * @private
	   * EXPERIMENTAL FEATURE -- can be removed/changed
	   * Change the parent input target element.
	   * If Null, then it is being set the to main element.
	   * @type {Null|EventTarget}
	   * @default null
	   */
	  inputTarget: null,

	  /**
	   * @private
	   * force an input class
	   * @type {Null|Function}
	   * @default null
	   */
	  inputClass: null,

	  /**
	   * @private
	   * Some CSS properties can be used to improve the working of Hammer.
	   * Add them to this method and they will be set when creating a new Manager.
	   * @namespace
	   */
	  cssProps: {
	    /**
	     * @private
	     * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
	     * @type {String}
	     * @default 'none'
	     */
	    userSelect: "none",

	    /**
	     * @private
	     * Disable the Windows Phone grippers when pressing an element.
	     * @type {String}
	     * @default 'none'
	     */
	    touchSelect: "none",

	    /**
	     * @private
	     * Disables the default callout shown when you touch and hold a touch target.
	     * On iOS, when you touch and hold a touch target such as a link, Safari displays
	     * a callout containing information about the link. This property allows you to disable that callout.
	     * @type {String}
	     * @default 'none'
	     */
	    touchCallout: "none",

	    /**
	     * @private
	     * Specifies whether zooming is enabled. Used by IE10>
	     * @type {String}
	     * @default 'none'
	     */
	    contentZooming: "none",

	    /**
	     * @private
	     * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
	     * @type {String}
	     * @default 'none'
	     */
	    userDrag: "none",

	    /**
	     * @private
	     * Overrides the highlight color shown when the user taps a link or a JavaScript
	     * clickable element in iOS. This property obeys the alpha value, if specified.
	     * @type {String}
	     * @default 'rgba(0,0,0,0)'
	     */
	    tapHighlightColor: "rgba(0,0,0,0)"
	  }
	};
	/**
	 * @private
	 * Default recognizer setup when calling `Hammer()`
	 * When creating a new Manager these will be skipped.
	 * This is separated with other defaults because of tree-shaking.
	 * @type {Array}
	 */

	var preset = [[RotateRecognizer, {
	  enable: false
	}], [PinchRecognizer, {
	  enable: false
	}, ['rotate']], [SwipeRecognizer, {
	  direction: DIRECTION_HORIZONTAL
	}], [PanRecognizer, {
	  direction: DIRECTION_HORIZONTAL
	}, ['swipe']], [TapRecognizer], [TapRecognizer, {
	  event: 'doubletap',
	  taps: 2
	}, ['tap']], [PressRecognizer]];

	var STOP = 1;
	var FORCED_STOP = 2;
	/**
	 * @private
	 * add/remove the css properties as defined in manager.options.cssProps
	 * @param {Manager} manager
	 * @param {Boolean} add
	 */

	function toggleCssProps(manager, add) {
	  var element = manager.element;

	  if (!element.style) {
	    return;
	  }

	  var prop;
	  each(manager.options.cssProps, function (value, name) {
	    prop = prefixed(element.style, name);

	    if (add) {
	      manager.oldCssProps[prop] = element.style[prop];
	      element.style[prop] = value;
	    } else {
	      element.style[prop] = manager.oldCssProps[prop] || "";
	    }
	  });

	  if (!add) {
	    manager.oldCssProps = {};
	  }
	}
	/**
	 * @private
	 * trigger dom event
	 * @param {String} event
	 * @param {Object} data
	 */


	function triggerDomEvent(event, data) {
	  var gestureEvent = document.createEvent("Event");
	  gestureEvent.initEvent(event, true, true);
	  gestureEvent.gesture = data;
	  data.target.dispatchEvent(gestureEvent);
	}
	/**
	* @private
	 * Manager
	 * @param {HTMLElement} element
	 * @param {Object} [options]
	 * @constructor
	 */


	var Manager =
	/*#__PURE__*/
	function () {
	  function Manager(element, options) {
	    var _this = this;

	    this.options = assign$1({}, defaults, options || {});
	    this.options.inputTarget = this.options.inputTarget || element;
	    this.handlers = {};
	    this.session = {};
	    this.recognizers = [];
	    this.oldCssProps = {};
	    this.element = element;
	    this.input = createInputInstance(this);
	    this.touchAction = new TouchAction(this, this.options.touchAction);
	    toggleCssProps(this, true);
	    each(this.options.recognizers, function (item) {
	      var recognizer = _this.add(new item[0](item[1]));

	      item[2] && recognizer.recognizeWith(item[2]);
	      item[3] && recognizer.requireFailure(item[3]);
	    }, this);
	  }
	  /**
	   * @private
	   * set options
	   * @param {Object} options
	   * @returns {Manager}
	   */


	  var _proto = Manager.prototype;

	  _proto.set = function set(options) {
	    assign$1(this.options, options); // Options that need a little more setup

	    if (options.touchAction) {
	      this.touchAction.update();
	    }

	    if (options.inputTarget) {
	      // Clean up existing event listeners and reinitialize
	      this.input.destroy();
	      this.input.target = options.inputTarget;
	      this.input.init();
	    }

	    return this;
	  };
	  /**
	   * @private
	   * stop recognizing for this session.
	   * This session will be discarded, when a new [input]start event is fired.
	   * When forced, the recognizer cycle is stopped immediately.
	   * @param {Boolean} [force]
	   */


	  _proto.stop = function stop(force) {
	    this.session.stopped = force ? FORCED_STOP : STOP;
	  };
	  /**
	   * @private
	   * run the recognizers!
	   * called by the inputHandler function on every movement of the pointers (touches)
	   * it walks through all the recognizers and tries to detect the gesture that is being made
	   * @param {Object} inputData
	   */


	  _proto.recognize = function recognize(inputData) {
	    var session = this.session;

	    if (session.stopped) {
	      return;
	    } // run the touch-action polyfill


	    this.touchAction.preventDefaults(inputData);
	    var recognizer;
	    var recognizers = this.recognizers; // this holds the recognizer that is being recognized.
	    // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
	    // if no recognizer is detecting a thing, it is set to `null`

	    var curRecognizer = session.curRecognizer; // reset when the last recognizer is recognized
	    // or when we're in a new session

	    if (!curRecognizer || curRecognizer && curRecognizer.state & STATE_RECOGNIZED) {
	      session.curRecognizer = null;
	      curRecognizer = null;
	    }

	    var i = 0;

	    while (i < recognizers.length) {
	      recognizer = recognizers[i]; // find out if we are allowed try to recognize the input for this one.
	      // 1.   allow if the session is NOT forced stopped (see the .stop() method)
	      // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
	      //      that is being recognized.
	      // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
	      //      this can be setup with the `recognizeWith()` method on the recognizer.

	      if (session.stopped !== FORCED_STOP && ( // 1
	      !curRecognizer || recognizer === curRecognizer || // 2
	      recognizer.canRecognizeWith(curRecognizer))) {
	        // 3
	        recognizer.recognize(inputData);
	      } else {
	        recognizer.reset();
	      } // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
	      // current active recognizer. but only if we don't already have an active recognizer


	      if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
	        session.curRecognizer = recognizer;
	        curRecognizer = recognizer;
	      }

	      i++;
	    }
	  };
	  /**
	   * @private
	   * get a recognizer by its event name.
	   * @param {Recognizer|String} recognizer
	   * @returns {Recognizer|Null}
	   */


	  _proto.get = function get(recognizer) {
	    if (recognizer instanceof Recognizer) {
	      return recognizer;
	    }

	    var recognizers = this.recognizers;

	    for (var i = 0; i < recognizers.length; i++) {
	      if (recognizers[i].options.event === recognizer) {
	        return recognizers[i];
	      }
	    }

	    return null;
	  };
	  /**
	   * @private add a recognizer to the manager
	   * existing recognizers with the same event name will be removed
	   * @param {Recognizer} recognizer
	   * @returns {Recognizer|Manager}
	   */


	  _proto.add = function add(recognizer) {
	    if (invokeArrayArg(recognizer, "add", this)) {
	      return this;
	    } // remove existing


	    var existing = this.get(recognizer.options.event);

	    if (existing) {
	      this.remove(existing);
	    }

	    this.recognizers.push(recognizer);
	    recognizer.manager = this;
	    this.touchAction.update();
	    return recognizer;
	  };
	  /**
	   * @private
	   * remove a recognizer by name or instance
	   * @param {Recognizer|String} recognizer
	   * @returns {Manager}
	   */


	  _proto.remove = function remove(recognizer) {
	    if (invokeArrayArg(recognizer, "remove", this)) {
	      return this;
	    }

	    var targetRecognizer = this.get(recognizer); // let's make sure this recognizer exists

	    if (recognizer) {
	      var recognizers = this.recognizers;
	      var index = inArray(recognizers, targetRecognizer);

	      if (index !== -1) {
	        recognizers.splice(index, 1);
	        this.touchAction.update();
	      }
	    }

	    return this;
	  };
	  /**
	   * @private
	   * bind event
	   * @param {String} events
	   * @param {Function} handler
	   * @returns {EventEmitter} this
	   */


	  _proto.on = function on(events, handler) {
	    if (events === undefined || handler === undefined) {
	      return this;
	    }

	    var handlers = this.handlers;
	    each(splitStr(events), function (event) {
	      handlers[event] = handlers[event] || [];
	      handlers[event].push(handler);
	    });
	    return this;
	  };
	  /**
	   * @private unbind event, leave emit blank to remove all handlers
	   * @param {String} events
	   * @param {Function} [handler]
	   * @returns {EventEmitter} this
	   */


	  _proto.off = function off(events, handler) {
	    if (events === undefined) {
	      return this;
	    }

	    var handlers = this.handlers;
	    each(splitStr(events), function (event) {
	      if (!handler) {
	        delete handlers[event];
	      } else {
	        handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
	      }
	    });
	    return this;
	  };
	  /**
	   * @private emit event to the listeners
	   * @param {String} event
	   * @param {Object} data
	   */


	  _proto.emit = function emit(event, data) {
	    // we also want to trigger dom events
	    if (this.options.domEvents) {
	      triggerDomEvent(event, data);
	    } // no handlers, so skip it all


	    var handlers = this.handlers[event] && this.handlers[event].slice();

	    if (!handlers || !handlers.length) {
	      return;
	    }

	    data.type = event;

	    data.preventDefault = function () {
	      data.srcEvent.preventDefault();
	    };

	    var i = 0;

	    while (i < handlers.length) {
	      handlers[i](data);
	      i++;
	    }
	  };
	  /**
	   * @private
	   * destroy the manager and unbinds all events
	   * it doesn't unbind dom events, that is the user own responsibility
	   */


	  _proto.destroy = function destroy() {
	    this.element && toggleCssProps(this, false);
	    this.handlers = {};
	    this.session = {};
	    this.input.destroy();
	    this.element = null;
	  };

	  return Manager;
	}();

	var SINGLE_TOUCH_INPUT_MAP = {
	  touchstart: INPUT_START,
	  touchmove: INPUT_MOVE,
	  touchend: INPUT_END,
	  touchcancel: INPUT_CANCEL
	};
	var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
	var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
	/**
	 * @private
	 * Touch events input
	 * @constructor
	 * @extends Input
	 */

	var SingleTouchInput =
	/*#__PURE__*/
	function (_Input) {
	  _inheritsLoose(SingleTouchInput, _Input);

	  function SingleTouchInput() {
	    var _this;

	    var proto = SingleTouchInput.prototype;
	    proto.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
	    proto.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
	    _this = _Input.apply(this, arguments) || this;
	    _this.started = false;
	    return _this;
	  }

	  var _proto = SingleTouchInput.prototype;

	  _proto.handler = function handler(ev) {
	    var type = SINGLE_TOUCH_INPUT_MAP[ev.type]; // should we handle the touch events?

	    if (type === INPUT_START) {
	      this.started = true;
	    }

	    if (!this.started) {
	      return;
	    }

	    var touches = normalizeSingleTouches.call(this, ev, type); // when done, reset the started state

	    if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
	      this.started = false;
	    }

	    this.callback(this.manager, type, {
	      pointers: touches[0],
	      changedPointers: touches[1],
	      pointerType: INPUT_TYPE_TOUCH,
	      srcEvent: ev
	    });
	  };

	  return SingleTouchInput;
	}(Input);

	function normalizeSingleTouches(ev, type) {
	  var all = toArray(ev.touches);
	  var changed = toArray(ev.changedTouches);

	  if (type & (INPUT_END | INPUT_CANCEL)) {
	    all = uniqueArray(all.concat(changed), 'identifier', true);
	  }

	  return [all, changed];
	}

	/**
	 * @private
	 * wrap a method with a deprecation warning and stack trace
	 * @param {Function} method
	 * @param {String} name
	 * @param {String} message
	 * @returns {Function} A new function wrapping the supplied method.
	 */
	function deprecate(method, name, message) {
	  var deprecationMessage = "DEPRECATED METHOD: " + name + "\n" + message + " AT \n";
	  return function () {
	    var e = new Error('get-stack-trace');
	    var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '').replace(/^\s+at\s+/gm, '').replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
	    var log = window.console && (window.console.warn || window.console.log);

	    if (log) {
	      log.call(window.console, deprecationMessage, stack);
	    }

	    return method.apply(this, arguments);
	  };
	}

	/**
	 * @private
	 * extend object.
	 * means that properties in dest will be overwritten by the ones in src.
	 * @param {Object} dest
	 * @param {Object} src
	 * @param {Boolean} [merge=false]
	 * @returns {Object} dest
	 */

	var extend = deprecate(function (dest, src, merge) {
	  var keys = Object.keys(src);
	  var i = 0;

	  while (i < keys.length) {
	    if (!merge || merge && dest[keys[i]] === undefined) {
	      dest[keys[i]] = src[keys[i]];
	    }

	    i++;
	  }

	  return dest;
	}, 'extend', 'Use `assign`.');

	/**
	 * @private
	 * merge the values from src in the dest.
	 * means that properties that exist in dest will not be overwritten by src
	 * @param {Object} dest
	 * @param {Object} src
	 * @returns {Object} dest
	 */

	var merge = deprecate(function (dest, src) {
	  return extend(dest, src, true);
	}, 'merge', 'Use `assign`.');

	/**
	 * @private
	 * simple class inheritance
	 * @param {Function} child
	 * @param {Function} base
	 * @param {Object} [properties]
	 */

	function inherit(child, base, properties) {
	  var baseP = base.prototype;
	  var childP;
	  childP = child.prototype = Object.create(baseP);
	  childP.constructor = child;
	  childP._super = baseP;

	  if (properties) {
	    assign$1(childP, properties);
	  }
	}

	/**
	 * @private
	 * simple function bind
	 * @param {Function} fn
	 * @param {Object} context
	 * @returns {Function}
	 */
	function bindFn(fn, context) {
	  return function boundFn() {
	    return fn.apply(context, arguments);
	  };
	}

	/**
	 * @private
	 * Simple way to create a manager with a default set of recognizers.
	 * @param {HTMLElement} element
	 * @param {Object} [options]
	 * @constructor
	 */

	var Hammer =
	/*#__PURE__*/
	function () {
	  var Hammer =
	  /**
	    * @private
	    * @const {string}
	    */
	  function Hammer(element, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return new Manager(element, _extends({
	      recognizers: preset.concat()
	    }, options));
	  };

	  Hammer.VERSION = "2.0.17-rc";
	  Hammer.DIRECTION_ALL = DIRECTION_ALL;
	  Hammer.DIRECTION_DOWN = DIRECTION_DOWN;
	  Hammer.DIRECTION_LEFT = DIRECTION_LEFT;
	  Hammer.DIRECTION_RIGHT = DIRECTION_RIGHT;
	  Hammer.DIRECTION_UP = DIRECTION_UP;
	  Hammer.DIRECTION_HORIZONTAL = DIRECTION_HORIZONTAL;
	  Hammer.DIRECTION_VERTICAL = DIRECTION_VERTICAL;
	  Hammer.DIRECTION_NONE = DIRECTION_NONE;
	  Hammer.DIRECTION_DOWN = DIRECTION_DOWN;
	  Hammer.INPUT_START = INPUT_START;
	  Hammer.INPUT_MOVE = INPUT_MOVE;
	  Hammer.INPUT_END = INPUT_END;
	  Hammer.INPUT_CANCEL = INPUT_CANCEL;
	  Hammer.STATE_POSSIBLE = STATE_POSSIBLE;
	  Hammer.STATE_BEGAN = STATE_BEGAN;
	  Hammer.STATE_CHANGED = STATE_CHANGED;
	  Hammer.STATE_ENDED = STATE_ENDED;
	  Hammer.STATE_RECOGNIZED = STATE_RECOGNIZED;
	  Hammer.STATE_CANCELLED = STATE_CANCELLED;
	  Hammer.STATE_FAILED = STATE_FAILED;
	  Hammer.Manager = Manager;
	  Hammer.Input = Input;
	  Hammer.TouchAction = TouchAction;
	  Hammer.TouchInput = TouchInput;
	  Hammer.MouseInput = MouseInput;
	  Hammer.PointerEventInput = PointerEventInput;
	  Hammer.TouchMouseInput = TouchMouseInput;
	  Hammer.SingleTouchInput = SingleTouchInput;
	  Hammer.Recognizer = Recognizer;
	  Hammer.AttrRecognizer = AttrRecognizer;
	  Hammer.Tap = TapRecognizer;
	  Hammer.Pan = PanRecognizer;
	  Hammer.Swipe = SwipeRecognizer;
	  Hammer.Pinch = PinchRecognizer;
	  Hammer.Rotate = RotateRecognizer;
	  Hammer.Press = PressRecognizer;
	  Hammer.on = addEventListeners;
	  Hammer.off = removeEventListeners;
	  Hammer.each = each;
	  Hammer.merge = merge;
	  Hammer.extend = extend;
	  Hammer.bindFn = bindFn;
	  Hammer.assign = assign$1;
	  Hammer.inherit = inherit;
	  Hammer.bindFn = bindFn;
	  Hammer.prefixed = prefixed;
	  Hammer.toArray = toArray;
	  Hammer.inArray = inArray;
	  Hammer.uniqueArray = uniqueArray;
	  Hammer.splitStr = splitStr;
	  Hammer.boolOrFn = boolOrFn;
	  Hammer.hasParent = hasParent;
	  Hammer.addEventListeners = addEventListeners;
	  Hammer.removeEventListeners = removeEventListeners;
	  Hammer.defaults = assign$1({}, defaults, {
	    preset: preset
	  });
	  return Hammer;
	}();

	//  style loader but by script tag, not by the loader.

	var defaults$1 = Hammer.defaults;

	var hammer_esm = /*#__PURE__*/Object.freeze({
		__proto__: null,
		'default': Hammer,
		INPUT_START: INPUT_START,
		INPUT_MOVE: INPUT_MOVE,
		INPUT_END: INPUT_END,
		INPUT_CANCEL: INPUT_CANCEL,
		STATE_POSSIBLE: STATE_POSSIBLE,
		STATE_BEGAN: STATE_BEGAN,
		STATE_CHANGED: STATE_CHANGED,
		STATE_ENDED: STATE_ENDED,
		STATE_RECOGNIZED: STATE_RECOGNIZED,
		STATE_CANCELLED: STATE_CANCELLED,
		STATE_FAILED: STATE_FAILED,
		DIRECTION_NONE: DIRECTION_NONE,
		DIRECTION_LEFT: DIRECTION_LEFT,
		DIRECTION_RIGHT: DIRECTION_RIGHT,
		DIRECTION_UP: DIRECTION_UP,
		DIRECTION_DOWN: DIRECTION_DOWN,
		DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
		DIRECTION_VERTICAL: DIRECTION_VERTICAL,
		DIRECTION_ALL: DIRECTION_ALL,
		Manager: Manager,
		Input: Input,
		TouchAction: TouchAction,
		TouchInput: TouchInput,
		MouseInput: MouseInput,
		PointerEventInput: PointerEventInput,
		TouchMouseInput: TouchMouseInput,
		SingleTouchInput: SingleTouchInput,
		Recognizer: Recognizer,
		AttrRecognizer: AttrRecognizer,
		Tap: TapRecognizer,
		Pan: PanRecognizer,
		Swipe: SwipeRecognizer,
		Pinch: PinchRecognizer,
		Rotate: RotateRecognizer,
		Press: PressRecognizer,
		on: addEventListeners,
		off: removeEventListeners,
		each: each,
		merge: merge,
		extend: extend,
		assign: assign$1,
		inherit: inherit,
		bindFn: bindFn,
		prefixed: prefixed,
		toArray: toArray,
		inArray: inArray,
		uniqueArray: uniqueArray,
		splitStr: splitStr,
		boolOrFn: boolOrFn,
		hasParent: hasParent,
		addEventListeners: addEventListeners,
		removeEventListeners: removeEventListeners,
		defaults: defaults$1
	});

	var require$$0 = /*@__PURE__*/getAugmentedNamespace(hammer_esm);

	var Utils = {};

	Object.defineProperty(Utils, "__esModule", { value: true });
	Utils.blackPixel = void 0;
	Utils.isMobile = isMobile;
	Utils.delay = delay;
	function isMobile() {
	    return /Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
	}
	Utils.blackPixel = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
	function delay(duration) {
	    return new Promise(function (resolve) { return setTimeout(resolve, duration); });
	}

	var hasRequiredComponent_ImageViewer;

	function requireComponent_ImageViewer () {
		if (hasRequiredComponent_ImageViewer) return Component_ImageViewer;
		hasRequiredComponent_ImageViewer = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
		    return new (P || (P = Promise))(function (resolve, reject) {
		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
		        step((generator = generator.apply(thisArg, _arguments || [])).next());
		    });
		};
		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
		    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		    function verb(n) { return function (v) { return step([n, v]); }; }
		    function step(op) {
		        if (f) throw new TypeError("Generator is already executing.");
		        while (g && (g = 0, op[0] && (_ = 0)), _) try {
		            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		            if (y = 0, t) op = [op[0] & 2, t.value];
		            switch (op[0]) {
		                case 0: case 1: t = op; break;
		                case 4: _.label++; return { value: op[1], done: false };
		                case 5: _.label++; y = op[1]; op = [0]; continue;
		                case 7: op = _.ops.pop(); _.trys.pop(); continue;
		                default:
		                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
		                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		                    if (t[2]) _.ops.pop();
		                    _.trys.pop(); continue;
		            }
		            op = body.call(thisArg, _);
		        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		    }
		};
		Object.defineProperty(Component_ImageViewer, "__esModule", { value: true });
		Component_ImageViewer.ComponentImageViewer = void 0;
		var hammerjs_1 = require$$0;
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var Utils_1 = Utils;
		var Morph_Components_1 = requireMorph_Components();
		var ComponentImageViewer = /** @class */ (function (_super) {
		    __extends(ComponentImageViewer, _super);
		    function ComponentImageViewer(options) {
		        var _a, _b, _c, _d, _e;
		        var _this = _super.call(this) || this;
		        _this._rawScale = 1;
		        _this._relativeScale = 1;
		        _this._relativeScaleBase = 1;
		        _this._left = 0;
		        _this._top = 0;
		        _this._firstLoad = true;
		        _this._dragging = false;
		        _this._dragStart = { originX: 0, originY: 0, startX: 0, startY: 0 };
		        window.viewer = _this;
		        _this.background = (_a = options === null || options === void 0 ? void 0 : options.background) !== null && _a !== void 0 ? _a : true;
		        _this.container = (0, CE_1.ce)('div', 'mux_imageviewer');
		        if (options.background != false)
		            _this.container.style.background = 'var(--mux-panel-sub-color)';
		        _this._wrapper = (0, CE_1.ce)('div', 'mux_imageviewer-wrapper');
		        _this._image = (0, CE_1.ce)('img', 'mux_imageviewer-image');
		        _this._image.style.display = 'none';
		        _this._image.addEventListener('load', function () { return __awaiter(_this, void 0, void 0, function () {
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        this._stopLoader();
		                        return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                    case 1:
		                        _a.sent();
		                        this._image.style.display = 'block';
		                        return [2 /*return*/];
		                }
		            });
		        }); });
		        _this._unsupported = (0, CE_1.ce)('div', 'mux_imageviewer-unsupported');
		        _this._unsupportedIcon = (0, CE_1.ce)('span', [
		            'material-symbols-outlined',
		            'mux_imageviewer-unsupported-icon',
		        ]);
		        _this._unsupportedText = (0, CE_1.ce)('div', 'mux_text');
		        _this._unsupportedButton = new Morph_Components_1.MorphComponent.Button({
		            mode: 'normal',
		            content: 'Open externally',
		            materialIcon: 'open_in_new',
		            target: function () {
		                window.open(_this._unsupportedTarget, '_blank');
		            },
		        }).container;
		        _this._unsupported.append(_this._unsupportedIcon, _this._unsupportedText, _this._unsupportedButton);
		        _this._wrapper.appendChild(_this._unsupported);
		        _this._wrapper.appendChild(_this._image);
		        _this._loader = (0, CE_1.ce)('div', 'mux_imageviewer-loader');
		        _this._loader.append((0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'), (0, CE_1.ce)('div', 'mux_imageviewer-loader-dot'));
		        _this._wrapper.appendChild(_this._loader);
		        var controlscontainer = (0, CE_1.ce)('div', 'mux_imageviewer-controlscontainer');
		        var controls = (0, CE_1.ce)('div', 'mux_imageviewer-controls');
		        controlscontainer.appendChild(controls);
		        if ((options === null || options === void 0 ? void 0 : options.controls) != false) {
		            var srcCount = (_c = (_b = options === null || options === void 0 ? void 0 : options.src) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
		            if (srcCount > 1) {
		                _this._thumbnails = (0, CE_1.ce)('div', [
		                    'mux_imageviewer-control',
		                    'mux_active',
		                ]);
		                _this._thumbnails.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'photo_library'));
		                _this._thumbnails.appendChild((0, CE_1.ce)('span', [
		                    'mux_imageviewer-control-badge',
		                    'mux_text',
		                    'mux_tiny',
		                ], null, String(srcCount)));
		                controls.appendChild(_this._thumbnails);
		            }
		            _this._zoomIn = (0, CE_1.ce)('div', 'mux_imageviewer-control');
		            _this._zoomIn.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'zoom_in'));
		            _this._zoomOut = (0, CE_1.ce)('div', 'mux_imageviewer-control');
		            _this._zoomOut.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'zoom_out'));
		            _this._fit = (0, CE_1.ce)('div', 'mux_imageviewer-control');
		            _this._fit.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'fit_screen'));
		            _this._highRes = (0, CE_1.ce)('div', 'mux_imageviewer-control');
		            _this._highRes.style.display = 'none';
		            _this._highRes.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'high_res'));
		            controls.append(_this._zoomIn, _this._zoomOut, _this._fit, _this._highRes);
		        }
		        if ((options === null || options === void 0 ? void 0 : options.downloadable) == true) {
		            var download = (0, CE_1.ce)('div', 'mux_imageviewer-control');
		            download.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'download'));
		            download.addEventListener('click', function () {
		                var a = document.createElement('a');
		                a.href = _this._image.src;
		                a.download = 'image';
		                a.click();
		            });
		            controls.appendChild(download);
		        }
		        if (controls.childNodes.length > 0)
		            _this._wrapper.appendChild(controlscontainer);
		        _this.container.appendChild(_this._wrapper);
		        if ((options === null || options === void 0 ? void 0 : options.src) instanceof Array) {
		            var sources = options.src;
		            if (sources.length == 0)
		                return _this;
		            if (sources.length == 1) {
		                _this.setImage(sources[0]);
		            }
		            else {
		                _this._sources = sources;
		                _this._drawThumbnails(sources, (_d = options === null || options === void 0 ? void 0 : options.thumbnailsOpen) !== null && _d !== void 0 ? _d : ((0, Utils_1.isMobile)() ? false : true));
		                _this._drawNavigationControls();
		                _this._imageCount = sources.length;
		                var startIndex = (_e = options === null || options === void 0 ? void 0 : options.startSrc) !== null && _e !== void 0 ? _e : 0;
		                _this.setImage(sources[startIndex], startIndex);
		            }
		        }
		        else {
		            var source = options.src;
		            _this.setImage(source);
		        }
		        _this.registerListeners();
		        return _this;
		    }
		    ComponentImageViewer.prototype.setImage = function (source, index) {
		        return __awaiter(this, void 0, void 0, function () {
		            var extention;
		            var _this = this;
		            var _a, _b, _c;
		            return __generator(this, function (_d) {
		                switch (_d.label) {
		                    case 0:
		                        this._startLoader();
		                        return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                    case 1:
		                        _d.sent();
		                        this._updateUI(index);
		                        if (source.normal.split('/').pop().split('.').length > 1) {
		                            extention = (_b = (_a = source.normal.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : '';
		                            if (!['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(extention)) {
		                                this._unsupportedTarget = (_c = source.full) !== null && _c !== void 0 ? _c : source.normal;
		                                if (['mp4', 'webm'].includes(extention)) {
		                                    return [2 /*return*/, this._showUnsupported('play_arrow', "Videos are not supported yet. Please open the file in a new tab.")];
		                                }
		                                return [2 /*return*/, this._showUnsupported('error_outline', "File extention ".concat(extention, " is not supported!"))];
		                            }
		                        }
		                        else
		                            this._image.onerror = function () {
		                                _this._showUnsupported('error_outline', "File extention ".concat(extention, " is not supported!"));
		                            };
		                        this._image.src = source.normal;
		                        if (source.full != undefined) {
		                            this._fullSrc = source.full;
		                            this._highRes.style.display = 'flex';
		                        }
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    ComponentImageViewer.prototype.next = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var current, next;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        current = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
		                        if (current == null)
		                            return [2 /*return*/];
		                        next = current.nextElementSibling;
		                        if (next == null)
		                            return [2 /*return*/];
		                        this._startLoader();
		                        return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                    case 1:
		                        _a.sent();
		                        next.click();
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    ComponentImageViewer.prototype.previous = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var current, prev;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        current = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
		                        if (current == null)
		                            return [2 /*return*/];
		                        prev = current.previousElementSibling;
		                        if (prev == null)
		                            return [2 /*return*/];
		                        this._startLoader();
		                        return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                    case 1:
		                        _a.sent();
		                        prev.click();
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    ComponentImageViewer.prototype._updateUI = function (index) {
		        if (index != undefined) {
		            this.callEvent('imageIndexChanged', index);
		            var previousThumb = this.container.querySelector('.mux_imageviewer-gallery-thumb.active');
		            if (previousThumb != null)
		                previousThumb.classList.remove('active');
		            var thumb = this.container.querySelector(".mux_imageviewer-gallery-thumb[index=\"".concat(index, "\"]"));
		            if (thumb != null) {
		                thumb.classList.add('active');
		                thumb.scrollIntoView({
		                    behavior: 'smooth',
		                    inline: 'center',
		                });
		                if (this._firstLoad) {
		                    this._firstLoad = false;
		                    setTimeout(function () {
		                        thumb.scrollIntoView({
		                            behavior: 'smooth',
		                            inline: 'center',
		                        });
		                    }, 500);
		                }
		            }
		        }
		        if (this._prev != undefined)
		            if (index == 0)
		                this._prev.classList.add('disabled');
		            else
		                this._prev.classList.remove('disabled');
		        if (this._next != undefined)
		            if (index == this._imageCount - 1)
		                this._next.classList.add('disabled');
		            else
		                this._next.classList.remove('disabled');
		    };
		    ComponentImageViewer.prototype._showUnsupported = function (icon, text) {
		        this._unsupportedIcon.innerText = icon;
		        this._unsupportedText.innerText = text;
		        this._stopLoader();
		        this._unsupported.style.display = 'flex';
		    };
		    ComponentImageViewer.prototype._startLoader = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        this._loader.style.display = 'flex';
		                        this._unsupported.style.display = 'none';
		                        this._image.style.display = 'none';
		                        return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                    case 1:
		                        _a.sent();
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    ComponentImageViewer.prototype._stopLoader = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            return __generator(this, function (_a) {
		                this._loader.style.display = 'none';
		                this._restartScaling();
		                return [2 /*return*/];
		            });
		        });
		    };
		    ComponentImageViewer.prototype._handleStart = function (originX, originY) {
		        this._dragging = true;
		        this._dragStart = {
		            originX: originX,
		            originY: originY,
		            startX: this._image.offsetLeft,
		            startY: this._image.offsetTop,
		        };
		    };
		    ComponentImageViewer.prototype._handleMove = function (x, y) {
		        var newX = this._validateX(this._dragStart.startX + x - this._dragStart.originX);
		        var newY = this._validateY(this._dragStart.startY + y - this._dragStart.originY);
		        this._left = newX;
		        this._top = newY;
		        this._image.style.left = "".concat(newX, "px");
		        this._image.style.top = "".concat(newY, "px");
		    };
		    ComponentImageViewer.prototype.registerListeners = function () {
		        var _this = this;
		        //Start
		        this.container.addEventListener('mousedown', function (e) {
		            _this._handleStart(e.clientX, e.clientY);
		        });
		        this.container.addEventListener('touchstart', function (e) {
		            _this._handleStart(e.touches[0].clientX, e.touches[0].clientY);
		        });
		        //Move
		        this.container.addEventListener('mousemove', function (e) {
		            if (!_this._dragging)
		                return;
		            if (e.buttons != 1) {
		                _this._dragging = false;
		                return;
		            }
		            _this._handleMove(e.clientX, e.clientY);
		        });
		        this.container.addEventListener('touchmove', function (e) {
		            if (!_this._dragging)
		                return;
		            _this._handleMove(e.touches[0].clientX, e.touches[0].clientY);
		        });
		        //End
		        this.container.addEventListener('mouseup', function (e) {
		            _this._dragging = false;
		        });
		        this.container.addEventListener('touchend', function (e) {
		            _this._dragging = false;
		        });
		        //Zoom
		        this.container.addEventListener('wheel', function (e) {
		            e.preventDefault();
		            _this._setScale(_this._relativeScale + e.deltaY * -0.003);
		        });
		        var mc = new hammerjs_1.default(this._wrapper);
		        mc.add(new hammerjs_1.default.Pinch());
		        var beforeScale = this._relativeScale;
		        mc.on('pinchstart', function (e) {
		            beforeScale = _this._relativeScale;
		        });
		        mc.on('pinch', function (e) {
		            _this._setScale(beforeScale * e.scale);
		        });
		        //Controls
		        if (this._thumbnails != undefined)
		            this._thumbnails.addEventListener('click', function () {
		                if (_this.container.classList.contains('mux_imageviewer-galleryopen')) {
		                    _this.container.classList.remove('mux_imageviewer-galleryopen');
		                    _this._thumbnails.classList.remove('mux_active');
		                    _this.callEvent('thumbnailsOpen', false);
		                }
		                else {
		                    _this.container.classList.add('mux_imageviewer-galleryopen');
		                    _this._thumbnails.classList.add('mux_active');
		                    _this.callEvent('thumbnailsOpen', true);
		                }
		            });
		        if (this._zoomIn != undefined)
		            this._zoomIn.addEventListener('click', function () { return _this.zoomIn(); });
		        if (this._zoomOut != undefined)
		            this._zoomOut.addEventListener('click', function () { return _this.zoomOut(); });
		        if (this._fit != undefined)
		            this._fit.addEventListener('click', function () { return _this.fitToContainer(); });
		        if (this._highRes != undefined)
		            this._highRes.addEventListener('click', function () { return __awaiter(_this, void 0, void 0, function () {
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            this._startLoader();
		                            this._image.style.display = 'none';
		                            return [4 /*yield*/, (0, Utils_1.delay)(10)];
		                        case 1:
		                            _a.sent();
		                            this._image.src = this._fullSrc;
		                            this._highRes.style.display = 'none';
		                            return [2 /*return*/];
		                    }
		                });
		            }); });
		    };
		    ComponentImageViewer.prototype._drawNavigationControls = function () {
		        var _this = this;
		        this._next = (0, CE_1.ce)('div', [
		            'mux_imageviewer-navigation',
		            'mux_imageviewer-navigation-right',
		        ]);
		        this._next.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'navigate_next'));
		        this._next.addEventListener('click', function () {
		            if (_this._next.classList.contains('disabled'))
		                return;
		            _this.next();
		        });
		        this._wrapper.appendChild(this._next);
		        this._prev = (0, CE_1.ce)('div', [
		            'mux_imageviewer-navigation',
		            'mux_imageviewer-navigation-left',
		        ]);
		        this._prev.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'navigate_before'));
		        this._prev.addEventListener('click', function () {
		            if (_this._prev.classList.contains('disabled'))
		                return;
		            _this.previous();
		        });
		        this._wrapper.appendChild(this._prev);
		    };
		    ComponentImageViewer.prototype._drawThumbnails = function (sources, openThumbnails) {
		        var _this = this;
		        var gallery = (0, CE_1.ce)('div', 'mux_imageviewer-gallery');
		        if (this.background != false)
		            gallery.style.background = 'var(--mux-panel-color)';
		        sources.forEach(function (source, index) {
		            var _a;
		            var thumb = (0, CE_1.ce)('img', 'mux_imageviewer-gallery-thumb', {
		                index: index,
		                src: (_a = source.thumbnail) !== null && _a !== void 0 ? _a : source.normal,
		            });
		            thumb.addEventListener('click', function () {
		                _this.setImage(source, index);
		            });
		            gallery.appendChild(thumb);
		        });
		        this.container.appendChild(gallery);
		        if (openThumbnails)
		            this.container.classList.add('mux_imageviewer-galleryopen');
		        this.fitToContainer();
		    };
		    ComponentImageViewer.prototype._validateX = function (x) {
		        var bounds = this._image.getBoundingClientRect();
		        var minInlay = this._wrapper.clientWidth - 10;
		        if (bounds.width < this._wrapper.clientWidth) {
		            x = (this._wrapper.clientWidth - bounds.width) / 2;
		        }
		        else {
		            x = Math.max(x, (bounds.width - minInlay) * -1);
		            x = Math.min(x, this._wrapper.clientWidth - minInlay);
		        }
		        return x;
		    };
		    ComponentImageViewer.prototype._validateY = function (y) {
		        var bounds = this._image.getBoundingClientRect();
		        var minInlay = this._wrapper.clientHeight - 10;
		        if (bounds.height < this._wrapper.clientHeight) {
		            y = (this._wrapper.clientHeight - bounds.height) / 2;
		        }
		        else {
		            y = Math.max(y, (bounds.height - minInlay) * -1);
		            y = Math.min(y, this._wrapper.clientHeight - minInlay);
		        }
		        return y;
		    };
		    ComponentImageViewer.prototype._restartScaling = function () {
		        var _this = this;
		        this._calculateRelativeScale(function () {
		            _this.fitToContainer();
		            _this._startScaleClock();
		        });
		        clearTimeout(this._restartScalingRepeat);
		        this._restartScalingRepeat = setTimeout(function () {
		            _this._calculateRelativeScale(function () {
		                _this.fitToContainer();
		                _this._startScaleClock();
		            });
		        }, 1000);
		    };
		    ComponentImageViewer.prototype._calculateRelativeScale = function (readyCallback) {
		        var _this = this;
		        var bounds = this._image.getBoundingClientRect();
		        clearTimeout(this._fitToContainerRetry);
		        if (bounds.width == 0 ||
		            bounds.height == 0 ||
		            this._image.width == 0 ||
		            this._image.height == 0)
		            return (this._fitToContainerRetry = setTimeout(function () { return _this._calculateRelativeScale(readyCallback); }, 100));
		        var maxWidth = this._wrapper.clientWidth - 20;
		        var maxHeight = this._wrapper.clientHeight - 20;
		        this._relativeScaleBase = Math.min(maxWidth / this._image.width, maxHeight / this._image.height);
		        this._setScale(this._relativeScale);
		        if (typeof readyCallback == 'function')
		            readyCallback();
		    };
		    ComponentImageViewer.prototype._setScale = function (factor) {
		        this._relativeScale = Math.min(Math.max(factor, 1), 10);
		        this._setRawScale(this._relativeScaleBase * factor);
		    };
		    ComponentImageViewer.prototype._setRawScale = function (scale) {
		        var bounds = this._image.getBoundingClientRect();
		        this._rawScale = Math.max(scale, this._relativeScaleBase);
		        var widthDiff = bounds.width - this._rawScale * this._image.clientWidth;
		        var heightDiff = bounds.height - this._rawScale * this._image.clientHeight;
		        this._image.style.transform = "scale(".concat(this._rawScale, ")");
		        this._left = this._validateX(this._left + widthDiff / 2);
		        this._image.style.left = "".concat(this._left, "px");
		        this._top = this._validateY(this._top + heightDiff / 2);
		        this._image.style.top = "".concat(this._top, "px");
		    };
		    ComponentImageViewer.prototype._startScaleClock = function () {
		        var _this = this;
		        if (this._startScaleClockInt != undefined)
		            return;
		        var lastWidth = this._wrapper.clientWidth;
		        var lastHeight = this._wrapper.clientHeight;
		        clearInterval(this._startScaleClockInt);
		        this._startScaleClockInt = setInterval(function () {
		            if (_this.container.parentElement == null)
		                return clearInterval(_this._startScaleClockInt);
		            if (lastWidth != _this._wrapper.clientWidth ||
		                lastHeight != _this._wrapper.clientHeight) {
		                lastWidth = _this._wrapper.clientWidth;
		                lastHeight = _this._wrapper.clientHeight;
		                _this._calculateRelativeScale();
		            }
		        }, 100);
		    };
		    ComponentImageViewer.prototype.setImageIndex = function (index) {
		        if (this._sources == undefined)
		            return;
		        if (this._sources[index] == undefined)
		            return;
		        this.setImage(this._sources[index], index);
		    };
		    ComponentImageViewer.prototype.fitToContainer = function () {
		        this._setScale(1);
		        this._left = this._validateX((this._wrapper.clientWidth - this._image.width * this._rawScale) / 2);
		        this._top = this._validateY((this._wrapper.clientHeight - this._image.height * this._rawScale) /
		            2);
		        this._image.style.left = "".concat(this._left, "px");
		        this._image.style.top = "".concat(this._top, "px");
		        this._image.style.opacity = '1';
		    };
		    ComponentImageViewer.prototype.zoomIn = function () {
		        this._setScale(this._relativeScale + 0.3);
		    };
		    ComponentImageViewer.prototype.zoomOut = function () {
		        this._setScale(this._relativeScale - 0.3);
		    };
		    return ComponentImageViewer;
		}(baseComponent_1.MUXComponent));
		Component_ImageViewer.ComponentImageViewer = ComponentImageViewer;
		
		return Component_ImageViewer;
	}

	var Component_Input = {};

	var __extends$3 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Input, "__esModule", { value: true });
	Component_Input.ComponentInput = void 0;
	var CE_1$3 = CE;
	var baseComponent_1$3 = baseComponent;
	var ComponentInput = /** @class */ (function (_super) {
	    __extends$3(ComponentInput, _super);
	    function ComponentInput(options) {
	        var _a;
	        var _this = _super.call(this) || this;
	        _this.container = (0, CE_1$3.ce)('input', 'mux_input', {
	            type: options.type,
	        });
	        var border = (_a = options.border) !== null && _a !== void 0 ? _a : 'hover';
	        if (border == 'always')
	            _this.container.classList.add('mux_input-alwaysborder');
	        else if (border == 'never')
	            _this.container.classList.add('mux_input-noborder');
	        if ((options === null || options === void 0 ? void 0 : options.min) != undefined)
	            _this.container.min = String(options.min);
	        if ((options === null || options === void 0 ? void 0 : options.max) != undefined)
	            _this.container.max = String(options.max);
	        if ((options === null || options === void 0 ? void 0 : options.step) != undefined)
	            _this.container.step = String(options.step);
	        if ((options === null || options === void 0 ? void 0 : options.maxLength) != undefined)
	            _this.container.maxLength = options.maxLength;
	        if ((options === null || options === void 0 ? void 0 : options.readOnly) != undefined)
	            _this.container.readOnly = options.readOnly;
	        if ((options === null || options === void 0 ? void 0 : options.placeholder) != undefined)
	            _this.container.placeholder = options.placeholder;
	        if ((options === null || options === void 0 ? void 0 : options.value) != undefined)
	            _this.container.value = options.value;
	        if ((options === null || options === void 0 ? void 0 : options.valueAsNumber) != undefined)
	            _this.container.valueAsNumber = options.valueAsNumber;
	        if (options.enabled == false)
	            _this.container.setAttribute('disabled', '');
	        _this.container.oninput = function () {
	            return _this.callEvent('input', _this.container.value);
	        };
	        _this.container.onfocus = function () { return _this.callEvent('focus'); };
	        _this.container.onblur = function () { return _this.callEvent('blur'); };
	        return _this;
	    }
	    ComponentInput.prototype.getValue = function () {
	        return this.container.value;
	    };
	    ComponentInput.prototype.getValueAsNumber = function () {
	        return this.container.valueAsNumber;
	    };
	    ComponentInput.prototype.setValue = function (value) {
	        this.container.value = value;
	    };
	    ComponentInput.prototype.setValueAsNumber = function (value) {
	        this.container.valueAsNumber = value;
	    };
	    return ComponentInput;
	}(baseComponent_1$3.MUXComponent));
	Component_Input.ComponentInput = ComponentInput;

	var Component_List = {};

	var hasRequiredComponent_List;

	function requireComponent_List () {
		if (hasRequiredComponent_List) return Component_List;
		hasRequiredComponent_List = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_List, "__esModule", { value: true });
		Component_List.ComponentList = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var Sortable = SortableExports;
		var ComponentList = /** @class */ (function (_super) {
		    __extends(ComponentList, _super);
		    function ComponentList(options) {
		        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
		        var _this = _super.call(this) || this;
		        _this.openGroups = [];
		        _this.groupComponents = new Map();
		        _this.options = options;
		        _this.dragable = (_a = options === null || options === void 0 ? void 0 : options.dragable) !== null && _a !== void 0 ? _a : false;
		        _this.hover = (_b = options === null || options === void 0 ? void 0 : options.hover) !== null && _b !== void 0 ? _b : false;
		        _this.grouped = (_c = options === null || options === void 0 ? void 0 : options.grouped) !== null && _c !== void 0 ? _c : false;
		        _this.groupsCloseable = (_d = options === null || options === void 0 ? void 0 : options.groupsCloseable) !== null && _d !== void 0 ? _d : false;
		        _this.sortGroupsAlphabetically =
		            (_e = options === null || options === void 0 ? void 0 : options.sortGroupsAlphabetically) !== null && _e !== void 0 ? _e : false;
		        _this.openGroups = (_f = options === null || options === void 0 ? void 0 : options.groupsOpen) !== null && _f !== void 0 ? _f : [];
		        _this.allowSingleItemGroups = (_g = options === null || options === void 0 ? void 0 : options.allowSingleItemGroups) !== null && _g !== void 0 ? _g : false;
		        _this.highlighted = (_h = options === null || options === void 0 ? void 0 : options.highlightedItem) !== null && _h !== void 0 ? _h : null;
		        if (_this.dragable == true && _this.grouped == true)
		            throw new Error("Unable to use 'grouped' for list component when 'canReorderByDrag' is also enabled. ");
		        _this.container = (0, CE_1.ce)('div', 'mux_list');
		        _this.updateItems((_j = options === null || options === void 0 ? void 0 : options.items) !== null && _j !== void 0 ? _j : []);
		        if (_this.dragable == true) {
		            _this.sortable = new Sortable(_this.container, {
		                ghostClass: 'mux_list-item-dragging',
		                onStart: function () {
		                    _this.container.classList.add('mux_list-dragging');
		                },
		                onEnd: function (evt) {
		                    _this.container.classList.remove('mux_list-dragging');
		                    _this.callEvent('orderUpdated', _this.getCurrentOrder());
		                },
		            });
		        }
		        return _this;
		    }
		    ComponentList.prototype.updateItems = function (items) {
		        var _this = this;
		        var _a;
		        this.container.innerHTML = '';
		        this.groupComponents.clear();
		        if (items == undefined || items.length == 0)
		            return;
		        if (this.grouped) {
		            var groups = [];
		            for (var i = 0; i < items.length; i++) {
		                var group = (_a = items[i].group) !== null && _a !== void 0 ? _a : 'Ungrouped';
		                if (!groups.includes(group)) {
		                    groups.push(group);
		                }
		            }
		            if (this.sortGroupsAlphabetically == true)
		                groups.sort();
		            for (var i = 0; i < groups.length; i++) {
		                this.ensureGroup(groups[i]);
		            }
		        }
		        items.forEach(function (item) { return _this.addItem(item); });
		        this.groupComponents.forEach(function (_a, group) {
		            var container = _a.container, content = _a.content;
		            if (content.children.length == 0) {
		                container.parentElement.removeChild(container);
		                _this.groupComponents.delete(group);
		            }
		            else {
		                if (content.children.length == 1 &&
		                    _this.allowSingleItemGroups == false) {
		                    container.classList.add('mux_group-singular');
		                }
		                else
		                    container.classList.remove('mux_group-singular');
		            }
		        });
		    };
		    ComponentList.prototype.getCurrentOrder = function () {
		        return Array.from(this.container.querySelectorAll('.mux_list-item')).map(function (item) {
		            return item.getAttribute('uid');
		        });
		    };
		    ComponentList.prototype.removeItem = function (uniqueIdentifier) {
		        var match = this.container.querySelector(".mux_list-item[uid=\"".concat(uniqueIdentifier, "\"]"));
		        if (match != null)
		            match.remove();
		        this.callEvent('orderUpdated', this.getCurrentOrder());
		    };
		    ComponentList.prototype.addItem = function (item) {
		        var _this = this;
		        var _a, _b;
		        var element = (0, CE_1.ce)('div', 'mux_list-item', {
		            uid: item.uniqueIdentifier,
		        });
		        if (this.hover)
		            element.classList.add('mux_list-item-hover');
		        // if (showSeperator) element.classList.add('mux_list-item-separator');
		        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.overwriteCursor) != null)
		            element.style.cursor = this.options.overwriteCursor;
		        if (this.highlighted != null &&
		            this.highlighted == item.uniqueIdentifier)
		            element.classList.add('mux_list-item-selected');
		        if (item.tooltip != undefined)
		            element.title = item.tooltip;
		        if (item.enabled == false)
		            element.classList.add('mux_list-item-disabled');
		        var content = (0, CE_1.ce)('div', 'mux_list-item-content');
		        element.appendChild(content);
		        element.onclick = function (e) {
		            var _a;
		            if (((_a = _this.options) === null || _a === void 0 ? void 0 : _a.highlightOnClick) == true)
		                _this.highlight(item.uniqueIdentifier);
		            if (item.click != undefined)
		                item.click();
		        };
		        if (item.materialIcon != undefined) {
		            var mi = (0, CE_1.ce)('span', ['mux_list-item-icon', 'material-symbols-outlined'], null, item.materialIcon);
		            content.appendChild(mi);
		            if (item.materialIconColor != undefined)
		                mi.style.color = item.materialIconColor;
		        }
		        else if (item.icon != undefined)
		            content.appendChild((0, CE_1.ce)('img', 'mux_list-item-icon', { src: item.icon }));
		        var text = (0, CE_1.ce)('div', 'mux_list-item-text');
		        if (item.text != undefined)
		            text.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_normal'], null, item.text));
		        if (item.subText != undefined)
		            text.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small'], null, item.subText));
		        content.appendChild(text);
		        if (item.actions != undefined && item.actions.length > 0) {
		            var actions = (0, CE_1.ce)('div', 'mux_list-item-actions');
		            var _loop_1 = function (i) {
		                action = (0, CE_1.ce)('div', 'mux_list-item-action');
		                if (item.actions[i].tooltip != undefined)
		                    action.title = item.actions[i].tooltip;
		                if (item.actions[i].materialIcon != undefined)
		                    action.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, item.actions[i].materialIcon));
		                else if (item.actions[i].icon != undefined)
		                    action.appendChild((0, CE_1.ce)('img', null, { src: item.actions[i].icon }));
		                action.onclick = function (e) {
		                    e.stopPropagation();
		                    e.stopImmediatePropagation();
		                    item.actions[i].click();
		                };
		                actions.appendChild(action);
		            };
		            var action;
		            for (var i = 0; i < item.actions.length; i++) {
		                _loop_1(i);
		            }
		            content.appendChild(actions);
		        }
		        if (this.grouped == true) {
		            var group = (_b = item.group) !== null && _b !== void 0 ? _b : 'Ungrouped';
		            var content = this.ensureGroup(group).content;
		            content.appendChild(element);
		        }
		        else
		            this.container.appendChild(element);
		        this.size = this.container.querySelectorAll('.mux_list-item').length;
		    };
		    ComponentList.prototype.highlight = function (uniqueIdentifier) {
		        this.highlighted = uniqueIdentifier;
		        this.container
		            .querySelectorAll('.mux_list-item')
		            .forEach(function (item) {
		            var uid = item.getAttribute('uid');
		            if (uid == uniqueIdentifier) {
		                item.classList.add('mux_list-item-selected');
		                item.scrollIntoView({
		                    behavior: 'smooth',
		                    block: 'center',
		                });
		            }
		            else
		                item.classList.remove('mux_list-item-selected');
		        });
		    };
		    ComponentList.prototype.ensureGroup = function (group) {
		        var _this = this;
		        if (this.groupComponents.has(group))
		            return this.groupComponents.get(group);
		        var groupComponent = new Index_1.MorphComponent.Group({
		            title: group,
		            open: this.openGroups.includes(group) ||
		                this.openGroups.includes('*') ||
		                this.groupsCloseable == false,
		            closeable: this.groupsCloseable,
		        });
		        groupComponent.on('openState', function (state) {
		            if (state) {
		                if (!_this.openGroups.includes(group))
		                    _this.openGroups.push(group);
		            }
		            else {
		                if (_this.openGroups.includes(group))
		                    _this.openGroups.splice(_this.openGroups.indexOf(group), 1);
		            }
		            _this.callEvent('openGroupsUpdated', _this.openGroups);
		        });
		        this.container.appendChild(groupComponent.container);
		        this.groupComponents.set(group, groupComponent);
		        return this.groupComponents.get(group);
		    };
		    return ComponentList;
		}(baseComponent_1.MUXComponent));
		Component_List.ComponentList = ComponentList;
		
		return Component_List;
	}

	var Component_MenuBar = {};

	var hasRequiredComponent_MenuBar;

	function requireComponent_MenuBar () {
		if (hasRequiredComponent_MenuBar) return Component_MenuBar;
		hasRequiredComponent_MenuBar = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		Object.defineProperty(Component_MenuBar, "__esModule", { value: true });
		Component_MenuBar.ComponentMenuBar = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var ComponentMenuBar = /** @class */ (function (_super) {
		    __extends(ComponentMenuBar, _super);
		    function ComponentMenuBar(options) {
		        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
		        var _this = _super.call(this) || this;
		        _this.enabledStates = {};
		        _this._leftItems = [];
		        _this._rightItems = [];
		        _this.mobileIgnoreItems = [];
		        _this._leftItems = (_a = options.left) !== null && _a !== void 0 ? _a : [];
		        _this._rightItems = (_b = options.right) !== null && _b !== void 0 ? _b : [];
		        _this.contextMaterialIconColor =
		            (_c = options.contextMaterialIconColor) !== null && _c !== void 0 ? _c : 'var(--mux-primary-color)';
		        _this.contextMenuAlign = (_d = options.contextMenuAlign) !== null && _d !== void 0 ? _d : 'below';
		        _this.contextAlignSide = {
		            below: 'center',
		            left: 'right',
		            right: 'left',
		        }[_this.contextMenuAlign];
		        _this.container = (0, CE_1.ce)('div', 'mux_menubar');
		        _this.size = (_e = options.size) !== null && _e !== void 0 ? _e : 'normal';
		        _this.container.classList.add("mux_menubar-".concat(_this.size));
		        _this.direction = (_f = options === null || options === void 0 ? void 0 : options.direction) !== null && _f !== void 0 ? _f : 'horizontal';
		        _this.container.classList.add("mux_menubar-direction-".concat(_this.direction));
		        _this.leftContainer = (0, CE_1.ce)('div', ['mux_menubar-locater', 'mux_left']);
		        _this.rightContainer = (0, CE_1.ce)('div', ['mux_menubar-locater', 'mux_right']);
		        _this.mobileContainer = (0, CE_1.ce)('div', 'mux_menubar-mobile');
		        var mobileRightItems = (0, CE_1.ce)('div', [
		            'mux_menubar-mobile-items',
		            'mux_right',
		        ]);
		        ((_h = (_g = options === null || options === void 0 ? void 0 : options.mobile) === null || _g === void 0 ? void 0 : _g.right) !== null && _h !== void 0 ? _h : []).forEach(function (item) {
		            return _this.addItem(item, mobileRightItems);
		        });
		        var mobileLeftItems = (0, CE_1.ce)('div', [
		            'mux_menubar-mobile-items',
		            'mux_left',
		        ]);
		        ((_k = (_j = options === null || options === void 0 ? void 0 : options.mobile) === null || _j === void 0 ? void 0 : _j.left) !== null && _k !== void 0 ? _k : []).forEach(function (item) {
		            return _this.addItem(item, mobileLeftItems);
		        });
		        if (((_l = options === null || options === void 0 ? void 0 : options.mobile) === null || _l === void 0 ? void 0 : _l.logo) != undefined) {
		            mobileLeftItems.style.left = '50px';
		            var logo = (0, CE_1.ce)('a', 'mux_menubar-mobile-logo', {
		                href: options.mobile.logo.href,
		            });
		            logo.appendChild((0, CE_1.ce)('img', null, { src: options.mobile.logo.src }));
		            _this.mobileContainer.appendChild(logo);
		        }
		        _this.mobileIgnoreItems = (_o = (_m = options === null || options === void 0 ? void 0 : options.mobile) === null || _m === void 0 ? void 0 : _m.ignoreItems) !== null && _o !== void 0 ? _o : [];
		        _this.addItem({
		            type: 'icon',
		            materialIcon: 'menu',
		            click: function () {
		                _this.openMobileMenu();
		                // this.rightContainer.classList.toggle('mux_menubar-visible');
		            },
		        }, mobileRightItems);
		        _this.mobileContainer.append(mobileLeftItems, mobileRightItems);
		        _this.container.append(_this.leftContainer, _this.rightContainer, _this.mobileContainer);
		        if ((options === null || options === void 0 ? void 0 : options.left) != undefined)
		            options.left.forEach(function (item) {
		                return _this.addItem(item, _this.leftContainer);
		            });
		        if ((options === null || options === void 0 ? void 0 : options.right) != undefined)
		            options.right.forEach(function (item) {
		                return _this.addItem(item, _this.rightContainer);
		            });
		        if (_this.direction == 'horizontal') {
		            _this.calculateSizing();
		            window.addEventListener('resize', function () {
		                _this.calculateSizing();
		            });
		            var c = 0;
		            _this.sizeClock = setInterval(function () {
		                if (c++ > 200)
		                    clearInterval(_this.sizeClock);
		                if (_this.container.parentElement != null) {
		                    clearInterval(_this.sizeClock);
		                    _this.calculateSizing();
		                }
		            }, 10);
		        }
		        else {
		            _this.leftContainer.classList.add('mux_menubar-visible');
		            _this.rightContainer.classList.add('mux_menubar-visible');
		        }
		        return _this;
		    }
		    ComponentMenuBar.prototype.calculateSizing = function () {
		        var menuSize = this.leftContainer.clientWidth + this.rightContainer.clientWidth;
		        var containerWidth = this.container.clientWidth;
		        if (menuSize != 0 && containerWidth != 0)
		            clearInterval(this.sizeClock);
		        if (menuSize > containerWidth) {
		            this.leftContainer.classList.remove('mux_menubar-visible');
		            this.rightContainer.classList.remove('mux_menubar-visible');
		            this.mobileContainer.classList.add('mux_menubar-visible');
		        }
		        else {
		            this.leftContainer.classList.add('mux_menubar-visible');
		            this.rightContainer.classList.add('mux_menubar-visible');
		            this.mobileContainer.classList.remove('mux_menubar-visible');
		        }
		    };
		    ComponentMenuBar.prototype.addItem = function (item, target) {
		        var _this = this;
		        if (item.type != 'image') {
		            var element = (0, CE_1.ce)(item.href != undefined ? 'a' : 'div', 'mux_menubar-item');
		            if (item.uniqueIdentifier != undefined)
		                element.setAttribute('uid', item.uniqueIdentifier);
		            if (item.enabled != undefined && item.enabled == false)
		                element.classList.add('mux_menubar-item-disabled');
		            if (item.href != undefined)
		                element.setAttribute('href', item.href);
		            if (item.tooltip != undefined)
		                element.title = item.tooltip;
		            if (item.selected == true)
		                element.classList.add('mux_menubar-item-selected');
		            if (item.materialIcon != undefined) {
		                var materialIcon = (0, CE_1.ce)('span', [
		                    'mux_menubar-item-materialicon',
		                    'material-symbols-outlined',
		                ], null, item.materialIcon);
		                if (item.materialIconTransform != undefined)
		                    materialIcon.style.transform = item.materialIconTransform;
		                element.appendChild(materialIcon);
		            }
		            switch (item.type) {
		                case 'icon':
		                    element.classList.add('mux_menubar-item-icon');
		                    element.onclick = item.click;
		                    break;
		                case 'normal':
		                    element.classList.add('mux_menubar-item-normal');
		                    element.appendChild((0, CE_1.ce)('p', ['mux_text', "mux_".concat(this.size)], null, item.text));
		                    break;
		            }
		            if (item.children == undefined || item.children.length == 0) {
		                if (item.click != undefined && item.href == undefined)
		                    element.onclick = item.click;
		            }
		            else {
		                // if (item.type == 'normal')
		                element.appendChild((0, CE_1.ce)('span', ['material-symbols-outlined', 'mux_menubar-item-arrow'], null, "keyboard_arrow_".concat({ below: 'down', left: 'left', right: 'right' }[this.contextMenuAlign])));
		                element.onclick = function () {
		                    var _a;
		                    if (element.classList.contains('mux_menubar-item-disabled'))
		                        return;
		                    var bounds = element.getBoundingClientRect();
		                    element.classList.add('mux_menubar-item-selected');
		                    for (var i = 0; i < item.children.length; i++)
		                        if (((_a = item.children[i]) === null || _a === void 0 ? void 0 : _a.uniqueIdentifier) != undefined) {
		                            if (_this.enabledStates[item.children[i].uniqueIdentifier] != undefined)
		                                item.children[i].enabled =
		                                    _this.enabledStates[item.children[i].uniqueIdentifier];
		                        }
		                    var x;
		                    var y;
		                    if (_this.contextMenuAlign == 'below') {
		                        x = bounds.x + bounds.width / 2;
		                        y = bounds.y + bounds.height;
		                    }
		                    else if (_this.contextMenuAlign == 'left') {
		                        x = bounds.x;
		                        y = bounds.y;
		                    }
		                    else if (_this.contextMenuAlign == 'right') {
		                        x = bounds.x + bounds.width;
		                        y = bounds.y;
		                    }
		                    _this.dropdown = new Index_1.MorphComponent.ContextMenu({
		                        x: x,
		                        y: y,
		                        align: _this.contextAlignSide,
		                        items: item.children,
		                        materialIconColor: _this.contextMaterialIconColor,
		                    });
		                    _this.dropdown.on('close', function () {
		                        element.classList.remove('mux_menubar-item-selected');
		                    });
		                };
		            }
		            target.appendChild(element);
		        }
		        else {
		            var icon = (0, CE_1.ce)(item.href != undefined ? 'a' : 'div', 'mux_menubar-image');
		            if (item.href != undefined)
		                icon.href = item.href;
		            icon.appendChild((0, CE_1.ce)('img', null, { src: item.url }));
		            target.appendChild(icon);
		        }
		    };
		    ComponentMenuBar.prototype.setSelected = function (uniqueIdentifier) {
		        this.selected = uniqueIdentifier;
		        this.container
		            .querySelectorAll('.mux_menubar-item')
		            .forEach(function (item) {
		            if (item.getAttribute('uid') == uniqueIdentifier &&
		                uniqueIdentifier != null)
		                item.classList.add('mux_menubar-item-selected');
		            else
		                item.classList.remove('mux_menubar-item-selected');
		        });
		        if (this.mobileMenu != null)
		            this.mobileMenu.setSelected(uniqueIdentifier);
		    };
		    ComponentMenuBar.prototype.setEnabled = function (uniqueIdentifier, enabled) {
		        var item = this.container.querySelector(".mux_menubar-item[uid=\"".concat(uniqueIdentifier, "\"]"));
		        if (item == null)
		            return;
		        if (enabled)
		            item.classList.remove('mux_menubar-item-disabled');
		        else
		            item.classList.add('mux_menubar-item-disabled');
		    };
		    ComponentMenuBar.prototype.openMobileMenu = function () {
		        var _this = this;
		        var container = (0, CE_1.ce)('div', 'mux_mobilemenu');
		        var inner = (0, CE_1.ce)('div', 'mux_mobilemenu-inner');
		        this.mobileMenu = new ComponentMenuBar({
		            direction: 'vertical',
		            left: this._leftItems
		                .filter(function (item) {
		                if (item.uniqueIdentifier == undefined)
		                    return true;
		                return !_this.mobileIgnoreItems.includes(item.uniqueIdentifier);
		            })
		                .map(function (item) {
		                if (item.type !== 'icon')
		                    return item;
		                return __assign(__assign({}, item), { type: 'normal' });
		            }),
		            right: this._rightItems
		                .filter(function (item) {
		                if (item.uniqueIdentifier == undefined)
		                    return true;
		                return !_this.mobileIgnoreItems.includes(item.uniqueIdentifier);
		            })
		                .map(function (item) {
		                if (item.type !== 'icon')
		                    return item;
		                return __assign(__assign({}, item), { type: 'normal' });
		            }),
		        });
		        this.mobileMenu.setSelected(this.selected);
		        inner.appendChild(this.mobileMenu.container);
		        container.appendChild(inner);
		        document.body.appendChild(container);
		        container.animate({ opacity: '1' }, { duration: 200 }).onfinish =
		            function () {
		                container.style.opacity = '1';
		            };
		        inner.animate({ transform: 'translateX(0%)' }, { duration: 200, easing: 'ease-out' }).onfinish = function () {
		            inner.style.transform = 'translateX(0%)';
		        };
		        container.onclick = function () {
		            container.animate({ opacity: '0' }, { duration: 200 }).onfinish =
		                function () {
		                    container.style.opacity = '0';
		                };
		            inner.animate({ transform: 'translateX(100%)' }, { duration: 200, easing: 'ease-in' }).onfinish = function () {
		                inner.style.transform = 'translateX(100%)';
		                _this.mobileMenu = null;
		                container.remove();
		            };
		        };
		        inner.onclick = function (e) {
		            e.stopPropagation();
		        };
		    };
		    return ComponentMenuBar;
		}(baseComponent_1.MUXComponent));
		Component_MenuBar.ComponentMenuBar = ComponentMenuBar;
		
		return Component_MenuBar;
	}

	var Component_PaletteCheckbox = {};

	var hasRequiredComponent_PaletteCheckbox;

	function requireComponent_PaletteCheckbox () {
		if (hasRequiredComponent_PaletteCheckbox) return Component_PaletteCheckbox;
		hasRequiredComponent_PaletteCheckbox = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_PaletteCheckbox, "__esModule", { value: true });
		Component_PaletteCheckbox.ComponentPaletteCheckbox = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var ComponentPaletteCheckbox = /** @class */ (function (_super) {
		    __extends(ComponentPaletteCheckbox, _super);
		    function ComponentPaletteCheckbox(options) {
		        var _a;
		        var _this = _super.call(this) || this;
		        _this.defaultView = 'recent_and_rest';
		        _this.lastChecked = [];
		        _this.recents = [];
		        _this.pid = options === null || options === void 0 ? void 0 : options.paletteUniqueIdentifier;
		        // if (pid != undefined && pid.length > 0)
		        // 	lastChecked = Validator.array(
		        // 		FieldStorage.getChannelValue('palette_checkbox', pid),
		        // 		[]
		        // 	);
		        _this.container = (0, CE_1.ce)('div', ['mux_palette', 'mux_palette-checkboxes']);
		        _this.container.onclick = function () { return _this.close(); };
		        _this.inner = (0, CE_1.ce)('div', 'mux_palette-inner');
		        _this.inner.onclick = function (e) { return e.stopPropagation(); };
		        _this.results = (0, CE_1.ce)('div', ['mux_palette-results']);
		        _this.inner.appendChild(_this.results);
		        _this.container.appendChild(_this.inner);
		        if ((options === null || options === void 0 ? void 0 : options.title) != undefined && options.title.trim().length > 0) {
		            _this.showResultLabel(options.title);
		        }
		        ((_a = options === null || options === void 0 ? void 0 : options.items) !== null && _a !== void 0 ? _a : []).forEach(function (item, i) {
		            return _this.renderSearchResult(item, i);
		        });
		        document.body.appendChild(_this.container);
		        setTimeout(function () {
		            _this.container.style.opacity = '1';
		            _this.inner.style.opacity = '1';
		            _this.inner.style.transform = 'scale(1)';
		        }, 20);
		        _this.registerKeyListener();
		        return _this;
		    }
		    ComponentPaletteCheckbox.prototype.close = function () {
		        var _this = this;
		        this.overwrite.close();
		        this.container.style.pointerEvents = 'none';
		        this.container.style.opacity = '0';
		        this.inner.style.opacity = '0';
		        this.inner.style.transform = 'scale(0.8)';
		        setTimeout(function () { return _this.destroy(); }, 400);
		        this.callEvent('close');
		    };
		    ComponentPaletteCheckbox.prototype.getChecked = function () {
		        var selected = Array.from(this.results.querySelectorAll('.mux_palette-results-item-checked')).map(function (item) {
		            return item.getAttribute('uid');
		        });
		        this.lastChecked = selected;
		        // FieldStorage.setChannelValue('palette_checkbox', this.pid, selected);
		        return selected;
		    };
		    ComponentPaletteCheckbox.prototype.renderSearchResult = function (result, index) {
		        var _this = this;
		        if (result.uniqueIdentifier == undefined)
		            throw new Error("Missing property 'uniqueIdentifier' inside one or more items of component 'PaletteCheckbox'");
		        var item = (0, CE_1.ce)('div', 'mux_palette-results-item', {
		            uid: result.uniqueIdentifier,
		        });
		        if (this.lastChecked.length == 0 && result.defaultValue == true)
		            item.classList.add('mux_palette-results-item-checked');
		        if (this.lastChecked.includes(result.uniqueIdentifier))
		            item.classList.add('mux_palette-results-item-checked');
		        if (index == 0)
		            item.classList.add('mux_palette-results-item-selected');
		        item.addEventListener('click', function () {
		            if (item.classList.contains('mux_palette-results-item-checked'))
		                item.classList.remove('mux_palette-results-item-checked');
		            else
		                item.classList.add('mux_palette-results-item-checked');
		            _this.getChecked();
		        });
		        var checkbox = (0, CE_1.ce)('div', 'mux_palette-results-item-checkbox');
		        checkbox.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, 'done'));
		        item.appendChild(checkbox);
		        if (result.materialIcon != undefined) {
		            var icon = (0, CE_1.ce)('div', 'material-symbols-outlined', null, result.materialIcon);
		            if (result.materialIconTransform != undefined)
		                icon.style.transform = result.materialIconTransform;
		            item.appendChild(icon);
		        }
		        else if (result.iconSrc != undefined)
		            item.appendChild((0, CE_1.ce)('img', 'mux_palette-results-item-icon', {
		                src: result.iconSrc,
		            }));
		        var text = (0, CE_1.ce)('div', [
		            'mux_palette-results-item-text',
		            'mux_text',
		            'mux_small',
		        ]);
		        if (result.prefix != undefined)
		            text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.prefix.trim()));
		        text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-main', null, result.name.trim()));
		        if (result.suffix != undefined)
		            text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.suffix.trim()));
		        item.appendChild(text);
		        item.appendChild((0, CE_1.ce)('div', [
		            'mux_palette-results-item-selectedtext',
		            'mux_text',
		            'mux_tiny',
		        ], null, '<space> to toggle'));
		        this.results.appendChild(item);
		        return item;
		    };
		    ComponentPaletteCheckbox.prototype.registerKeyListener = function () {
		        var _this = this;
		        this.overwrite = Index_1.MorphKey.createOverwrite();
		        this.overwrite.bind('Escape', function () { return _this.close(); });
		        this.overwrite.bind('Enter', function () {
		            var checked = _this.getChecked();
		            _this.callEvent('selected', checked);
		            _this.close();
		        });
		        this.overwrite.bind(' ', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null)
		                selected.click();
		        });
		        this.overwrite.bind('ArrowUp', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null &&
		                selected.previousElementSibling != null &&
		                selected.previousElementSibling.classList.contains('mux_palette-results-item')) {
		                selected.classList.remove('mux_palette-results-item-selected');
		                selected.previousElementSibling.classList.add('mux_palette-results-item-selected');
		                setTimeout(function () {
		                    if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
		                        selected.previousElementSibling.scrollIntoView({
		                            behavior: 'auto',
		                            block: 'center',
		                            inline: 'center',
		                        });
		                }, 50);
		            }
		        });
		        this.overwrite.bind('ArrowDown', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null &&
		                selected.nextElementSibling != null &&
		                selected.nextElementSibling.classList.contains('mux_palette-results-item')) {
		                selected.classList.remove('mux_palette-results-item-selected');
		                selected.nextElementSibling.classList.add('mux_palette-results-item-selected');
		                setTimeout(function () {
		                    if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
		                        selected.previousElementSibling.scrollIntoView({
		                            behavior: 'auto',
		                            block: 'center',
		                            inline: 'center',
		                        });
		                }, 50);
		            }
		        });
		    };
		    ComponentPaletteCheckbox.prototype.showResultLabel = function (text, materialIcon) {
		        var label = (0, CE_1.ce)('div', 'mux_palette-results-header');
		        if (materialIcon != undefined)
		            label.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, materialIcon));
		        label.appendChild((0, CE_1.ce)('span', null, null, text));
		        this.results.appendChild(label);
		    };
		    ComponentPaletteCheckbox.prototype.getSelectedResult = function () {
		        if (this.results == null)
		            return null;
		        return this.results.querySelector('.mux_palette-results-item-selected');
		    };
		    return ComponentPaletteCheckbox;
		}(baseComponent_1.MUXComponent));
		Component_PaletteCheckbox.ComponentPaletteCheckbox = ComponentPaletteCheckbox;
		
		return Component_PaletteCheckbox;
	}

	var Component_PaletteSearch = {};

	var hasRequiredComponent_PaletteSearch;

	function requireComponent_PaletteSearch () {
		if (hasRequiredComponent_PaletteSearch) return Component_PaletteSearch;
		hasRequiredComponent_PaletteSearch = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
		    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
		        if (ar || !(i in from)) {
		            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
		            ar[i] = from[i];
		        }
		    }
		    return to.concat(ar || Array.prototype.slice.call(from));
		};
		Object.defineProperty(Component_PaletteSearch, "__esModule", { value: true });
		Component_PaletteSearch.ComponentPaletteSearch = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var ComponentPaletteSearch = /** @class */ (function (_super) {
		    __extends(ComponentPaletteSearch, _super);
		    function ComponentPaletteSearch(options) {
		        var _a, _b, _c;
		        var _this = _super.call(this) || this;
		        _this.defaultView = 'recent_and_rest';
		        _this.recents = [];
		        _this.pid = options === null || options === void 0 ? void 0 : options.paletteUniqueIdentifier;
		        _this.defaultView = (_a = options === null || options === void 0 ? void 0 : options.defaultView) !== null && _a !== void 0 ? _a : 'recent_and_rest';
		        if ((_this.defaultView == 'recent' ||
		            _this.defaultView == 'recent_and_rest') &&
		            (_this.pid == undefined || _this.pid.trim().length == 0))
		            throw new Error("Property 'paletteUniqueIdentifier' is required in component 'PaletteSearch' to use recents.");
		        // if (pid != undefined && pid.length > 0)
		        // 	recents = Validator.array(
		        // 		FieldStorage.getChannelValue('palette_search', pid),
		        // 		[]
		        // 	);
		        _this.container = (0, CE_1.ce)('div', 'mux_palette');
		        _this.container.onclick = function () { return _this.close(); };
		        _this.inner = (0, CE_1.ce)('div', 'mux_palette-inner');
		        _this.inner.onclick = function (e) { return e.stopPropagation(); };
		        var input = (0, CE_1.ce)('input', 'mux_palette-input', {
		            type: 'text',
		            placeholder: (_b = options === null || options === void 0 ? void 0 : options.placeholder) !== null && _b !== void 0 ? _b : 'Starting typing to search...',
		        });
		        input.oninput = function () { return _this.handleInputUpdate(input.value); };
		        _this.inner.appendChild(input);
		        _this.results = (0, CE_1.ce)('div', ['mux_palette-results']);
		        _this.inner.appendChild(_this.results);
		        _this.container.appendChild(_this.inner);
		        document.body.appendChild(_this.container);
		        _this.items = (_c = options === null || options === void 0 ? void 0 : options.items) !== null && _c !== void 0 ? _c : [];
		        _this.registerKeyListener();
		        _this.showDefaultView();
		        setTimeout(function () {
		            _this.container.style.opacity = '1';
		            _this.inner.style.opacity = '1';
		            _this.inner.style.transform = 'scale(1)';
		            input.focus();
		        }, 20);
		        return _this;
		    }
		    ComponentPaletteSearch.prototype.close = function () {
		        var _this = this;
		        this.overwrite.close();
		        this.container.style.pointerEvents = 'none';
		        this.container.style.opacity = '0';
		        this.inner.style.opacity = '0';
		        this.inner.style.transform = 'scale(0.8)';
		        setTimeout(function () { return _this.destroy(); }, 400);
		        this.callEvent('close');
		    };
		    ComponentPaletteSearch.prototype.registerKeyListener = function () {
		        var _this = this;
		        this.overwrite = Index_1.MorphKey.createOverwrite();
		        this.overwrite.bind('Escape', function () { return _this.close(); });
		        this.overwrite.bind('Enter', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null)
		                selected.click();
		        });
		        this.overwrite.bind('ArrowUp', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null &&
		                selected.previousElementSibling != null &&
		                selected.previousElementSibling.classList.contains('mux_palette-results-item')) {
		                selected.classList.remove('mux_palette-results-item-selected');
		                selected.previousElementSibling.classList.add('mux_palette-results-item-selected');
		                setTimeout(function () {
		                    if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
		                        selected.previousElementSibling.scrollIntoView({
		                            behavior: 'auto',
		                            block: 'center',
		                            inline: 'center',
		                        });
		                }, 50);
		            }
		        });
		        this.overwrite.bind('ArrowDown', function () {
		            var selected = _this.getSelectedResult();
		            if (selected != null &&
		                selected.nextElementSibling != null &&
		                selected.nextElementSibling.classList.contains('mux_palette-results-item')) {
		                selected.classList.remove('mux_palette-results-item-selected');
		                selected.nextElementSibling.classList.add('mux_palette-results-item-selected');
		                setTimeout(function () {
		                    if ((selected === null || selected === void 0 ? void 0 : selected.previousElementSibling) != null)
		                        selected.previousElementSibling.scrollIntoView({
		                            behavior: 'auto',
		                            block: 'center',
		                            inline: 'center',
		                        });
		                }, 50);
		            }
		        });
		    };
		    ComponentPaletteSearch.prototype.search = function (query) {
		        var tagwords = this.getTags(query);
		        var results = [];
		        for (var i = 0; i < this.items.length; i++) {
		            var item = this.items[i];
		            var score = this.getScore(tagwords, item.tags != undefined ? item.tags : this.getTags(item.name)) *
		                (item.scoreWeight != undefined && !isNaN(item.scoreWeight)
		                    ? item.scoreWeight
		                    : 1);
		            if (score > 0)
		                results.push(__assign({ score: score }, item));
		        }
		        return results;
		    };
		    ComponentPaletteSearch.prototype.addToRecents = function (recentId) {
		        var newRecents = [];
		        __spreadArray([recentId], this.recents, true).forEach(function (id) {
		            if (!newRecents.includes(id))
		                newRecents.push(id);
		        });
		        if (newRecents.length > 5)
		            newRecents.splice(5, newRecents.length - 5);
		        this.recents = newRecents;
		        // FieldStorage.setChannelValue('palette_search', pid, this.recents);
		    };
		    ComponentPaletteSearch.prototype.renderSearchResult = function (result, index) {
		        var _this = this;
		        var item = (0, CE_1.ce)(result.href != undefined ? 'a' : 'div', 'mux_palette-results-item');
		        if (result.href != undefined)
		            item.href = result.href;
		        else if (result.click != undefined)
		            item.addEventListener('click', function () {
		                result.click();
		                _this.close();
		            });
		        if (this.pid != undefined &&
		            this.pid.length > 0 &&
		            (result.uniqueIdentifier != undefined || result.href != undefined)) {
		            item.addEventListener('click', function () {
		                var _a;
		                return _this.addToRecents((_a = result.uniqueIdentifier) !== null && _a !== void 0 ? _a : "address:".concat(result.href));
		            });
		        }
		        if (index == 0)
		            item.classList.add('mux_palette-results-item-selected');
		        if (result.materialIcon != undefined) {
		            var icon = (0, CE_1.ce)('span', 'material-symbols-outlined', null, result.materialIcon);
		            if (result.materialIconTransform != undefined)
		                icon.style.transform = result.materialIconTransform;
		            item.appendChild(icon);
		        }
		        else if (result.iconSrc != undefined)
		            item.appendChild((0, CE_1.ce)('img', 'mux_palette-results-item-icon', {
		                src: result.iconSrc,
		            }));
		        var text = (0, CE_1.ce)('div', [
		            'mux_palette-results-item-text',
		            'mux_text',
		            'mux_small',
		        ]);
		        if (result.prefix != undefined)
		            text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.prefix.trim()));
		        text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-main', null, result.name.trim()));
		        if (result.suffix != undefined)
		            text.appendChild((0, CE_1.ce)('span', 'mux_palette-results-item-text-sub', null, result.suffix.trim()));
		        item.appendChild(text);
		        // if (result.selectedText != undefined) {
		        // 	item.appendChild(
		        // 		ce(
		        // 			'div',
		        // 			['mux_palette-results-item-selectedtext', 'mux_text', 'mux_tiny'],
		        // 			null,
		        // 			result.selectedText
		        // 		)
		        // 	);
		        // }
		        this.results.appendChild(item);
		        return item;
		    };
		    ComponentPaletteSearch.prototype.showDefaultView = function () {
		        var _this = this;
		        this.results.innerHTML = '';
		        switch (this.defaultView) {
		            case 'all':
		                this.items.forEach(function (item, i) {
		                    return _this.renderSearchResult(item, i);
		                });
		                break;
		            case 'none':
		                return;
		            case 'recent_and_rest':
		                var recentItems = this.getRecentItems();
		                if (recentItems.length > 0)
		                    this.showResultLabel('Recent actions', 'schedule');
		                recentItems.forEach(function (item, i) {
		                    return _this.renderSearchResult(item, i);
		                });
		                var otherItems = this.items.filter(function (item) {
		                    var _a;
		                    if (item.uniqueIdentifier == undefined && item.href == null)
		                        return true;
		                    return !_this.recents.includes((_a = item.uniqueIdentifier) !== null && _a !== void 0 ? _a : "address:".concat(item.href));
		                });
		                if (otherItems.length > 0) {
		                    otherItems.forEach(function (item, i) {
		                        var itemElement = _this.renderSearchResult(item, i + recentItems.length);
		                        if (i == 0 && recentItems.length > 0)
		                            itemElement.classList.add('mux_palette-results-item-separator');
		                    });
		                }
		                break;
		            case 'recent':
		            default:
		                this.showResultLabel('Recent actions', 'schedule');
		                this.getRecentItems().forEach(function (item, i) {
		                    return _this.renderSearchResult(item, i);
		                });
		                break;
		        }
		    };
		    ComponentPaletteSearch.prototype.getRecentItems = function () {
		        if (this.recents == undefined || this.recents.length == 0)
		            return [];
		        var addressMap = new Map();
		        var uidMap = new Map();
		        this.items.forEach(function (item) {
		            if (item.uniqueIdentifier != undefined &&
		                item.uniqueIdentifier.trim().length > 0)
		                uidMap.set(item.uniqueIdentifier.trim(), item);
		            if (item.href != undefined && item.href.trim().length > 0)
		                addressMap.set(item.href.trim(), item);
		        });
		        var recentItems = [];
		        this.recents.forEach(function (recentId) {
		            if (recentId.startsWith('address:')) {
		                if (addressMap.has(recentId.replace('address:', '')))
		                    recentItems.push(addressMap.get(recentId.replace('address:', '')));
		            }
		            else {
		                if (uidMap.has(recentId))
		                    recentItems.push(uidMap.get(recentId));
		            }
		        });
		        return recentItems;
		    };
		    ComponentPaletteSearch.prototype.handleInputUpdate = function (value) {
		        var _this = this;
		        if (value.trim().length < 1)
		            return this.showDefaultView();
		        this.results.innerHTML = '';
		        var searchresults = this.search(value.trim());
		        if (searchresults.length == 0)
		            return this.showResultLabel('No results based on your search query.', 'warning');
		        searchresults
		            .sort(function (a, b) {
		            return b.score - a.score;
		        })
		            .forEach(function (result, index) { return _this.renderSearchResult(result, index); });
		    };
		    ComponentPaletteSearch.prototype.showResultLabel = function (text, materialIcon) {
		        var label = (0, CE_1.ce)('div', 'mux_palette-results-label');
		        if (materialIcon != undefined)
		            label.appendChild((0, CE_1.ce)('span', 'material-symbols-outlined', null, materialIcon));
		        label.appendChild((0, CE_1.ce)('span', null, null, text));
		        this.results.appendChild(label);
		    };
		    ComponentPaletteSearch.prototype.getSelectedResult = function () {
		        if (this.results == null)
		            return null;
		        return this.results.querySelector('.mux_palette-results-item-selected');
		    };
		    ComponentPaletteSearch.prototype.getScore = function (queryWords, tagWords) {
		        var score = 0;
		        var _loop_1 = function (i) {
		            tagWords.forEach(function (tagWord) {
		                if (tagWord.includes(queryWords[i])) {
		                    score += tagWord.startsWith(queryWords[i]) ? 2 : 1;
		                }
		            });
		        };
		        for (var i = 0; i < queryWords.length; i++) {
		            _loop_1(i);
		        }
		        return score;
		    };
		    ComponentPaletteSearch.prototype.getTags = function (query) {
		        var tags = [];
		        query
		            .toLowerCase()
		            .split(' ')
		            .map(function (word) {
		            return word.trim();
		        })
		            .filter(function (word) {
		            return word.length > 0;
		        })
		            .forEach(function (tag) {
		            if (!tags.includes(tag))
		                tags.push(tag);
		        });
		        return tags;
		    };
		    return ComponentPaletteSearch;
		}(baseComponent_1.MUXComponent));
		Component_PaletteSearch.ComponentPaletteSearch = ComponentPaletteSearch;
		
		return Component_PaletteSearch;
	}

	var Component_Resizer = {};

	var __extends$2 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Resizer, "__esModule", { value: true });
	Component_Resizer.ComponentResizer = void 0;
	var CE_1$2 = CE;
	var baseComponent_1$2 = baseComponent;
	var ComponentResizer = /** @class */ (function (_super) {
	    __extends$2(ComponentResizer, _super);
	    function ComponentResizer(options) {
	        var _a, _b, _c;
	        var _this = _super.call(this) || this;
	        _this.startPoint = null;
	        _this.startSize = null;
	        _this.preMove = true;
	        _this.moveEvent = function (e) {
	            _this.handleMove(e);
	        };
	        _this.touchEndEvent = function (e) {
	            _this.stopResize();
	        };
	        _this.direction = (_a = options === null || options === void 0 ? void 0 : options.direction) !== null && _a !== void 0 ? _a : 'right';
	        _this.closeable = (_b = options === null || options === void 0 ? void 0 : options.closeable) !== null && _b !== void 0 ? _b : false;
	        _this.min = options === null || options === void 0 ? void 0 : options.min;
	        _this.max = options === null || options === void 0 ? void 0 : options.max;
	        _this.relative = (_c = options === null || options === void 0 ? void 0 : options.relative) !== null && _c !== void 0 ? _c : false;
	        _this.container = (0, CE_1$2.ce)('div', 'mux_resizer');
	        var area = (0, CE_1$2.ce)('div', 'mux_resizer-area');
	        var grab = (0, CE_1$2.ce)('div', 'mux_resizer-grab');
	        var grabHandle = (0, CE_1$2.ce)('span', ['material-symbols-outlined', 'mux_resizer-grab-handle'], null, 'drag_handle');
	        if (options.direction == 'left' || options.direction == 'right')
	            grabHandle.style.transform = 'rotate(90deg)';
	        grab.appendChild(grabHandle);
	        var grabOpen = (0, CE_1$2.ce)('span', ['material-symbols-outlined', 'mux_resizer-grab-open'], null, {
	            left: 'arrow_left',
	            right: 'arrow_right',
	            up: 'arrow_drop_up',
	            down: 'arrow_drop_down',
	        }[_this.direction]);
	        grab.appendChild(grabOpen);
	        area.appendChild(grab);
	        if ((options === null || options === void 0 ? void 0 : options.existingContainer) != undefined) {
	            if (!options.existingContainer.classList.contains('mux_resizer'))
	                throw new Error('Container of registered resizer does not contain mux_resizer classname');
	            _this.container = options.existingContainer;
	            if (_this.container.querySelector('.mux_resizer-area') != null) {
	                var existingArea = _this.container.querySelector('.mux_resizer-area');
	                _this.container.removeChild(existingArea);
	            }
	        }
	        _this.container.appendChild(area);
	        _this.container.classList.add("mux_resizer-direction-".concat(_this.direction));
	        _this.currentSize =
	            _this.direction == 'left' || _this.direction == 'right'
	                ? _this.container.clientWidth
	                : _this.container.clientHeight;
	        area.addEventListener('mousedown', function (e) { return _this.startResize(e); });
	        area.addEventListener('touchstart', function (e) { return _this.startResize(e); });
	        grab.addEventListener('mousedown', function (e) { return _this.startResize(e); });
	        area.addEventListener('touchstart', function (e) { return _this.startResize(e); });
	        grab.addEventListener('click', function () {
	            if (!_this.container.classList.contains('mux_resizer-closed'))
	                return;
	            var size = typeof _this.min === 'function' ? _this.min() : _this.min;
	            if (_this.direction == 'left' || _this.direction == 'right')
	                _this.container.style.width = _this.toSize(size);
	            else if (_this.direction == 'up' || _this.direction == 'down')
	                _this.container.style.height = _this.toSize(size);
	            _this.currentSize = size;
	            _this.callEvent('resized', size);
	            _this.container.classList.remove('mux_resizer-closed');
	        });
	        if (!_this.relative)
	            window.addEventListener('resize', function () {
	                _this.setSize(_this.currentSize);
	            });
	        return _this;
	    }
	    ComponentResizer.prototype.toSize = function (value) {
	        if (!this.relative)
	            return "".concat(value, "px");
	        var parentSize = this.direction == 'left' || this.direction == 'right'
	            ? this.container.parentElement.clientWidth
	            : this.container.parentElement.clientHeight;
	        var percent = (value / parentSize) * 100;
	        return "".concat(percent, "%");
	    };
	    ComponentResizer.prototype.setSize = function (size) {
	        var value = this.parseNewValue(size);
	        if (this.direction == 'left' || this.direction == 'right')
	            this.container.style.width = this.toSize(value);
	        else if (this.direction == 'up' || this.direction == 'down')
	            this.container.style.height = this.toSize(value);
	        this.currentSize = value;
	        this.callEvent('resized', value);
	    };
	    ComponentResizer.prototype.getSize = function () {
	        return this.currentSize;
	    };
	    ComponentResizer.prototype.parseNewValue = function (value) {
	        var _min = typeof this.min === 'function' ? this.min() : this.min;
	        var _max = typeof this.max === 'function' ? this.max() : this.max;
	        value >= _min
	            ? this.container.classList.remove('mux_resizer-block')
	            : this.container.classList.add('mux_resizer-block');
	        if (_min >= 0) {
	            if (this.closeable == true && value < _min * 0.5) {
	                this.container.classList.add('mux_resizer-closed');
	                this.callEvent('resized', 0);
	                return 0;
	            }
	            else
	                value = Math.max(_min, value);
	        }
	        if (_max > 0)
	            value = Math.min(_max, value);
	        this.container.classList.remove('mux_resizer-closed');
	        return value;
	    };
	    ComponentResizer.prototype.startResize = function (e) {
	        var _a = this.pageCoords(e), x = _a.x, y = _a.y;
	        var bounds = this.container.getBoundingClientRect();
	        if (this.direction == 'left' || this.direction == 'right') {
	            this.startPoint = x;
	            this.startSize = bounds.width;
	        }
	        else if (this.direction == 'up' || this.direction == 'down') {
	            this.startPoint = y;
	            this.startSize = bounds.height;
	        }
	        window.addEventListener('mousemove', this.moveEvent);
	        window.addEventListener('touchmove', this.moveEvent);
	        window.addEventListener('touchend', this.touchEndEvent);
	        this.container.classList.add('mux_resizer-moving');
	        this.callEvent('startResize');
	    };
	    ComponentResizer.prototype.stopResize = function () {
	        this.startPoint = null;
	        this.startSize = null;
	        this.preMove = true;
	        this.container.classList.remove('mux_resizer-moving');
	        window.removeEventListener('mousemove', this.moveEvent);
	        window.removeEventListener('touchmove', this.moveEvent);
	        window.removeEventListener('touchend', this.touchEndEvent);
	        this.callEvent('stopResize');
	    };
	    ComponentResizer.prototype.handleMove = function (e) {
	        var _a, _b, _c;
	        if (((_a = e === null || e === void 0 ? void 0 : e.buttons) !== null && _a !== void 0 ? _a : 1) != 1 ||
	            ((_c = (_b = e === null || e === void 0 ? void 0 : e.touches) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 1) == 0 ||
	            this.startPoint == null ||
	            this.startSize == null) {
	            this.stopResize();
	            return;
	        }
	        var _d = this.pageCoords(e), x = _d.x, y = _d.y;
	        if (this.preMove) {
	            var startSpan = Math.abs(this.startPoint -
	                (this.direction == 'left' || this.direction == 'right'
	                    ? x
	                    : y));
	            if (startSpan >= 10) {
	                this.preMove = false;
	                this.container.classList.add('mux_resizer-moving');
	            }
	            else
	                return;
	        }
	        var value = null;
	        if (this.direction == 'left' || this.direction == 'right') {
	            value = this.parseNewValue(this.startSize +
	                (this.direction == 'left'
	                    ? this.startPoint - x
	                    : x - this.startPoint));
	            this.container.style.width = this.toSize(value);
	        }
	        else if (this.direction == 'up' || this.direction == 'down') {
	            value = this.parseNewValue(this.startSize +
	                (this.direction == 'up'
	                    ? this.startPoint - y
	                    : y - this.startPoint));
	            this.container.style.height = this.toSize(value);
	        }
	        this.currentSize = value;
	        this.callEvent('resized', value);
	    };
	    ComponentResizer.prototype.pageCoords = function (e) {
	        var _a, _b, _c, _d;
	        return {
	            x: (_a = e.pageX) !== null && _a !== void 0 ? _a : (_b = e.touches[0]) === null || _b === void 0 ? void 0 : _b.pageX,
	            y: (_c = e.pageY) !== null && _c !== void 0 ? _c : (_d = e.touches[0]) === null || _d === void 0 ? void 0 : _d.pageY,
	        };
	    };
	    return ComponentResizer;
	}(baseComponent_1$2.MUXComponent));
	Component_Resizer.ComponentResizer = ComponentResizer;

	var Component_Row = {};

	var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Row, "__esModule", { value: true });
	Component_Row.ComponentRow = void 0;
	var CE_1$1 = CE;
	var baseComponent_1$1 = baseComponent;
	var ComponentRow = /** @class */ (function (_super) {
	    __extends$1(ComponentRow, _super);
	    function ComponentRow(options) {
	        var _this = _super.call(this) || this;
	        _this.container = (0, CE_1$1.ce)('div', 'mux_row');
	        if ((options === null || options === void 0 ? void 0 : options.spreadEven) == true)
	            _this.container.classList.add('mux_spread');
	        if ((options === null || options === void 0 ? void 0 : options.indent) == true)
	            _this.container.classList.add('mux_indent');
	        if ((options === null || options === void 0 ? void 0 : options.disabled) == true)
	            _this.container.classList.add('mux_disabled');
	        if ((options === null || options === void 0 ? void 0 : options.tooltip) != undefined)
	            _this.container.title = options.tooltip;
	        _this.content = (0, CE_1$1.ce)('div', 'mux_row-content');
	        var label = (0, CE_1$1.ce)('div', ['mux_row-label', 'mux_text'], null, options.label);
	        if ((options === null || options === void 0 ? void 0 : options.layout) != undefined && options.layout == 'valueFirst') {
	            _this.container.appendChild(_this.content);
	            _this.container.appendChild(label);
	        }
	        else {
	            _this.container.appendChild(label);
	            _this.container.appendChild(_this.content);
	        }
	        if (options.content != undefined)
	            _this.content.appendChild(options.content);
	        return _this;
	    }
	    ComponentRow.prototype.setEnabled = function (state) {
	        if (state)
	            this.container.classList.remove('mux_disabled');
	        else
	            this.container.classList.add('mux_disabled');
	    };
	    ComponentRow.prototype.setTooltip = function (tooltip) {
	        if (tooltip == null)
	            this.container.removeAttribute('title');
	        else
	            this.container.title = tooltip;
	    };
	    return ComponentRow;
	}(baseComponent_1$1.MUXComponent));
	Component_Row.ComponentRow = ComponentRow;

	var Component_Select = {};

	var hasRequiredComponent_Select;

	function requireComponent_Select () {
		if (hasRequiredComponent_Select) return Component_Select;
		hasRequiredComponent_Select = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Select, "__esModule", { value: true });
		Component_Select.ComponentSelect = void 0;
		var Index_1 = requireIndex();
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var ComponentSelect = /** @class */ (function (_super) {
		    __extends(ComponentSelect, _super);
		    function ComponentSelect(options) {
		        var _a, _b, _c;
		        var _this = _super.call(this) || this;
		        _this.show = 'name';
		        _this.show = (_a = options.show) !== null && _a !== void 0 ? _a : 'name';
		        _this.container = (0, CE_1.ce)('div', 'mux_select');
		        var border = (_b = options.border) !== null && _b !== void 0 ? _b : 'hover';
		        if (border == 'always')
		            _this.container.classList.add('mux_select-alwaysborder');
		        else if (border == 'never')
		            _this.container.classList.add('mux_select-noborder');
		        _this.input = new Index_1.MorphComponent.Input({
		            type: 'text',
		            border: 'never',
		        });
		        _this.input.container.onkeydown = function (e) {
		            e.preventDefault();
		        };
		        _this.container.appendChild(_this.input.container);
		        _this.content = (0, CE_1.ce)('div', 'mux_select-content');
		        _this.container.appendChild(_this.content);
		        _this.container.appendChild((0, CE_1.ce)('span', ['material-symbols-outlined', 'mux_select-arrow'], null, 'keyboard_arrow_down'));
		        _this.input.container.onfocus = function () {
		            _this.input.container.blur();
		            _this.toggleContext();
		        };
		        _this.input.container.onblur = function () {
		            _this.context.close('selectblur');
		        };
		        _this.container.onclick = function () { return _this.toggleContext(); };
		        _this.items = (_c = options === null || options === void 0 ? void 0 : options.items) !== null && _c !== void 0 ? _c : [];
		        _this.select(options.selectedId, false);
		        return _this;
		    }
		    ComponentSelect.prototype.setItems = function (items) {
		        this.items = items;
		    };
		    ComponentSelect.prototype.select = function (id, dispatchEvent) {
		        var _a;
		        if (dispatchEvent === void 0) { dispatchEvent = true; }
		        var item = this.items.find(function (i) {
		            if (i.type == 'separator')
		                return false;
		            return i.id == id;
		        });
		        this.selectedId = id;
		        this.content.innerHTML = '';
		        if (item == null) {
		            this.content.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small', 'mux_select-none'], null, 'None selected'));
		            return;
		        }
		        if (item.materialIcon != undefined) {
		            var materialIcon = (0, CE_1.ce)('span', 'material-symbols-outlined', null, item.materialIcon);
		            if (item.materialIconTransform != undefined)
		                materialIcon.style.transform = item.materialIconTransform;
		            this.content.appendChild(materialIcon);
		        }
		        else if (item.icon != undefined) {
		            this.content.appendChild((0, CE_1.ce)('img', 'mux_select-content-icon', { src: item.icon }));
		        }
		        this.content.appendChild((0, CE_1.ce)('div', ['mux_text', 'mux_small'], null, (_a = item.text) !== null && _a !== void 0 ? _a : item.id));
		        if (dispatchEvent)
		            this.callEvent('input', id);
		    };
		    ComponentSelect.prototype.setSelected = function (id) {
		        this.select(id, false);
		    };
		    ComponentSelect.prototype.getSelected = function () {
		        return this.selectedId;
		    };
		    ComponentSelect.prototype.toggleContext = function () {
		        var _this = this;
		        if (this.context != null) {
		            return this.context.close('selecttoggle');
		        }
		        var bounds = this.container.getBoundingClientRect();
		        this.context = new Index_1.MorphComponent.ContextMenu({
		            x: bounds.x + bounds.width / 2,
		            y: bounds.y + bounds.height,
		            align: 'center',
		            selected: this.selectedId,
		            items: this.items.map(function (item) {
		                var _a, _b;
		                if (item.type == 'separator') {
		                    return { type: 'separator' };
		                }
		                return {
		                    type: (_a = item.type) !== null && _a !== void 0 ? _a : 'normal',
		                    uniqueIdentifier: item.id,
		                    text: (_b = item.text) !== null && _b !== void 0 ? _b : item.id,
		                    materialIcon: item.materialIcon,
		                    materialIconTransform: item.materialIconTransform,
		                    icon: item.icon,
		                    click: function () {
		                        _this.select(item.id, true);
		                    },
		                };
		            }),
		        });
		        this.container.classList.add('mux_select-open');
		        this.context.on('close', function () {
		            _this.container.classList.remove('mux_select-open');
		            _this.context = null;
		        });
		    };
		    return ComponentSelect;
		}(baseComponent_1.MUXComponent));
		Component_Select.ComponentSelect = ComponentSelect;
		
		return Component_Select;
	}

	var Component_Table = {};

	var Component_Table_Button = {};

	var Component_Table__base = {};

	Object.defineProperty(Component_Table__base, "__esModule", { value: true });
	Component_Table__base.ComponentTable_Base = void 0;
	var ComponentTable_Base = /** @class */ (function () {
	    function ComponentTable_Base() {
	    }
	    ComponentTable_Base.prototype.createElement = function (cell, rowId, column, component, asNumber) {
	        return null;
	    };
	    return ComponentTable_Base;
	}());
	Component_Table__base.ComponentTable_Base = ComponentTable_Base;

	var hasRequiredComponent_Table_Button;

	function requireComponent_Table_Button () {
		if (hasRequiredComponent_Table_Button) return Component_Table_Button;
		hasRequiredComponent_Table_Button = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_Button, "__esModule", { value: true });
		Component_Table_Button.ComponentTable_Button = void 0;
		var Index_1 = requireIndex();
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Button = /** @class */ (function (_super) {
		    __extends(ComponentTable_Button, _super);
		    function ComponentTable_Button() {
		        return _super.call(this) || this;
		    }
		    ComponentTable_Button.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var container = (0, Index_1.ce)('div', ['mux_table-button']);
		        var btn = (0, Index_1.ce)('div', [
		            'mux_table-button-btn',
		            'mux_text',
		            'mux_small',
		            "mux_table-button-btn-".concat(encodeURI(cell.text)),
		        ], { title: cell.tooltip }, cell.text);
		        btn.onclick = function (e) {
		            e.stopPropagation();
		            component.callEvent('buttonClick', rowId, column.uniqueIdentifier);
		        };
		        container.appendChild(btn);
		        return container;
		    };
		    return ComponentTable_Button;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Button.ComponentTable_Button = ComponentTable_Button;
		
		return Component_Table_Button;
	}

	var Component_Table_Duration = {};

	var Component_Table_Text = {};

	var hasRequiredComponent_Table_Text;

	function requireComponent_Table_Text () {
		if (hasRequiredComponent_Table_Text) return Component_Table_Text;
		hasRequiredComponent_Table_Text = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_Text, "__esModule", { value: true });
		Component_Table_Text.ComponentTable_Text = void 0;
		var Index_1 = requireIndex();
		var TextHighlighter_1 = TextHighlighter;
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Text = /** @class */ (function (_super) {
		    __extends(ComponentTable_Text, _super);
		    function ComponentTable_Text(allowHighlighting) {
		        var _this = _super.call(this) || this;
		        _this.allowHighlighting = allowHighlighting;
		        return _this;
		    }
		    ComponentTable_Text.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var _a, _b, _c, _d, _e, _f;
		        if (asNumber === void 0) { asNumber = false; }
		        var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
		        var container = (0, Index_1.ce)('div', 'mux_table-text', {
		            title: (_a = cell === null || cell === void 0 ? void 0 : cell.tooltip) !== null && _a !== void 0 ? _a : '',
		        });
		        var text = this.allowHighlighting
		            ? (0, TextHighlighter_1.generateTextHighlights)(String(cell.value).trim())
		            : (0, Index_1.ce)('div', ['mux_text', 'mux_small'], null, "".concat((_b = cell.prefix) !== null && _b !== void 0 ? _b : '', " ").concat(cell.value).trim());
		        text.prepend((0, Index_1.ce)('span', null, null, cell.prefix));
		        text.style.justifyContent = {
		            left: 'flex-Start',
		            right: 'flex-end',
		            center: 'center',
		        }[(_c = cell.align) !== null && _c !== void 0 ? _c : 'left'];
		        var editonly = column.editonly;
		        container.appendChild(text);
		        if (column.editable) {
		            var inputContainer = (0, Index_1.ce)('div', 'mux_table-edit-input');
		            var inputPrefix = (0, Index_1.ce)('div', ['mux_text', 'mux_small', 'mux_table-edit-input-prefix'], null, (_d = cell.prefix) !== null && _d !== void 0 ? _d : '');
		            var input = new Index_1.MorphComponent.Input({
		                type: 'text',
		                value: String((_e = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _e !== void 0 ? _e : '').trim(),
		                border: 'always',
		            });
		            if (editonly)
		                input.on('input', function () {
		                    component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber
		                        ? input.container.value
		                        : parseFloat(input.container.value));
		                });
		            input.container.style.textAlign = (_f = cell.align) !== null && _f !== void 0 ? _f : 'left';
		            inputContainer.appendChild(inputPrefix);
		            inputContainer.appendChild(input.container);
		            container.appendChild(inputContainer);
		            container.style.cursor = 'pointer';
		            var hasFirst = false;
		            var clickTimeout;
		            container.onclick = function () {
		                clearTimeout(clickTimeout);
		                if (hasFirst == false) {
		                    hasFirst = true;
		                    clickTimeout = setTimeout(function () {
		                        hasFirst = false;
		                    }, 1000);
		                }
		                else {
		                    openEdit();
		                    hasFirst = false;
		                }
		            };
		            var openEdit = function () {
		                text.style.display = 'none';
		                inputContainer.style.display = 'flex';
		                input.container.focus();
		                input.container.setSelectionRange(input.container.value.length, input.container.value.length);
		                var initValue = input.container.value;
		                var close = function () {
		                    if (editonly)
		                        return;
		                    window.removeEventListener('click', onclick);
		                    component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber
		                        ? input.container.value
		                        : parseFloat(input.container.value));
		                    text.innerText = input.container.value;
		                    text.style.display = 'flex';
		                    inputContainer.style.display = 'none';
		                };
		                input.container.onkeydown = function (e) {
		                    if (editonly)
		                        return;
		                    if (e.key == 'Enter')
		                        close();
		                    else if (e.key == 'Escape') {
		                        input.container.value = initValue;
		                        text.innerText = input.container.value;
		                        close();
		                    }
		                };
		                if (!editonly) {
		                    var onclick = function (e) {
		                        if (e.target == undefined ||
		                            e.target != input.container)
		                            close();
		                    };
		                    setTimeout(function () { return window.addEventListener('click', onclick); }, 100);
		                }
		            };
		            if (editonly)
		                openEdit();
		        }
		        wrapper.appendChild(container);
		        if (cell.subText != undefined) {
		            wrapper.appendChild((0, Index_1.ce)('div', ['mux_text', 'mux_tiny', 'mux_table-subtext'], null, cell.subText.trim()));
		        }
		        return wrapper;
		    };
		    return ComponentTable_Text;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Text.ComponentTable_Text = ComponentTable_Text;
		
		return Component_Table_Text;
	}

	var hasRequiredComponent_Table_Duration;

	function requireComponent_Table_Duration () {
		if (hasRequiredComponent_Table_Duration) return Component_Table_Duration;
		hasRequiredComponent_Table_Duration = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_Duration, "__esModule", { value: true });
		Component_Table_Duration.ComponentTable_Duration = void 0;
		var Component_Table_Text_1 = requireComponent_Table_Text();
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Duration = /** @class */ (function (_super) {
		    __extends(ComponentTable_Duration, _super);
		    function ComponentTable_Duration() {
		        var _this = _super.call(this) || this;
		        _this._text = new Component_Table_Text_1.ComponentTable_Text(false);
		        return _this;
		    }
		    ComponentTable_Duration.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var element = this._text.createElement(cell, rowId, column, component, true);
		        var elementText = element.querySelector('.mux_text');
		        if (elementText != null)
		            elementText.style.justifyContent = 'center';
		        element.classList.add('mux_table-duration');
		        var input = element.querySelector('input');
		        var regex = /^[0-9.]+$/;
		        element.addEventListener('input', function () {
		            var currentValue = input.value;
		            if (!regex.test(currentValue)) {
		                input.value = currentValue.slice(0, -1);
		            }
		        });
		        return element;
		    };
		    return ComponentTable_Duration;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Duration.ComponentTable_Duration = ComponentTable_Duration;
		
		return Component_Table_Duration;
	}

	var Component_Table_Icons = {};

	var hasRequiredComponent_Table_Icons;

	function requireComponent_Table_Icons () {
		if (hasRequiredComponent_Table_Icons) return Component_Table_Icons;
		hasRequiredComponent_Table_Icons = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_Icons, "__esModule", { value: true });
		Component_Table_Icons.ComponentTable_Icons = void 0;
		var Index_1 = requireIndex();
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Icons = /** @class */ (function (_super) {
		    __extends(ComponentTable_Icons, _super);
		    function ComponentTable_Icons() {
		        return _super.call(this) || this;
		    }
		    ComponentTable_Icons.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var _a;
		        var container = (0, Index_1.ce)('div', ['mux_table-icons']);
		        ((_a = cell === null || cell === void 0 ? void 0 : cell.items) !== null && _a !== void 0 ? _a : []).forEach(function (item) {
		            var itemElement = (0, Index_1.ce)('div', 'mux_table-icon');
		            itemElement.appendChild((0, Index_1.ce)('span', 'material-symbols-outlined', null, item.materialIcon));
		            if (item.color != undefined)
		                itemElement.style.color = item.color;
		            itemElement.onclick = function (e) {
		                e.stopPropagation();
		                item.click();
		            };
		            container.appendChild(itemElement);
		        });
		        return container;
		    };
		    return ComponentTable_Icons;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Icons.ComponentTable_Icons = ComponentTable_Icons;
		
		return Component_Table_Icons;
	}

	var Component_Table_MaterialSymbol = {};

	var hasRequiredComponent_Table_MaterialSymbol;

	function requireComponent_Table_MaterialSymbol () {
		if (hasRequiredComponent_Table_MaterialSymbol) return Component_Table_MaterialSymbol;
		hasRequiredComponent_Table_MaterialSymbol = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_MaterialSymbol, "__esModule", { value: true });
		Component_Table_MaterialSymbol.ComponentTable_MaterialSymbol = void 0;
		var Index_1 = requireIndex();
		var TextHighlighter_1 = TextHighlighter;
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_MaterialSymbol = /** @class */ (function (_super) {
		    __extends(ComponentTable_MaterialSymbol, _super);
		    function ComponentTable_MaterialSymbol() {
		        return _super.call(this) || this;
		    }
		    ComponentTable_MaterialSymbol.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var _a, _b, _c, _d;
		        if (asNumber === void 0) { asNumber = false; }
		        var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
		        var container = (0, Index_1.ce)('div', 'mux_table-text', {
		            title: (_a = cell === null || cell === void 0 ? void 0 : cell.tooltip) !== null && _a !== void 0 ? _a : '',
		        });
		        var text = this.allowHighlighting
		            ? (0, TextHighlighter_1.generateTextHighlights)(String(cell.materialIcon).trim())
		            : (0, Index_1.ce)('span', ['material-symbols-outlined', 'g_text'], null, cell.materialIcon);
		        text.style.justifyContent = {
		            left: 'flex-Start',
		            right: 'flex-end',
		            center: 'center',
		        }[(_b = cell.align) !== null && _b !== void 0 ? _b : 'left'];
		        container.appendChild(text);
		        if (column.editable) {
		            var inputContainer = (0, Index_1.ce)('div', 'mux_table-edit-input');
		            var input = (0, Index_1.ce)('input', null, {
		                type: 'text',
		                value: String((_c = cell === null || cell === void 0 ? void 0 : cell.materialIcon) !== null && _c !== void 0 ? _c : '').trim(),
		            });
		            input.style.textAlign = (_d = cell.align) !== null && _d !== void 0 ? _d : 'left';
		            inputContainer.appendChild(input);
		            container.appendChild(inputContainer);
		            container.style.cursor = 'pointer';
		            var hasFirst = false;
		            var clickTimeout;
		            container.onclick = function () {
		                clearTimeout(clickTimeout);
		                if (hasFirst == false) {
		                    hasFirst = true;
		                    clickTimeout = setTimeout(function () {
		                        hasFirst = false;
		                    }, 1000);
		                }
		                else {
		                    openEdit();
		                    hasFirst = false;
		                }
		            };
		            var openEdit = function () {
		                text.style.display = 'none';
		                inputContainer.style.display = 'flex';
		                input.focus();
		                input.setSelectionRange(input.value.length, input.value.length);
		                var initValue = input.value;
		                var close = function () {
		                    window.removeEventListener('click', onclick);
		                    component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, !asNumber ? input.value : parseFloat(input.value));
		                    text.innerText = input.value;
		                    text.style.display = 'flex';
		                    inputContainer.style.display = 'none';
		                };
		                input.onkeydown = function (e) {
		                    if (e.key == 'Enter')
		                        close();
		                    else if (e.key == 'Escape') {
		                        input.value = initValue;
		                        text.innerText = input.value;
		                        close();
		                    }
		                };
		                var onclick = function (e) {
		                    if (e.target == undefined || e.target != input)
		                        close();
		                };
		                setTimeout(function () { return window.addEventListener('click', onclick); }, 100);
		            };
		        }
		        wrapper.appendChild(container);
		        // if (cell.materialIcon != undefined) {
		        // 	wrapper.appendChild(
		        // 		ce(
		        // 			'div',
		        // 			['mux_text', 'mux_tiny', 'mux_table-subtext'],
		        // 			null,
		        // 			cell.subMaterialSymbol.trim()
		        // 		)
		        // 	);
		        // }
		        return wrapper;
		    };
		    return ComponentTable_MaterialSymbol;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_MaterialSymbol.ComponentTable_MaterialSymbol = ComponentTable_MaterialSymbol;
		
		return Component_Table_MaterialSymbol;
	}

	var Component_Table_Number = {};

	var hasRequiredComponent_Table_Number;

	function requireComponent_Table_Number () {
		if (hasRequiredComponent_Table_Number) return Component_Table_Number;
		hasRequiredComponent_Table_Number = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table_Number, "__esModule", { value: true });
		Component_Table_Number.ComponentTable_Number = void 0;
		var Component_Table_Text_1 = requireComponent_Table_Text();
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Number = /** @class */ (function (_super) {
		    __extends(ComponentTable_Number, _super);
		    function ComponentTable_Number() {
		        var _this = _super.call(this) || this;
		        _this._text = new Component_Table_Text_1.ComponentTable_Text(false);
		        return _this;
		    }
		    ComponentTable_Number.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var element = this._text.createElement(cell, rowId, column, component);
		        element.classList.add('mux_table-number');
		        var input = element.querySelector('input');
		        var regex = /^[0-9.]+$/;
		        element.addEventListener('input', function () {
		            var currentValue = input.value;
		            if (!regex.test(currentValue)) {
		                input.value = currentValue.slice(0, -1);
		                component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.value);
		            }
		        });
		        return element;
		    };
		    return ComponentTable_Number;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Number.ComponentTable_Number = ComponentTable_Number;
		
		return Component_Table_Number;
	}

	var Component_Table_Select = {};

	var hasRequiredComponent_Table_Select;

	function requireComponent_Table_Select () {
		if (hasRequiredComponent_Table_Select) return Component_Table_Select;
		hasRequiredComponent_Table_Select = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		Object.defineProperty(Component_Table_Select, "__esModule", { value: true });
		Component_Table_Select.ComponentTable_Select = void 0;
		var Index_1 = requireIndex();
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_Select = /** @class */ (function (_super) {
		    __extends(ComponentTable_Select, _super);
		    function ComponentTable_Select() {
		        return _super.call(this) || this;
		    }
		    ComponentTable_Select.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var container = (0, Index_1.ce)('div', 'mux_table-select', { title: cell.tooltip });
		        var options = {};
		        for (var i = 0; i < column.options.length; i++)
		            options[column.options[i].uniqueIdentifier] = column.options[i];
		        var setSelected = function (uniqueIdentifier) {
		            var _a, _b, _c, _d, _e, _f;
		            var selected = (options === null || options === void 0 ? void 0 : options[uniqueIdentifier]) != undefined
		                ? uniqueIdentifier
		                : column.options[0].uniqueIdentifier;
		            var selectedTransform = (_a = options === null || options === void 0 ? void 0 : options[selected].materialIconTransform) !== null && _a !== void 0 ? _a : 'unset';
		            var option = options === null || options === void 0 ? void 0 : options[selected];
		            textSpan.innerText = (_b = option === null || option === void 0 ? void 0 : option.text) !== null && _b !== void 0 ? _b : '';
		            iconSpan.innerText = (_d = (_c = options === null || options === void 0 ? void 0 : options[selected]) === null || _c === void 0 ? void 0 : _c.materialIcon) !== null && _d !== void 0 ? _d : '';
		            iconSpan.style.transform = selectedTransform !== null && selectedTransform !== void 0 ? selectedTransform : '';
		            container.title = "".concat((_f = (_e = options === null || options === void 0 ? void 0 : options[selected]) === null || _e === void 0 ? void 0 : _e.text) !== null && _f !== void 0 ? _f : '', " | Click to change");
		        };
		        var iconSpan = (0, Index_1.ce)('span', 'material-symbols-outlined', null);
		        var textSpan = (0, Index_1.ce)('span', ['mux_text', 'mux_small'], null);
		        var arrow = (0, Index_1.ce)('span', ['mux_table-select-arrow', 'material-symbols-outlined'], null, 'keyboard_arrow_down');
		        container.append(iconSpan, textSpan);
		        container.appendChild(arrow);
		        setSelected(cell.value);
		        container.onclick = function () {
		            var bounds = container.getBoundingClientRect();
		            var items = column.options.map(function (item) {
		                return __assign({ click: function () {
		                        component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, item.uniqueIdentifier);
		                        setSelected(item.uniqueIdentifier);
		                    } }, item);
		            });
		            new Index_1.MorphComponent.ContextMenu({
		                x: bounds.x + bounds.width / 2,
		                y: bounds.y + bounds.height,
		                items: items,
		            });
		        };
		        return container;
		    };
		    return ComponentTable_Select;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_Select.ComponentTable_Select = ComponentTable_Select;
		
		return Component_Table_Select;
	}

	var Component_Table_TextSuggestions = {};

	var hasRequiredComponent_Table_TextSuggestions;

	function requireComponent_Table_TextSuggestions () {
		if (hasRequiredComponent_Table_TextSuggestions) return Component_Table_TextSuggestions;
		hasRequiredComponent_Table_TextSuggestions = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
		    return new (P || (P = Promise))(function (resolve, reject) {
		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
		        step((generator = generator.apply(thisArg, _arguments || [])).next());
		    });
		};
		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
		    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		    function verb(n) { return function (v) { return step([n, v]); }; }
		    function step(op) {
		        if (f) throw new TypeError("Generator is already executing.");
		        while (g && (g = 0, op[0] && (_ = 0)), _) try {
		            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		            if (y = 0, t) op = [op[0] & 2, t.value];
		            switch (op[0]) {
		                case 0: case 1: t = op; break;
		                case 4: _.label++; return { value: op[1], done: false };
		                case 5: _.label++; y = op[1]; op = [0]; continue;
		                case 7: op = _.ops.pop(); _.trys.pop(); continue;
		                default:
		                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
		                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		                    if (t[2]) _.ops.pop();
		                    _.trys.pop(); continue;
		            }
		            op = body.call(thisArg, _);
		        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		    }
		};
		Object.defineProperty(Component_Table_TextSuggestions, "__esModule", { value: true });
		Component_Table_TextSuggestions.ComponentTable_TextSuggestions = void 0;
		var Index_1 = requireIndex();
		var Component_ContextMenu_1 = Component_ContextMenu;
		var Component_Table__base_1 = Component_Table__base;
		var ComponentTable_TextSuggestions = /** @class */ (function (_super) {
		    __extends(ComponentTable_TextSuggestions, _super);
		    function ComponentTable_TextSuggestions() {
		        return _super.call(this) || this;
		    }
		    ComponentTable_TextSuggestions.prototype.createElement = function (cell, rowId, column, component, asNumber) {
		        var _a, _b, _c, _d;
		        var wrapper = (0, Index_1.ce)('div', 'mux_table-wrapper');
		        var container = (0, Index_1.ce)('div', 'mux_table-textsuggestions');
		        var optionTitles = {};
		        var optionIds = column.options.map(function (option) {
		            optionTitles[option.uniqueIdentifier] = option.text;
		            return option.uniqueIdentifier;
		        });
		        var input = new Index_1.MorphComponent.Input({
		            type: 'text',
		            value: (_b = optionTitles[String((_a = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _a !== void 0 ? _a : '').trim()]) !== null && _b !== void 0 ? _b : String((_c = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _c !== void 0 ? _c : '').trim(),
		            border: 'always',
		        });
		        input.container.setAttribute('valueId', String((_d = cell === null || cell === void 0 ? void 0 : cell.value) !== null && _d !== void 0 ? _d : '').trim());
		        var arrow = (0, Index_1.ce)('span', 'material-symbols-outlined', null, 'arrow_drop_down');
		        arrow.onclick = function () {
		            input.container.focus();
		            showContext();
		        };
		        input.container.addEventListener('focus', function () {
		            var _a;
		            input.setValue((_a = input.container.getAttribute('valueId')) !== null && _a !== void 0 ? _a : '');
		        });
		        input.on('blur', function () {
		            var optionTitle = optionTitles[input.container.getAttribute('valueId')];
		            if (optionTitle == null) {
		                if (input.getValue().length > 0)
		                    component.callEvent('textSuggestionFailed', rowId, column.uniqueIdentifier);
		                input.setValue('');
		                input.container.removeAttribute('valueId');
		            }
		            else {
		                input.setValue(optionTitle);
		            }
		            component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.container.getAttribute('valueId'));
		            setTimeout(function () {
		                context === null || context === void 0 ? void 0 : context.destroy();
		            }, 250);
		        });
		        input.container.addEventListener('keydown', function (e) {
		            if (e.key != ' ' || !e.ctrlKey)
		                return;
		            e.preventDefault();
		            showContext();
		        });
		        input.on('input', function () { return showContext(); });
		        var context;
		        var showContextTimeout;
		        function showContext() {
		            return __awaiter(this, arguments, void 0, function (instant) {
		                if (instant === void 0) { instant = false; }
		                return __generator(this, function (_a) {
		                    context === null || context === void 0 ? void 0 : context.close('blur');
		                    if (optionIds.includes(input.getValue())) {
		                        input.container.setAttribute('valueId', input.getValue());
		                        return [2 /*return*/];
		                    }
		                    input.container.removeAttribute('valueId');
		                    clearTimeout(showContextTimeout);
		                    showContextTimeout = setTimeout(function () {
		                        var _a;
		                        var firstId;
		                        var value = ((_a = input.getValue()) !== null && _a !== void 0 ? _a : '').toLowerCase();
		                        var options = value.length == 0
		                            ? []
		                            : column.options
		                                .map(function (option) {
		                                var _a, _b;
		                                var text = ((_a = option === null || option === void 0 ? void 0 : option.text) !== null && _a !== void 0 ? _a : '').toLowerCase();
		                                var id = ((_b = option === null || option === void 0 ? void 0 : option.uniqueIdentifier) !== null && _b !== void 0 ? _b : '').toLowerCase();
		                                return { text: text, id: id, option: option };
		                            })
		                                .filter(function (_a) {
		                                var text = _a.text, id = _a.id; _a.option;
		                                return (text.includes(value) ||
		                                    id.includes(value));
		                            })
		                                .map(function (_a) {
		                                var text = _a.text, id = _a.id, option = _a.option;
		                                var score = 1;
		                                if (text.startsWith(value) ||
		                                    id.startsWith(value))
		                                    score += 1;
		                                if (text.includes(value) ||
		                                    id.includes(value))
		                                    score += 1;
		                                if (text == value || id == value)
		                                    score += 1;
		                                return { score: score, option: option };
		                            })
		                                .sort(function (a, b) { return b.score - a.score; })
		                                .map(function (_a, index) {
		                                _a.score; var option = _a.option;
		                                if (index == 0)
		                                    firstId = option.uniqueIdentifier;
		                                return __assign(__assign({}, option), { click: function () {
		                                        input.setValue(option.text);
		                                        input.container.setAttribute('valueId', option.uniqueIdentifier);
		                                        component.callEvent('valueUpdated', rowId, column.uniqueIdentifier, input.getValue());
		                                        component.callEvent('textSuggestionCompleted');
		                                    } });
		                            });
		                        if (options.length == 0)
		                            return;
		                        var bounds = input.container.getBoundingClientRect();
		                        context = new Component_ContextMenu_1.ComponentContextMenu({
		                            items: options,
		                            selected: firstId,
		                            x: bounds.x + bounds.width / 2,
		                            y: bounds.y + bounds.height,
		                        });
		                    }, instant ? 0 : 200);
		                    return [2 /*return*/];
		                });
		            });
		        }
		        container.appendChild(input.container);
		        container.appendChild(arrow);
		        wrapper.appendChild(container);
		        return wrapper;
		    };
		    return ComponentTable_TextSuggestions;
		}(Component_Table__base_1.ComponentTable_Base));
		Component_Table_TextSuggestions.ComponentTable_TextSuggestions = ComponentTable_TextSuggestions;
		
		return Component_Table_TextSuggestions;
	}

	var hasRequiredComponent_Table;

	function requireComponent_Table () {
		if (hasRequiredComponent_Table) return Component_Table;
		hasRequiredComponent_Table = 1;
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (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 __());
		    };
		})();
		Object.defineProperty(Component_Table, "__esModule", { value: true });
		Component_Table.ComponentTable = void 0;
		var CE_1 = CE;
		var baseComponent_1 = baseComponent;
		var Component_Table_Button_1 = requireComponent_Table_Button();
		var Component_Table_Duration_1 = requireComponent_Table_Duration();
		var Component_Table_Icons_1 = requireComponent_Table_Icons();
		var Component_Table_MaterialSymbol_1 = requireComponent_Table_MaterialSymbol();
		var Component_Table_Number_1 = requireComponent_Table_Number();
		var Component_Table_Select_1 = requireComponent_Table_Select();
		var Component_Table_Text_1 = requireComponent_Table_Text();
		var Component_Table_TextSuggestions_1 = requireComponent_Table_TextSuggestions();
		var Sortable = SortableExports;
		var ComponentTable = /** @class */ (function (_super) {
		    __extends(ComponentTable, _super);
		    function ComponentTable(options) {
		        var _a, _b;
		        var _this_1 = _super.call(this) || this;
		        _this_1.columns = [];
		        _this_1.rows = [];
		        _this_1.hiddenRows = [];
		        _this_1.columnMap = {};
		        _this_1.highlight = function (uniqueIdentifier, style, scrollIntoView, deselectOther) {
		            var _a, _b, _c;
		            if (scrollIntoView === void 0) { scrollIntoView = false; }
		            if (deselectOther === void 0) { deselectOther = true; }
		            var rows = _this_1.table.querySelectorAll('tr');
		            var styles = typeof style == 'string' ? [style] : style;
		            for (var i = 0; i < rows.length; i++) {
		                if (uniqueIdentifier != null &&
		                    rows[i].getAttribute('uid') == uniqueIdentifier) {
		                    (_a = rows[i].classList).remove.apply(_a, ['selected', 'active', 'outline'].map(function (st) {
		                        return "mux_table-row-".concat(st);
		                    }));
		                    if (style != 'none') {
		                        (_b = rows[i].classList).add.apply(_b, styles.map(function (st) {
		                            return "mux_table-row-".concat(st);
		                        }));
		                        if (scrollIntoView)
		                            rows[i].scrollIntoView({
		                                block: 'center',
		                                behavior: 'smooth',
		                            });
		                    }
		                }
		                else if (deselectOther)
		                    (_c = rows[i].classList).remove.apply(_c, ['selected', 'active', 'outline'].map(function (st) {
		                        return "mux_table-row-".concat(st);
		                    }));
		            }
		        };
		        _this_1.container = (0, CE_1.ce)('div', 'mux_table');
		        _this_1.columns = (_a = options === null || options === void 0 ? void 0 : options.columns) !== null && _a !== void 0 ? _a : [];
		        _this_1.table = (0, CE_1.ce)('table');
		        var headerRow = (0, CE_1.ce)('tr');
		        _this_1.columns.forEach(function (column) {
		            var cell = (0, CE_1.ce)('th', null, { uid: column.uniqueIdentifier });
		            _this_1.columnMap[column.uniqueIdentifier] = column;
		            if (column.width != undefined)
		                cell.style.width = column.width;
		            if (column.noLeftBorder == true)
		                cell.classList.add('mux_table-noborder');
		            if (column.title != undefined) {
		                var title = (0, CE_1.ce)('div', ['mux_table-text', 'mux_header', 'mux_small'], null, column.title);
		                cell.appendChild(title);
		                if (column.headerAlign != undefined)
		                    title.style.textAlign = column.headerAlign;
		            }
		            headerRow.appendChild(cell);
		        });
		        _this_1.table.appendChild(headerRow);
		        _this_1.container.appendChild(_this_1.table);
		        var _this = _this_1;
		        var sortable = new Sortable(_this_1.table, {
		            filter: ((_b = options === null || options === void 0 ? void 0 : options.dragableIgnore) !== null && _b !== void 0 ? _b : []).join(', '),
		            preventOnFilter: false,
		            handle: options === null || options === void 0 ? void 0 : options.dragableHandle,
		            ghostClass: 'mux_table-row-dragging',
		            onStart: function () {
		                _this.table.classList.add('mux_table-dragging');
		                _this.callEvent('dragStart');
		            },
		            onEnd: function (evt) {
		                _this.callEvent('dragEnd');
		                _this.table.classList.remove('mux_table-dragging');
		                _this.callEvent('orderUpdated', _this.getOrder());
		                _this.updateRowBackgrounds();
		            },
		        });
		        if (options.dragable != true) {
		            sortable.option('disabled', true);
		        }
		        if (options.rows != undefined) {
		            options.rows.forEach(function (row) { return _this_1.addRow(row, true); });
		            _this_1.updateRowBackgrounds();
		        }
		        return _this_1;
		    }
		    ComponentTable.prototype.getOrder = function () {
		        var order = [];
		        var rows = this.table.querySelectorAll('tr');
		        for (var i = 1; i < rows.length; i++)
		            order.push(rows[i].getAttribute('uid'));
		        return order;
		    };
		    ComponentTable.prototype.clear = function () {
		        this.rows = [];
		        var rows = this.table.querySelectorAll('tr');
		        if (rows.length > 1)
		            for (var i = 1; i < rows.length; i++)
		                rows[i].parentElement.removeChild(rows[i]);
		    };
		    ComponentTable.prototype.addRows = function (rows) {
		        var _this_1 = this;
		        rows.forEach(function (row) { return _this_1.addRow(row, true); });
		        this.updateRowBackgrounds();
		    };
		    ComponentTable.prototype.addRow = function (row, silent) {
		        if (silent === void 0) { silent = false; }
		        return this._createRow(row, null, silent);
		    };
		    ComponentTable.prototype.insertRow = function (index, row, silent) {
		        if (silent === void 0) { silent = false; }
		        if (index < 0 || index > this.rows.length)
		            return;
		        return this._createRow(row, index + 1, silent);
		    };
		    ComponentTable.prototype._createRow = function (row, insertIndex, silent) {
		        var _this_1 = this;
		        this.rows.push(row.uniqueIdentifier);
		        var rowElement = (0, CE_1.ce)('tr', 'mux_table-row', {
		            uid: row.uniqueIdentifier,
		        });
		        if (!this.hiddenRows.includes(row.uniqueIdentifier))
		            rowElement.classList.add('mux_table-row-visible');
		        rowElement.onclick = function (e) {
		            _this_1.callEvent('click', row.uniqueIdentifier, e);
		        };
		        if (row.child)
		            rowElement.classList.add('mux_table-row-child');
		        if (row.highlight != undefined)
		            rowElement.classList.add("mux_table-row-".concat(row.highlight));
		        this.columns.forEach(function (columnSettings) {
		            var cellElement = (0, CE_1.ce)('td', null, {
		                uid: columnSettings.uniqueIdentifier,
		            });
		            if (columnSettings.width != undefined)
		                cellElement.style.width = columnSettings.width;
		            var handler = columnTypes[columnSettings.type];
		            var cell = row.cells[columnSettings.uniqueIdentifier];
		            if (cell == undefined)
		                return;
		            cellElement.appendChild(handler.createElement(cell, row.uniqueIdentifier, columnSettings, _this_1));
		            rowElement.appendChild(cellElement);
		        });
		        if (insertIndex != null) {
		            var rows = this.table.querySelectorAll('tr');
		            if (insertIndex >= rows.length)
		                this.table.appendChild(rowElement);
		            else
		                this.table.insertBefore(rowElement, rows[insertIndex]);
		        }
		        else
		            this.table.appendChild(rowElement);
		        if (!silent)
		            this.updateRowBackgrounds();
		    };
		    ComponentTable.prototype.updateCell = function (rowId, columnId, value) {
		        var row = this.table.querySelector("tr[uid=\"".concat(rowId, "\"]"));
		        if (row == null)
		            return;
		        var cell = row.querySelector("td[uid=\"".concat(columnId, "\""));
		        if (cell == null)
		            return;
		        var columnSettings = this.columnMap[columnId];
		        var handler = columnTypes[columnSettings.type];
		        cell.innerHTML = '';
		        cell.appendChild(handler.createElement(value, rowId, columnSettings, this));
		    };
		    ComponentTable.prototype.setDragable = function (dragable) {
		        this.Sortable.option('disabled', !dragable);
		    };
		    ComponentTable.prototype.updateRowBackgrounds = function () {
		        var rows = this.table.querySelectorAll('.mux_table-row-visible');
		        var counter = 0;
		        var insideChild = false;
		        for (var i = 0; i < rows.length; i++) {
		            var isChild = rows[i].classList.contains('mux_table-row-child');
		            if (insideChild != isChild) {
		                insideChild = isChild;
		                counter = 0;
		            }
		            var odd = (counter + 1) % 2 == 0;
		            counter++;
		            if (odd)
		                rows[i].classList.add('mux_table-row-odd');
		            else
		                rows[i].classList.remove('mux_table-row-odd');
		        }
		    };
		    ComponentTable.extendTypes = function (type, handler) {
		        columnTypes[type] = handler;
		    };
		    return ComponentTable;
		}(baseComponent_1.MUXComponent));
		Component_Table.ComponentTable = ComponentTable;
		var columnTypes = {
		    text: new Component_Table_Text_1.ComponentTable_Text(true),
		    textsuggestions: new Component_Table_TextSuggestions_1.ComponentTable_TextSuggestions(),
		    number: new Component_Table_Number_1.ComponentTable_Number(),
		    button: new Component_Table_Button_1.ComponentTable_Button(),
		    duration: new Component_Table_Duration_1.ComponentTable_Duration(),
		    icons: new Component_Table_Icons_1.ComponentTable_Icons(),
		    select: new Component_Table_Select_1.ComponentTable_Select(),
		    materialSymbol: new Component_Table_MaterialSymbol_1.ComponentTable_MaterialSymbol(),
		};
		
		return Component_Table;
	}

	var Component_Text = {};

	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (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 __());
	    };
	})();
	Object.defineProperty(Component_Text, "__esModule", { value: true });
	Component_Text.ComponentText = void 0;
	var CE_1 = CE;
	var baseComponent_1 = baseComponent;
	var ComponentText = /** @class */ (function (_super) {
	    __extends(ComponentText, _super);
	    function ComponentText(options) {
	        var _a;
	        var _this = _super.call(this) || this;
	        var size = (_a = options === null || options === void 0 ? void 0 : options.size) !== null && _a !== void 0 ? _a : 'normal';
	        _this.container = (0, CE_1.ce)('div', ['mux_text', "mux_".concat(size)], null, options === null || options === void 0 ? void 0 : options.content);
	        return _this;
	    }
	    ComponentText.prototype.update = function (content) {
	        this.container.innerHTML = content;
	    };
	    return ComponentText;
	}(baseComponent_1.MUXComponent));
	Component_Text.ComponentText = ComponentText;

	var hasRequiredMorph_Components;

	function requireMorph_Components () {
		if (hasRequiredMorph_Components) return Morph_Components;
		hasRequiredMorph_Components = 1;
		Object.defineProperty(Morph_Components, "__esModule", { value: true });
		Morph_Components.MorphComponent = void 0;
		var Component_Button_1 = Component_Button;
		var Component_Cards_1 = Component_Cards;
		var Component_ContextMenu_1 = Component_ContextMenu;
		var Component_Dialog_1 = requireComponent_Dialog();
		var Component_Group_1 = Component_Group;
		var Component_Header_1 = Component_Header;
		var Component_IconGrid_1 = Component_IconGrid;
		var Component_ImageViewer_1 = requireComponent_ImageViewer();
		var Component_Input_1 = Component_Input;
		var Component_List_1 = requireComponent_List();
		var Component_MenuBar_1 = requireComponent_MenuBar();
		var Component_PaletteCheckbox_1 = requireComponent_PaletteCheckbox();
		var Component_PaletteSearch_1 = requireComponent_PaletteSearch();
		var Component_Resizer_1 = Component_Resizer;
		var Component_Row_1 = Component_Row;
		var Component_Select_1 = requireComponent_Select();
		var Component_Table_1 = requireComponent_Table();
		var Component_Text_1 = Component_Text;
		Morph_Components.MorphComponent = {
		    Header: Component_Header_1.ComponentHeader,
		    Text: Component_Text_1.ComponentText,
		    Button: Component_Button_1.ComponentButton,
		    Input: Component_Input_1.ComponentInput,
		    Select: Component_Select_1.ComponentSelect,
		    Group: Component_Group_1.ComponentGroup,
		    List: Component_List_1.ComponentList,
		    Cards: Component_Cards_1.ComponentCards,
		    IconGrid: Component_IconGrid_1.ComponentIconGrid,
		    Table: Component_Table_1.ComponentTable,
		    Row: Component_Row_1.ComponentRow,
		    Dialog: Component_Dialog_1.ComponentDialog,
		    PaletteSearch: Component_PaletteSearch_1.ComponentPaletteSearch,
		    PaletteCheckbox: Component_PaletteCheckbox_1.ComponentPaletteCheckbox,
		    ImageViewer: Component_ImageViewer_1.ComponentImageViewer,
		    MenuBar: Component_MenuBar_1.ComponentMenuBar,
		    ContextMenu: Component_ContextMenu_1.ComponentContextMenu,
		    Resizer: Component_Resizer_1.ComponentResizer,
		    extend: function (name, component) {
		        this[name] = component;
		    },
		};
		
		return Morph_Components;
	}

	var Morph_Features = {};

	var Feature_Alert = {};

	var hasRequiredFeature_Alert;

	function requireFeature_Alert () {
		if (hasRequiredFeature_Alert) return Feature_Alert;
		hasRequiredFeature_Alert = 1;
		Object.defineProperty(Feature_Alert, "__esModule", { value: true });
		Feature_Alert.FeatureAlert = FeatureAlert;
		var Index_1 = requireIndex();
		function FeatureAlert(options, callback) {
		    return new Promise(function (resolve) {
		        var _a;
		        var dialog = new Index_1.MorphComponent.Dialog({
		            title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Alert',
		            width: 'small',
		            height: 'auto',
		            cancelButtonVisible: false,
		        });
		        dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
		        var res = function () {
		            if (typeof callback == 'function')
		                callback();
		            resolve();
		        };
		        dialog.on('close', function () { return res(); });
		        dialog.on('ok', function () { return res(); });
		    });
		}
		
		return Feature_Alert;
	}

	var Feature_Confirm = {};

	var hasRequiredFeature_Confirm;

	function requireFeature_Confirm () {
		if (hasRequiredFeature_Confirm) return Feature_Confirm;
		hasRequiredFeature_Confirm = 1;
		Object.defineProperty(Feature_Confirm, "__esModule", { value: true });
		Feature_Confirm.FeatureConfirm = FeatureConfirm;
		var Index_1 = requireIndex();
		function FeatureConfirm(options, callback) {
		    return new Promise(function (resolve) {
		        var _a;
		        var dialog = new Index_1.MorphComponent.Dialog({
		            title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Confirm',
		            width: 'small',
		            height: 'auto',
		        });
		        dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
		        var res = function (state) {
		            if (typeof callback == 'function')
		                callback(state);
		            resolve(state);
		        };
		        dialog.on('close', function () { return res(null); });
		        dialog.on('cancel', function () { return res(false); });
		        dialog.on('ok', function () { return res(true); });
		    });
		}
		
		return Feature_Confirm;
	}

	var Feature_Loader = {};

	var hasRequiredFeature_Loader;

	function requireFeature_Loader () {
		if (hasRequiredFeature_Loader) return Feature_Loader;
		hasRequiredFeature_Loader = 1;
		Object.defineProperty(Feature_Loader, "__esModule", { value: true });
		Feature_Loader.FeatureLoader = FeatureLoader;
		var Index_1 = requireIndex();
		function FeatureLoader(options) {
		    var _a, _b;
		    var active = (_a = options === null || options === void 0 ? void 0 : options.active) !== null && _a !== void 0 ? _a : false;
		    var message = (_b = options === null || options === void 0 ? void 0 : options.message) !== null && _b !== void 0 ? _b : '';
		    var progress = options === null || options === void 0 ? void 0 : options.progress;
		    if (active == true)
		        showLoader(message, progress);
		    else
		        removeExisting();
		}
		function showLoader(message, progress) {
		    var loader = document.querySelector('.mux_loader');
		    if (loader == null) {
		        loader = (0, Index_1.ce)('div', 'mux_loader');
		        loader.appendChild((0, Index_1.ce)('span', 'material-symbols-outlined', null, 'circle'));
		        document.body.appendChild(loader);
		    }
		    var existingProgress = loader.querySelector('.mux_loader-progress');
		    if (progress == null) {
		        if (existingProgress != null)
		            existingProgress.remove();
		    }
		    else {
		        if (existingProgress != null) {
		            existingProgress.style.setProperty('--progress', "".concat(progress, "%"));
		            existingProgress.querySelector('.mux_loader-progress-label').innerText = "".concat(Math.round(progress), "%");
		        }
		        else {
		            var progressBar = (0, Index_1.ce)('div', 'mux_loader-progress');
		            progressBar.style.setProperty('--progress', "".concat(progress, "%"));
		            var value = (0, Index_1.ce)('div', 'mux_loader-progress-value');
		            value.appendChild((0, Index_1.ce)('div', 'mux_loader-progress-label', null, "".concat(Math.round(progress), "%")));
		            progressBar.appendChild(value);
		            loader.appendChild(progressBar);
		        }
		    }
		    var existingText = loader.querySelector('.mux_loader-message');
		    if (message.trim().length == 0) {
		        if (existingText != null)
		            existingText.remove();
		    }
		    else {
		        if (existingText != null)
		            existingText.innerText = message;
		        else {
		            if (loader.querySelector('.mux_loader-progress') != null)
		                loader.insertBefore((0, Index_1.ce)('div', ['mux_text', 'mux_loader-message'], null, message), loader.querySelector('.mux_loader-progress'));
		            else
		                loader.appendChild((0, Index_1.ce)('div', ['mux_text', 'mux_loader-message'], null, message));
		        }
		    }
		}
		function removeExisting() {
		    var existing = document.querySelector('.mux_loader');
		    if (existing != null)
		        existing.remove();
		}
		
		return Feature_Loader;
	}

	var Feature_Notification = {};

	var hasRequiredFeature_Notification;

	function requireFeature_Notification () {
		if (hasRequiredFeature_Notification) return Feature_Notification;
		hasRequiredFeature_Notification = 1;
		Object.defineProperty(Feature_Notification, "__esModule", { value: true });
		Feature_Notification.FeatureNotification = FeatureNotification;
		var Index_1 = requireIndex();
		var NotificationHandler = new (/** @class */ (function () {
		    function class_1() {
		        var _this = this;
		        window.addEventListener('DOMContentLoaded', function () { return _this.prepare(); });
		    }
		    class_1.prototype.prepare = function () {
		        this.container = (0, Index_1.ce)('div', 'mux_notifications');
		        document.body.appendChild(this.container);
		    };
		    class_1.prototype.append = function (notification) {
		        var _a, _b, _c;
		        var element = (0, Index_1.ce)('div', 'mux_notification');
		        element.classList.add('mux_notification-' + notification.level);
		        var icon = (0, Index_1.ce)('span', ['material-symbols-outlined', 'mux_notification-icon'], null, {
		            info: 'exclamation',
		            warning: 'exclamation',
		            error: 'close',
		            success: 'check',
		        }[(_a = notification.level) !== null && _a !== void 0 ? _a : 'info']);
		        if (notification.level == 'info')
		            icon.style.transform = 'rotate(180deg)';
		        element.appendChild(icon);
		        element.appendChild((0, Index_1.ce)('div', 'mux_text', null, notification.message));
		        if ((notification === null || notification === void 0 ? void 0 : notification.action) != null) {
		            var action = (0, Index_1.ce)('span', ['material-symbols-outlined', 'mux_notification-action'], null, notification.action.materialIcon);
		            action.onclick = function () {
		                notification.action.click();
		                clearTimeout(hideTimeout);
		                closeNotification();
		            };
		            element.appendChild(action);
		        }
		        if ((_b = notification === null || notification === void 0 ? void 0 : notification.closeable) !== null && _b !== void 0 ? _b : true) {
		            element.onclick = function () {
		                closeNotification();
		            };
		        }
		        this.container.prepend(element);
		        var openNotification = function () {
		            element.style.opacity = '1';
		            element.style.transform = 'translateX(0px)';
		        };
		        var closeNotification = function () {
		            clearTimeout(hideTimeout);
		            element.style.marginTop = "-".concat(element.clientHeight + 6, "px");
		            element.style.opacity = '0';
		            element.style.transform = 'translateX(100%)';
		            element.style.pointerEvents = 'none';
		            element.ontransitionend = function () { return element.remove(); };
		        };
		        setTimeout(function () { return openNotification(); }, 100);
		        var hideTimeout = setTimeout(function () { return closeNotification(); }, ((_c = notification === null || notification === void 0 ? void 0 : notification.seconds) !== null && _c !== void 0 ? _c : 10) * 1000);
		        return new NotificationInstance(closeNotification);
		    };
		    return class_1;
		}()))();
		var NotificationInstance = /** @class */ (function () {
		    function NotificationInstance(close) {
		        this._close = close;
		    }
		    NotificationInstance.prototype.close = function () {
		        this._close();
		    };
		    return NotificationInstance;
		}());
		function FeatureNotification(notification) {
		    var _a;
		    if (((_a = notification === null || notification === void 0 ? void 0 : notification.message) !== null && _a !== void 0 ? _a : '').trim().length == 0)
		        return;
		    return NotificationHandler.append(notification);
		}
		
		return Feature_Notification;
	}

	var Feature_Prompt = {};

	var hasRequiredFeature_Prompt;

	function requireFeature_Prompt () {
		if (hasRequiredFeature_Prompt) return Feature_Prompt;
		hasRequiredFeature_Prompt = 1;
		Object.defineProperty(Feature_Prompt, "__esModule", { value: true });
		Feature_Prompt.FeaturePrompt = FeaturePrompt;
		var Index_1 = requireIndex();
		function FeaturePrompt(options, callback) {
		    return new Promise(function (resolve) {
		        var _a, _b, _c, _d;
		        var dialog = new Index_1.MorphComponent.Dialog({
		            title: (_a = options === null || options === void 0 ? void 0 : options.title) !== null && _a !== void 0 ? _a : 'Prompt',
		            width: 'small',
		            height: 'auto',
		        });
		        dialog.content.appendChild((0, Index_1.ce)('div', 'mux_text', null, options.message));
		        var input = new Index_1.MorphComponent.Input({
		            type: (_b = options.type) !== null && _b !== void 0 ? _b : 'text',
		            value: (_c = options.default) !== null && _c !== void 0 ? _c : '',
		            placeholder: (_d = options.placeholder) !== null && _d !== void 0 ? _d : '',
		            border: 'always',
		        });
		        input.container.style.margin = 'var(--mux-edge-offset-tiny) 0px';
		        input.container.onfocus = function () {
		            errorMessage.style.height = '0px';
		        };
		        dialog.content.appendChild(input.container);
		        var errorMessage = (0, Index_1.ce)('div', ['mux_text', 'mux_small'], null, 'Value can not be empty!');
		        errorMessage.style.height = '0px';
		        errorMessage.style.transitionDuration =
		            'var(--mux-transition-animation)';
		        errorMessage.style.overflow = 'hidden';
		        errorMessage.style.color = 'var(--mux-color-red)';
		        dialog.content.appendChild(errorMessage);
		        var res = function (value) {
		            if (typeof callback == 'function')
		                callback(value);
		            resolve(value);
		        };
		        dialog.on('close', function () { return res(null); });
		        dialog.on('cancel', function () { return res(null); });
		        dialog.on('ok', function (closeEvent) {
		            if (!options.canBeEmpty && input.getValue().trim() == '') {
		                errorMessage.style.height = '14px';
		                return closeEvent.preventClose();
		            }
		            res(input.getValue());
		        });
		        input.container.focus();
		    });
		}
		
		return Feature_Prompt;
	}

	var hasRequiredMorph_Features;

	function requireMorph_Features () {
		if (hasRequiredMorph_Features) return Morph_Features;
		hasRequiredMorph_Features = 1;
		Object.defineProperty(Morph_Features, "__esModule", { value: true });
		Morph_Features.MorphFeature = void 0;
		var Feature_Alert_1 = requireFeature_Alert();
		var Feature_Confirm_1 = requireFeature_Confirm();
		var Feature_Loader_1 = requireFeature_Loader();
		var Feature_Notification_1 = requireFeature_Notification();
		var Feature_Prompt_1 = requireFeature_Prompt();
		Morph_Features.MorphFeature = {
		    Confirm: Feature_Confirm_1.FeatureConfirm,
		    Alert: Feature_Alert_1.FeatureAlert,
		    Prompt: Feature_Prompt_1.FeaturePrompt,
		    Notification: Feature_Notification_1.FeatureNotification,
		    Loader: Feature_Loader_1.FeatureLoader,
		    extend: function (name, component) {
		        this[name] = component;
		    },
		};
		
		return Morph_Features;
	}

	var Morph_Utils = {};

	var clone$1 = {};

	Object.defineProperty(clone$1, "__esModule", { value: true });
	clone$1.clone = clone;
	function clone(object) {
	    if (typeof object !== 'object')
	        return object;
	    return JSON.parse(JSON.stringify(object !== null && object !== void 0 ? object : {}));
	}

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.ce = exports.clone = void 0;
		var clone_1 = clone$1;
		Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return clone_1.clone; } });
		var CE_1 = CE;
		Object.defineProperty(exports, "ce", { enumerable: true, get: function () { return CE_1.ce; } });
		
	} (Morph_Utils));

	var hasRequiredIndex;

	function requireIndex () {
		if (hasRequiredIndex) return Index;
		hasRequiredIndex = 1;
		(function (exports) {
			var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
			    if (k2 === undefined) k2 = k;
			    var desc = Object.getOwnPropertyDescriptor(m, k);
			    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
			      desc = { enumerable: true, get: function() { return m[k]; } };
			    }
			    Object.defineProperty(o, k2, desc);
			}) : (function(o, m, k, k2) {
			    if (k2 === undefined) k2 = k;
			    o[k2] = m[k];
			}));
			var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
			    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
			};
			Object.defineProperty(exports, "__esModule", { value: true });
			exports.MUXComponent = void 0;
			var version = require$$0$1.version;
			if (window._MorphUXInitialized === undefined) {
			    console.log('MorphUX Loaded');
			    console.log("Version ".concat(version));
			    window._MorphUXInitialized = true;
			}
			__exportStar(requireMorph_Components(), exports);
			__exportStar(requireMorph_Features(), exports);
			__exportStar(Morph_Keys, exports);
			__exportStar(Morph_Utils, exports);
			var baseComponent_1 = baseComponent;
			Object.defineProperty(exports, "MUXComponent", { enumerable: true, get: function () { return baseComponent_1.MUXComponent; } });
			
		} (Index));
		return Index;
	}

	Object.defineProperty(checklist, "__esModule", { value: true });
	checklist.Checklist = void 0;
	var morphux_1$1 = requireIndex();
	var Checklist = /** @class */ (function () {
	    function Checklist(Main) {
	        this.Rows = {
	            CAMERAPC: document.querySelector(".ntsh-checklist-row[status=\"CAMERAPC\"]"),
	            CAMERAPROCESS: document.querySelector(".ntsh-checklist-row[status=\"CAMERAPROCESS\"]"),
	            CAMERAUNITYSTREAM: document.querySelector(".ntsh-checklist-row[status=\"CAMERAUNITYSTREAM\"]"),
	            UNITYBUILD: document.querySelector(".ntsh-checklist-row[status=\"UNITYBUILD\"]"),
	            REPLAYFUNCTION: document.querySelector(".ntsh-checklist-row[status=\"REPLAYFUNCTION\"]"),
	        };
	        this.FullReboot = document.querySelector('.ntsh-fullreboot-button');
	        this._Main = Main;
	        this.registerListeners();
	    }
	    Checklist.prototype.update = function (status) {
	        this.updateRow(this.Rows.CAMERAPC, status.CAMERAPC);
	        this.updateRow(this.Rows.CAMERAPROCESS, status.CAMERAPROCESS);
	        this.updateRow(this.Rows.CAMERAUNITYSTREAM, status.CAMERAUNITYSTREAM);
	        this.updateRow(this.Rows.UNITYBUILD, status.UNITYBUILD);
	        this.updateRow(this.Rows.REPLAYFUNCTION, status.REPLAYFUNCTION);
	    };
	    Checklist.prototype.updateRow = function (row, state) {
	        var _a, _b, _c;
	        var status = row.querySelector('.ntsh-checklist-row-status');
	        var message = row.querySelector('p');
	        var startButton = row.querySelector('.ntsh-checklist-row-button.start');
	        var stopButton = row.querySelector('.ntsh-checklist-row-button.stop');
	        var rebootButton = row.querySelector('.ntsh-checklist-row-button.reboot');
	        status.classList.remove('RED', 'GREEN', 'YELLOW', 'GRAY');
	        status.classList.add(state.state);
	        message.innerText = state.message;
	        startButton.style.display = ((_a = state.buttons) === null || _a === void 0 ? void 0 : _a.start) ? 'block' : 'none';
	        stopButton.style.display = ((_b = state.buttons) === null || _b === void 0 ? void 0 : _b.stop) ? 'block' : 'none';
	        rebootButton.style.display = ((_c = state.buttons) === null || _c === void 0 ? void 0 : _c.reboot) ? 'block' : 'none';
	    };
	    Checklist.prototype.registerListeners = function () {
	        var _this = this;
	        this.FullReboot.onclick = function () {
	            morphux_1$1.MorphFeature.Confirm({
	                title: 'Full Reboot',
	                message: 'Are you sure you want to perform a full reboot?',
	            }, function (state) {
	                if (!state)
	                    return;
	                _this._Main.socket.emit('status', 'fullreboot');
	            });
	        };
	        var _loop_1 = function (key) {
	            var row = this_1.Rows[key];
	            var startButton = row.querySelector('.ntsh-checklist-row-button.start');
	            startButton.onclick = function () {
	                return morphux_1$1.MorphFeature.Confirm({
	                    title: 'Start',
	                    message: 'Are you sure you want to start?',
	                }, function (state) {
	                    if (!state)
	                        return;
	                    _this._Main.socket.emit('status', 'start', key);
	                });
	            };
	            var stopButton = row.querySelector('.ntsh-checklist-row-button.stop');
	            stopButton.onclick = function () {
	                return morphux_1$1.MorphFeature.Confirm({
	                    title: 'Stop',
	                    message: 'Are you sure you want to stop?',
	                }, function (state) {
	                    if (!state)
	                        return;
	                    _this._Main.socket.emit('status', 'stop', key);
	                });
	            };
	            var rebootButton = row.querySelector('.ntsh-checklist-row-button.reboot');
	            rebootButton.onclick = function () {
	                return morphux_1$1.MorphFeature.Confirm({
	                    title: 'Reboot',
	                    message: 'Are you sure you want to reboot?',
	                }, function (state) {
	                    if (!state)
	                        return;
	                    _this._Main.socket.emit('status', 'reboot', key);
	                });
	            };
	        };
	        var this_1 = this;
	        for (var key in this.Rows) {
	            _loop_1(key);
	        }
	    };
	    return Checklist;
	}());
	checklist.Checklist = Checklist;

	var calibration = {};

	Object.defineProperty(calibration, "__esModule", { value: true });
	calibration.Calibration = void 0;
	var Calibration = /** @class */ (function () {
	    function Calibration(Main) {
	        this.visible = false;
	        this.container = document.querySelector('.ntsh-calibration');
	        this.image = this.container.querySelector('img.stream');
	        this._Main = Main;
	        this.registerListeners();
	        this.startClock();
	    }
	    Calibration.prototype.startClock = function () {
	        var _this = this;
	        setInterval(function () {
	            if (_this.visible && _this.image)
	                _this.image.src = "/calibrationImage?t=".concat(Date.now());
	        }, 1000);
	    };
	    Calibration.prototype.registerListeners = function () {
	        var _this = this;
	        this.observer = new IntersectionObserver(function (entries) {
	            entries.forEach(function (entry) {
	                if (entry.isIntersecting) {
	                    _this.visible = true;
	                    // console.log('Calibration visible');
	                }
	                else {
	                    _this.visible = false;
	                    // console.log('Calibration not visible');
	                }
	            });
	        });
	        this.observer.observe(this.container);
	    };
	    return Calibration;
	}());
	calibration.Calibration = Calibration;

	var outOfServiceMode = {};

	var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
	    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(outOfServiceMode, "__esModule", { value: true });
	outOfServiceMode.OutOfServiceMode = void 0;
	var OutOfServiceMode = /** @class */ (function () {
	    function OutOfServiceMode(Main) {
	        this.state = false;
	        this.input = document.querySelector('.ntsh-outofservicemode-input');
	        this._Main = Main;
	        this.registerListeners();
	    }
	    OutOfServiceMode.prototype.registerListeners = function () {
	        var _this = this;
	        this.input.addEventListener('change', function () { return __awaiter$1(_this, void 0, void 0, function () {
	            var valid;
	            return __generator$1(this, function (_a) {
	                switch (_a.label) {
	                    case 0: return [4 /*yield*/, this._Main.executeCommand(this.state ? 'disableOutOfService' : 'enableOutOfService', "Are you sure you want to set the installation to \"".concat(this.state ? 'Out of Service' : 'Operational', "\"?"), 'unityWebSocket')];
	                    case 1:
	                        valid = _a.sent();
	                        if (!valid)
	                            this.input.checked = this.state;
	                        this.state = this.input.checked;
	                        return [2 /*return*/];
	                }
	            });
	        }); });
	    };
	    return OutOfServiceMode;
	}());
	outOfServiceMode.OutOfServiceMode = OutOfServiceMode;

	var timer = {};

	Object.defineProperty(timer, "__esModule", { value: true });
	timer.Timer = void 0;
	var Timer = /** @class */ (function () {
	    function Timer(Main) {
	        this.startup = document.querySelector('.ntsh-timer-startup');
	        this.shutdown = document.querySelector('.ntsh-timer-shutdown');
	        this._Main = Main;
	        this.registerListeners();
	    }
	    Timer.prototype.update = function (data) {
	        var start = "".concat(data.start.hour.toString().padStart(2, '0'), ":").concat(data.start.minute.toString().padStart(2, '0'));
	        var end = "".concat(data.end.hour.toString().padStart(2, '0'), ":").concat(data.end.minute.toString().padStart(2, '0'));
	        this.startup.value = start;
	        this.shutdown.value = end;
	    };
	    Timer.prototype.registerListeners = function () {
	        var _this = this;
	        this.startup.onchange = function () {
	            var _a = _this.startup.value.split(':').map(Number), hour = _a[0], minute = _a[1];
	            _this._Main.socket.emit('setTimerStart', { hour: hour, minute: minute });
	        };
	        this.shutdown.onchange = function () {
	            var _a = _this.shutdown.value.split(':').map(Number), hour = _a[0], minute = _a[1];
	            _this._Main.socket.emit('setTimerEnd', { hour: hour, minute: minute });
	        };
	    };
	    return Timer;
	}());
	timer.Timer = Timer;

	var lighting = {};

	Object.defineProperty(lighting, "__esModule", { value: true });
	lighting.Lighting = void 0;
	var Lighting = /** @class */ (function () {
	    function Lighting(Main) {
	        this.autoLightingInput = document.querySelector('.ntsh-autolighting input');
	        this.gainInput = document.querySelector('.ntsh_lightingsettings-gain');
	        this.exposureInput = document.querySelector('.ntsh_lightingsettings-exposure');
	        this.whiteBalanceInput = document.querySelector('.ntsh_lightingsettings-whitebalance');
	        this._Main = Main;
	        this.registerListeners();
	    }
	    Lighting.prototype.update = function (state) {
	        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
	        if (((_a = state === null || state === void 0 ? void 0 : state.parameters) === null || _a === void 0 ? void 0 : _a.advancedSliders) == null)
	            return;
	        var autoExposureIndex = (_b = state.parameters) === null || _b === void 0 ? void 0 : _b.advancedSliders.findIndex(function (slider) { return slider.sliderName === 'AutoExposure'; });
	        var autoExposureSlider = (_c = state.parameters) === null || _c === void 0 ? void 0 : _c.advancedSliders[autoExposureIndex !== null && autoExposureIndex !== void 0 ? autoExposureIndex : -1];
	        var gainSliderIndex = (_d = state.parameters) === null || _d === void 0 ? void 0 : _d.advancedSliders.findIndex(function (slider) { return slider.sliderName === 'Gain'; });
	        var gainSlider = (_e = state.parameters) === null || _e === void 0 ? void 0 : _e.advancedSliders[gainSliderIndex !== null && gainSliderIndex !== void 0 ? gainSliderIndex : -1];
	        var exposureSliderIndex = (_f = state.parameters) === null || _f === void 0 ? void 0 : _f.advancedSliders.findIndex(function (slider) { return slider.sliderName === 'Exposure'; });
	        var exposureSlider = (_g = state.parameters) === null || _g === void 0 ? void 0 : _g.advancedSliders[exposureSliderIndex !== null && exposureSliderIndex !== void 0 ? exposureSliderIndex : -1];
	        var whiteBalanceSliderIndex = (_h = state.parameters) === null || _h === void 0 ? void 0 : _h.advancedSliders.findIndex(function (slider) { return slider.sliderName === 'Whitebalance'; });
	        var whiteBalanceSlider = (_j = state.parameters) === null || _j === void 0 ? void 0 : _j.advancedSliders[whiteBalanceSliderIndex !== null && whiteBalanceSliderIndex !== void 0 ? whiteBalanceSliderIndex : -1];
	        this.autoLightingInput.checked = (autoExposureSlider === null || autoExposureSlider === void 0 ? void 0 : autoExposureSlider.outputValue) === 1;
	        this.gainInput.valueAsNumber =
	            (_k = gainSlider === null || gainSlider === void 0 ? void 0 : gainSlider.outputValue) !== null && _k !== void 0 ? _k : this.gainInput.valueAsNumber;
	        this.exposureInput.valueAsNumber =
	            (_l = exposureSlider === null || exposureSlider === void 0 ? void 0 : exposureSlider.outputValue) !== null && _l !== void 0 ? _l : this.exposureInput.valueAsNumber;
	        this.whiteBalanceInput.valueAsNumber =
	            (_m = whiteBalanceSlider === null || whiteBalanceSlider === void 0 ? void 0 : whiteBalanceSlider.outputValue) !== null && _m !== void 0 ? _m : this.whiteBalanceInput.valueAsNumber;
	        this.autoLightingInput.setAttribute('index', (_o = autoExposureIndex === null || autoExposureIndex === void 0 ? void 0 : autoExposureIndex.toString()) !== null && _o !== void 0 ? _o : '-1');
	        this.gainInput.setAttribute('index', (_p = gainSliderIndex === null || gainSliderIndex === void 0 ? void 0 : gainSliderIndex.toString()) !== null && _p !== void 0 ? _p : '-1');
	        this.exposureInput.setAttribute('index', (_q = exposureSliderIndex === null || exposureSliderIndex === void 0 ? void 0 : exposureSliderIndex.toString()) !== null && _q !== void 0 ? _q : '-1');
	        this.whiteBalanceInput.setAttribute('index', (_r = whiteBalanceSliderIndex === null || whiteBalanceSliderIndex === void 0 ? void 0 : whiteBalanceSliderIndex.toString()) !== null && _r !== void 0 ? _r : '-1');
	    };
	    Lighting.prototype.registerListeners = function () {
	        var _this = this;
	        this.autoLightingInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'advancedParameterValue', parseInt((_a = _this.autoLightingInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.autoLightingInput.checked ? 1 : 0);
	        };
	        this.gainInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'advancedParameterValue', parseInt((_a = _this.gainInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.gainInput.valueAsNumber);
	        };
	        this.exposureInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'advancedParameterValue', parseInt((_a = _this.exposureInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.exposureInput.valueAsNumber);
	        };
	        this.whiteBalanceInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'advancedParameterValue', parseInt((_a = _this.whiteBalanceInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.whiteBalanceInput.valueAsNumber);
	        };
	    };
	    return Lighting;
	}());
	lighting.Lighting = Lighting;

	var sound = {};

	Object.defineProperty(sound, "__esModule", { value: true });
	sound.Sound = void 0;
	var Sound = /** @class */ (function () {
	    function Sound(Main) {
	        this.volumeInput = document.querySelector('.ntsh_soundsettings-volume');
	        this.eqLowInput = document.querySelector('.ntsh_soundsettings-eqlow');
	        this.eqMidInput = document.querySelector('.ntsh_soundsettings-eqmid');
	        this.eqHighInput = document.querySelector('.ntsh_soundsettings-eqhigh');
	        this._Main = Main;
	        this.registerListeners();
	    }
	    Sound.prototype.update = function (state) {
	        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
	        if (((_a = state === null || state === void 0 ? void 0 : state.parameters) === null || _a === void 0 ? void 0 : _a.sliders) == null)
	            return;
	        var volumeSliderIndex = (_b = state.parameters) === null || _b === void 0 ? void 0 : _b.sliders.findIndex(function (slider) { return slider.sliderName === 'Volume'; });
	        var volumeSlider = (_c = state.parameters) === null || _c === void 0 ? void 0 : _c.sliders[volumeSliderIndex !== null && volumeSliderIndex !== void 0 ? volumeSliderIndex : -1];
	        var eqLowSliderIndex = (_d = state.parameters) === null || _d === void 0 ? void 0 : _d.sliders.findIndex(function (slider) { return slider.sliderName === 'EQ_Low'; });
	        var eqLowSlider = (_e = state.parameters) === null || _e === void 0 ? void 0 : _e.sliders[eqLowSliderIndex !== null && eqLowSliderIndex !== void 0 ? eqLowSliderIndex : -1];
	        var eqMidSliderIndex = (_f = state.parameters) === null || _f === void 0 ? void 0 : _f.sliders.findIndex(function (slider) { return slider.sliderName === 'EQ_Mid'; });
	        var eqMidSlider = (_g = state.parameters) === null || _g === void 0 ? void 0 : _g.sliders[eqMidSliderIndex !== null && eqMidSliderIndex !== void 0 ? eqMidSliderIndex : -1];
	        var eqHighSliderIndex = (_h = state.parameters) === null || _h === void 0 ? void 0 : _h.sliders.findIndex(function (slider) { return slider.sliderName === 'EQ_High'; });
	        var eqHighSlider = (_j = state.parameters) === null || _j === void 0 ? void 0 : _j.sliders[eqHighSliderIndex !== null && eqHighSliderIndex !== void 0 ? eqHighSliderIndex : -1];
	        this.volumeInput.valueAsNumber =
	            (_k = volumeSlider === null || volumeSlider === void 0 ? void 0 : volumeSlider.outputValue) !== null && _k !== void 0 ? _k : this.volumeInput.valueAsNumber;
	        this.eqLowInput.valueAsNumber =
	            (_l = eqLowSlider === null || eqLowSlider === void 0 ? void 0 : eqLowSlider.outputValue) !== null && _l !== void 0 ? _l : this.eqLowInput.valueAsNumber;
	        this.eqMidInput.valueAsNumber =
	            (_m = eqMidSlider === null || eqMidSlider === void 0 ? void 0 : eqMidSlider.outputValue) !== null && _m !== void 0 ? _m : this.eqMidInput.valueAsNumber;
	        this.eqHighInput.valueAsNumber =
	            (_o = eqHighSlider === null || eqHighSlider === void 0 ? void 0 : eqHighSlider.outputValue) !== null && _o !== void 0 ? _o : this.eqHighInput.valueAsNumber;
	        this.volumeInput.setAttribute('index', (_p = volumeSliderIndex === null || volumeSliderIndex === void 0 ? void 0 : volumeSliderIndex.toString()) !== null && _p !== void 0 ? _p : '-1');
	        this.eqLowInput.setAttribute('index', (_q = eqLowSliderIndex === null || eqLowSliderIndex === void 0 ? void 0 : eqLowSliderIndex.toString()) !== null && _q !== void 0 ? _q : '-1');
	        this.eqMidInput.setAttribute('index', (_r = eqMidSliderIndex === null || eqMidSliderIndex === void 0 ? void 0 : eqMidSliderIndex.toString()) !== null && _r !== void 0 ? _r : '-1');
	        this.eqHighInput.setAttribute('index', (_s = eqHighSliderIndex === null || eqHighSliderIndex === void 0 ? void 0 : eqHighSliderIndex.toString()) !== null && _s !== void 0 ? _s : '-1');
	    };
	    Sound.prototype.registerListeners = function () {
	        var _this = this;
	        this.volumeInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'parameterValue', parseInt((_a = _this.volumeInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.volumeInput.valueAsNumber);
	        };
	        this.eqLowInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'parameterValue', parseInt((_a = _this.eqLowInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.eqLowInput.valueAsNumber);
	        };
	        this.eqMidInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'parameterValue', parseInt((_a = _this.eqMidInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.eqMidInput.valueAsNumber);
	        };
	        this.eqHighInput.onchange = function () {
	            var _a;
	            _this._Main.socket.emit('unityWebSocket', 'parameterValue', parseInt((_a = _this.eqHighInput.getAttribute('index')) !== null && _a !== void 0 ? _a : '-1'), _this.eqHighInput.valueAsNumber);
	        };
	    };
	    return Sound;
	}());
	sound.Sound = Sound;

	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
	    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(main$1, "__esModule", { value: true });
	exports.Main = main$1.Main = void 0;
	var socket_io_client_1 = cjsExports;
	var menu_1 = menu;
	var checklist_1 = checklist;
	var calibration_1 = calibration;
	var morphux_1 = requireIndex();
	var outOfServiceMode_1 = outOfServiceMode;
	var timer_1 = timer;
	var lighting_1 = lighting;
	var sound_1 = sound;
	var socket = (0, socket_io_client_1.io)('/');
	var Main = /** @class */ (function () {
	    function Main() {
	        this.Menu = new menu_1.Menu();
	        this.CheckList = new checklist_1.Checklist(this);
	        this.Calibration = new calibration_1.Calibration(this);
	        this.OutOfServiceMode = new outOfServiceMode_1.OutOfServiceMode(this);
	        this.Timer = new timer_1.Timer(this);
	        this.Lighting = new lighting_1.Lighting(this);
	        this.Sound = new sound_1.Sound(this);
	        this.socket = socket;
	        this.supportButton = document.querySelector('.ntsh-support img');
	        this.supportNumber = '';
	        this.registerListeners();
	    }
	    Main.prototype.registerListeners = function () {
	        var _this = this;
	        this.supportButton.onclick = function () { return _this.showSupport(); };
	        socket.on('status', function (data) {
	            _this.CheckList.update(data);
	        });
	        socket.on('supportNumber', function (number) {
	            _this.supportNumber = number;
	        });
	        socket.on('unityWebSocketState', function (state) {
	            var _a, _b, _c, _d;
	            _this.OutOfServiceMode.input.checked =
	                (_b = (_a = state === null || state === void 0 ? void 0 : state.parameters) === null || _a === void 0 ? void 0 : _a.outOfService) !== null && _b !== void 0 ? _b : false;
	            _this.OutOfServiceMode.state =
	                (_d = (_c = state === null || state === void 0 ? void 0 : state.parameters) === null || _c === void 0 ? void 0 : _c.outOfService) !== null && _d !== void 0 ? _d : false;
	            _this.Lighting.update(state);
	            _this.Sound.update(state);
	        });
	        socket.on('timer', function (data) {
	            _this.Timer.update(data);
	        });
	    };
	    Main.prototype.executeCommand = function (command_1, message_1) {
	        return __awaiter(this, arguments, void 0, function (command, message, type) {
	            var _this = this;
	            if (type === void 0) { type = 'unityRunner'; }
	            return __generator(this, function (_a) {
	                return [2 /*return*/, new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
	                        var confirmed;
	                        return __generator(this, function (_a) {
	                            switch (_a.label) {
	                                case 0: return [4 /*yield*/, morphux_1.MorphFeature.Confirm({
	                                        title: 'Are you sure?',
	                                        message: message,
	                                    })];
	                                case 1:
	                                    confirmed = _a.sent();
	                                    if (!confirmed)
	                                        return [2 /*return*/, resolve(false)];
	                                    morphux_1.MorphFeature.Loader({
	                                        active: true,
	                                        message: "Dispatching command...",
	                                    });
	                                    socket.emit(type, command, function (response) {
	                                        morphux_1.MorphFeature.Loader({ active: false });
	                                        if (!response.succeed)
	                                            return morphux_1.MorphFeature.Alert({
	                                                title: 'Error',
	                                                message: response.message,
	                                            });
	                                        morphux_1.MorphFeature.Notification({
	                                            level: 'success',
	                                            message: "Dispatched command",
	                                        });
	                                    });
	                                    resolve(true);
	                                    return [2 /*return*/];
	                            }
	                        });
	                    }); })];
	            });
	        });
	    };
	    Main.prototype.showSupport = function () {
	        return __awaiter(this, void 0, void 0, function () {
	            var dialog, callAnchor;
	            return __generator(this, function (_a) {
	                dialog = new morphux_1.MorphComponent.Dialog({
	                    title: 'Contact Support',
	                    width: 'medium',
	                    height: 'auto',
	                    okButtonVisible: false,
	                    cancelButtonVisible: false,
	                });
	                this.supportNumber.slice();
	                callAnchor = (0, morphux_1.ce)('a', 'ntsh_callanchor', { href: "tel:".concat(this.supportNumber) }, "+".concat(this.supportNumber));
	                dialog.content.appendChild(callAnchor);
	                setTimeout(function () { return callAnchor.click(); }, 100);
	                return [2 /*return*/];
	            });
	        });
	    };
	    return Main;
	}());
	exports.Main = main$1.Main = Main;
	new Main();

	exports["default"] = main$1;

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

	return exports;

})({});
//# sourceMappingURL=script.js.map
