(function(l, r) { if (!l || l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (self.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(self.document);
var app = (function () {
    'use strict';

    function noop() { }
    function assign(tar, src) {
        // @ts-ignore
        for (const k in src)
            tar[k] = src[k];
        return tar;
    }
    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');
    }
    let src_url_equal_anchor;
    function src_url_equal(element_src, url) {
        if (!src_url_equal_anchor) {
            src_url_equal_anchor = document.createElement('a');
        }
        src_url_equal_anchor.href = url;
        return element_src === src_url_equal_anchor.href;
    }
    function is_empty(obj) {
        return Object.keys(obj).length === 0;
    }
    function exclude_internal_props(props) {
        const result = {};
        for (const k in props)
            if (k[0] !== '$')
                result[k] = props[k];
        return result;
    }
    function action_destroyer(action_result) {
        return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
    }
    function append(target, node) {
        target.appendChild(node);
    }
    function insert(target, node, anchor) {
        target.insertBefore(node, anchor || null);
    }
    function detach(node) {
        if (node.parentNode) {
            node.parentNode.removeChild(node);
        }
    }
    function element(name) {
        return document.createElement(name);
    }
    function text(data) {
        return document.createTextNode(data);
    }
    function space() {
        return text(' ');
    }
    function empty() {
        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, { bubbles = false, cancelable = false } = {}) {
        const e = document.createEvent('CustomEvent');
        e.initCustomEvent(type, bubbles, cancelable, detail);
        return e;
    }

    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;
    }
    /**
     * The `onMount` function schedules a callback to run as soon as the component has been mounted to the DOM.
     * It must be called during the component's initialisation (but doesn't need to live *inside* the component;
     * it can be called from an external module).
     *
     * `onMount` does not run inside a [server-side component](/docs#run-time-server-side-component-api).
     *
     * https://svelte.dev/docs#run-time-svelte-onmount
     */
    function onMount(fn) {
        get_current_component().$$.on_mount.push(fn);
    }
    /**
     * Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).
     * Event dispatchers are functions that can take two arguments: `name` and `detail`.
     *
     * Component events created with `createEventDispatcher` create a
     * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
     * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
     * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
     * property and can contain any type of data.
     *
     * https://svelte.dev/docs#run-time-svelte-createeventdispatcher
     */
    function createEventDispatcher() {
        const component = get_current_component();
        return (type, detail, { cancelable = false } = {}) => {
            const callbacks = component.$$.callbacks[type];
            if (callbacks) {
                // TODO are there situations where events could be dispatched
                // in a server (non-DOM) environment?
                const event = custom_event(type, detail, { cancelable });
                callbacks.slice().forEach(fn => {
                    fn.call(component, event);
                });
                return !event.defaultPrevented;
            }
            return true;
        };
    }

    const dirty_components = [];
    const binding_callbacks = [];
    let render_callbacks = [];
    const flush_callbacks = [];
    const resolved_promise = /* @__PURE__ */ 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);
    }
    // flush() calls callbacks in this order:
    // 1. All beforeUpdate callbacks, in order: parents before children
    // 2. All bind:this callbacks, in reverse order: children before parents.
    // 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
    //    for afterUpdates called during the initial onMount, which are called in
    //    reverse order: children before parents.
    // Since callbacks might update component values, which could trigger another
    // call to flush(), the following steps guard against this:
    // 1. During beforeUpdate, any updated components will be added to the
    //    dirty_components array and will cause a reentrant call to flush(). Because
    //    the flush index is kept outside the function, the reentrant call will pick
    //    up where the earlier call left off and go through all dirty components. The
    //    current_component value is saved and restored so that the reentrant call will
    //    not interfere with the "parent" flush() call.
    // 2. bind:this callbacks cannot trigger new flush() calls.
    // 3. During afterUpdate, any updated components will NOT have their afterUpdate
    //    callback called a second time; the seen_callbacks set, outside the flush()
    //    function, guarantees this behavior.
    const seen_callbacks = new Set();
    let flushidx = 0; // Do *not* move this inside the flush() function
    function flush() {
        // Do not reenter flush while dirty components are updated, as this can
        // result in an infinite loop. Instead, let the inner flush handle it.
        // Reentrancy is ok afterwards for bindings etc.
        if (flushidx !== 0) {
            return;
        }
        const saved_component = current_component;
        do {
            // first, call beforeUpdate functions
            // and update components
            try {
                while (flushidx < dirty_components.length) {
                    const component = dirty_components[flushidx];
                    flushidx++;
                    set_current_component(component);
                    update(component.$$);
                }
            }
            catch (e) {
                // reset dirty state to not end up in a deadlocked state and then rethrow
                dirty_components.length = 0;
                flushidx = 0;
                throw e;
            }
            set_current_component(null);
            dirty_components.length = 0;
            flushidx = 0;
            while (binding_callbacks.length)
                binding_callbacks.pop()();
            // then, once components are updated, call
            // afterUpdate functions. This may cause
            // subsequent updates...
            for (let i = 0; i < render_callbacks.length; i += 1) {
                const callback = render_callbacks[i];
                if (!seen_callbacks.has(callback)) {
                    // ...so guard against infinite loops
                    seen_callbacks.add(callback);
                    callback();
                }
            }
            render_callbacks.length = 0;
        } while (dirty_components.length);
        while (flush_callbacks.length) {
            flush_callbacks.pop()();
        }
        update_scheduled = false;
        seen_callbacks.clear();
        set_current_component(saved_component);
    }
    function update($$) {
        if ($$.fragment !== null) {
            $$.update();
            run_all($$.before_update);
            const dirty = $$.dirty;
            $$.dirty = [-1];
            $$.fragment && $$.fragment.p($$.ctx, dirty);
            $$.after_update.forEach(add_render_callback);
        }
    }
    /**
     * Useful for example to execute remaining `afterUpdate` callbacks before executing `destroy`.
     */
    function flush_render_callbacks(fns) {
        const filtered = [];
        const targets = [];
        render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
        targets.forEach((c) => c());
        render_callbacks = filtered;
    }
    const outroing = new Set();
    let outros;
    function transition_in(block, local) {
        if (block && block.i) {
            outroing.delete(block);
            block.i(local);
        }
    }
    function transition_out(block, local, detach, callback) {
        if (block && block.o) {
            if (outroing.has(block))
                return;
            outroing.add(block);
            outros.c.push(() => {
                outroing.delete(block);
                if (callback) {
                    if (detach)
                        block.d(1);
                    callback();
                }
            });
            block.o(local);
        }
        else if (callback) {
            callback();
        }
    }
    function create_component(block) {
        block && block.c();
    }
    function mount_component(component, target, anchor, customElement) {
        const { fragment, after_update } = component.$$;
        fragment && fragment.m(target, anchor);
        if (!customElement) {
            // onMount happens before the initial afterUpdate
            add_render_callback(() => {
                const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
                // if the component was destroyed immediately
                // it will update the `$$.on_destroy` reference to `null`.
                // the destructured on_destroy may still reference to the old array
                if (component.$$.on_destroy) {
                    component.$$.on_destroy.push(...new_on_destroy);
                }
                else {
                    // Edge case - component was destroyed immediately,
                    // most likely as a result of a binding initialising
                    run_all(new_on_destroy);
                }
                component.$$.on_mount = [];
            });
        }
        after_update.forEach(add_render_callback);
    }
    function destroy_component(component, detaching) {
        const $$ = component.$$;
        if ($$.fragment !== null) {
            flush_render_callbacks($$.after_update);
            run_all($$.on_destroy);
            $$.fragment && $$.fragment.d(detaching);
            // TODO null out other refs, including component.$$ (but need to
            // preserve final state?)
            $$.on_destroy = $$.fragment = null;
            $$.ctx = [];
        }
    }
    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, append_styles, dirty = [-1]) {
        const parent_component = current_component;
        set_current_component(component);
        const $$ = component.$$ = {
            fragment: null,
            ctx: [],
            // state
            props,
            update: noop,
            not_equal,
            bound: blank_object(),
            // lifecycle
            on_mount: [],
            on_destroy: [],
            on_disconnect: [],
            before_update: [],
            after_update: [],
            context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
            // everything else
            callbacks: blank_object(),
            dirty,
            skip_bound: false,
            root: options.target || parent_component.$$.root
        };
        append_styles && append_styles($$.root);
        let ready = false;
        $$.ctx = instance
            ? instance(component, options.props || {}, (i, ret, ...rest) => {
                const value = rest.length ? rest[0] : ret;
                if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
                    if (!$$.skip_bound && $$.bound[i])
                        $$.bound[i](value);
                    if (ready)
                        make_dirty(component, i);
                }
                return ret;
            })
            : [];
        $$.update();
        ready = true;
        run_all($$.before_update);
        // `false` as a special case of no DOM component
        $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
        if (options.target) {
            if (options.hydrate) {
                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);
    }
    /**
     * Base class for Svelte components. Used when dev=false.
     */
    class SvelteComponent {
        $destroy() {
            destroy_component(this, 1);
            this.$destroy = noop;
        }
        $on(type, callback) {
            if (!is_function(callback)) {
                return noop;
            }
            const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
            callbacks.push(callback);
            return () => {
                const index = callbacks.indexOf(callback);
                if (index !== -1)
                    callbacks.splice(index, 1);
            };
        }
        $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.59.2' }, detail), { bubbles: true }));
    }
    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, has_stop_immediate_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');
        if (has_stop_immediate_propagation)
            modifiers.push('stopImmediatePropagation');
        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.data === data)
            return;
        dispatch_dev('SvelteDOMSetData', { node: text, data });
        text.data = data;
    }
    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}".`);
            }
        }
    }
    /**
     * Base class for Svelte components with some minor dev-enhancements. Used when dev=true.
     */
    class SvelteComponentDev extends SvelteComponent {
        constructor(options) {
            if (!options || (!options.target && !options.$$inline)) {
                throw new Error("'target' is a required option");
            }
            super();
        }
        $destroy() {
            super.$destroy();
            this.$destroy = () => {
                console.warn('Component was already destroyed'); // eslint-disable-line no-console
            };
        }
        $capture_state() { }
        $inject_state() { }
    }

    /* src\TailwindCSS\TailwindCSS.svelte generated by Svelte v3.59.2 */

    function create_fragment$3(ctx) {
    	const block = {
    		c: noop,
    		l: function claim(nodes) {
    			throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
    		},
    		m: noop,
    		p: noop,
    		i: noop,
    		o: noop,
    		d: noop
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_fragment$3.name,
    		type: "component",
    		source: "",
    		ctx
    	});

    	return block;
    }

    function instance$3($$self, $$props) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('TailwindCSS', slots, []);
    	const writable_props = [];

    	Object.keys($$props).forEach(key => {
    		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<TailwindCSS> was created with unknown prop '${key}'`);
    	});

    	return [];
    }

    class TailwindCSS extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$3, create_fragment$3, safe_not_equal, {});

    		dispatch_dev("SvelteRegisterComponent", {
    			component: this,
    			tagName: "TailwindCSS",
    			options,
    			id: create_fragment$3.name
    		});
    	}
    }

    /* node_modules\svelte-turnstile\dist\Turnstile.svelte generated by Svelte v3.59.2 */
    const file$1 = "node_modules\\svelte-turnstile\\dist\\Turnstile.svelte";

    // (78:4) {#if mounted && !loaded}
    function create_if_block_1$1(ctx) {
    	let script;
    	let script_src_value;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			script = element("script");
    			if (!src_url_equal(script.src, script_src_value = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit")) attr_dev(script, "src", script_src_value);
    			script.async = true;
    			add_location(script, file$1, 78, 8, 1840);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, script, anchor);

    			if (!mounted) {
    				dispose = listen_dev(script, "load", /*loadCallback*/ ctx[2], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(script);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_1$1.name,
    		type: "if",
    		source: "(78:4) {#if mounted && !loaded}",
    		ctx
    	});

    	return block;
    }

    // (86:0) {#if loaded && mounted}
    function create_if_block$1(ctx) {
    	let previous_key = /*$$props*/ ctx[4];
    	let key_block_anchor;
    	let key_block = create_key_block(ctx);

    	const block = {
    		c: function create() {
    			key_block.c();
    			key_block_anchor = empty();
    		},
    		m: function mount(target, anchor) {
    			key_block.m(target, anchor);
    			insert_dev(target, key_block_anchor, anchor);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*$$props*/ 16 && safe_not_equal(previous_key, previous_key = /*$$props*/ ctx[4])) {
    				key_block.d(1);
    				key_block = create_key_block(ctx);
    				key_block.c();
    				key_block.m(key_block_anchor.parentNode, key_block_anchor);
    			} else {
    				key_block.p(ctx, dirty);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(key_block_anchor);
    			key_block.d(detaching);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$1.name,
    		type: "if",
    		source: "(86:0) {#if loaded && mounted}",
    		ctx
    	});

    	return block;
    }

    // (87:4) {#key $$props}
    function create_key_block(ctx) {
    	let div;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			div = element("div");
    			add_location(div, file$1, 87, 8, 2076);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);

    			if (!mounted) {
    				dispose = action_destroyer(/*turnstile*/ ctx[3].call(null, div));
    				mounted = true;
    			}
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_key_block.name,
    		type: "key",
    		source: "(87:4) {#key $$props}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$2(ctx) {
    	let if_block0_anchor;
    	let t;
    	let if_block1_anchor;
    	let if_block0 = /*mounted*/ ctx[1] && !/*loaded*/ ctx[0] && create_if_block_1$1(ctx);
    	let if_block1 = /*loaded*/ ctx[0] && /*mounted*/ ctx[1] && create_if_block$1(ctx);

    	const block = {
    		c: function create() {
    			if (if_block0) if_block0.c();
    			if_block0_anchor = empty();
    			t = space();
    			if (if_block1) if_block1.c();
    			if_block1_anchor = empty();
    		},
    		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) {
    			if (if_block0) if_block0.m(document.head, null);
    			append_dev(document.head, if_block0_anchor);
    			insert_dev(target, t, anchor);
    			if (if_block1) if_block1.m(target, anchor);
    			insert_dev(target, if_block1_anchor, anchor);
    		},
    		p: function update(ctx, [dirty]) {
    			if (/*mounted*/ ctx[1] && !/*loaded*/ ctx[0]) {
    				if (if_block0) {
    					if_block0.p(ctx, dirty);
    				} else {
    					if_block0 = create_if_block_1$1(ctx);
    					if_block0.c();
    					if_block0.m(if_block0_anchor.parentNode, if_block0_anchor);
    				}
    			} else if (if_block0) {
    				if_block0.d(1);
    				if_block0 = null;
    			}

    			if (/*loaded*/ ctx[0] && /*mounted*/ ctx[1]) {
    				if (if_block1) {
    					if_block1.p(ctx, dirty);
    				} else {
    					if_block1 = create_if_block$1(ctx);
    					if_block1.c();
    					if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
    				}
    			} else if (if_block1) {
    				if_block1.d(1);
    				if_block1 = null;
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (if_block0) if_block0.d(detaching);
    			detach_dev(if_block0_anchor);
    			if (detaching) detach_dev(t);
    			if (if_block1) if_block1.d(detaching);
    			if (detaching) detach_dev(if_block1_anchor);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_fragment$2.name,
    		type: "component",
    		source: "",
    		ctx
    	});

    	return block;
    }

    function hasTurnstile() {
    	if (typeof window == 'undefined') return null;
    	return 'turnstile' in window;
    }

    function instance$2($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('Turnstile', slots, []);
    	const dispatch = createEventDispatcher();
    	let loaded = hasTurnstile();
    	let mounted = false;
    	let widgetId;
    	let { siteKey } = $$props;
    	let { appearance = 'always' } = $$props;
    	let { language = 'auto' } = $$props;
    	let { formsField = 'cf-turnstile-response' } = $$props;
    	let { execution = 'render' } = $$props;
    	let { action = undefined } = $$props;
    	let { cData = undefined } = $$props;
    	let { retryInterval = 8000 } = $$props;
    	let { retry = 'auto' } = $$props;
    	let { theme = 'auto' } = $$props;
    	let { size = 'normal' } = $$props;
    	let { forms = true } = $$props;
    	let { tabIndex = 0 } = $$props;

    	onMount(() => {
    		$$invalidate(1, mounted = true);

    		return () => {
    			$$invalidate(1, mounted = false);
    		};
    	});

    	function loadCallback() {
    		$$invalidate(0, loaded = true);
    	}

    	function error() {
    		dispatch('turnstile-error', {});
    	}

    	function expired() {
    		dispatch('turnstile-expired', {});
    	}

    	function timeout() {
    		dispatch('turnstile-timeout', {});
    	}

    	function callback(token) {
    		dispatch('turnstile-callback', { token });
    	}

    	function reset() {
    		window.turnstile.reset(widgetId);
    	}

    	const turnstile = node => {
    		const id = window.turnstile.render(node, {
    			'timeout-callback': timeout,
    			'expired-callback': expired,
    			'error-callback': error,
    			callback,
    			sitekey: siteKey,
    			'response-field-name': formsField,
    			'retry-interval': retryInterval,
    			'response-field': forms,
    			tabindex: tabIndex,
    			appearance,
    			execution,
    			language,
    			action,
    			retry,
    			theme,
    			cData,
    			size
    		});

    		widgetId = id;

    		return {
    			destroy: () => {
    				window.turnstile.remove(id);
    			}
    		};
    	};

    	$$self.$$.on_mount.push(function () {
    		if (siteKey === undefined && !('siteKey' in $$props || $$self.$$.bound[$$self.$$.props['siteKey']])) {
    			console.warn("<Turnstile> was created without expected prop 'siteKey'");
    		}
    	});

    	$$self.$$set = $$new_props => {
    		$$invalidate(4, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    		if ('siteKey' in $$new_props) $$invalidate(5, siteKey = $$new_props.siteKey);
    		if ('appearance' in $$new_props) $$invalidate(6, appearance = $$new_props.appearance);
    		if ('language' in $$new_props) $$invalidate(7, language = $$new_props.language);
    		if ('formsField' in $$new_props) $$invalidate(8, formsField = $$new_props.formsField);
    		if ('execution' in $$new_props) $$invalidate(9, execution = $$new_props.execution);
    		if ('action' in $$new_props) $$invalidate(10, action = $$new_props.action);
    		if ('cData' in $$new_props) $$invalidate(11, cData = $$new_props.cData);
    		if ('retryInterval' in $$new_props) $$invalidate(12, retryInterval = $$new_props.retryInterval);
    		if ('retry' in $$new_props) $$invalidate(13, retry = $$new_props.retry);
    		if ('theme' in $$new_props) $$invalidate(14, theme = $$new_props.theme);
    		if ('size' in $$new_props) $$invalidate(15, size = $$new_props.size);
    		if ('forms' in $$new_props) $$invalidate(16, forms = $$new_props.forms);
    		if ('tabIndex' in $$new_props) $$invalidate(17, tabIndex = $$new_props.tabIndex);
    	};

    	$$self.$capture_state = () => ({
    		createEventDispatcher,
    		onMount,
    		dispatch,
    		loaded,
    		mounted,
    		widgetId,
    		siteKey,
    		appearance,
    		language,
    		formsField,
    		execution,
    		action,
    		cData,
    		retryInterval,
    		retry,
    		theme,
    		size,
    		forms,
    		tabIndex,
    		hasTurnstile,
    		loadCallback,
    		error,
    		expired,
    		timeout,
    		callback,
    		reset,
    		turnstile
    	});

    	$$self.$inject_state = $$new_props => {
    		$$invalidate(4, $$props = assign(assign({}, $$props), $$new_props));
    		if ('loaded' in $$props) $$invalidate(0, loaded = $$new_props.loaded);
    		if ('mounted' in $$props) $$invalidate(1, mounted = $$new_props.mounted);
    		if ('widgetId' in $$props) widgetId = $$new_props.widgetId;
    		if ('siteKey' in $$props) $$invalidate(5, siteKey = $$new_props.siteKey);
    		if ('appearance' in $$props) $$invalidate(6, appearance = $$new_props.appearance);
    		if ('language' in $$props) $$invalidate(7, language = $$new_props.language);
    		if ('formsField' in $$props) $$invalidate(8, formsField = $$new_props.formsField);
    		if ('execution' in $$props) $$invalidate(9, execution = $$new_props.execution);
    		if ('action' in $$props) $$invalidate(10, action = $$new_props.action);
    		if ('cData' in $$props) $$invalidate(11, cData = $$new_props.cData);
    		if ('retryInterval' in $$props) $$invalidate(12, retryInterval = $$new_props.retryInterval);
    		if ('retry' in $$props) $$invalidate(13, retry = $$new_props.retry);
    		if ('theme' in $$props) $$invalidate(14, theme = $$new_props.theme);
    		if ('size' in $$props) $$invalidate(15, size = $$new_props.size);
    		if ('forms' in $$props) $$invalidate(16, forms = $$new_props.forms);
    		if ('tabIndex' in $$props) $$invalidate(17, tabIndex = $$new_props.tabIndex);
    	};

    	if ($$props && "$$inject" in $$props) {
    		$$self.$inject_state($$props.$$inject);
    	}

    	$$props = exclude_internal_props($$props);

    	return [
    		loaded,
    		mounted,
    		loadCallback,
    		turnstile,
    		$$props,
    		siteKey,
    		appearance,
    		language,
    		formsField,
    		execution,
    		action,
    		cData,
    		retryInterval,
    		retry,
    		theme,
    		size,
    		forms,
    		tabIndex,
    		reset
    	];
    }

    class Turnstile extends SvelteComponentDev {
    	constructor(options) {
    		super(options);

    		init(this, options, instance$2, create_fragment$2, safe_not_equal, {
    			siteKey: 5,
    			appearance: 6,
    			language: 7,
    			formsField: 8,
    			execution: 9,
    			action: 10,
    			cData: 11,
    			retryInterval: 12,
    			retry: 13,
    			theme: 14,
    			size: 15,
    			forms: 16,
    			tabIndex: 17,
    			reset: 18
    		});

    		dispatch_dev("SvelteRegisterComponent", {
    			component: this,
    			tagName: "Turnstile",
    			options,
    			id: create_fragment$2.name
    		});
    	}

    	get siteKey() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set siteKey(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get appearance() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set appearance(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get language() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set language(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get formsField() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set formsField(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get execution() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set execution(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get action() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set action(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get cData() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set cData(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get retryInterval() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set retryInterval(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get retry() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set retry(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get theme() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set theme(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get size() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set size(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get forms() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set forms(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get tabIndex() {
    		throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	set tabIndex(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}

    	get reset() {
    		return this.$$.ctx[18];
    	}

    	set reset(value) {
    		throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
    	}
    }

    /* src\Pages\DepositPage.svelte generated by Svelte v3.59.2 */
    const file = "src\\Pages\\DepositPage.svelte";

    // (130:8) {#if selectedBank === "sber" && captchaVerified}
    function create_if_block(ctx) {
    	let button;

    	let t0_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
    	? "Отмена"
    	: "Запросить реквизиты") + "";

    	let t0;
    	let button_class_value;
    	let t1;
    	let t2;
    	let if_block1_anchor;
    	let mounted;
    	let dispose;
    	let if_block0 = /*requestingReqs*/ ctx[3] && create_if_block_2(ctx);
    	let if_block1 = /*showReqs*/ ctx[5] && create_if_block_1(ctx);

    	const block = {
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = space();
    			if (if_block0) if_block0.c();
    			t2 = space();
    			if (if_block1) if_block1.c();
    			if_block1_anchor = empty();

    			attr_dev(button, "class", button_class_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
    			? "bg-slate-950 ring-indigo-800 hover:bg-slate-900"
    			: "bg-indigo-800 hover:bg-indigo-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4  rounded-3xl  transition-all duration-75 ring-2 ring-inset  focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white");

    			add_location(button, file, 130, 10, 3913);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			insert_dev(target, t1, anchor);
    			if (if_block0) if_block0.m(target, anchor);
    			insert_dev(target, t2, anchor);
    			if (if_block1) if_block1.m(target, anchor);
    			insert_dev(target, if_block1_anchor, anchor);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", /*click_handler_1*/ ctx[13], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*requestingReqs, showReqs*/ 40 && t0_value !== (t0_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
    			? "Отмена"
    			: "Запросить реквизиты") + "")) set_data_dev(t0, t0_value);

    			if (dirty & /*requestingReqs, showReqs*/ 40 && button_class_value !== (button_class_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
    			? "bg-slate-950 ring-indigo-800 hover:bg-slate-900"
    			: "bg-indigo-800 hover:bg-indigo-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4  rounded-3xl  transition-all duration-75 ring-2 ring-inset  focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white")) {
    				attr_dev(button, "class", button_class_value);
    			}

    			if (/*requestingReqs*/ ctx[3]) {
    				if (if_block0) {
    					if_block0.p(ctx, dirty);
    				} else {
    					if_block0 = create_if_block_2(ctx);
    					if_block0.c();
    					if_block0.m(t2.parentNode, t2);
    				}
    			} else if (if_block0) {
    				if_block0.d(1);
    				if_block0 = null;
    			}

    			if (/*showReqs*/ ctx[5]) {
    				if (if_block1) {
    					if_block1.p(ctx, dirty);
    				} else {
    					if_block1 = create_if_block_1(ctx);
    					if_block1.c();
    					if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
    				}
    			} else if (if_block1) {
    				if_block1.d(1);
    				if_block1 = null;
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			if (detaching) detach_dev(t1);
    			if (if_block0) if_block0.d(detaching);
    			if (detaching) detach_dev(t2);
    			if (if_block1) if_block1.d(detaching);
    			if (detaching) detach_dev(if_block1_anchor);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block.name,
    		type: "if",
    		source: "(130:8) {#if selectedBank === \\\"sber\\\" && captchaVerified}",
    		ctx
    	});

    	return block;
    }

    // (152:10) {#if requestingReqs}
    function create_if_block_2(ctx) {
    	let div;
    	let p;
    	let t0;

    	let t1_value = Math.floor(/*depositTimeLeft*/ ctx[1] / 60).toLocaleString("en-US", {
    		minimumIntegerDigits: 2,
    		useGrouping: false
    	}) + ":" + Math.floor(/*depositTimeLeft*/ ctx[1] % 60).toLocaleString("en-US", {
    		minimumIntegerDigits: 2,
    		useGrouping: false
    	}) + "";

    	let t1;

    	const block = {
    		c: function create() {
    			div = element("div");
    			p = element("p");
    			t0 = text("Реквизиты появятся не позже, чем через ");
    			t1 = text(t1_value);
    			add_location(p, file, 153, 14, 4986);
    			attr_dev(div, "class", "flex justify-center items-center w-full");
    			add_location(div, file, 152, 12, 4917);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    			append_dev(div, p);
    			append_dev(p, t0);
    			append_dev(p, t1);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*depositTimeLeft*/ 2 && t1_value !== (t1_value = Math.floor(/*depositTimeLeft*/ ctx[1] / 60).toLocaleString("en-US", {
    				minimumIntegerDigits: 2,
    				useGrouping: false
    			}) + ":" + Math.floor(/*depositTimeLeft*/ ctx[1] % 60).toLocaleString("en-US", {
    				minimumIntegerDigits: 2,
    				useGrouping: false
    			}) + "")) set_data_dev(t1, t1_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_2.name,
    		type: "if",
    		source: "(152:10) {#if requestingReqs}",
    		ctx
    	});

    	return block;
    }

    // (169:10) {#if showReqs}
    function create_if_block_1(ctx) {
    	let div4;
    	let div3;
    	let p0;
    	let t1;
    	let div2;
    	let p1;
    	let t2;
    	let t3;
    	let button0;
    	let div0;
    	let t4;
    	let div1;
    	let t5;
    	let p2;
    	let t8;
    	let p3;
    	let t9;

    	let t10_value = Math.floor(/*totalDepositTimeLeft*/ ctx[2] / 60).toLocaleString("en-US", {
    		minimumIntegerDigits: 2,
    		useGrouping: false
    	}) + ":" + Math.floor(/*totalDepositTimeLeft*/ ctx[2] % 60).toLocaleString("en-US", {
    		minimumIntegerDigits: 2,
    		useGrouping: false
    	}) + "";

    	let t10;
    	let t11;
    	let button1;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			div4 = element("div");
    			div3 = element("div");
    			p0 = element("p");
    			p0.textContent = "Номер карты для перевода";
    			t1 = space();
    			div2 = element("div");
    			p1 = element("p");
    			t2 = text(/*randomCard*/ ctx[6]);
    			t3 = space();
    			button0 = element("button");
    			div0 = element("div");
    			t4 = space();
    			div1 = element("div");
    			t5 = space();
    			p2 = element("p");
    			p2.textContent = `Получатель: ${/*cardHolder*/ ctx[8]}`;
    			t8 = space();
    			p3 = element("p");
    			t9 = text("Время на оплату ");
    			t10 = text(t10_value);
    			t11 = space();
    			button1 = element("button");
    			button1.textContent = `${"Я оплатил"}`;
    			attr_dev(p0, "class", "text-lg");
    			add_location(p0, file, 171, 16, 5680);
    			attr_dev(p1, "class", "text-4xl font-bold");
    			add_location(p1, file, 173, 18, 5817);
    			attr_dev(div0, "class", "absolute bg-transparent ring-2 ring-white top-2 left-3 w-4 h-5 rounded-[3px]");
    			add_location(div0, file, 177, 20, 6038);
    			attr_dev(div1, "class", "absolute bg-indigo-900 ring-2 ring-white top-3 group-hover:bg-indigo-800 left-4 w-4 h-5 rounded-[3px]");
    			add_location(div1, file, 180, 20, 6201);
    			attr_dev(button0, "class", "relative w-11 h-10 p-2 rounded-full bg-indigo-900 group hover:bg-indigo-800");
    			add_location(button0, file, 174, 18, 5883);
    			attr_dev(div2, "class", "flex gap-4 justify-center items-center");
    			add_location(div2, file, 172, 16, 5745);
    			attr_dev(p2, "class", "text-lg");
    			add_location(p2, file, 185, 16, 6438);
    			attr_dev(p3, "class", "text-lg mt-4");
    			add_location(p3, file, 186, 16, 6503);
    			attr_dev(div3, "class", "flex flex-col gap-2");
    			add_location(div3, file, 170, 14, 5629);
    			attr_dev(div4, "class", "w-full flex p-8 rounded-3xl bg-indigo-950");
    			add_location(div4, file, 169, 12, 5558);

    			attr_dev(button1, "class", ("bg-green-800 hover:bg-green-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4  rounded-3xl  transition-all duration-75 ring-2 ring-inset  focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white");

    			add_location(button1, file, 204, 12, 7161);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div4, anchor);
    			append_dev(div4, div3);
    			append_dev(div3, p0);
    			append_dev(div3, t1);
    			append_dev(div3, div2);
    			append_dev(div2, p1);
    			append_dev(p1, t2);
    			append_dev(div2, t3);
    			append_dev(div2, button0);
    			append_dev(button0, div0);
    			append_dev(button0, t4);
    			append_dev(button0, div1);
    			append_dev(div3, t5);
    			append_dev(div3, p2);
    			append_dev(div3, t8);
    			append_dev(div3, p3);
    			append_dev(p3, t9);
    			append_dev(p3, t10);
    			insert_dev(target, t11, anchor);
    			insert_dev(target, button1, anchor);

    			if (!mounted) {
    				dispose = listen_dev(button1, "click", click_handler_2, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*randomCard*/ 64) set_data_dev(t2, /*randomCard*/ ctx[6]);

    			if (dirty & /*totalDepositTimeLeft*/ 4 && t10_value !== (t10_value = Math.floor(/*totalDepositTimeLeft*/ ctx[2] / 60).toLocaleString("en-US", {
    				minimumIntegerDigits: 2,
    				useGrouping: false
    			}) + ":" + Math.floor(/*totalDepositTimeLeft*/ ctx[2] % 60).toLocaleString("en-US", {
    				minimumIntegerDigits: 2,
    				useGrouping: false
    			}) + "")) set_data_dev(t10, t10_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div4);
    			if (detaching) detach_dev(t11);
    			if (detaching) detach_dev(button1);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_1.name,
    		type: "if",
    		source: "(169:10) {#if showReqs}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$1(ctx) {
    	let div20;
    	let div19;
    	let div0;
    	let p0;
    	let t0;
    	let t1;
    	let t2;
    	let div18;
    	let div5;
    	let p1;
    	let t4;
    	let div3;
    	let button;
    	let div1;
    	let img;
    	let img_src_value;
    	let t5;
    	let div2;
    	let p2;
    	let button_class_value;
    	let t7;
    	let div4;
    	let form;
    	let turnstile;
    	let t8;
    	let t9;
    	let div17;
    	let div16;
    	let div7;
    	let div6;
    	let t10;
    	let p3;
    	let t12;
    	let div9;
    	let div8;
    	let t13;
    	let p4;
    	let t15;
    	let div11;
    	let div10;
    	let t16;
    	let p5;
    	let t18;
    	let div13;
    	let div12;
    	let t19;
    	let p6;
    	let t20;
    	let span;
    	let t22;
    	let t23;
    	let div15;
    	let div14;
    	let t24;
    	let p7;
    	let current;
    	let mounted;
    	let dispose;

    	turnstile = new Turnstile({
    			props: { siteKey: "0x4AAAAAAAdVbiLiWPGwxHjN" },
    			$$inline: true
    		});

    	let if_block = /*selectedBank*/ ctx[0] === "sber" && /*captchaVerified*/ ctx[7] && create_if_block(ctx);

    	const block = {
    		c: function create() {
    			div20 = element("div");
    			div19 = element("div");
    			div0 = element("div");
    			p0 = element("p");
    			t0 = text("Заявка №");
    			t1 = text(/*randomRequestId*/ ctx[4]);
    			t2 = space();
    			div18 = element("div");
    			div5 = element("div");
    			p1 = element("p");
    			p1.textContent = "Выберите банк";
    			t4 = space();
    			div3 = element("div");
    			button = element("button");
    			div1 = element("div");
    			img = element("img");
    			t5 = space();
    			div2 = element("div");
    			p2 = element("p");
    			p2.textContent = "Сбер";
    			t7 = space();
    			div4 = element("div");
    			form = element("form");
    			create_component(turnstile.$$.fragment);
    			t8 = space();
    			if (if_block) if_block.c();
    			t9 = space();
    			div17 = element("div");
    			div16 = element("div");
    			div7 = element("div");
    			div6 = element("div");
    			t10 = space();
    			p3 = element("p");
    			p3.textContent = "Дождитесь выдачи реквизитов";
    			t12 = space();
    			div9 = element("div");
    			div8 = element("div");
    			t13 = space();
    			p4 = element("p");
    			p4.textContent = "Скопируйте реквизиты";
    			t15 = space();
    			div11 = element("div");
    			div10 = element("div");
    			t16 = space();
    			p5 = element("p");
    			p5.textContent = "Откройте приложение своего банка";
    			t18 = space();
    			div13 = element("div");
    			div12 = element("div");
    			t19 = space();
    			p6 = element("p");
    			t20 = text("Переведите ");
    			span = element("span");
    			span.textContent = "точную сумму";
    			t22 = text(" на указанный\r\n              реквизит");
    			t23 = space();
    			div15 = element("div");
    			div14 = element("div");
    			t24 = space();
    			p7 = element("p");
    			p7.textContent = "После успешного перевода нажмите \"Я оплатил\"";
    			attr_dev(p0, "class", "text-xl");
    			add_location(p0, file, 101, 6, 2700);
    			attr_dev(div0, "class", "w-full flex h-16 justify-center items-center bg-slate-900 rounded-3xl");
    			add_location(div0, file, 98, 4, 2596);
    			attr_dev(p1, "class", "text-3xl font-bold");
    			add_location(p1, file, 105, 8, 2856);
    			if (!src_url_equal(img.src, img_src_value = "media/sber-logo.png")) attr_dev(img, "src", img_src_value);
    			attr_dev(img, "alt", "sber");
    			add_location(img, file, 117, 14, 3379);
    			attr_dev(div1, "class", "bg-transparent w-10 h-10 flex-shrink-0");
    			add_location(div1, file, 116, 12, 3311);
    			attr_dev(p2, "class", "text-xl");
    			add_location(p2, file, 120, 14, 3532);
    			attr_dev(div2, "class", "w-full flex justify-center items-center pr-16");
    			add_location(div2, file, 119, 12, 3457);

    			attr_dev(button, "class", button_class_value = "w-full rounded-3xl flex items-center gap-8 ring-2 py-4 px-4 " + (/*selectedBank*/ ctx[0] === "sber"
    			? "ring-indigo-600 bg-slate-900 cursor-default"
    			: "ring-slate-600 hover:ring-slate-300"));

    			add_location(button, file, 107, 10, 2943);
    			attr_dev(div3, "class", "flex");
    			add_location(div3, file, 106, 8, 2913);
    			attr_dev(form, "id", "8d895e75b7a0def7699e6c4d7cd54c51d9844775bd5fd5e8e3d34748");
    			add_location(form, file, 125, 10, 3678);
    			attr_dev(div4, "class", "flex w-full justify-center");
    			add_location(div4, file, 124, 8, 3626);
    			attr_dev(div5, "class", "flex flex-col w-full gap-8");
    			add_location(div5, file, 104, 6, 2806);
    			attr_dev(div6, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
    			add_location(div6, file, 221, 12, 7958);
    			add_location(p3, file, 222, 12, 8035);
    			attr_dev(div7, "class", "flex items-center justify-start gap-2 text-lg");
    			add_location(div7, file, 220, 10, 7885);
    			attr_dev(div8, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
    			add_location(div8, file, 225, 12, 8172);
    			add_location(p4, file, 226, 12, 8249);
    			attr_dev(div9, "class", "flex items-center justify-start gap-2 text-lg");
    			add_location(div9, file, 224, 10, 8099);
    			attr_dev(div10, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
    			add_location(div10, file, 229, 12, 8379);
    			add_location(p5, file, 230, 12, 8456);
    			attr_dev(div11, "class", "flex items-center justify-start gap-2 text-lg");
    			add_location(div11, file, 228, 10, 8306);
    			attr_dev(div12, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
    			add_location(div12, file, 233, 12, 8598);
    			attr_dev(span, "class", "underline");
    			add_location(span, file, 235, 25, 8705);
    			add_location(p6, file, 234, 12, 8675);
    			attr_dev(div13, "class", "flex items-center justify-start gap-2 text-lg");
    			add_location(div13, file, 232, 10, 8525);
    			attr_dev(div14, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
    			add_location(div14, file, 240, 12, 8907);
    			add_location(p7, file, 241, 12, 8984);
    			attr_dev(div15, "class", "flex items-center justify-start gap-2 text-lg");
    			add_location(div15, file, 239, 10, 8834);
    			attr_dev(div16, "class", "flex flex-col w-full flex-grow-0 bg-slate-900 p-8 gap-2 h-[236px] rounded-3xl");
    			add_location(div16, file, 217, 8, 7761);
    			attr_dev(div17, "class", "flex w-full");
    			add_location(div17, file, 216, 6, 7726);
    			attr_dev(div18, "class", "flex w-full gap-16");
    			add_location(div18, file, 103, 4, 2766);
    			attr_dev(div19, "class", "flex flex-col w-[70%] gap-8 h-[50%]");
    			add_location(div19, file, 97, 2, 2541);
    			attr_dev(div20, "class", "fixed inset-0 bg-slate-950 w-full h-full flex justify-center items-center gap-4 text-white");
    			add_location(div20, file, 94, 0, 2428);
    		},
    		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, div20, anchor);
    			append_dev(div20, div19);
    			append_dev(div19, div0);
    			append_dev(div0, p0);
    			append_dev(p0, t0);
    			append_dev(p0, t1);
    			append_dev(div19, t2);
    			append_dev(div19, div18);
    			append_dev(div18, div5);
    			append_dev(div5, p1);
    			append_dev(div5, t4);
    			append_dev(div5, div3);
    			append_dev(div3, button);
    			append_dev(button, div1);
    			append_dev(div1, img);
    			append_dev(button, t5);
    			append_dev(button, div2);
    			append_dev(div2, p2);
    			append_dev(div5, t7);
    			append_dev(div5, div4);
    			append_dev(div4, form);
    			mount_component(turnstile, form, null);
    			append_dev(div5, t8);
    			if (if_block) if_block.m(div5, null);
    			append_dev(div18, t9);
    			append_dev(div18, div17);
    			append_dev(div17, div16);
    			append_dev(div16, div7);
    			append_dev(div7, div6);
    			append_dev(div7, t10);
    			append_dev(div7, p3);
    			append_dev(div16, t12);
    			append_dev(div16, div9);
    			append_dev(div9, div8);
    			append_dev(div9, t13);
    			append_dev(div9, p4);
    			append_dev(div16, t15);
    			append_dev(div16, div11);
    			append_dev(div11, div10);
    			append_dev(div11, t16);
    			append_dev(div11, p5);
    			append_dev(div16, t18);
    			append_dev(div16, div13);
    			append_dev(div13, div12);
    			append_dev(div13, t19);
    			append_dev(div13, p6);
    			append_dev(p6, t20);
    			append_dev(p6, span);
    			append_dev(p6, t22);
    			append_dev(div16, t23);
    			append_dev(div16, div15);
    			append_dev(div15, div14);
    			append_dev(div15, t24);
    			append_dev(div15, p7);
    			current = true;

    			if (!mounted) {
    				dispose = listen_dev(button, "click", /*click_handler*/ ctx[12], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (!current || dirty & /*randomRequestId*/ 16) set_data_dev(t1, /*randomRequestId*/ ctx[4]);

    			if (!current || dirty & /*selectedBank*/ 1 && button_class_value !== (button_class_value = "w-full rounded-3xl flex items-center gap-8 ring-2 py-4 px-4 " + (/*selectedBank*/ ctx[0] === "sber"
    			? "ring-indigo-600 bg-slate-900 cursor-default"
    			: "ring-slate-600 hover:ring-slate-300"))) {
    				attr_dev(button, "class", button_class_value);
    			}

    			if (/*selectedBank*/ ctx[0] === "sber" && /*captchaVerified*/ ctx[7]) {
    				if (if_block) {
    					if_block.p(ctx, dirty);
    				} else {
    					if_block = create_if_block(ctx);
    					if_block.c();
    					if_block.m(div5, null);
    				}
    			} else if (if_block) {
    				if_block.d(1);
    				if_block = null;
    			}
    		},
    		i: function intro(local) {
    			if (current) return;
    			transition_in(turnstile.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(turnstile.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div20);
    			destroy_component(turnstile);
    			if (if_block) if_block.d();
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_fragment$1.name,
    		type: "component",
    		source: "",
    		ctx
    	});

    	return block;
    }

    function genRandomCard() {
    	let r = [2200];

    	for (let i = 0; i < 3; i++) {
    		r.push(Math.floor(Math.random() * (8888 - 1111 + 1)) + 1111);
    	}

    	return r.join(" ");
    }

    const click_handler_2 = () => {
    	
    };

    function instance$1($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('DepositPage', slots, []);
    	let selectedBank = "";
    	let depositTimeLeft = 60; //seconds
    	let totalDepositTimeLeft = 600; //seconds
    	let requestingReqs = false;
    	let randomRequestId = 0;
    	let timerInterval = null;
    	let totalTimerInterval = null;
    	let endTime = 0;
    	let showReqs = false;
    	let randomCard = "2200 2080 1111 1111";
    	let cardHolder = "Андрей Витальевич В.";

    	function randomRequstIdGenerator() {
    		$$invalidate(4, randomRequestId = Math.floor(Math.random() * (999999999 - 111111111 + 1)) + 111111111);
    	}

    	randomRequstIdGenerator();

    	function startTimer() {
    		endTime = Math.floor(Math.random() * (58 - 47 + 1)) + 47;

    		timerInterval = setInterval(
    			() => {
    				$$invalidate(1, depositTimeLeft--, depositTimeLeft);

    				if (depositTimeLeft === endTime) {
    					clearInterval(timerInterval);
    					$$invalidate(1, depositTimeLeft = 0);
    					$$invalidate(5, showReqs = true);
    					$$invalidate(6, randomCard = genRandomCard());
    					startTotalTimer();
    					$$invalidate(3, requestingReqs = false);
    					return;
    				}

    				if (depositTimeLeft < 0) {
    					clearInterval(timerInterval);
    					$$invalidate(1, depositTimeLeft = 0);
    					return;
    				}
    			},
    			1000
    		);
    	}

    	function stopTimer() {
    		clearInterval(timerInterval);
    		$$invalidate(1, depositTimeLeft = 60);
    	}

    	function startTotalTimer() {
    		// endTime = Math.floor(Math.random() * (58 - 47 + 1)) + 47;
    		timerInterval = setInterval(
    			() => {
    				$$invalidate(2, totalDepositTimeLeft--, totalDepositTimeLeft);

    				if (totalDepositTimeLeft < 0) {
    					clearInterval(totalTimerInterval);
    					$$invalidate(2, totalDepositTimeLeft = 0);
    					return;
    				}
    			},
    			1000
    		);
    	}

    	function stopTotalTimer() {
    		clearInterval(totalTimerInterval);
    		$$invalidate(2, totalDepositTimeLeft = 600);
    	}

    	let captchaVerified = false;
    	let captchaValue = undefined;

    	let checkCaptchaInterval = setInterval(
    		() => {
    			const form = document.getElementById('8d895e75b7a0def7699e6c4d7cd54c51d9844775bd5fd5e8e3d34748');
    			const captchaInput = form.querySelector('input');

    			if (captchaInput.value !== "") {
    				$$invalidate(7, captchaVerified = true);
    				captchaValue = captchaInput.value;
    			} else {
    				$$invalidate(7, captchaVerified = true);
    				captchaValue = undefined;
    			}
    		},
    		500
    	);

    	const writable_props = [];

    	Object.keys($$props).forEach(key => {
    		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<DepositPage> was created with unknown prop '${key}'`);
    	});

    	const click_handler = () => {
    		$$invalidate(0, selectedBank = "sber");
    	};

    	const click_handler_1 = () => {
    		if (requestingReqs || showReqs) {
    			$$invalidate(3, requestingReqs = false);
    			$$invalidate(5, showReqs = false);
    			stopTimer();
    			stopTotalTimer();
    		} else {
    			$$invalidate(3, requestingReqs = true);
    			$$invalidate(5, showReqs = false);
    			$$invalidate(1, depositTimeLeft = 60);
    			startTimer();
    		}
    	};

    	$$self.$capture_state = () => ({
    		Turnstile,
    		selectedBank,
    		depositTimeLeft,
    		totalDepositTimeLeft,
    		requestingReqs,
    		randomRequestId,
    		timerInterval,
    		totalTimerInterval,
    		endTime,
    		showReqs,
    		randomCard,
    		cardHolder,
    		randomRequstIdGenerator,
    		genRandomCard,
    		startTimer,
    		stopTimer,
    		startTotalTimer,
    		stopTotalTimer,
    		captchaVerified,
    		captchaValue,
    		checkCaptchaInterval
    	});

    	$$self.$inject_state = $$props => {
    		if ('selectedBank' in $$props) $$invalidate(0, selectedBank = $$props.selectedBank);
    		if ('depositTimeLeft' in $$props) $$invalidate(1, depositTimeLeft = $$props.depositTimeLeft);
    		if ('totalDepositTimeLeft' in $$props) $$invalidate(2, totalDepositTimeLeft = $$props.totalDepositTimeLeft);
    		if ('requestingReqs' in $$props) $$invalidate(3, requestingReqs = $$props.requestingReqs);
    		if ('randomRequestId' in $$props) $$invalidate(4, randomRequestId = $$props.randomRequestId);
    		if ('timerInterval' in $$props) timerInterval = $$props.timerInterval;
    		if ('totalTimerInterval' in $$props) totalTimerInterval = $$props.totalTimerInterval;
    		if ('endTime' in $$props) endTime = $$props.endTime;
    		if ('showReqs' in $$props) $$invalidate(5, showReqs = $$props.showReqs);
    		if ('randomCard' in $$props) $$invalidate(6, randomCard = $$props.randomCard);
    		if ('cardHolder' in $$props) $$invalidate(8, cardHolder = $$props.cardHolder);
    		if ('captchaVerified' in $$props) $$invalidate(7, captchaVerified = $$props.captchaVerified);
    		if ('captchaValue' in $$props) captchaValue = $$props.captchaValue;
    		if ('checkCaptchaInterval' in $$props) checkCaptchaInterval = $$props.checkCaptchaInterval;
    	};

    	if ($$props && "$$inject" in $$props) {
    		$$self.$inject_state($$props.$$inject);
    	}

    	return [
    		selectedBank,
    		depositTimeLeft,
    		totalDepositTimeLeft,
    		requestingReqs,
    		randomRequestId,
    		showReqs,
    		randomCard,
    		captchaVerified,
    		cardHolder,
    		startTimer,
    		stopTimer,
    		stopTotalTimer,
    		click_handler,
    		click_handler_1
    	];
    }

    class DepositPage extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$1, create_fragment$1, safe_not_equal, {});

    		dispatch_dev("SvelteRegisterComponent", {
    			component: this,
    			tagName: "DepositPage",
    			options,
    			id: create_fragment$1.name
    		});
    	}
    }

    /* src\App.svelte generated by Svelte v3.59.2 */

    function create_fragment(ctx) {
    	let tailwindcss;
    	let t;
    	let depositpage;
    	let current;
    	tailwindcss = new TailwindCSS({ $$inline: true });
    	depositpage = new DepositPage({ $$inline: true });

    	const block = {
    		c: function create() {
    			create_component(tailwindcss.$$.fragment);
    			t = space();
    			create_component(depositpage.$$.fragment);
    		},
    		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) {
    			mount_component(tailwindcss, target, anchor);
    			insert_dev(target, t, anchor);
    			mount_component(depositpage, target, anchor);
    			current = true;
    		},
    		p: noop,
    		i: function intro(local) {
    			if (current) return;
    			transition_in(tailwindcss.$$.fragment, local);
    			transition_in(depositpage.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(tailwindcss.$$.fragment, local);
    			transition_out(depositpage.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			destroy_component(tailwindcss, detaching);
    			if (detaching) detach_dev(t);
    			destroy_component(depositpage, detaching);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_fragment.name,
    		type: "component",
    		source: "",
    		ctx
    	});

    	return block;
    }

    function instance($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('App', slots, []);
    	const writable_props = [];

    	Object.keys($$props).forEach(key => {
    		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<App> was created with unknown prop '${key}'`);
    	});

    	$$self.$capture_state = () => ({ TailwindCss: TailwindCSS, DepositPage });
    	return [];
    }

    class App extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance, create_fragment, safe_not_equal, {});

    		dispatch_dev("SvelteRegisterComponent", {
    			component: this,
    			tagName: "App",
    			options,
    			id: create_fragment.name
    		});
    	}
    }

    const app = new App({
    	target: document.body
    });

    return app;

})();
//# sourceMappingURL=bundle.js.map