@everymatrix/casino-tournaments-tab 0.0.265

package/dist/casino-tournaments-tab.js

@@ -0,0 +1,751 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.app = factory());
+}(this, (function () { 'use strict';
+
+    function noop() { }
+    function add_location(element, file, line, column, char) {
+        element.__svelte_meta = {
+            loc: { file, line, column, char }
+        };
+    }
+    function run(fn) {
+        return fn();
+    }
+    function blank_object() {
+        return Object.create(null);
+    }
+    function run_all(fns) {
+        fns.forEach(run);
+    }
+    function is_function(thing) {
+        return typeof thing === 'function';
+    }
+    function safe_not_equal(a, b) {
+        return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+    }
+    function is_empty(obj) {
+        return Object.keys(obj).length === 0;
+    }
+
+    function append(target, node) {
+        target.appendChild(node);
+    }
+    function insert(target, node, anchor) {
+        target.insertBefore(node, anchor || null);
+    }
+    function detach(node) {
+        node.parentNode.removeChild(node);
+    }
+    function destroy_each(iterations, detaching) {
+        for (let i = 0; i < iterations.length; i += 1) {
+            if (iterations[i])
+                iterations[i].d(detaching);
+        }
+    }
+    function element(name) {
+        return document.createElement(name);
+    }
+    function text(data) {
+        return document.createTextNode(data);
+    }
+    function space() {
+        return text(' ');
+    }
+    function listen(node, event, handler, options) {
+        node.addEventListener(event, handler, options);
+        return () => node.removeEventListener(event, handler, options);
+    }
+    function attr(node, attribute, value) {
+        if (value == null)
+            node.removeAttribute(attribute);
+        else if (node.getAttribute(attribute) !== value)
+            node.setAttribute(attribute, value);
+    }
+    function children(element) {
+        return Array.from(element.childNodes);
+    }
+    function custom_event(type, detail) {
+        const e = document.createEvent('CustomEvent');
+        e.initCustomEvent(type, false, false, detail);
+        return e;
+    }
+    function attribute_to_object(attributes) {
+        const result = {};
+        for (const attribute of attributes) {
+            result[attribute.name] = attribute.value;
+        }
+        return result;
+    }
+
+    let current_component;
+    function set_current_component(component) {
+        current_component = component;
+    }
+    function get_current_component() {
+        if (!current_component)
+            throw new Error('Function called outside component initialization');
+        return current_component;
+    }
+    function onMount(fn) {
+        get_current_component().$$.on_mount.push(fn);
+    }
+
+    const dirty_components = [];
+    const binding_callbacks = [];
+    const render_callbacks = [];
+    const flush_callbacks = [];
+    const resolved_promise = Promise.resolve();
+    let update_scheduled = false;
+    function schedule_update() {
+        if (!update_scheduled) {
+            update_scheduled = true;
+            resolved_promise.then(flush);
+        }
+    }
+    function add_render_callback(fn) {
+        render_callbacks.push(fn);
+    }
+    let flushing = false;
+    const seen_callbacks = new Set();
+    function flush() {
+        if (flushing)
+            return;
+        flushing = true;
+        do {
+            // first, call beforeUpdate functions
+            // and update components
+            for (let i = 0; i < dirty_components.length; i += 1) {
+                const component = dirty_components[i];
+                set_current_component(component);
+                update(component.$$);
+            }
+            set_current_component(null);
+            dirty_components.length = 0;
+            while (binding_callbacks.length)
+                binding_callbacks.pop()();
+            // then, once components are updated, call
+            // afterUpdate functions. This may cause
+            // subsequent updates...
+            for (let i = 0; i < render_callbacks.length; i += 1) {
+                const callback = render_callbacks[i];
+                if (!seen_callbacks.has(callback)) {
+                    // ...so guard against infinite loops
+                    seen_callbacks.add(callback);
+                    callback();
+                }
+            }
+            render_callbacks.length = 0;
+        } while (dirty_components.length);
+        while (flush_callbacks.length) {
+            flush_callbacks.pop()();
+        }
+        update_scheduled = false;
+        flushing = false;
+        seen_callbacks.clear();
+    }
+    function update($$) {
+        if ($$.fragment !== null) {
+            $$.update();
+            run_all($$.before_update);
+            const dirty = $$.dirty;
+            $$.dirty = [-1];
+            $$.fragment && $$.fragment.p($$.ctx, dirty);
+            $$.after_update.forEach(add_render_callback);
+        }
+    }
+    const outroing = new Set();
+    function transition_in(block, local) {
+        if (block && block.i) {
+            outroing.delete(block);
+            block.i(local);
+        }
+    }
+
+    const globals = (typeof window !== 'undefined'
+        ? window
+        : typeof globalThis !== 'undefined'
+            ? globalThis
+            : global);
+    function mount_component(component, target, anchor, customElement) {
+        const { fragment, on_mount, on_destroy, after_update } = component.$$;
+        fragment && fragment.m(target, anchor);
+        if (!customElement) {
+            // onMount happens before the initial afterUpdate
+            add_render_callback(() => {
+                const new_on_destroy = on_mount.map(run).filter(is_function);
+                if (on_destroy) {
+                    on_destroy.push(...new_on_destroy);
+                }
+                else {
+                    // Edge case - component was destroyed immediately,
+                    // most likely as a result of a binding initialising
+                    run_all(new_on_destroy);
+                }
+                component.$$.on_mount = [];
+            });
+        }
+        after_update.forEach(add_render_callback);
+    }
+    function destroy_component(component, detaching) {
+        const $$ = component.$$;
+        if ($$.fragment !== null) {
+            run_all($$.on_destroy);
+            $$.fragment && $$.fragment.d(detaching);
+            // TODO null out other refs, including component.$$ (but need to
+            // preserve final state?)
+            $$.on_destroy = $$.fragment = null;
+            $$.ctx = [];
+        }
+    }
+    function make_dirty(component, i) {
+        if (component.$$.dirty[0] === -1) {
+            dirty_components.push(component);
+            schedule_update();
+            component.$$.dirty.fill(0);
+        }
+        component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
+    }
+    function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
+        const parent_component = current_component;
+        set_current_component(component);
+        const $$ = component.$$ = {
+            fragment: null,
+            ctx: null,
+            // state
+            props,
+            update: noop,
+            not_equal,
+            bound: blank_object(),
+            // lifecycle
+            on_mount: [],
+            on_destroy: [],
+            on_disconnect: [],
+            before_update: [],
+            after_update: [],
+            context: new Map(parent_component ? parent_component.$$.context : options.context || []),
+            // everything else
+            callbacks: blank_object(),
+            dirty,
+            skip_bound: false
+        };
+        let ready = false;
+        $$.ctx = instance
+            ? instance(component, options.props || {}, (i, ret, ...rest) => {
+                const value = rest.length ? rest[0] : ret;
+                if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+                    if (!$$.skip_bound && $$.bound[i])
+                        $$.bound[i](value);
+                    if (ready)
+                        make_dirty(component, i);
+                }
+                return ret;
+            })
+            : [];
+        $$.update();
+        ready = true;
+        run_all($$.before_update);
+        // `false` as a special case of no DOM component
+        $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
+        if (options.target) {
+            if (options.hydrate) {
+                const nodes = children(options.target);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                $$.fragment && $$.fragment.l(nodes);
+                nodes.forEach(detach);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                $$.fragment && $$.fragment.c();
+            }
+            if (options.intro)
+                transition_in(component.$$.fragment);
+            mount_component(component, options.target, options.anchor, options.customElement);
+            flush();
+        }
+        set_current_component(parent_component);
+    }
+    let SvelteElement;
+    if (typeof HTMLElement === 'function') {
+        SvelteElement = class extends HTMLElement {
+            constructor() {
+                super();
+                this.attachShadow({ mode: 'open' });
+            }
+            connectedCallback() {
+                const { on_mount } = this.$$;
+                this.$$.on_disconnect = on_mount.map(run).filter(is_function);
+                // @ts-ignore todo: improve typings
+                for (const key in this.$$.slotted) {
+                    // @ts-ignore todo: improve typings
+                    this.appendChild(this.$$.slotted[key]);
+                }
+            }
+            attributeChangedCallback(attr, _oldValue, newValue) {
+                this[attr] = newValue;
+            }
+            disconnectedCallback() {
+                run_all(this.$$.on_disconnect);
+            }
+            $destroy() {
+                destroy_component(this, 1);
+                this.$destroy = noop;
+            }
+            $on(type, callback) {
+                // TODO should this delegate to addEventListener?
+                const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
+                callbacks.push(callback);
+                return () => {
+                    const index = callbacks.indexOf(callback);
+                    if (index !== -1)
+                        callbacks.splice(index, 1);
+                };
+            }
+            $set($$props) {
+                if (this.$$set && !is_empty($$props)) {
+                    this.$$.skip_bound = true;
+                    this.$$set($$props);
+                    this.$$.skip_bound = false;
+                }
+            }
+        };
+    }
+
+    function dispatch_dev(type, detail) {
+        document.dispatchEvent(custom_event(type, Object.assign({ version: '3.37.0' }, detail)));
+    }
+    function append_dev(target, node) {
+        dispatch_dev('SvelteDOMInsert', { target, node });
+        append(target, node);
+    }
+    function insert_dev(target, node, anchor) {
+        dispatch_dev('SvelteDOMInsert', { target, node, anchor });
+        insert(target, node, anchor);
+    }
+    function detach_dev(node) {
+        dispatch_dev('SvelteDOMRemove', { node });
+        detach(node);
+    }
+    function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
+        const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
+        if (has_prevent_default)
+            modifiers.push('preventDefault');
+        if (has_stop_propagation)
+            modifiers.push('stopPropagation');
+        dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
+        const dispose = listen(node, event, handler, options);
+        return () => {
+            dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
+            dispose();
+        };
+    }
+    function attr_dev(node, attribute, value) {
+        attr(node, attribute, value);
+        if (value == null)
+            dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
+        else
+            dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
+    }
+    function set_data_dev(text, data) {
+        data = '' + data;
+        if (text.wholeText === data)
+            return;
+        dispatch_dev('SvelteDOMSetData', { node: text, data });
+        text.data = data;
+    }
+    function validate_each_argument(arg) {
+        if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
+            let msg = '{#each} only iterates over array-like objects.';
+            if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
+                msg += ' You can use a spread to convert this iterable into an array.';
+            }
+            throw new Error(msg);
+        }
+    }
+    function validate_slots(name, slot, keys) {
+        for (const slot_key of Object.keys(slot)) {
+            if (!~keys.indexOf(slot_key)) {
+                console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
+            }
+        }
+    }
+
+    const composeMessageHandler = (listeners) => {
+      const handler = e => {
+        Object.keys(listeners).map(key => {
+          if (e.data && e.data.type == key) {
+            const {type, ...restData} = e.data;
+            listeners[key](restData);
+          }
+        });
+      };
+
+      return handler
+    };
+
+    const onMountMessageLifeCycle = (messageRegisters) => {
+      
+      const messageHandler = composeMessageHandler(messageRegisters);
+
+      onMount(() => {
+        window.addEventListener('message', messageHandler, false);
+        return () => {
+          window.removeEventListener('message', messageHandler);
+        }
+      });
+    };
+
+    /* src/CasinoTournamentsTab.svelte generated by Svelte v3.37.0 */
+
+    const { Object: Object_1 } = globals;
+    const file = "src/CasinoTournamentsTab.svelte";
+
+    function get_each_context(ctx, list, i) {
+    	const child_ctx = ctx.slice();
+    	child_ctx[7] = list[i];
+    	return child_ctx;
+    }
+
+    // (35:8) {#if totalReceiver[_tab] >= 0}
+    function create_if_block(ctx) {
+    	let sup;
+    	let span;
+    	let t_value = /*totalReceiver*/ ctx[0][/*_tab*/ ctx[7]] + "";
+    	let t;
+
+    	const block = {
+    		c: function create() {
+    			sup = element("sup");
+    			span = element("span");
+    			t = text(t_value);
+    			attr_dev(span, "part", "SupText");
+    			add_location(span, file, 36, 10, 1110);
+    			attr_dev(sup, "part", "sup");
+    			add_location(sup, file, 35, 8, 1083);
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, sup, anchor);
+    			append_dev(sup, span);
+    			append_dev(span, t);
+    		},
+    		p: function update(ctx, dirty) {
+    			if (dirty & /*totalReceiver, __tabs*/ 5 && t_value !== (t_value = /*totalReceiver*/ ctx[0][/*_tab*/ ctx[7]] + "")) set_data_dev(t, t_value);
+    		},
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(sup);
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_if_block.name,
+    		type: "if",
+    		source: "(35:8) {#if totalReceiver[_tab] >= 0}",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    // (22:4) {#each __tabs as _tab}
+    function create_each_block(ctx) {
+    	let li;
+    	let span;
+    	let t0_value = /*textReceiver*/ ctx[1][/*_tab*/ ctx[7]] + "";
+    	let t0;
+    	let t1;
+    	let t2;
+    	let li_class_value;
+    	let li_part_value;
+    	let mounted;
+    	let dispose;
+    	let if_block = /*totalReceiver*/ ctx[0][/*_tab*/ ctx[7]] >= 0 && create_if_block(ctx);
+
+    	function click_handler() {
+    		return /*click_handler*/ ctx[6](/*_tab*/ ctx[7]);
+    	}
+
+    	const block = {
+    		c: function create() {
+    			li = element("li");
+    			span = element("span");
+    			t0 = text(t0_value);
+    			t1 = space();
+    			if (if_block) if_block.c();
+    			t2 = space();
+    			attr_dev(span, "part", "LiText");
+    			add_location(span, file, 30, 8, 967);
+    			attr_dev(li, "class", li_class_value = /*__tab*/ ctx[3] === /*_tab*/ ctx[7] ? "active" : "");
+    			attr_dev(li, "part", li_part_value = `${/*_tab*/ ctx[7]} li`);
+    			add_location(li, file, 22, 6, 739);
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, li, anchor);
+    			append_dev(li, span);
+    			append_dev(span, t0);
+    			append_dev(li, t1);
+    			if (if_block) if_block.m(li, null);
+    			append_dev(li, t2);
+
+    			if (!mounted) {
+    				dispose = listen_dev(li, "click", click_handler, false, false, false);
+    				mounted = true;
+    			}
+    		},
+    		p: function update(new_ctx, dirty) {
+    			ctx = new_ctx;
+    			if (dirty & /*textReceiver, __tabs*/ 6 && t0_value !== (t0_value = /*textReceiver*/ ctx[1][/*_tab*/ ctx[7]] + "")) set_data_dev(t0, t0_value);
+
+    			if (/*totalReceiver*/ ctx[0][/*_tab*/ ctx[7]] >= 0) {
+    				if (if_block) {
+    					if_block.p(ctx, dirty);
+    				} else {
+    					if_block = create_if_block(ctx);
+    					if_block.c();
+    					if_block.m(li, t2);
+    				}
+    			} else if (if_block) {
+    				if_block.d(1);
+    				if_block = null;
+    			}
+
+    			if (dirty & /*__tab, __tabs*/ 12 && li_class_value !== (li_class_value = /*__tab*/ ctx[3] === /*_tab*/ ctx[7] ? "active" : "")) {
+    				attr_dev(li, "class", li_class_value);
+    			}
+
+    			if (dirty & /*__tabs*/ 4 && li_part_value !== (li_part_value = `${/*_tab*/ ctx[7]} li`)) {
+    				attr_dev(li, "part", li_part_value);
+    			}
+    		},
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(li);
+    			if (if_block) if_block.d();
+    			mounted = false;
+    			dispose();
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_each_block.name,
+    		type: "each",
+    		source: "(22:4) {#each __tabs as _tab}",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    function create_fragment(ctx) {
+    	let div;
+    	let ul;
+    	let each_value = /*__tabs*/ ctx[2];
+    	validate_each_argument(each_value);
+    	let each_blocks = [];
+
+    	for (let i = 0; i < each_value.length; i += 1) {
+    		each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
+    	}
+
+    	const block = {
+    		c: function create() {
+    			div = element("div");
+    			ul = element("ul");
+
+    			for (let i = 0; i < each_blocks.length; i += 1) {
+    				each_blocks[i].c();
+    			}
+
+    			this.c = noop;
+    			attr_dev(ul, "part", "ul");
+    			add_location(ul, file, 20, 2, 691);
+    			attr_dev(div, "class", "casino-tournaments-tab");
+    			attr_dev(div, "part", "CustomStylingContainer");
+    			add_location(div, file, 19, 0, 622);
+    		},
+    		l: function claim(nodes) {
+    			throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
+    		},
+    		m: function mount(target, anchor) {
+    			insert_dev(target, div, anchor);
+    			append_dev(div, ul);
+
+    			for (let i = 0; i < each_blocks.length; i += 1) {
+    				each_blocks[i].m(ul, null);
+    			}
+    		},
+    		p: function update(ctx, [dirty]) {
+    			if (dirty & /*__tab, __tabs, window, totalReceiver, textReceiver*/ 15) {
+    				each_value = /*__tabs*/ ctx[2];
+    				validate_each_argument(each_value);
+    				let i;
+
+    				for (i = 0; i < each_value.length; i += 1) {
+    					const child_ctx = get_each_context(ctx, each_value, i);
+
+    					if (each_blocks[i]) {
+    						each_blocks[i].p(child_ctx, dirty);
+    					} else {
+    						each_blocks[i] = create_each_block(child_ctx);
+    						each_blocks[i].c();
+    						each_blocks[i].m(ul, null);
+    					}
+    				}
+
+    				for (; i < each_blocks.length; i += 1) {
+    					each_blocks[i].d(1);
+    				}
+
+    				each_blocks.length = each_value.length;
+    			}
+    		},
+    		i: noop,
+    		o: noop,
+    		d: function destroy(detaching) {
+    			if (detaching) detach_dev(div);
+    			destroy_each(each_blocks, detaching);
+    		}
+    	};
+
+    	dispatch_dev("SvelteRegisterBlock", {
+    		block,
+    		id: create_fragment.name,
+    		type: "component",
+    		source: "",
+    		ctx
+    	});
+
+    	return block;
+    }
+
+    function instance($$self, $$props, $$invalidate) {
+    	let __tabs;
+    	let __tab;
+    	let { $$slots: slots = {}, $$scope } = $$props;
+    	validate_slots("undefined", slots, []);
+    	let { tabs = "" } = $$props; // 'tab1,tab2,tab3'
+    	let { tab = undefined } = $$props; // 'tab1'
+    	let totalReceiver = {};
+    	let textReceiver = {};
+
+    	onMountMessageLifeCycle({
+    		TournamentsTabTotalUpdate: data => {
+    			$$invalidate(0, totalReceiver = Object.assign(Object.assign({}, totalReceiver), { [data.state]: data.total }));
+    		},
+    		TournamentsTabLocaleTextUpdate: data => {
+    			$$invalidate(1, textReceiver = Object.assign(Object.assign({}, textReceiver), { [data.state]: data.text }));
+    		}
+    	});
+
+    	const writable_props = ["tabs", "tab"];
+
+    	Object_1.keys($$props).forEach(key => {
+    		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(`<undefined> was created with unknown prop '${key}'`);
+    	});
+
+    	const click_handler = _tab => {
+    		$$invalidate(3, __tab = _tab);
+    		window.postMessage({ type: "TournamentsTabSwitch", tab: _tab });
+    	};
+
+    	$$self.$$set = $$props => {
+    		if ("tabs" in $$props) $$invalidate(4, tabs = $$props.tabs);
+    		if ("tab" in $$props) $$invalidate(5, tab = $$props.tab);
+    	};
+
+    	$$self.$capture_state = () => ({
+    		onMountMessageLifeCycle,
+    		tabs,
+    		tab,
+    		totalReceiver,
+    		textReceiver,
+    		__tabs,
+    		__tab
+    	});
+
+    	$$self.$inject_state = $$props => {
+    		if ("tabs" in $$props) $$invalidate(4, tabs = $$props.tabs);
+    		if ("tab" in $$props) $$invalidate(5, tab = $$props.tab);
+    		if ("totalReceiver" in $$props) $$invalidate(0, totalReceiver = $$props.totalReceiver);
+    		if ("textReceiver" in $$props) $$invalidate(1, textReceiver = $$props.textReceiver);
+    		if ("__tabs" in $$props) $$invalidate(2, __tabs = $$props.__tabs);
+    		if ("__tab" in $$props) $$invalidate(3, __tab = $$props.__tab);
+    	};
+
+    	if ($$props && "$$inject" in $$props) {
+    		$$self.$inject_state($$props.$$inject);
+    	}
+
+    	$$self.$$.update = () => {
+    		if ($$self.$$.dirty & /*tabs*/ 16) {
+    			$$invalidate(2, __tabs = tabs.split(","));
+    		}
+
+    		if ($$self.$$.dirty & /*tab*/ 32) {
+    			$$invalidate(3, __tab = tab);
+    		}
+    	};
+
+    	return [totalReceiver, textReceiver, __tabs, __tab, tabs, tab, click_handler];
+    }
+
+    class CasinoTournamentsTab extends SvelteElement {
+    	constructor(options) {
+    		super();
+    		this.shadowRoot.innerHTML = `<style>:host{font-family:system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji'}*,*::before,*::after{margin:0;padding:0;list-style:none;text-decoration:none;outline:none;box-sizing:border-box}.casino-tournaments-tab{color:#F7F7F7;font:inherit;margin:3.125vw 0 1.25vw 0}.casino-tournaments-tab ul{display:flex;justify-content:space-between;width:100%;font-weight:600;font-size:3.75vw;border-bottom:0.3125vw #424242 solid}.casino-tournaments-tab ul li{position:relative;text-align:center;padding:2.5vw 3.125vw;word-break:break-word;flex:auto;display:block}.casino-tournaments-tab ul li.active{color:#FF8364;border-bottom:0.625vw #FF8364 solid}.casino-tournaments-tab ul li span{margin:auto 0}.casino-tournaments-tab sup{box-sizing:border-box;position:absolute;top:2.8125vw;right:0;transform:translate(0%, -50%);transform-origin:100% 0%;overflow:hidden;direction:ltr;z-index:auto;min-width:4.375vw;height:4.375vw;color:#fff;font-weight:400;font-size:4.375vw;line-height:4.375vw;white-space:nowrap;text-align:center;background:#FF8364;border-radius:3.125vw}.casino-tournaments-tab sup span{font-size:3.125vw;font-weight:600;padding-right:0.15625vw;display:inline-block;vertical-align:super}</style>`;
+
+    		init(
+    			this,
+    			{
+    				target: this.shadowRoot,
+    				props: attribute_to_object(this.attributes),
+    				customElement: true
+    			},
+    			instance,
+    			create_fragment,
+    			safe_not_equal,
+    			{ tabs: 4, tab: 5 }
+    		);
+
+    		if (options) {
+    			if (options.target) {
+    				insert_dev(options.target, this, options.anchor);
+    			}
+
+    			if (options.props) {
+    				this.$set(options.props);
+    				flush();
+    			}
+    		}
+    	}
+
+    	static get observedAttributes() {
+    		return ["tabs", "tab"];
+    	}
+
+    	get tabs() {
+    		return this.$$.ctx[4];
+    	}
+
+    	set tabs(tabs) {
+    		this.$set({ tabs });
+    		flush();
+    	}
+
+    	get tab() {
+    		return this.$$.ctx[5];
+    	}
+
+    	set tab(tab) {
+    		this.$set({ tab });
+    		flush();
+    	}
+    }
+
+    !customElements.get('casino-tournaments-tab') && customElements.define('casino-tournaments-tab', CasinoTournamentsTab);
+
+    return CasinoTournamentsTab;
+
+})));
+//# sourceMappingURL=casino-tournaments-tab.js.map