(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 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 validate_store(store, name) {
        if (store != null && typeof store.subscribe !== 'function') {
            throw new Error(`'${name}' is not a store with a 'subscribe' method`);
        }
    }
    function subscribe(store, ...callbacks) {
        if (store == null) {
            return noop;
        }
        const unsub = store.subscribe(...callbacks);
        return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
    }
    function component_subscribe(component, store, callback) {
        component.$$.on_destroy.push(subscribe(store, callback));
    }
    function null_to_empty(value) {
        return value == null ? '' : value;
    }

    const globals = (typeof window !== 'undefined'
        ? window
        : typeof globalThis !== 'undefined'
            ? globalThis
            : global);
    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 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 empty() {
        return text('');
    }
    function listen(node, event, handler, options) {
        node.addEventListener(event, handler, options);
        return () => node.removeEventListener(event, handler, options);
    }
    function prevent_default(fn) {
        return function (event) {
            event.preventDefault();
            // @ts-ignore
            return fn.call(this, event);
        };
    }
    function attr(node, attribute, value) {
        if (value == null)
            node.removeAttribute(attribute);
        else if (node.getAttribute(attribute) !== value)
            node.setAttribute(attribute, value);
    }
    function to_number(value) {
        return value === '' ? null : +value;
    }
    function children(element) {
        return Array.from(element.childNodes);
    }
    function set_input_value(input, value) {
        input.value = value == null ? '' : value;
    }
    function set_style(node, key, value, important) {
        if (value == null) {
            node.style.removeProperty(key);
        }
        else {
            node.style.setProperty(key, value, important ? 'important' : '');
        }
    }
    function select_option(select, value, mounting) {
        for (let i = 0; i < select.options.length; i += 1) {
            const option = select.options[i];
            if (option.__value === value) {
                option.selected = true;
                return;
            }
        }
        if (!mounting || value !== undefined) {
            select.selectedIndex = -1; // no option should be selected
        }
    }
    function select_value(select) {
        const selected_option = select.querySelector(':checked');
        return selected_option && selected_option.__value;
    }
    function toggle_class(element, name, toggle) {
        element.classList[toggle ? 'add' : 'remove'](name);
    }
    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);
    }
    /**
     * Schedules a callback to run immediately before the component is unmounted.
     *
     * Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the
     * only one that runs inside a server-side component.
     *
     * https://svelte.dev/docs#run-time-svelte-ondestroy
     */
    function onDestroy(fn) {
        get_current_component().$$.on_destroy.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 group_outros() {
        outros = {
            r: 0,
            c: [],
            p: outros // parent group
        };
    }
    function check_outros() {
        if (!outros.r) {
            run_all(outros.c);
        }
        outros = outros.p;
    }
    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 destroy_block(block, lookup) {
        block.d(1);
        lookup.delete(block.key);
    }
    function outro_and_destroy_block(block, lookup) {
        transition_out(block, 1, 1, () => {
            lookup.delete(block.key);
        });
    }
    function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {
        let o = old_blocks.length;
        let n = list.length;
        let i = o;
        const old_indexes = {};
        while (i--)
            old_indexes[old_blocks[i].key] = i;
        const new_blocks = [];
        const new_lookup = new Map();
        const deltas = new Map();
        const updates = [];
        i = n;
        while (i--) {
            const child_ctx = get_context(ctx, list, i);
            const key = get_key(child_ctx);
            let block = lookup.get(key);
            if (!block) {
                block = create_each_block(key, child_ctx);
                block.c();
            }
            else if (dynamic) {
                // defer updates until all the DOM shuffling is done
                updates.push(() => block.p(child_ctx, dirty));
            }
            new_lookup.set(key, new_blocks[i] = block);
            if (key in old_indexes)
                deltas.set(key, Math.abs(i - old_indexes[key]));
        }
        const will_move = new Set();
        const did_move = new Set();
        function insert(block) {
            transition_in(block, 1);
            block.m(node, next);
            lookup.set(block.key, block);
            next = block.first;
            n--;
        }
        while (o && n) {
            const new_block = new_blocks[n - 1];
            const old_block = old_blocks[o - 1];
            const new_key = new_block.key;
            const old_key = old_block.key;
            if (new_block === old_block) {
                // do nothing
                next = new_block.first;
                o--;
                n--;
            }
            else if (!new_lookup.has(old_key)) {
                // remove old block
                destroy(old_block, lookup);
                o--;
            }
            else if (!lookup.has(new_key) || will_move.has(new_key)) {
                insert(new_block);
            }
            else if (did_move.has(old_key)) {
                o--;
            }
            else if (deltas.get(new_key) > deltas.get(old_key)) {
                did_move.add(new_key);
                insert(new_block);
            }
            else {
                will_move.add(old_key);
                o--;
            }
        }
        while (o--) {
            const old_block = old_blocks[o];
            if (!new_lookup.has(old_block.key))
                destroy(old_block, lookup);
        }
        while (n)
            insert(new_blocks[n - 1]);
        run_all(updates);
        return new_blocks;
    }
    function validate_each_keys(ctx, list, get_context, get_key) {
        const keys = new Set();
        for (let i = 0; i < list.length; i++) {
            const key = get_key(get_context(ctx, list, i));
            if (keys.has(key)) {
                throw new Error('Cannot have duplicate keys in a keyed each');
            }
            keys.add(key);
        }
    }
    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 prop_dev(node, property, value) {
        node[property] = value;
        dispatch_dev('SvelteDOMSetProperty', { node, property, 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_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}".`);
            }
        }
    }
    /**
     * 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\VideoGradioComponentBrainstorming.svelte generated by Svelte v3.59.2 */

    const { console: console_1$7 } = globals;
    const file$h = "src\\VideoGradioComponentBrainstorming.svelte";

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

    // (85:4) {#each kitchenOptions as option}
    function create_each_block$a(ctx) {
    	let option;
    	let t_value = /*option*/ ctx[15] + "";
    	let t;

    	const block = {
    		c: function create() {
    			option = element("option");
    			t = text(t_value);
    			option.__value = /*option*/ ctx[15];
    			option.value = option.__value;
    			add_location(option, file$h, 85, 6, 2561);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, option, anchor);
    			append_dev(option, t);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(option);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$a.name,
    		type: "each",
    		source: "(85:4) {#each kitchenOptions as option}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$h(ctx) {
    	let h1;
    	let t1;
    	let div1;
    	let video;
    	let track;
    	let track_src_value;
    	let t2;
    	let div0;
    	let t3;
    	let t4;
    	let t5;
    	let canvas_1;
    	let t6;
    	let input;
    	let t7;
    	let div2;
    	let button;
    	let t9;
    	let select;
    	let mounted;
    	let dispose;
    	let each_value = /*kitchenOptions*/ ctx[4];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			h1 = element("h1");
    			h1.textContent = "AI Vision Assistant - Auto prompt HF agent + Cohere + Object detection - Text write on screen test";
    			t1 = space();
    			div1 = element("div");
    			video = element("video");
    			track = element("track");
    			t2 = space();
    			div0 = element("div");
    			t3 = text("Text Overlay Test and ");
    			t4 = text(/*TestVerb*/ ctx[3]);
    			t5 = space();
    			canvas_1 = element("canvas");
    			t6 = space();
    			input = element("input");
    			t7 = space();
    			div2 = element("div");
    			button = element("button");
    			button.textContent = "Verb Test";
    			t9 = space();
    			select = element("select");

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

    			add_location(h1, file$h, 66, 0, 1800);
    			attr_dev(track, "kind", "captions");
    			if (!src_url_equal(track.src, track_src_value = "path/to/your/captions/file.vtt")) attr_dev(track, "src", track_src_value);
    			attr_dev(track, "srclang", "en");
    			attr_dev(track, "label", "English");
    			add_location(track, file$h, 72, 4, 2006);
    			attr_dev(video, "id", "videoCanvas");
    			video.autoplay = true;
    			attr_dev(video, "class", "svelte-ufd3fo");
    			add_location(video, file$h, 70, 2, 1965);
    			attr_dev(div0, "id", "overlayText");
    			attr_dev(div0, "class", "svelte-ufd3fo");
    			add_location(div0, file$h, 74, 2, 2111);
    			attr_dev(div1, "id", "videoContainer");
    			attr_dev(div1, "class", "svelte-ufd3fo");
    			add_location(div1, file$h, 68, 0, 1911);
    			attr_dev(canvas_1, "id", "myCanvas");
    			set_style(canvas_1, "border", "2px solid black");
    			attr_dev(canvas_1, "width", "500");
    			attr_dev(canvas_1, "height", "500");
    			add_location(canvas_1, file$h, 77, 0, 2186);
    			attr_dev(input, "type", "text");
    			add_location(input, file$h, 78, 0, 2294);
    			add_location(button, file$h, 82, 2, 2429);
    			if (/*selectedOption*/ ctx[0] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[9].call(select));
    			add_location(select, file$h, 83, 2, 2479);
    			attr_dev(div2, "id", "frameForButtons");
    			add_location(div2, file$h, 81, 0, 2399);
    		},
    		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, h1, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, div1, anchor);
    			append_dev(div1, video);
    			append_dev(video, track);
    			append_dev(div1, t2);
    			append_dev(div1, div0);
    			append_dev(div0, t3);
    			append_dev(div0, t4);
    			insert_dev(target, t5, anchor);
    			insert_dev(target, canvas_1, anchor);
    			/*canvas_1_binding*/ ctx[7](canvas_1);
    			insert_dev(target, t6, anchor);
    			insert_dev(target, input, anchor);
    			set_input_value(input, /*textToDisplay*/ ctx[2]);
    			insert_dev(target, t7, anchor);
    			insert_dev(target, div2, anchor);
    			append_dev(div2, button);
    			append_dev(div2, t9);
    			append_dev(div2, select);

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

    			select_option(select, /*selectedOption*/ ctx[0], true);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input, "input", /*input_input_handler*/ ctx[8]),
    					listen_dev(input, "input", /*updateText*/ ctx[6], false, false, false, false),
    					listen_dev(button, "click", /*testText*/ ctx[5], false, false, false, false),
    					listen_dev(select, "change", /*select_change_handler*/ ctx[9])
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*TestVerb*/ 8) set_data_dev(t4, /*TestVerb*/ ctx[3]);

    			if (dirty & /*textToDisplay*/ 4 && input.value !== /*textToDisplay*/ ctx[2]) {
    				set_input_value(input, /*textToDisplay*/ ctx[2]);
    			}

    			if (dirty & /*kitchenOptions*/ 16) {
    				each_value = /*kitchenOptions*/ ctx[4];
    				validate_each_argument(each_value);
    				let i;

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

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

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

    				each_blocks.length = each_value.length;
    			}

    			if (dirty & /*selectedOption, kitchenOptions*/ 17) {
    				select_option(select, /*selectedOption*/ ctx[0]);
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(h1);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(div1);
    			if (detaching) detach_dev(t5);
    			if (detaching) detach_dev(canvas_1);
    			/*canvas_1_binding*/ ctx[7](null);
    			if (detaching) detach_dev(t6);
    			if (detaching) detach_dev(input);
    			if (detaching) detach_dev(t7);
    			if (detaching) detach_dev(div2);
    			destroy_each(each_blocks, detaching);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function ocrTest() {
    	
    } // Logic for 'Test OCR' button

    function instance$h($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('VideoGradioComponentBrainstorming', slots, []);
    	let selectedOption = 'Stove - lu'; // default value
    	let kitchenOptions = ['Stove - lu', 'Refrigerator - bingxiang', 'Spoon - shao']; /* ... other options ... */
    	let canvas;
    	let ctx;
    	let textToDisplay = 'Initial Text';
    	let counter = 0;
    	let hud_text;
    	let TestVerb = "|Test verb|";

    	// Functions for button commands
    	function testText() {
    		// Logic for 'verb test' button
    		const randomIndex = Math.floor(Math.random() * kitchenOptions.length);

    		$$invalidate(3, TestVerb = kitchenOptions[randomIndex]);
    	}

    	// Image source
    	let imageSrc = 'path_to_your_image/Blooms-Taxonomy-650x366.jpg';

    	// Video stream setup
    	onMount(() => {
    		// Initialize video stream here
    		ctx = canvas.getContext('2d');

    		setInterval(
    			() => {
    				drawText(textToDisplay);
    			},
    			1000
    		); // Update every second
    	});

    	function drawText(hud_info) {
    		if (ctx) {
    			hud_text = "HUD Info Update: " + counter++ + " " + hud_info;
    			ctx.clearRect(0, 0, canvas.width, canvas.height); // Clear the canvas
    			ctx.font = '30px Arial';
    			ctx.fillStyle = 'black';
    			ctx.fillText(hud_text, 50, 50);
    		}
    	}

    	function updateText(event) {
    		$$invalidate(2, textToDisplay = event.target.value);
    		drawText();
    	}

    	// Camera as Video Stream
    	navigator.mediaDevices.getUserMedia({ video: true }).then(stream => {
    		const video = document.getElementById('videoCanvas');
    		video.srcObject = stream;
    	}).catch(err => {
    		console.error("Error accessing the camera: ", err);
    	});

    	const writable_props = [];

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

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

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

    	function select_change_handler() {
    		selectedOption = select_value(this);
    		$$invalidate(0, selectedOption);
    		$$invalidate(4, kitchenOptions);
    	}

    	$$self.$capture_state = () => ({
    		onMount,
    		selectedOption,
    		kitchenOptions,
    		canvas,
    		ctx,
    		textToDisplay,
    		counter,
    		hud_text,
    		TestVerb,
    		testText,
    		ocrTest,
    		imageSrc,
    		drawText,
    		updateText
    	});

    	$$self.$inject_state = $$props => {
    		if ('selectedOption' in $$props) $$invalidate(0, selectedOption = $$props.selectedOption);
    		if ('kitchenOptions' in $$props) $$invalidate(4, kitchenOptions = $$props.kitchenOptions);
    		if ('canvas' in $$props) $$invalidate(1, canvas = $$props.canvas);
    		if ('ctx' in $$props) ctx = $$props.ctx;
    		if ('textToDisplay' in $$props) $$invalidate(2, textToDisplay = $$props.textToDisplay);
    		if ('counter' in $$props) counter = $$props.counter;
    		if ('hud_text' in $$props) hud_text = $$props.hud_text;
    		if ('TestVerb' in $$props) $$invalidate(3, TestVerb = $$props.TestVerb);
    		if ('imageSrc' in $$props) imageSrc = $$props.imageSrc;
    	};

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

    	return [
    		selectedOption,
    		canvas,
    		textToDisplay,
    		TestVerb,
    		kitchenOptions,
    		testText,
    		updateText,
    		canvas_1_binding,
    		input_input_handler,
    		select_change_handler
    	];
    }

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

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

    const subscriber_queue = [];
    /**
     * Create a `Writable` store that allows both updating and reading by subscription.
     * @param {*=}value initial value
     * @param {StartStopNotifier=} start
     */
    function writable(value, start = noop) {
        let stop;
        const subscribers = new Set();
        function set(new_value) {
            if (safe_not_equal(value, new_value)) {
                value = new_value;
                if (stop) { // store is ready
                    const run_queue = !subscriber_queue.length;
                    for (const subscriber of subscribers) {
                        subscriber[1]();
                        subscriber_queue.push(subscriber, value);
                    }
                    if (run_queue) {
                        for (let i = 0; i < subscriber_queue.length; i += 2) {
                            subscriber_queue[i][0](subscriber_queue[i + 1]);
                        }
                        subscriber_queue.length = 0;
                    }
                }
            }
        }
        function update(fn) {
            set(fn(value));
        }
        function subscribe(run, invalidate = noop) {
            const subscriber = [run, invalidate];
            subscribers.add(subscriber);
            if (subscribers.size === 1) {
                stop = start(set) || noop;
            }
            run(value);
            return () => {
                subscribers.delete(subscriber);
                if (subscribers.size === 0 && stop) {
                    stop();
                    stop = null;
                }
            };
        }
        return { set, update, subscribe };
    }

    /* src\MovingDotPortfromReact.svelte generated by Svelte v3.59.2 */
    const file$g = "src\\MovingDotPortfromReact.svelte";

    function create_fragment$g(ctx) {
    	let button;

    	const block = {
    		c: function create() {
    			button = element("button");
    			attr_dev(button, "class", "MovingDot svelte-1mg0qyd");
    			set_style(button, "left", /*position*/ ctx[0].x + "px");
    			set_style(button, "top", /*position*/ ctx[0].y + "px");
    			attr_dev(button, "tabindex", "0");
    			add_location(button, file$g, 48, 0, 1573);
    		},
    		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, button, anchor);
    			/*button_binding*/ ctx[4](button);
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*position*/ 1) {
    				set_style(button, "left", /*position*/ ctx[0].x + "px");
    			}

    			if (dirty & /*position*/ 1) {
    				set_style(button, "top", /*position*/ ctx[0].y + "px");
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			/*button_binding*/ ctx[4](null);
    		}
    	};

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

    	return block;
    }

    const step = 10;

    function instance$g($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotPortfromReact', slots, []);
    	let { position = { x: 0, y: 0 } } = $$props;
    	let { boundaries = { minX: 0, maxX: 100, minY: 0, maxY: 100 } } = $$props;
    	const dispatch = createEventDispatcher();
    	let dotElement; // Reference to the dot element

    	function moveDot(newX, newY) {
    		// Update position with a new object for Svelte reactivity
    		let boundedX = Math.max(boundaries.minX, Math.min(newX, boundaries.maxX));

    		let boundedY = Math.max(boundaries.minY, Math.min(newY, boundaries.maxY));

    		// Update position
    		$$invalidate(0, position = { x: boundedX, y: boundedY });

    		// Dispatch the move event with the new position
    		dispatch('move', position);
    	}

    	const handleKeyPress = e => {
    		e.preventDefault();
    		let newX = position.x;
    		let newY = position.y;

    		switch (e.key) {
    			case 'ArrowLeft':
    				newX -= step;
    				break;
    			case 'ArrowRight':
    				newX += step;
    				break;
    			case 'ArrowUp':
    				newY -= step;
    				break;
    			case 'ArrowDown':
    				newY += step;
    				break;
    		}

    		moveDot(newX, newY);
    	};

    	function focusDot() {
    		//On click for the space its imported into
    		dotElement.focus();
    	}

    	onMount(() => {
    		dotElement.addEventListener('keydown', handleKeyPress);
    	});

    	onDestroy(() => {
    		dotElement.removeEventListener('keydown', handleKeyPress);
    	});

    	const writable_props = ['position', 'boundaries'];

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

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

    	$$self.$$set = $$props => {
    		if ('position' in $$props) $$invalidate(0, position = $$props.position);
    		if ('boundaries' in $$props) $$invalidate(2, boundaries = $$props.boundaries);
    	};

    	$$self.$capture_state = () => ({
    		onMount,
    		onDestroy,
    		createEventDispatcher,
    		position,
    		boundaries,
    		step,
    		dispatch,
    		dotElement,
    		moveDot,
    		handleKeyPress,
    		focusDot
    	});

    	$$self.$inject_state = $$props => {
    		if ('position' in $$props) $$invalidate(0, position = $$props.position);
    		if ('boundaries' in $$props) $$invalidate(2, boundaries = $$props.boundaries);
    		if ('dotElement' in $$props) $$invalidate(1, dotElement = $$props.dotElement);
    	};

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

    	return [position, dotElement, boundaries, focusDot, button_binding];
    }

    class MovingDotPortfromReact extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$g, create_fragment$g, safe_not_equal, { position: 0, boundaries: 2, focusDot: 3 });

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

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

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

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

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

    	get focusDot() {
    		return this.$$.ctx[3];
    	}

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

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

    const file$f = "src\\MovingDotTargetPortfromReact.svelte";

    function create_fragment$f(ctx) {
    	let div;

    	const block = {
    		c: function create() {
    			div = element("div");
    			attr_dev(div, "class", "target svelte-4yc66h");
    			set_style(div, "left", /*position*/ ctx[0].x + "px");
    			set_style(div, "top", /*position*/ ctx[0].y + "px");
    			add_location(div, file$f, 4, 0, 49);
    		},
    		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);
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*position*/ 1) {
    				set_style(div, "left", /*position*/ ctx[0].x + "px");
    			}

    			if (dirty & /*position*/ 1) {
    				set_style(div, "top", /*position*/ ctx[0].y + "px");
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    		}
    	};

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

    	return block;
    }

    function instance$f($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotTargetPortfromReact', slots, []);
    	let { position } = $$props;

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

    	const writable_props = ['position'];

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

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

    	$$self.$capture_state = () => ({ position });

    	$$self.$inject_state = $$props => {
    		if ('position' in $$props) $$invalidate(0, position = $$props.position);
    	};

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

    	return [position];
    }

    class MovingDotTargetPortfromReact extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$f, create_fragment$f, safe_not_equal, { position: 0 });

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

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

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

    const health = writable(100);
    const mana = writable(50);
    const strength = writable(10);
    const agility = writable(10);
    const intelligence = writable(10);
    const charisma = writable(10);
    const luck = writable(10);
    const money = writable(1000);
    const fightplayerHuman = createfightPlayer();
    const fightplayerComputer = createfightPlayer();
    const fightcurrentTurn = writable('human'); // 'human' or 'computer'

    function createfightPlayer() {
        return writable({
            fighthealth: 100,
            fightstamina: 100,
            fightisBlocking: false,
            fightcooldowns: {
                attack: 0,
                specialAttack: 0,
            },
        });
    }

    const inventory$1 = writable([
        // Sample inventory items
        { type: "weapon", name: "Sword", description: "A sharp blade." },
        { type: "armor", name: "Shield", description: "Protects against attacks." },
        { type: "consumable", name: "Health Potion", description: "Restores health." },
        // Add more items as needed
    ]);

    const skills$1 = writable([
        // Sample skills
        { branch: "Combat", name: "Basic Attack", learned: false },
        { branch: "Magic", name: "Fireball", learned: false },
        { branch: "Stealth", name: "Sneak", learned: false },
        // Add more skills as needed
    ]);

    const objectives = writable([
        // Sample objectives
        { id: "Seperate", name: "Visit Mountain Peak", complete: false },
        { id: "Mission 1", name: "Intercept The Courier (Search the Locations)", complete: false },
        { id: "Mission 1", name: "Deliver the package to Market Stall", complete: false },
        // Add more objectives as needed
    ]);

    const targets = writable([
        { name: "Target 1", x: 50, y: 50, collisionType: "alert", collisiontext: "First Test"},
        { name: "Target 2", x: 100, y: 100, collisionType: "", collisiontext: ""},
        { name: "Entrance", x: 995, y: 660, collisionType: "modal", modalConfig: {
            title: "Entrance",
            content: "You've reached the Entrance. What's your next step?",
            actions: [
                {
                    label: "Ask for guidance on next move",
                    action: "askforDirections"
                },
                {
                    label: "Buy an Axe",
                    action: "buyAxeAlert"
                },
                // ... more actions if necessary
            ]},
        },
        { name: "Market Stall", x: 200, y: 300, collisionType: "", collisiontext: "" },   // A market stall in the bustling market area.
        { name: "Inn Entrance", x: 400, y: 450, collisionType: "", collisiontext: "" },   // The entrance to the inn for rest or information.
        { name: "Town Hall", x: 600, y: 350, collisionType: "", collisiontext: "" },      // The entrance to the town hall for quests.
        { name: "Fountain", x: 500, y: 500, collisionType: "", collisiontext: "" },       // A fountain in the town square as a meeting point.
        { name: "Bridge", x: 1100, y: 700, collisionType: "", collisiontext: "" },        // A bridge in the mystical forest area.
        { name: "Waterfall", x: 1300, y: 800, collisionType: "", collisiontext: "" },     // A waterfall that could hide secrets or treasures.
        { name: "Mountain Peak", x: 1500, y: 100, collisionType: "", collisiontext: "" },
    ]);

    function addInventoryItem(item) {
        inventory$1.update(items => {
            return [...items, item];
        });
    }

    // actions.js

    const themeActions = { //Editing this schema affects the change theme function in MovingDotSpace and MovingDotModal handleitemclick and the default theme in gamethemeConfig and the configuration manager in theme manager
        'Default': {
            buyAxeAlert() {
                money.update(h => h - 10 > 0 ? h - 10 : 0); // Decreases money but never below 0
                const newItem = {type: "weapon", name: "Axe", description: "A heavy, sharp axe."};
                addInventoryItem(newItem);  
            },
            askforDirections() {
                alert("Stranger: Go back to the fountain");
            }
        },
        'Space Odyssey': {
            refuelShip() {
                // Logic to refuel the ship
            },
            tradeGoods() {
                // Logic to trade goods
            },
            // ... add more space-specific actions
        },
        'Medieval Fantasy': {
            knightalert() {
                alert("The armourer said he went to see the mini waterfall for some relaxtion");
            },
            buyAxeAlert() {
                money.update(h => h - 10 > 0 ? h - 10 : 0); // Decreases money but never below 0
                const newItem = {type: "weapon", name: "Axe", description: "A heavy, sharp axe."};
                addInventoryItem(newItem);  
            },
            askforDirections() {
                alert("Stranger: Go back to the fountain");
            },
            defendCastle() {
                // Logic to defend the castle
            },
            slayDragon() {
                // Logic to slay the dragon
            },
            // ... add more medieval-specific actions
        },
        'Cyberpunk': {
            hackSystem() {
                // Logic to hack a system
                alert("it worked");
            },
            navigateNeonStreets() {
                // Logic for navigating neon streets
            },
            // ... add more cyberpunk-specific actions
        },
        // ... other themes with their specific actions
        'Fantasy Adventure': {
            findBookOfEldrak() {
                const newItem = {type: "book", name: "Book of Eldrak", description: "An ancient tome containing half of a map to the Artefact of Vorin."};
                addInventoryItem(newItem);
                alert("You have found the Book of Eldrak hidden within the ancient library.");
            },
            acquirePeculiarAmulet() {
                money.update(h => h - 50 > 0 ? h - 50 : 0); // Assumes the amulet costs some currency
                const newItem = {type: "amulet", name: "Peculiar Amulet", description: "Reveals unseen paths and protects against dark magic."};
                addInventoryItem(newItem);
                alert("The peculiar amulet is now yours. It feels warm to the touch, humming with hidden power.");
            },
            seekGuidanceFromElara() {
                alert("Elara: The amulet and book you possess are keys to unlocking the Artefact's resting place. Trust in the light, even when surrounded by shadow.");
            },
            choosePathInWhisperingWoods() {
                const choice = confirm("Will you follow the hidden path revealed by the amulet, or tread the well-worn trail?");
                if (choice) {
                    alert("You chose the hidden path, where shadows dance and the air whispers secrets.");
                } else {
                    alert("You chose the well-worn trail, where the woods seem less foreboding, yet eyes watch from the darkness.");
                }
            },
            confrontTheKeeper() {
                const fightOrTalk = confirm("A shadowy figure blocks your path. Will you fight or attempt to communicate?");
                if (fightOrTalk) {
                    initiateCombat("Shadowy Figure");
                } else {
                    alert("Your words pierce the silence, and the figure pauses, considering your presence.");
                }
            },
            useArtefactWisely() {
                const decision = confirm("With the Artefact of Vorin in hand, will you use its power to protect Eldoria or seek to uncover its deeper secrets?");
                if (decision) {
                    alert("You decide to protect Eldoria, using the Artefact to ward off shadows and bring peace.");
                } else {
                    alert("You delve into the Artefact's secrets, seeking knowledge and truths long forgotten.");
                }
            },
            approachAncientOak() {
                if (objectives["LeaveEldoria"].complete === "true") {
                    alert("The Ancient Oak stands before you, its presence both imposing and inviting.");
                    intelligence.update(h => h + 10 > 100 ? h + 10 : 0); // Decreases money but never below 0
                    alert("Your wisdom increases as the forest spirit imparts its knowledge.");
                } else {
                    alert("You feel drawn to the Ancient Oak, but something tells you it's not yet time.");
                }
            },
            
            acquireMagicalAcorn() {
                const newItem = {type: "artifact", name: "Magical Acorn", description: "A gift from the forest spirit, promising future aid."};
                addInventoryItem(newItem);
                alert("The forest spirit bestows upon you a Magical Acorn.");
            },
            
            exploreCrystalClearing() {
                if (skills["Ancient Lore"].learned) {
                    alert("The Crystal Clearing reveals visions of the future, guiding your path.");
                } else {
                    alert("The visions in the Crystal Clearing are cryptic, hinting at knowledge you have yet to acquire.");
                }
            },
            
            discoverShrineRelic() {
                const newItem = {type: "relic", name: "Shrine Relic", description: "A powerful artifact that enhances magical abilities, found in the Ruined Shrine."};
                addInventoryItem(newItem);
                alert("You've found a Shrine Relic among the ancient ruins.");
                learnSkill("Ancient Lore");
            },
            
            navigateEchoingCaves() {
                if (skills["Stealth Movement"].learned) {
                    const newItem = {type: "record", name: "Echoing Cave Echoes", description: "A recording of whispers from the Echoing Caves, revealing secrets and hidden paths."};
                    addInventoryItem(newItem);
                    alert("Using your stealth, you navigate the caves and capture their whispers.");
                } else {
                    alert("The caves are treacherous without the aid of stealth. You retreat, vowing to return.");
                }
            },
            
            converseWithGraveyardSpirits() {
                if (skills["Negotiation"].learned) {
                    increaseStats("endurance");
                    increaseStats("intelligence");
                    alert("Your words resonate with the spirits, granting you their blessing.");
                } else {
                    alert("The spirits demand a tribute of words you do not yet possess.");
                }
            },
            
            masterArtifacts() {
                if (objectives["UncoverForgottenGraveyard"].complete && inventory.some(item => item.type === "relic" || item.type === "artifact")) {
                    learnSkill("Artifact Mastery");
                    alert("With the relics and artifacts in your possession, you gain mastery over their ancient powers.");
                } else {
                    alert("You ponder the artifacts you've collected, feeling the weight of their history and the potential of their power.");
                }
            },        
        },
    };

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

    const { console: console_1$6 } = globals;
    const file$e = "src\\MovingDotSpaceSimpleModal.svelte";

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

    // (31:0) {#if isOpen}
    function create_if_block$7(ctx) {
    	let div3;
    	let div2;
    	let div0;
    	let h2;
    	let t0;
    	let t1;
    	let button;
    	let t3;
    	let div1;
    	let t4;
    	let t5;
    	let ul;
    	let mounted;
    	let dispose;
    	let each_value = /*items*/ ctx[3];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			div3 = element("div");
    			div2 = element("div");
    			div0 = element("div");
    			h2 = element("h2");
    			t0 = text(/*title*/ ctx[1]);
    			t1 = space();
    			button = element("button");
    			button.textContent = "×";
    			t3 = space();
    			div1 = element("div");
    			t4 = text(/*content*/ ctx[2]);
    			t5 = space();
    			ul = element("ul");

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

    			add_location(h2, file$e, 34, 8, 1031);
    			add_location(button, file$e, 35, 8, 1057);
    			attr_dev(div0, "class", "modal-header svelte-m51ous");
    			add_location(div0, file$e, 33, 6, 995);
    			attr_dev(ul, "class", "modal-items");
    			add_location(ul, file$e, 39, 8, 1181);
    			attr_dev(div1, "class", "modal-content svelte-m51ous");
    			add_location(div1, file$e, 37, 6, 1125);
    			attr_dev(div2, "class", "modal svelte-m51ous");
    			add_location(div2, file$e, 32, 4, 968);
    			attr_dev(div3, "class", "modal-overlay svelte-m51ous");
    			add_location(div3, file$e, 31, 2, 935);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div3, anchor);
    			append_dev(div3, div2);
    			append_dev(div2, div0);
    			append_dev(div0, h2);
    			append_dev(h2, t0);
    			append_dev(div0, t1);
    			append_dev(div0, button);
    			append_dev(div2, t3);
    			append_dev(div2, div1);
    			append_dev(div1, t4);
    			append_dev(div1, t5);
    			append_dev(div1, ul);

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

    			if (!mounted) {
    				dispose = listen_dev(button, "click", /*closeModal*/ ctx[4], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*title*/ 2) set_data_dev(t0, /*title*/ ctx[1]);
    			if (dirty & /*content*/ 4) set_data_dev(t4, /*content*/ ctx[2]);

    			if (dirty & /*handleItemClick, items*/ 40) {
    				each_value = /*items*/ ctx[3];
    				validate_each_argument(each_value);
    				let i;

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

    					if (each_blocks[i]) {
    						each_blocks[i].p(child_ctx, dirty);
    					} else {
    						each_blocks[i] = create_each_block$9(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;
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div3);
    			destroy_each(each_blocks, detaching);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$7.name,
    		type: "if",
    		source: "(31:0) {#if isOpen}",
    		ctx
    	});

    	return block;
    }

    // (41:10) {#each items as item}
    function create_each_block$9(ctx) {
    	let button;
    	let t_value = /*item*/ ctx[9].label + "";
    	let t;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[8](/*item*/ ctx[9]);
    	}

    	const block = {
    		c: function create() {
    			button = element("button");
    			t = text(t_value);
    			add_location(button, file$e, 41, 12, 1252);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*items*/ 8 && t_value !== (t_value = /*item*/ ctx[9].label + "")) set_data_dev(t, t_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$9.name,
    		type: "each",
    		source: "(41:10) {#each items as item}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$e(ctx) {
    	let if_block_anchor;
    	let if_block = /*isOpen*/ ctx[0] && create_if_block$7(ctx);

    	const block = {
    		c: function create() {
    			if (if_block) if_block.c();
    			if_block_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_block) if_block.m(target, anchor);
    			insert_dev(target, if_block_anchor, anchor);
    		},
    		p: function update(ctx, [dirty]) {
    			if (/*isOpen*/ ctx[0]) {
    				if (if_block) {
    					if_block.p(ctx, dirty);
    				} else {
    					if_block = create_if_block$7(ctx);
    					if_block.c();
    					if_block.m(if_block_anchor.parentNode, if_block_anchor);
    				}
    			} else if (if_block) {
    				if_block.d(1);
    				if_block = null;
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (if_block) if_block.d(detaching);
    			if (detaching) detach_dev(if_block_anchor);
    		}
    	};

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

    	return block;
    }

    function instance$e($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceSimpleModal', slots, []);
    	let { isOpen = false } = $$props;
    	let { title = '' } = $$props;
    	let { content = '' } = $$props;
    	let { items = [] } = $$props;
    	let { onClose } = $$props;
    	let { currentTheme = '' } = $$props;

    	function closeModal() {
    		if (onClose) {
    			onClose();
    		}
    	}

    	function handleItemClick(item) {
    		// You can define what happens when an item is clicked, e.g., close modal, trigger an event, etc.
    		console.log("Item clicked:", item);

    		closeModal();

    		if (themeActions[currentTheme] && themeActions[currentTheme][item.action]) {
    			themeActions[currentTheme][item.action]();
    		} else {
    			console.error(`Action "${item.action}" not found for theme "${currentTheme}".`);
    		}
    	}

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

    	const writable_props = ['isOpen', 'title', 'content', 'items', 'onClose', 'currentTheme'];

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

    	const click_handler = item => handleItemClick(item);

    	$$self.$$set = $$props => {
    		if ('isOpen' in $$props) $$invalidate(0, isOpen = $$props.isOpen);
    		if ('title' in $$props) $$invalidate(1, title = $$props.title);
    		if ('content' in $$props) $$invalidate(2, content = $$props.content);
    		if ('items' in $$props) $$invalidate(3, items = $$props.items);
    		if ('onClose' in $$props) $$invalidate(6, onClose = $$props.onClose);
    		if ('currentTheme' in $$props) $$invalidate(7, currentTheme = $$props.currentTheme);
    	};

    	$$self.$capture_state = () => ({
    		isOpen,
    		title,
    		content,
    		items,
    		onClose,
    		currentTheme,
    		themeActions,
    		closeModal,
    		handleItemClick
    	});

    	$$self.$inject_state = $$props => {
    		if ('isOpen' in $$props) $$invalidate(0, isOpen = $$props.isOpen);
    		if ('title' in $$props) $$invalidate(1, title = $$props.title);
    		if ('content' in $$props) $$invalidate(2, content = $$props.content);
    		if ('items' in $$props) $$invalidate(3, items = $$props.items);
    		if ('onClose' in $$props) $$invalidate(6, onClose = $$props.onClose);
    		if ('currentTheme' in $$props) $$invalidate(7, currentTheme = $$props.currentTheme);
    	};

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

    	return [
    		isOpen,
    		title,
    		content,
    		items,
    		closeModal,
    		handleItemClick,
    		onClose,
    		currentTheme,
    		click_handler
    	];
    }

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

    		init(this, options, instance$e, create_fragment$e, safe_not_equal, {
    			isOpen: 0,
    			title: 1,
    			content: 2,
    			items: 3,
    			onClose: 6,
    			currentTheme: 7
    		});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    const file$d = "src\\MovingDotStatDisplay.svelte";

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

    function get_each_context_1$3(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[16] = list[i];
    	return child_ctx;
    }

    function get_each_context_2(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[16] = list[i];
    	return child_ctx;
    }

    // (22:6) {#each $objectives as item}
    function create_each_block_2(ctx) {
    	let li;
    	let t0_value = /*item*/ ctx[16].id + "";
    	let t0;
    	let t1;
    	let t2_value = /*item*/ ctx[16].name + "";
    	let t2;
    	let t3;
    	let t4_value = (/*item*/ ctx[16].complete ? '(Completed)' : '') + "";
    	let t4;
    	let li_class_value;

    	const block = {
    		c: function create() {
    			li = element("li");
    			t0 = text(t0_value);
    			t1 = text(": ");
    			t2 = text(t2_value);
    			t3 = space();
    			t4 = text(t4_value);
    			attr_dev(li, "class", li_class_value = "" + (null_to_empty(/*item*/ ctx[16].complete ? 'completedobjetive' : '') + " svelte-w7krpq"));
    			add_location(li, file$d, 23, 8, 762);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, li, anchor);
    			append_dev(li, t0);
    			append_dev(li, t1);
    			append_dev(li, t2);
    			append_dev(li, t3);
    			append_dev(li, t4);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*$objectives*/ 256 && t0_value !== (t0_value = /*item*/ ctx[16].id + "")) set_data_dev(t0, t0_value);
    			if (dirty & /*$objectives*/ 256 && t2_value !== (t2_value = /*item*/ ctx[16].name + "")) set_data_dev(t2, t2_value);
    			if (dirty & /*$objectives*/ 256 && t4_value !== (t4_value = (/*item*/ ctx[16].complete ? '(Completed)' : '') + "")) set_data_dev(t4, t4_value);

    			if (dirty & /*$objectives*/ 256 && li_class_value !== (li_class_value = "" + (null_to_empty(/*item*/ ctx[16].complete ? 'completedobjetive' : '') + " svelte-w7krpq"))) {
    				attr_dev(li, "class", li_class_value);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(li);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block_2.name,
    		type: "each",
    		source: "(22:6) {#each $objectives as item}",
    		ctx
    	});

    	return block;
    }

    // (33:8) {#each $inventory as item}
    function create_each_block_1$3(ctx) {
    	let button;
    	let t0_value = /*item*/ ctx[16].name + "";
    	let t0;
    	let t1;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[12](/*item*/ ctx[16]);
    	}

    	const block = {
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = space();
    			attr_dev(button, "class", "skill");
    			add_location(button, file$d, 33, 10, 1064);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			append_dev(button, t1);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*$inventory*/ 512 && t0_value !== (t0_value = /*item*/ ctx[16].name + "")) set_data_dev(t0, t0_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block_1$3.name,
    		type: "each",
    		source: "(33:8) {#each $inventory as item}",
    		ctx
    	});

    	return block;
    }

    // (46:8) {#each $skills as skill}
    function create_each_block$8(ctx) {
    	let li;
    	let t0_value = /*skill*/ ctx[13].name + "";
    	let t0;
    	let t1;
    	let t2_value = /*skill*/ ctx[13].branch + "";
    	let t2;
    	let t3;
    	let t4_value = (/*skill*/ ctx[13].learned ? 'Yes' : 'No') + "";
    	let t4;

    	const block = {
    		c: function create() {
    			li = element("li");
    			t0 = text(t0_value);
    			t1 = text(": ");
    			t2 = text(t2_value);
    			t3 = text(" - Learned: ");
    			t4 = text(t4_value);
    			add_location(li, file$d, 46, 10, 1413);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, li, anchor);
    			append_dev(li, t0);
    			append_dev(li, t1);
    			append_dev(li, t2);
    			append_dev(li, t3);
    			append_dev(li, t4);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*$skills*/ 1024 && t0_value !== (t0_value = /*skill*/ ctx[13].name + "")) set_data_dev(t0, t0_value);
    			if (dirty & /*$skills*/ 1024 && t2_value !== (t2_value = /*skill*/ ctx[13].branch + "")) set_data_dev(t2, t2_value);
    			if (dirty & /*$skills*/ 1024 && t4_value !== (t4_value = (/*skill*/ ctx[13].learned ? 'Yes' : 'No') + "")) set_data_dev(t4, t4_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(li);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$8.name,
    		type: "each",
    		source: "(46:8) {#each $skills as skill}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$d(ctx) {
    	let div10;
    	let div4;
    	let div3;
    	let span;
    	let b;
    	let t1;
    	let div0;
    	let t2;
    	let t3;
    	let t4;
    	let t5;
    	let t6;
    	let t7;
    	let t8;
    	let t9;
    	let t10;
    	let t11;
    	let t12;
    	let t13;
    	let t14;
    	let div1;
    	let t15;
    	let t16;
    	let t17;
    	let div2;
    	let t18;
    	let t19;
    	let t20;
    	let div5;
    	let ul0;
    	let t21;
    	let div7;
    	let div6;
    	let h20;
    	let t23;
    	let ul1;
    	let t24;
    	let div9;
    	let div8;
    	let h21;
    	let t26;
    	let ul2;
    	let each_value_2 = /*$objectives*/ ctx[8];
    	validate_each_argument(each_value_2);
    	let each_blocks_2 = [];

    	for (let i = 0; i < each_value_2.length; i += 1) {
    		each_blocks_2[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i));
    	}

    	let each_value_1 = /*$inventory*/ ctx[9];
    	validate_each_argument(each_value_1);
    	let each_blocks_1 = [];

    	for (let i = 0; i < each_value_1.length; i += 1) {
    		each_blocks_1[i] = create_each_block_1$3(get_each_context_1$3(ctx, each_value_1, i));
    	}

    	let each_value = /*$skills*/ ctx[10];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			div10 = element("div");
    			div4 = element("div");
    			div3 = element("div");
    			span = element("span");
    			b = element("b");
    			b.textContent = "Player Stats";
    			t1 = space();
    			div0 = element("div");
    			t2 = text("Health: ");
    			t3 = text(/*$health*/ ctx[0]);
    			t4 = text(" Mana: ");
    			t5 = text(/*$mana*/ ctx[1]);
    			t6 = text(" Strength: ");
    			t7 = text(/*$strength*/ ctx[2]);
    			t8 = text(" Agility: ");
    			t9 = text(/*$agility*/ ctx[3]);
    			t10 = text(" Intelligence: ");
    			t11 = text(/*$intelligence*/ ctx[4]);
    			t12 = text(" Charisma: ");
    			t13 = text(/*$charisma*/ ctx[5]);
    			t14 = space();
    			div1 = element("div");
    			t15 = text("Luck: ");
    			t16 = text(/*$luck*/ ctx[6]);
    			t17 = space();
    			div2 = element("div");
    			t18 = text("Money: ");
    			t19 = text(/*$money*/ ctx[7]);
    			t20 = space();
    			div5 = element("div");
    			ul0 = element("ul");

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

    			t21 = space();
    			div7 = element("div");
    			div6 = element("div");
    			h20 = element("h2");
    			h20.textContent = "Inventory";
    			t23 = space();
    			ul1 = element("ul");

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

    			t24 = space();
    			div9 = element("div");
    			div8 = element("div");
    			h21 = element("h2");
    			h21.textContent = "Skill Tree / Abilities";
    			t26 = space();
    			ul2 = element("ul");

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

    			add_location(b, file$d, 12, 13, 363);
    			add_location(span, file$d, 12, 6, 356);
    			add_location(div0, file$d, 13, 6, 399);
    			add_location(div1, file$d, 14, 6, 543);
    			add_location(div2, file$d, 15, 6, 575);
    			attr_dev(div3, "class", "stats svelte-w7krpq");
    			add_location(div3, file$d, 11, 4, 329);
    			attr_dev(div4, "class", "grid-statsitem svelte-w7krpq");
    			add_location(div4, file$d, 10, 2, 295);
    			add_location(ul0, file$d, 20, 4, 663);
    			attr_dev(div5, "class", "grid-statsitem svelte-w7krpq");
    			add_location(div5, file$d, 19, 2, 629);
    			add_location(h20, file$d, 30, 6, 986);
    			add_location(ul1, file$d, 31, 6, 1012);
    			attr_dev(div6, "class", "inventory svelte-w7krpq");
    			add_location(div6, file$d, 29, 4, 955);
    			attr_dev(div7, "class", "grid-statsitem svelte-w7krpq");
    			add_location(div7, file$d, 28, 2, 921);
    			add_location(h21, file$d, 43, 6, 1324);
    			add_location(ul2, file$d, 44, 6, 1363);
    			attr_dev(div8, "class", "skill-tree svelte-w7krpq");
    			add_location(div8, file$d, 42, 4, 1292);
    			attr_dev(div9, "class", "grid-statsitem svelte-w7krpq");
    			add_location(div9, file$d, 41, 2, 1258);
    			attr_dev(div10, "class", "grid-statsContainer svelte-w7krpq");
    			add_location(div10, file$d, 9, 0, 258);
    		},
    		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, div10, anchor);
    			append_dev(div10, div4);
    			append_dev(div4, div3);
    			append_dev(div3, span);
    			append_dev(span, b);
    			append_dev(div3, t1);
    			append_dev(div3, div0);
    			append_dev(div0, t2);
    			append_dev(div0, t3);
    			append_dev(div0, t4);
    			append_dev(div0, t5);
    			append_dev(div0, t6);
    			append_dev(div0, t7);
    			append_dev(div0, t8);
    			append_dev(div0, t9);
    			append_dev(div0, t10);
    			append_dev(div0, t11);
    			append_dev(div0, t12);
    			append_dev(div0, t13);
    			append_dev(div3, t14);
    			append_dev(div3, div1);
    			append_dev(div1, t15);
    			append_dev(div1, t16);
    			append_dev(div3, t17);
    			append_dev(div3, div2);
    			append_dev(div2, t18);
    			append_dev(div2, t19);
    			append_dev(div10, t20);
    			append_dev(div10, div5);
    			append_dev(div5, ul0);

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

    			append_dev(div10, t21);
    			append_dev(div10, div7);
    			append_dev(div7, div6);
    			append_dev(div6, h20);
    			append_dev(div6, t23);
    			append_dev(div6, ul1);

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

    			append_dev(div10, t24);
    			append_dev(div10, div9);
    			append_dev(div9, div8);
    			append_dev(div8, h21);
    			append_dev(div8, t26);
    			append_dev(div8, ul2);

    			for (let i = 0; i < each_blocks.length; i += 1) {
    				if (each_blocks[i]) {
    					each_blocks[i].m(ul2, null);
    				}
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*$health*/ 1) set_data_dev(t3, /*$health*/ ctx[0]);
    			if (dirty & /*$mana*/ 2) set_data_dev(t5, /*$mana*/ ctx[1]);
    			if (dirty & /*$strength*/ 4) set_data_dev(t7, /*$strength*/ ctx[2]);
    			if (dirty & /*$agility*/ 8) set_data_dev(t9, /*$agility*/ ctx[3]);
    			if (dirty & /*$intelligence*/ 16) set_data_dev(t11, /*$intelligence*/ ctx[4]);
    			if (dirty & /*$charisma*/ 32) set_data_dev(t13, /*$charisma*/ ctx[5]);
    			if (dirty & /*$luck*/ 64) set_data_dev(t16, /*$luck*/ ctx[6]);
    			if (dirty & /*$money*/ 128) set_data_dev(t19, /*$money*/ ctx[7]);

    			if (dirty & /*$objectives*/ 256) {
    				each_value_2 = /*$objectives*/ ctx[8];
    				validate_each_argument(each_value_2);
    				let i;

    				for (i = 0; i < each_value_2.length; i += 1) {
    					const child_ctx = get_each_context_2(ctx, each_value_2, i);

    					if (each_blocks_2[i]) {
    						each_blocks_2[i].p(child_ctx, dirty);
    					} else {
    						each_blocks_2[i] = create_each_block_2(child_ctx);
    						each_blocks_2[i].c();
    						each_blocks_2[i].m(ul0, null);
    					}
    				}

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

    				each_blocks_2.length = each_value_2.length;
    			}

    			if (dirty & /*toggleSkill, alert, $inventory*/ 2560) {
    				each_value_1 = /*$inventory*/ ctx[9];
    				validate_each_argument(each_value_1);
    				let i;

    				for (i = 0; i < each_value_1.length; i += 1) {
    					const child_ctx = get_each_context_1$3(ctx, each_value_1, i);

    					if (each_blocks_1[i]) {
    						each_blocks_1[i].p(child_ctx, dirty);
    					} else {
    						each_blocks_1[i] = create_each_block_1$3(child_ctx);
    						each_blocks_1[i].c();
    						each_blocks_1[i].m(ul1, null);
    					}
    				}

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

    				each_blocks_1.length = each_value_1.length;
    			}

    			if (dirty & /*$skills*/ 1024) {
    				each_value = /*$skills*/ ctx[10];
    				validate_each_argument(each_value);
    				let i;

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

    					if (each_blocks[i]) {
    						each_blocks[i].p(child_ctx, dirty);
    					} else {
    						each_blocks[i] = create_each_block$8(child_ctx);
    						each_blocks[i].c();
    						each_blocks[i].m(ul2, 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(div10);
    			destroy_each(each_blocks_2, detaching);
    			destroy_each(each_blocks_1, detaching);
    			destroy_each(each_blocks, detaching);
    		}
    	};

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

    	return block;
    }

    function instance$d($$self, $$props, $$invalidate) {
    	let $health;
    	let $mana;
    	let $strength;
    	let $agility;
    	let $intelligence;
    	let $charisma;
    	let $luck;
    	let $money;
    	let $objectives;
    	let $inventory;
    	let $skills;
    	validate_store(health, 'health');
    	component_subscribe($$self, health, $$value => $$invalidate(0, $health = $$value));
    	validate_store(mana, 'mana');
    	component_subscribe($$self, mana, $$value => $$invalidate(1, $mana = $$value));
    	validate_store(strength, 'strength');
    	component_subscribe($$self, strength, $$value => $$invalidate(2, $strength = $$value));
    	validate_store(agility, 'agility');
    	component_subscribe($$self, agility, $$value => $$invalidate(3, $agility = $$value));
    	validate_store(intelligence, 'intelligence');
    	component_subscribe($$self, intelligence, $$value => $$invalidate(4, $intelligence = $$value));
    	validate_store(charisma, 'charisma');
    	component_subscribe($$self, charisma, $$value => $$invalidate(5, $charisma = $$value));
    	validate_store(luck, 'luck');
    	component_subscribe($$self, luck, $$value => $$invalidate(6, $luck = $$value));
    	validate_store(money, 'money');
    	component_subscribe($$self, money, $$value => $$invalidate(7, $money = $$value));
    	validate_store(objectives, 'objectives');
    	component_subscribe($$self, objectives, $$value => $$invalidate(8, $objectives = $$value));
    	validate_store(inventory$1, 'inventory');
    	component_subscribe($$self, inventory$1, $$value => $$invalidate(9, $inventory = $$value));
    	validate_store(skills$1, 'skills');
    	component_subscribe($$self, skills$1, $$value => $$invalidate(10, $skills = $$value));
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotStatDisplay', slots, []);

    	function toggleSkill(skill) {
    		skill.learned = !skill.learned;
    		skills$1.update(n => n);
    	}

    	const writable_props = [];

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

    	const click_handler = item => toggleSkill(alert(item.description, item.type));

    	$$self.$capture_state = () => ({
    		health,
    		mana,
    		strength,
    		agility,
    		intelligence,
    		charisma,
    		luck,
    		money,
    		inventory: inventory$1,
    		skills: skills$1,
    		objectives,
    		toggleSkill,
    		$health,
    		$mana,
    		$strength,
    		$agility,
    		$intelligence,
    		$charisma,
    		$luck,
    		$money,
    		$objectives,
    		$inventory,
    		$skills
    	});

    	return [
    		$health,
    		$mana,
    		$strength,
    		$agility,
    		$intelligence,
    		$charisma,
    		$luck,
    		$money,
    		$objectives,
    		$inventory,
    		$skills,
    		toggleSkill,
    		click_handler
    	];
    }

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

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

    /* src\MovingDotSpaceThemeManager.svelte generated by Svelte v3.59.2 */
    const file$c = "src\\MovingDotSpaceThemeManager.svelte";

    function create_fragment$c(ctx) {
    	let hr;
    	let t0;
    	let form;
    	let input0;
    	let t1;
    	let input1;
    	let t2;
    	let input2;
    	let t3;
    	let button0;
    	let t5;
    	let button1;
    	let t7;
    	let input3;
    	let t8;
    	let label;
    	let t10;
    	let div3;
    	let div0;
    	let t11;
    	let br0;
    	let t12;
    	let br1;
    	let t13;
    	let t14;
    	let div1;
    	let t15;
    	let t16;
    	let br2;
    	let t17;
    	let br3;
    	let br4;
    	let t18;
    	let t19;
    	let div2;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			hr = element("hr");
    			t0 = text("\r\nIncomplete Custom game setting assistant\r\n\r\n");
    			form = element("form");
    			input0 = element("input");
    			t1 = space();
    			input1 = element("input");
    			t2 = space();
    			input2 = element("input");
    			t3 = space();
    			button0 = element("button");
    			button0.textContent = "Add Item";
    			t5 = space();
    			button1 = element("button");
    			button1.textContent = "Download Configuration";
    			t7 = space();
    			input3 = element("input");
    			t8 = space();
    			label = element("label");
    			label.textContent = "Upload Configuration";
    			t10 = space();
    			div3 = element("div");
    			div0 = element("div");
    			t11 = text("Website = multilingual support in chrome ");
    			br0 = element("br");
    			t12 = text("\r\n        The mechanics here are location based so story should be location based ");
    			br1 = element("br");
    			t13 = text("\r\n        Simultaneous relationships between multiple items = complexity - eg. player location and objectives");
    			t14 = space();
    			div1 = element("div");
    			t15 = text(/*ChangedContentPlaceholder*/ ctx[0]);
    			t16 = space();
    			br2 = element("br");
    			t17 = text("\r\n        Most stories for games are about a character that lacks something to beat their problems and the 90% inbetween the begining and the end is acquiring\r\n        ");
    			br3 = element("br");
    			br4 = element("br");
    			t18 = text("\r\n        Example - Write a story where the main event are in this order: gosomewhere getsomething makeobservation getsomething talktosomeone makeobservation getsomething talktosomeone gosomewhere fight talktosomeone fight fight talktosomeone talktosomeone talktosomeone gosomewhere talktosomeone");
    			t19 = space();
    			div2 = element("div");
    			div2.textContent = "lets write the story to fit this order - stats location stats inventory stats location location skills inventory stats inventory skills skills skills stats stats skills";
    			add_location(hr, file$c, 66, 0, 2505);
    			attr_dev(input0, "type", "text");
    			attr_dev(input0, "placeholder", "Type (weapon, armor, consumable)");
    			add_location(input0, file$c, 70, 4, 2641);
    			attr_dev(input1, "type", "text");
    			attr_dev(input1, "placeholder", "Name");
    			add_location(input1, file$c, 71, 4, 2741);
    			attr_dev(input2, "type", "text");
    			attr_dev(input2, "placeholder", "Description");
    			add_location(input2, file$c, 72, 4, 2813);
    			attr_dev(button0, "type", "submit");
    			add_location(button0, file$c, 73, 4, 2899);
    			add_location(form, file$c, 69, 0, 2594);
    			add_location(button1, file$c, 79, 0, 3078);
    			attr_dev(input3, "type", "file");
    			attr_dev(input3, "id", "fileInput");
    			set_style(input3, "display", "none");
    			add_location(input3, file$c, 80, 0, 3152);
    			attr_dev(label, "for", "fileInput");
    			attr_dev(label, "class", "btn");
    			add_location(label, file$c, 81, 0, 3241);
    			add_location(br0, file$c, 85, 49, 3407);
    			add_location(br1, file$c, 86, 80, 3493);
    			add_location(div0, file$c, 84, 4, 3351);
    			add_location(br2, file$c, 91, 38, 3671);
    			add_location(br3, file$c, 93, 8, 3843);
    			add_location(br4, file$c, 93, 12, 3847);
    			add_location(div1, file$c, 90, 4, 3626);
    			add_location(div2, file$c, 97, 4, 4168);
    			attr_dev(div3, "class", "grid-themegridContainer svelte-a95t5t");
    			add_location(div3, file$c, 83, 0, 3308);
    		},
    		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, hr, anchor);
    			insert_dev(target, t0, anchor);
    			insert_dev(target, form, anchor);
    			append_dev(form, input0);
    			set_input_value(input0, /*newItem*/ ctx[1].type);
    			append_dev(form, t1);
    			append_dev(form, input1);
    			set_input_value(input1, /*newItem*/ ctx[1].name);
    			append_dev(form, t2);
    			append_dev(form, input2);
    			set_input_value(input2, /*newItem*/ ctx[1].description);
    			append_dev(form, t3);
    			append_dev(form, button0);
    			insert_dev(target, t5, anchor);
    			insert_dev(target, button1, anchor);
    			insert_dev(target, t7, anchor);
    			insert_dev(target, input3, anchor);
    			insert_dev(target, t8, anchor);
    			insert_dev(target, label, anchor);
    			insert_dev(target, t10, anchor);
    			insert_dev(target, div3, anchor);
    			append_dev(div3, div0);
    			append_dev(div0, t11);
    			append_dev(div0, br0);
    			append_dev(div0, t12);
    			append_dev(div0, br1);
    			append_dev(div0, t13);
    			append_dev(div3, t14);
    			append_dev(div3, div1);
    			append_dev(div1, t15);
    			append_dev(div1, t16);
    			append_dev(div1, br2);
    			append_dev(div1, t17);
    			append_dev(div1, br3);
    			append_dev(div1, br4);
    			append_dev(div1, t18);
    			append_dev(div3, t19);
    			append_dev(div3, div2);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input0, "input", /*input0_input_handler*/ ctx[5]),
    					listen_dev(input1, "input", /*input1_input_handler*/ ctx[6]),
    					listen_dev(input2, "input", /*input2_input_handler*/ ctx[7]),
    					listen_dev(form, "submit", prevent_default(/*addItem*/ ctx[2]), false, true, false, false),
    					listen_dev(button1, "click", /*downloadConfiguration*/ ctx[3], false, false, false, false),
    					listen_dev(input3, "change", /*handleFileUpload*/ ctx[4], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*newItem*/ 2 && input0.value !== /*newItem*/ ctx[1].type) {
    				set_input_value(input0, /*newItem*/ ctx[1].type);
    			}

    			if (dirty & /*newItem*/ 2 && input1.value !== /*newItem*/ ctx[1].name) {
    				set_input_value(input1, /*newItem*/ ctx[1].name);
    			}

    			if (dirty & /*newItem*/ 2 && input2.value !== /*newItem*/ ctx[1].description) {
    				set_input_value(input2, /*newItem*/ ctx[1].description);
    			}

    			if (dirty & /*ChangedContentPlaceholder*/ 1) set_data_dev(t15, /*ChangedContentPlaceholder*/ ctx[0]);
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(hr);
    			if (detaching) detach_dev(t0);
    			if (detaching) detach_dev(form);
    			if (detaching) detach_dev(t5);
    			if (detaching) detach_dev(button1);
    			if (detaching) detach_dev(t7);
    			if (detaching) detach_dev(input3);
    			if (detaching) detach_dev(t8);
    			if (detaching) detach_dev(label);
    			if (detaching) detach_dev(t10);
    			if (detaching) detach_dev(div3);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function instance$c($$self, $$props, $$invalidate) {
    	let $targets;
    	let $objectives;
    	let $skills;
    	let $inventory;
    	validate_store(targets, 'targets');
    	component_subscribe($$self, targets, $$value => $$invalidate(10, $targets = $$value));
    	validate_store(objectives, 'objectives');
    	component_subscribe($$self, objectives, $$value => $$invalidate(11, $objectives = $$value));
    	validate_store(skills$1, 'skills');
    	component_subscribe($$self, skills$1, $$value => $$invalidate(12, $skills = $$value));
    	validate_store(inventory$1, 'inventory');
    	component_subscribe($$self, inventory$1, $$value => $$invalidate(13, $inventory = $$value));
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceThemeManager', slots, []);
    	let { ChangedContentPlaceholder = "" } = $$props;
    	let newItem = { type: "", name: "", description: "" };
    	let newSkill = { branch: "", name: "", learned: false };
    	let newObjective = { branch: "", name: "", complete: false };

    	// ... similarly for targets
    	function addItem() {
    		inventory$1.update(items => [...items, newItem]);
    		$$invalidate(1, newItem = { type: "", name: "", description: "" }); // Reset form
    	}

    	function addSkill() {
    		skills$1.update(skills => [...skills, newSkill]);
    		newSkill = { branch: "", name: "", learned: false }; // Reset form
    	}

    	function addObjective() {
    		objectives.update(objectives => [...objectives, newObjective]);
    		newObjective = { branch: "", name: "", complete: false }; // Reset form
    	}

    	// ... similarly for targets
    	// Functions to save and load configurations to/from localStorage or a backend would also be defined here
    	// Function to download the current configuration as a JSON file
    	function downloadConfiguration() {
    		const gameConfig = {
    			inventory: $inventory,
    			skills: $skills,
    			objectives: $objectives,
    			targets: $targets
    		};

    		const blob = new Blob([JSON.stringify(gameConfig, null, 2)], { type: 'application/json' });
    		const href = URL.createObjectURL(blob);
    		const link = document.createElement('a');
    		link.href = href;
    		link.download = 'gameConfig.json';
    		document.body.appendChild(link);
    		link.click();
    		document.body.removeChild(link);
    	}

    	// Function to load configuration from an uploaded JSON file
    	function handleFileUpload(event) {
    		const file = event.target.files[0];

    		if (file) {
    			const reader = new FileReader();

    			reader.onload = e => {
    				const fileContent = e.target.result;
    				const { inventory: loadedInventory, skills: loadedSkills, objectives: loadedObjectives, targets: loadedTargets } = JSON.parse(fileContent);
    				inventory$1.set(loadedInventory);
    				skills$1.set(loadedSkills);
    				objectives.set(loadedObjectives);
    				targets.set(loadedTargets);
    				alert('Configuration loaded!');
    			};

    			reader.readAsText(file);
    		}
    	}

    	const writable_props = ['ChangedContentPlaceholder'];

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

    	function input0_input_handler() {
    		newItem.type = this.value;
    		$$invalidate(1, newItem);
    	}

    	function input1_input_handler() {
    		newItem.name = this.value;
    		$$invalidate(1, newItem);
    	}

    	function input2_input_handler() {
    		newItem.description = this.value;
    		$$invalidate(1, newItem);
    	}

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

    	$$self.$capture_state = () => ({
    		ChangedContentPlaceholder,
    		inventory: inventory$1,
    		skills: skills$1,
    		objectives,
    		targets,
    		newItem,
    		newSkill,
    		newObjective,
    		addItem,
    		addSkill,
    		addObjective,
    		downloadConfiguration,
    		handleFileUpload,
    		$targets,
    		$objectives,
    		$skills,
    		$inventory
    	});

    	$$self.$inject_state = $$props => {
    		if ('ChangedContentPlaceholder' in $$props) $$invalidate(0, ChangedContentPlaceholder = $$props.ChangedContentPlaceholder);
    		if ('newItem' in $$props) $$invalidate(1, newItem = $$props.newItem);
    		if ('newSkill' in $$props) newSkill = $$props.newSkill;
    		if ('newObjective' in $$props) newObjective = $$props.newObjective;
    	};

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

    	return [
    		ChangedContentPlaceholder,
    		newItem,
    		addItem,
    		downloadConfiguration,
    		handleFileUpload,
    		input0_input_handler,
    		input1_input_handler,
    		input2_input_handler
    	];
    }

    class MovingDotSpaceThemeManager extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$c, create_fragment$c, safe_not_equal, { ChangedContentPlaceholder: 0 });

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

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

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

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

    const file$b = "src\\MovingDotSpaceGameFight.svelte";

    // (88:8) {#if $fightcurrentTurn === 'human'}
    function create_if_block$6(ctx) {
    	let button0;
    	let t1;
    	let button1;
    	let t3;
    	let button2;
    	let mounted;
    	let dispose;

    	const block_1 = {
    		c: function create() {
    			button0 = element("button");
    			button0.textContent = "Attack";
    			t1 = space();
    			button1 = element("button");
    			button1.textContent = "Special Attack";
    			t3 = space();
    			button2 = element("button");
    			button2.textContent = "Block";
    			add_location(button0, file$b, 88, 12, 3623);
    			add_location(button1, file$b, 89, 12, 3730);
    			add_location(button2, file$b, 90, 12, 3856);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button0, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, button1, anchor);
    			insert_dev(target, t3, anchor);
    			insert_dev(target, button2, anchor);

    			if (!mounted) {
    				dispose = [
    					listen_dev(button0, "click", /*click_handler*/ ctx[5], false, false, false, false),
    					listen_dev(button1, "click", /*click_handler_1*/ ctx[6], false, false, false, false),
    					listen_dev(button2, "click", /*click_handler_2*/ ctx[7], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button0);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(button1);
    			if (detaching) detach_dev(t3);
    			if (detaching) detach_dev(button2);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block: block_1,
    		id: create_if_block$6.name,
    		type: "if",
    		source: "(88:8) {#if $fightcurrentTurn === 'human'}",
    		ctx
    	});

    	return block_1;
    }

    function create_fragment$b(ctx) {
    	let div4;
    	let div0;
    	let t0;
    	let br0;
    	let t1;
    	let t2_value = /*$fightplayerHuman*/ ctx[1].fighthealth + "";
    	let t2;
    	let t3;
    	let br1;
    	let t4;
    	let t5_value = /*$fightplayerHuman*/ ctx[1].fightstamina + "";
    	let t5;
    	let t6;
    	let br2;
    	let t7;

    	let t8_value = (/*$fightplayerHuman*/ ctx[1].fightisBlocking
    	? 'Blocking'
    	: '') + "";

    	let t8;
    	let t9;
    	let br3;
    	let t10;
    	let t11_value = /*$fightplayerHuman*/ ctx[1].fightcooldowns.attack + "";
    	let t11;
    	let t12;
    	let br4;
    	let t13;
    	let div2;
    	let div1;

    	let t14_value = (/*$fightcurrentTurn*/ ctx[0] === 'human'
    	? "Your turn"
    	: "Computer's turn") + "";

    	let t14;
    	let t15;
    	let t16;
    	let div3;
    	let t17;
    	let br5;
    	let t18;
    	let t19_value = /*$fightplayerComputer*/ ctx[2].fighthealth + "";
    	let t19;
    	let t20;
    	let br6;
    	let t21;
    	let t22_value = /*$fightplayerComputer*/ ctx[2].fightstamina + "";
    	let t22;
    	let t23;
    	let br7;
    	let t24;

    	let t25_value = (/*$fightplayerComputer*/ ctx[2].fightisBlocking
    	? 'Blocking'
    	: '') + "";

    	let t25;
    	let t26;
    	let br8;
    	let t27;
    	let t28_value = /*$fightplayerComputer*/ ctx[2].fightcooldowns.attack + "";
    	let t28;
    	let t29;
    	let br9;
    	let if_block = /*$fightcurrentTurn*/ ctx[0] === 'human' && create_if_block$6(ctx);

    	const block_1 = {
    		c: function create() {
    			div4 = element("div");
    			div0 = element("div");
    			t0 = text("Player 1 ");
    			br0 = element("br");
    			t1 = text("\r\n        Health: ");
    			t2 = text(t2_value);
    			t3 = space();
    			br1 = element("br");
    			t4 = text("\r\n        Stamina: ");
    			t5 = text(t5_value);
    			t6 = space();
    			br2 = element("br");
    			t7 = space();
    			t8 = text(t8_value);
    			t9 = space();
    			br3 = element("br");
    			t10 = text("\r\n        Cooldown: Attack - ");
    			t11 = text(t11_value);
    			t12 = text("s ");
    			br4 = element("br");
    			t13 = space();
    			div2 = element("div");
    			div1 = element("div");
    			t14 = text(t14_value);
    			t15 = space();
    			if (if_block) if_block.c();
    			t16 = space();
    			div3 = element("div");
    			t17 = text("Player 2 ");
    			br5 = element("br");
    			t18 = text("\r\n        Health: ");
    			t19 = text(t19_value);
    			t20 = space();
    			br6 = element("br");
    			t21 = text("\r\n        Stamina: ");
    			t22 = text(t22_value);
    			t23 = space();
    			br7 = element("br");
    			t24 = space();
    			t25 = text(t25_value);
    			t26 = space();
    			br8 = element("br");
    			t27 = text("\r\n        Cooldown: Attack - ");
    			t28 = text(t28_value);
    			t29 = text("s ");
    			br9 = element("br");
    			add_location(br0, file$b, 76, 17, 3171);
    			add_location(br1, file$b, 77, 48, 3225);
    			add_location(br2, file$b, 78, 50, 3281);
    			add_location(br3, file$b, 79, 62, 3349);
    			add_location(br4, file$b, 80, 70, 3425);
    			add_location(div0, file$b, 75, 4, 3147);
    			add_location(div1, file$b, 84, 8, 3464);
    			add_location(div2, file$b, 83, 4, 3449);
    			add_location(br5, file$b, 95, 17, 3978);
    			add_location(br6, file$b, 96, 51, 4035);
    			add_location(br7, file$b, 97, 53, 4094);
    			add_location(br8, file$b, 98, 65, 4165);
    			add_location(br9, file$b, 99, 73, 4244);
    			add_location(div3, file$b, 94, 4, 3954);
    			attr_dev(div4, "class", "statscontainer svelte-izilsr");
    			add_location(div4, file$b, 74, 0, 3113);
    		},
    		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, div4, anchor);
    			append_dev(div4, div0);
    			append_dev(div0, t0);
    			append_dev(div0, br0);
    			append_dev(div0, t1);
    			append_dev(div0, t2);
    			append_dev(div0, t3);
    			append_dev(div0, br1);
    			append_dev(div0, t4);
    			append_dev(div0, t5);
    			append_dev(div0, t6);
    			append_dev(div0, br2);
    			append_dev(div0, t7);
    			append_dev(div0, t8);
    			append_dev(div0, t9);
    			append_dev(div0, br3);
    			append_dev(div0, t10);
    			append_dev(div0, t11);
    			append_dev(div0, t12);
    			append_dev(div0, br4);
    			append_dev(div4, t13);
    			append_dev(div4, div2);
    			append_dev(div2, div1);
    			append_dev(div1, t14);
    			append_dev(div2, t15);
    			if (if_block) if_block.m(div2, null);
    			append_dev(div4, t16);
    			append_dev(div4, div3);
    			append_dev(div3, t17);
    			append_dev(div3, br5);
    			append_dev(div3, t18);
    			append_dev(div3, t19);
    			append_dev(div3, t20);
    			append_dev(div3, br6);
    			append_dev(div3, t21);
    			append_dev(div3, t22);
    			append_dev(div3, t23);
    			append_dev(div3, br7);
    			append_dev(div3, t24);
    			append_dev(div3, t25);
    			append_dev(div3, t26);
    			append_dev(div3, br8);
    			append_dev(div3, t27);
    			append_dev(div3, t28);
    			append_dev(div3, t29);
    			append_dev(div3, br9);
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*$fightplayerHuman*/ 2 && t2_value !== (t2_value = /*$fightplayerHuman*/ ctx[1].fighthealth + "")) set_data_dev(t2, t2_value);
    			if (dirty & /*$fightplayerHuman*/ 2 && t5_value !== (t5_value = /*$fightplayerHuman*/ ctx[1].fightstamina + "")) set_data_dev(t5, t5_value);

    			if (dirty & /*$fightplayerHuman*/ 2 && t8_value !== (t8_value = (/*$fightplayerHuman*/ ctx[1].fightisBlocking
    			? 'Blocking'
    			: '') + "")) set_data_dev(t8, t8_value);

    			if (dirty & /*$fightplayerHuman*/ 2 && t11_value !== (t11_value = /*$fightplayerHuman*/ ctx[1].fightcooldowns.attack + "")) set_data_dev(t11, t11_value);

    			if (dirty & /*$fightcurrentTurn*/ 1 && t14_value !== (t14_value = (/*$fightcurrentTurn*/ ctx[0] === 'human'
    			? "Your turn"
    			: "Computer's turn") + "")) set_data_dev(t14, t14_value);

    			if (/*$fightcurrentTurn*/ ctx[0] === 'human') {
    				if (if_block) {
    					if_block.p(ctx, dirty);
    				} else {
    					if_block = create_if_block$6(ctx);
    					if_block.c();
    					if_block.m(div2, null);
    				}
    			} else if (if_block) {
    				if_block.d(1);
    				if_block = null;
    			}

    			if (dirty & /*$fightplayerComputer*/ 4 && t19_value !== (t19_value = /*$fightplayerComputer*/ ctx[2].fighthealth + "")) set_data_dev(t19, t19_value);
    			if (dirty & /*$fightplayerComputer*/ 4 && t22_value !== (t22_value = /*$fightplayerComputer*/ ctx[2].fightstamina + "")) set_data_dev(t22, t22_value);

    			if (dirty & /*$fightplayerComputer*/ 4 && t25_value !== (t25_value = (/*$fightplayerComputer*/ ctx[2].fightisBlocking
    			? 'Blocking'
    			: '') + "")) set_data_dev(t25, t25_value);

    			if (dirty & /*$fightplayerComputer*/ 4 && t28_value !== (t28_value = /*$fightplayerComputer*/ ctx[2].fightcooldowns.attack + "")) set_data_dev(t28, t28_value);
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div4);
    			if (if_block) if_block.d();
    		}
    	};

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

    	return block_1;
    }

    function updatefightPlayer(player, changes) {
    	player.update(current => {
    		return { ...current, ...changes };
    	});
    }

    function instance$b($$self, $$props, $$invalidate) {
    	let $fightcurrentTurn;
    	let $fightplayerHuman;
    	let $fightplayerComputer;
    	validate_store(fightcurrentTurn, 'fightcurrentTurn');
    	component_subscribe($$self, fightcurrentTurn, $$value => $$invalidate(0, $fightcurrentTurn = $$value));
    	validate_store(fightplayerHuman, 'fightplayerHuman');
    	component_subscribe($$self, fightplayerHuman, $$value => $$invalidate(1, $fightplayerHuman = $$value));
    	validate_store(fightplayerComputer, 'fightplayerComputer');
    	component_subscribe($$self, fightplayerComputer, $$value => $$invalidate(2, $fightplayerComputer = $$value));
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceGameFight', slots, []);

    	function switchTurn() {
    		fightcurrentTurn.update(turn => turn === 'human' ? 'computer' : 'human');

    		// Immediately after switching to computer's turn, initiate the computer's action.
    		if ($fightcurrentTurn === 'computer') {
    			setTimeout(() => computerAction(), 1000); // Simulate thinking delay for the computer's turn
    		}
    	}

    	function performAttack(attacker, defender, attackType = 'normal') {
    		//fightcurrentTurn.update(turn => {
    		if ($fightcurrentTurn === 'human' && attacker === fightplayerHuman || $fightcurrentTurn === 'computer' && attacker === fightplayerComputer) {
    			// Perform attack logic here
    			attacker.update(a => {
    				if (a.fightstamina < 20 || a.fightcooldowns.attack > 0) {
    					return a; // Not enough stamina or attack is on cooldown
    				}

    				defender.update(d => {
    					if (!d.fightisBlocking) {
    						d.fighthealth -= attackType === 'normal' ? 10 : 25; // Special attack does more damage
    					}

    					return d;
    				});

    				return {
    					...a,
    					fightstamina: a.fightstamina - 20,
    					fightcooldowns: {
    						...a.fightcooldowns,
    						attack: attackType === 'normal' ? 1 : 3
    					}, // Cooldown in seconds
    					
    				};
    			});

    			// Start cooldown timer
    			setTimeout(
    				() => {
    					attacker.update(a => {
    						return {
    							...a,
    							fightcooldowns: { ...a.fightcooldowns, attack: 0 }
    						};
    					});
    				},
    				attackType === 'normal' ? 1000 : 3000
    			); // Cooldown period
    		}

    		switchTurn();
    	}

    	function block(player) {
    		if ($fightcurrentTurn === 'human' && player === fightplayerHuman || $fightcurrentTurn === 'computer' && player === fightplayerComputer) {
    			// Perform block logic here
    			updatefightPlayer(player, { fightisBlocking: true });

    			setTimeout(
    				() => {
    					updatefightPlayer(player, { fightisBlocking: false });
    				},
    				1000
    			); // Unblock after 1 second
    		}

    		switchTurn();
    	}

    	function computerAction() {
    		// Simple AI: Choose to attack or block randomly
    		const action = Math.random() > 0.4 ? 'attack' : 'block';

    		if (action === 'attack') {
    			performAttack(fightplayerComputer, fightplayerHuman);
    		} else {
    			block(fightplayerComputer);
    		}
    	} //switchTurn(); // Return control to the human player

    	const writable_props = [];

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

    	const click_handler = () => performAttack(fightplayerHuman, fightplayerComputer);
    	const click_handler_1 = () => performAttack(fightplayerHuman, fightplayerComputer, 'special');
    	const click_handler_2 = () => block(fightplayerHuman);

    	$$self.$capture_state = () => ({
    		fightplayerHuman,
    		fightplayerComputer,
    		fightcurrentTurn,
    		switchTurn,
    		updatefightPlayer,
    		performAttack,
    		block,
    		computerAction,
    		$fightcurrentTurn,
    		$fightplayerHuman,
    		$fightplayerComputer
    	});

    	return [
    		$fightcurrentTurn,
    		$fightplayerHuman,
    		$fightplayerComputer,
    		performAttack,
    		block,
    		click_handler,
    		click_handler_1,
    		click_handler_2
    	];
    }

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

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

    /* src\MovingDotSpaceModalBrainstorm.svelte generated by Svelte v3.59.2 */
    const file$a = "src\\MovingDotSpaceModalBrainstorm.svelte";

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

    // (52:6) {#each options as option}
    function create_each_block$7(ctx) {
    	let button;
    	let t_value = /*option*/ ctx[7].text + "";
    	let t;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[4](/*option*/ ctx[7]);
    	}

    	const block = {
    		c: function create() {
    			button = element("button");
    			t = text(t_value);
    			add_location(button, file$a, 52, 8, 2162);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$7.name,
    		type: "each",
    		source: "(52:6) {#each options as option}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$a(ctx) {
    	let div1;
    	let h2;
    	let t1;
    	let p0;
    	let t3;
    	let p1;
    	let t4;
    	let t5;
    	let div0;
    	let t6;
    	let p2;
    	let t7;
    	let each_value = /*options*/ ctx[3];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			div1 = element("div");
    			h2 = element("h2");
    			h2.textContent = "Spatial Anomaly";
    			t1 = space();
    			p0 = element("p");
    			p0.textContent = `${/*anomalyDescription*/ ctx[2]}`;
    			t3 = space();
    			p1 = element("p");
    			t4 = text(/*analyzeResult*/ ctx[0]);
    			t5 = space();
    			div0 = element("div");

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

    			t6 = space();
    			p2 = element("p");
    			t7 = text(/*interactResult*/ ctx[1]);
    			add_location(h2, file$a, 46, 4, 1987);
    			add_location(p0, file$a, 47, 4, 2017);
    			add_location(p1, file$a, 49, 4, 2086);
    			add_location(div0, file$a, 50, 4, 2114);
    			add_location(p2, file$a, 55, 4, 2258);
    			add_location(div1, file$a, 45, 2, 1976);
    		},
    		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, div1, anchor);
    			append_dev(div1, h2);
    			append_dev(div1, t1);
    			append_dev(div1, p0);
    			append_dev(div1, t3);
    			append_dev(div1, p1);
    			append_dev(p1, t4);
    			append_dev(div1, t5);
    			append_dev(div1, div0);

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

    			append_dev(div1, t6);
    			append_dev(div1, p2);
    			append_dev(p2, t7);
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*analyzeResult*/ 1) set_data_dev(t4, /*analyzeResult*/ ctx[0]);

    			if (dirty & /*options*/ 8) {
    				each_value = /*options*/ ctx[3];
    				validate_each_argument(each_value);
    				let i;

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

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

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

    				each_blocks.length = each_value.length;
    			}

    			if (dirty & /*interactResult*/ 2) set_data_dev(t7, /*interactResult*/ ctx[1]);
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div1);
    			destroy_each(each_blocks, detaching);
    		}
    	};

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

    	return block;
    }

    function ignoreAnomaly() {
    	
    } // Code to ignore the anomaly and continue the game
    // ...

    function instance$a($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceModalBrainstorm', slots, []);
    	let anomalyDescription = "A massive spatial anomaly has been detected in your vicinity. Scanner readings indicate it could be a wormhole or a highly unstable nebula. Proceed with caution.";

    	let options = [
    		{
    			text: "Analyze Anomaly",
    			action: analyzeAnomaly
    		},
    		{
    			text: "Interact with Anomaly",
    			action: interactAnomaly
    		},
    		{
    			text: "Ignore Anomaly",
    			action: ignoreAnomaly
    		}
    	];

    	let analyzeResult = "";
    	let interactResult = "";

    	onMount(() => {
    		// Perform initial anomaly scan
    		analyzeAnomaly();
    	});

    	function analyzeAnomaly() {
    		// Simulate anomaly analysis
    		setTimeout(
    			() => {
    				$$invalidate(0, analyzeResult = "Scans indicate the anomaly is a highly volatile wormhole. Tampering with it could be extremely dangerous or potentially open up new regions of space.");
    			},
    			2000
    		);
    	}

    	function interactAnomaly() {
    		// Simulate anomaly interaction
    		setTimeout(
    			() => {
    				const randomOutcome = Math.random();

    				if (randomOutcome < 0.3) {
    					$$invalidate(1, interactResult = "Your attempt to interact with the wormhole has destabilized it, causing severe damage to your ship's systems. You'll need to find a safe haven for repairs.");
    				} else if (randomOutcome < 0.6) {
    					$$invalidate(1, interactResult = "The wormhole seems to have transported you to an unknown region of space. Your navigational systems are scrambled, and you'll need to find a way to recalibrate them.");
    				} else {
    					$$invalidate(1, interactResult = "Your interaction with the wormhole appears to have been successful. You've discovered a hidden sector filled with valuable resources and advanced technology.");
    				}
    			},
    			3000
    		);
    	}

    	const writable_props = [];

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

    	const click_handler = option => option.action();

    	$$self.$capture_state = () => ({
    		onMount,
    		anomalyDescription,
    		options,
    		analyzeResult,
    		interactResult,
    		analyzeAnomaly,
    		interactAnomaly,
    		ignoreAnomaly
    	});

    	$$self.$inject_state = $$props => {
    		if ('anomalyDescription' in $$props) $$invalidate(2, anomalyDescription = $$props.anomalyDescription);
    		if ('options' in $$props) $$invalidate(3, options = $$props.options);
    		if ('analyzeResult' in $$props) $$invalidate(0, analyzeResult = $$props.analyzeResult);
    		if ('interactResult' in $$props) $$invalidate(1, interactResult = $$props.interactResult);
    	};

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

    	return [analyzeResult, interactResult, anomalyDescription, options, click_handler];
    }

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

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

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

    const file$9 = "src\\MovingDotSpaceGameFind.svelte";

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

    function get_each_context_1$2(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[12] = list[i];
    	child_ctx[14] = i;
    	return child_ctx;
    }

    // (63:4) {:else}
    function create_else_block$1(ctx) {
    	let p;

    	const block = {
    		c: function create() {
    			p = element("p");
    			p.textContent = "Game over. Try again!";
    			add_location(p, file$9, 63, 6, 1832);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_else_block$1.name,
    		type: "else",
    		source: "(63:4) {:else}",
    		ctx
    	});

    	return block;
    }

    // (61:34) 
    function create_if_block_1$2(ctx) {
    	let p;

    	const block = {
    		c: function create() {
    			p = element("p");
    			p.textContent = "You won! 🎉";
    			add_location(p, file$9, 61, 6, 1793);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_1$2.name,
    		type: "if",
    		source: "(61:34) ",
    		ctx
    	});

    	return block;
    }

    // (59:4) {#if gameState === 'playing'}
    function create_if_block$5(ctx) {
    	let p;
    	let t0;
    	let t1;

    	const block = {
    		c: function create() {
    			p = element("p");
    			t0 = text("Presses Remaining: ");
    			t1 = text(/*pressesRemaining*/ ctx[0]);
    			add_location(p, file$9, 59, 6, 1705);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    			append_dev(p, t0);
    			append_dev(p, t1);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*pressesRemaining*/ 1) set_data_dev(t1, /*pressesRemaining*/ ctx[0]);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$5.name,
    		type: "if",
    		source: "(59:4) {#if gameState === 'playing'}",
    		ctx
    	});

    	return block;
    }

    // (71:6) {#each row as cell, colIndex}
    function create_each_block_1$2(ctx) {
    	let button;

    	let t0_value = (/*cell*/ ctx[12].pressed
    	? /*rowIndex*/ ctx[11] === /*correctItem*/ ctx[1].row && /*colIndex*/ ctx[14] === /*correctItem*/ ctx[1].col
    		? '✅'
    		: '❌'
    	: '') + "";

    	let t0;
    	let t1;
    	let button_disabled_value;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[6](/*rowIndex*/ ctx[11], /*colIndex*/ ctx[14]);
    	}

    	const block = {
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = space();
    			button.disabled = button_disabled_value = /*gameState*/ ctx[2] !== 'playing';
    			attr_dev(button, "class", "svelte-p3ubim");
    			toggle_class(button, "pressed", /*cell*/ ctx[12].pressed);
    			add_location(button, file$9, 71, 8, 2045);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			append_dev(button, t1);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;

    			if (dirty & /*grid, correctItem*/ 10 && t0_value !== (t0_value = (/*cell*/ ctx[12].pressed
    			? /*rowIndex*/ ctx[11] === /*correctItem*/ ctx[1].row && /*colIndex*/ ctx[14] === /*correctItem*/ ctx[1].col
    				? '✅'
    				: '❌'
    			: '') + "")) set_data_dev(t0, t0_value);

    			if (dirty & /*gameState*/ 4 && button_disabled_value !== (button_disabled_value = /*gameState*/ ctx[2] !== 'playing')) {
    				prop_dev(button, "disabled", button_disabled_value);
    			}

    			if (dirty & /*grid*/ 8) {
    				toggle_class(button, "pressed", /*cell*/ ctx[12].pressed);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block_1$2.name,
    		type: "each",
    		source: "(71:6) {#each row as cell, colIndex}",
    		ctx
    	});

    	return block;
    }

    // (70:4) {#each grid as row, rowIndex}
    function create_each_block$6(ctx) {
    	let each_1_anchor;
    	let each_value_1 = /*row*/ ctx[9];
    	validate_each_argument(each_value_1);
    	let each_blocks = [];

    	for (let i = 0; i < each_value_1.length; i += 1) {
    		each_blocks[i] = create_each_block_1$2(get_each_context_1$2(ctx, each_value_1, i));
    	}

    	const block = {
    		c: function create() {
    			for (let i = 0; i < each_blocks.length; i += 1) {
    				each_blocks[i].c();
    			}

    			each_1_anchor = empty();
    		},
    		m: function mount(target, anchor) {
    			for (let i = 0; i < each_blocks.length; i += 1) {
    				if (each_blocks[i]) {
    					each_blocks[i].m(target, anchor);
    				}
    			}

    			insert_dev(target, each_1_anchor, anchor);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*gameState, grid, pressButton, correctItem*/ 30) {
    				each_value_1 = /*row*/ ctx[9];
    				validate_each_argument(each_value_1);
    				let i;

    				for (i = 0; i < each_value_1.length; i += 1) {
    					const child_ctx = get_each_context_1$2(ctx, each_value_1, i);

    					if (each_blocks[i]) {
    						each_blocks[i].p(child_ctx, dirty);
    					} else {
    						each_blocks[i] = create_each_block_1$2(child_ctx);
    						each_blocks[i].c();
    						each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
    					}
    				}

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

    				each_blocks.length = each_value_1.length;
    			}
    		},
    		d: function destroy(detaching) {
    			destroy_each(each_blocks, detaching);
    			if (detaching) detach_dev(each_1_anchor);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$6.name,
    		type: "each",
    		source: "(70:4) {#each grid as row, rowIndex}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$9(ctx) {
    	let div0;
    	let t0;
    	let button;
    	let t2;
    	let div1;
    	let mounted;
    	let dispose;

    	function select_block_type(ctx, dirty) {
    		if (/*gameState*/ ctx[2] === 'playing') return create_if_block$5;
    		if (/*gameState*/ ctx[2] === 'won') return create_if_block_1$2;
    		return create_else_block$1;
    	}

    	let current_block_type = select_block_type(ctx);
    	let if_block = current_block_type(ctx);
    	let each_value = /*grid*/ ctx[3];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			div0 = element("div");
    			if_block.c();
    			t0 = space();
    			button = element("button");
    			button.textContent = "Restart Game";
    			t2 = space();
    			div1 = element("div");

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

    			attr_dev(button, "class", "svelte-p3ubim");
    			add_location(button, file$9, 65, 4, 1877);
    			add_location(div0, file$9, 57, 2, 1657);
    			attr_dev(div1, "class", "grid svelte-p3ubim");
    			add_location(div1, file$9, 68, 2, 1945);
    		},
    		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, div0, anchor);
    			if_block.m(div0, null);
    			append_dev(div0, t0);
    			append_dev(div0, button);
    			insert_dev(target, t2, anchor);
    			insert_dev(target, div1, anchor);

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

    			if (!mounted) {
    				dispose = listen_dev(button, "click", /*resetGame*/ ctx[5], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
    				if_block.p(ctx, dirty);
    			} else {
    				if_block.d(1);
    				if_block = current_block_type(ctx);

    				if (if_block) {
    					if_block.c();
    					if_block.m(div0, t0);
    				}
    			}

    			if (dirty & /*grid, gameState, pressButton, correctItem*/ 30) {
    				each_value = /*grid*/ ctx[3];
    				validate_each_argument(each_value);
    				let i;

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

    					if (each_blocks[i]) {
    						each_blocks[i].p(child_ctx, dirty);
    					} else {
    						each_blocks[i] = create_each_block$6(child_ctx);
    						each_blocks[i].c();
    						each_blocks[i].m(div1, 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(div0);
    			if_block.d();
    			if (detaching) detach_dev(t2);
    			if (detaching) detach_dev(div1);
    			destroy_each(each_blocks, detaching);
    			mounted = false;
    			dispose();
    		}
    	};

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

    	return block;
    }

    function instance$9($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceGameFind', slots, []);
    	let gridSize = 10;
    	let maxPresses = 20; // Maximum number of presses allowed
    	let pressesRemaining = maxPresses;

    	let correctItem = {
    		row: Math.floor(Math.random() * gridSize),
    		col: Math.floor(Math.random() * gridSize)
    	};

    	let gameState = "playing"; // Can be "playing", "won", or "lost"

    	// Generate initial grid state
    	let grid = Array(gridSize).fill().map(() => Array(gridSize).fill().map(() => ({ pressed: false })));

    	function pressButton(row, col) {
    		if (grid[row][col].pressed || pressesRemaining === 0 || gameState !== "playing") {
    			return; // Ignore if already pressed or no presses left or game not in playing state
    		}

    		$$invalidate(3, grid[row][col].pressed = true, grid);
    		$$invalidate(0, pressesRemaining -= 1);

    		// Check for win condition
    		if (row === correctItem.row && col === correctItem.col) {
    			$$invalidate(2, gameState = "won");
    		} else if (pressesRemaining === 0) {
    			$$invalidate(2, gameState = "lost");
    		}
    	}

    	function resetGame() {
    		$$invalidate(0, pressesRemaining = maxPresses);

    		$$invalidate(1, correctItem = {
    			row: Math.floor(Math.random() * gridSize),
    			col: Math.floor(Math.random() * gridSize)
    		});

    		$$invalidate(3, grid = Array(gridSize).fill().map(() => Array(gridSize).fill().map(() => ({ pressed: false }))));
    		$$invalidate(2, gameState = "playing");
    	}

    	const writable_props = [];

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

    	const click_handler = (rowIndex, colIndex) => pressButton(rowIndex, colIndex);

    	$$self.$capture_state = () => ({
    		gridSize,
    		maxPresses,
    		pressesRemaining,
    		correctItem,
    		gameState,
    		grid,
    		pressButton,
    		resetGame
    	});

    	$$self.$inject_state = $$props => {
    		if ('gridSize' in $$props) gridSize = $$props.gridSize;
    		if ('maxPresses' in $$props) maxPresses = $$props.maxPresses;
    		if ('pressesRemaining' in $$props) $$invalidate(0, pressesRemaining = $$props.pressesRemaining);
    		if ('correctItem' in $$props) $$invalidate(1, correctItem = $$props.correctItem);
    		if ('gameState' in $$props) $$invalidate(2, gameState = $$props.gameState);
    		if ('grid' in $$props) $$invalidate(3, grid = $$props.grid);
    	};

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

    	return [
    		pressesRemaining,
    		correctItem,
    		gameState,
    		grid,
    		pressButton,
    		resetGame,
    		click_handler
    	];
    }

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

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

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

    const file$8 = "src\\MovingDotSpaceGameOrder.svelte";

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

    // (72:39) 
    function create_if_block_2(ctx) {
    	let p;

    	const block = {
    		c: function create() {
    			p = element("p");
    			p.textContent = "Incorrect order. Try again!";
    			add_location(p, file$8, 72, 4, 2206);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_2.name,
    		type: "if",
    		source: "(72:39) ",
    		ctx
    	});

    	return block;
    }

    // (70:2) {#if gameStatus === "correct"}
    function create_if_block_1$1(ctx) {
    	let p;

    	const block = {
    		c: function create() {
    			p = element("p");
    			p.textContent = "You guessed the correct order! 🎉";
    			add_location(p, file$8, 70, 4, 2119);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_1$1.name,
    		type: "if",
    		source: "(70:2) {#if gameStatus === \\\"correct\\\"}",
    		ctx
    	});

    	return block;
    }

    // (79:4) {#each Array(gridSize) as _, i}
    function create_each_block$5(ctx) {
    	let button;
    	let t0_value = /*i*/ ctx[12] + 1 + "";
    	let t0;
    	let t1;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[8](/*i*/ ctx[12]);
    	}

    	const block = {
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = space();
    			attr_dev(button, "data-number", /*i*/ ctx[12] + 1);
    			attr_dev(button, "class", "svelte-7k1yf9");
    			toggle_class(button, "pressed", /*userOrder*/ ctx[0].includes(/*i*/ ctx[12] + 1));
    			add_location(button, file$8, 79, 6, 2378);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			append_dev(button, t1);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;

    			if (dirty & /*userOrder*/ 1) {
    				toggle_class(button, "pressed", /*userOrder*/ ctx[0].includes(/*i*/ ctx[12] + 1));
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$5.name,
    		type: "each",
    		source: "(79:4) {#each Array(gridSize) as _, i}",
    		ctx
    	});

    	return block;
    }

    // (86:2) {#if !checkOnEveryPress && gameStatus === ""}
    function create_if_block$4(ctx) {
    	let button;
    	let t;
    	let button_disabled_value;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			button = element("button");
    			t = text("Check Order");
    			button.disabled = button_disabled_value = /*userOrder*/ ctx[0].length !== /*gridSize*/ ctx[3];
    			attr_dev(button, "class", "svelte-7k1yf9");
    			add_location(button, file$8, 86, 4, 2600);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", /*checkOrder*/ ctx[5], false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*userOrder*/ 1 && button_disabled_value !== (button_disabled_value = /*userOrder*/ ctx[0].length !== /*gridSize*/ ctx[3])) {
    				prop_dev(button, "disabled", button_disabled_value);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$4.name,
    		type: "if",
    		source: "(86:2) {#if !checkOnEveryPress && gameStatus === \\\"\\\"}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$8(ctx) {
    	let div0;
    	let input;
    	let t0;
    	let label;
    	let t2;
    	let t3;
    	let button;
    	let t5;
    	let div1;
    	let t6;
    	let if_block1_anchor;
    	let mounted;
    	let dispose;

    	function select_block_type(ctx, dirty) {
    		if (/*gameStatus*/ ctx[2] === "correct") return create_if_block_1$1;
    		if (/*gameStatus*/ ctx[2] === "incorrect") return create_if_block_2;
    	}

    	let current_block_type = select_block_type(ctx);
    	let if_block0 = current_block_type && current_block_type(ctx);
    	let each_value = Array(/*gridSize*/ ctx[3]);
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	let if_block1 = !/*checkOnEveryPress*/ ctx[1] && /*gameStatus*/ ctx[2] === "" && create_if_block$4(ctx);

    	const block = {
    		c: function create() {
    			div0 = element("div");
    			input = element("input");
    			t0 = space();
    			label = element("label");
    			label.textContent = "Check order on every press";
    			t2 = space();
    			if (if_block0) if_block0.c();
    			t3 = space();
    			button = element("button");
    			button.textContent = "Restart Game";
    			t5 = space();
    			div1 = element("div");

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

    			t6 = space();
    			if (if_block1) if_block1.c();
    			if_block1_anchor = empty();
    			attr_dev(input, "type", "checkbox");
    			add_location(input, file$8, 65, 4, 1962);
    			add_location(label, file$8, 66, 4, 2024);
    			attr_dev(div0, "class", "controls svelte-7k1yf9");
    			add_location(div0, file$8, 64, 2, 1934);
    			attr_dev(button, "class", "svelte-7k1yf9");
    			add_location(button, file$8, 75, 2, 2257);
    			attr_dev(div1, "class", "grid svelte-7k1yf9");
    			add_location(div1, file$8, 77, 2, 2315);
    		},
    		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, div0, anchor);
    			append_dev(div0, input);
    			input.checked = /*checkOnEveryPress*/ ctx[1];
    			append_dev(div0, t0);
    			append_dev(div0, label);
    			insert_dev(target, t2, anchor);
    			if (if_block0) if_block0.m(target, anchor);
    			insert_dev(target, t3, anchor);
    			insert_dev(target, button, anchor);
    			insert_dev(target, t5, anchor);
    			insert_dev(target, div1, anchor);

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

    			insert_dev(target, t6, anchor);
    			if (if_block1) if_block1.m(target, anchor);
    			insert_dev(target, if_block1_anchor, anchor);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input, "change", /*input_change_handler*/ ctx[7]),
    					listen_dev(button, "click", /*resetGame*/ ctx[6], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*checkOnEveryPress*/ 2) {
    				input.checked = /*checkOnEveryPress*/ ctx[1];
    			}

    			if (current_block_type !== (current_block_type = select_block_type(ctx))) {
    				if (if_block0) if_block0.d(1);
    				if_block0 = current_block_type && current_block_type(ctx);

    				if (if_block0) {
    					if_block0.c();
    					if_block0.m(t3.parentNode, t3);
    				}
    			}

    			if (dirty & /*userOrder, handlePress*/ 17) {
    				each_value = Array(/*gridSize*/ ctx[3]);
    				validate_each_argument(each_value);
    				let i;

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

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

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

    				each_blocks.length = each_value.length;
    			}

    			if (!/*checkOnEveryPress*/ ctx[1] && /*gameStatus*/ ctx[2] === "") {
    				if (if_block1) {
    					if_block1.p(ctx, dirty);
    				} else {
    					if_block1 = create_if_block$4(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 (detaching) detach_dev(div0);
    			if (detaching) detach_dev(t2);

    			if (if_block0) {
    				if_block0.d(detaching);
    			}

    			if (detaching) detach_dev(t3);
    			if (detaching) detach_dev(button);
    			if (detaching) detach_dev(t5);
    			if (detaching) detach_dev(div1);
    			destroy_each(each_blocks, detaching);
    			if (detaching) detach_dev(t6);
    			if (if_block1) if_block1.d(detaching);
    			if (detaching) detach_dev(if_block1_anchor);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function instance$8($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpaceGameOrder', slots, []);
    	let gridSize = 4; // Grid size for simplicity
    	let correctOrder = Array.from({ length: gridSize }, (_, i) => i + 1).sort(() => 0.5 - Math.random()); // Randomized correct order
    	let userOrder = []; // User's order
    	let checkOnEveryPress = false; // Start with manual check
    	let gameStatus = ""; // "", "correct", or "incorrect"

    	function handlePress(number) {
    		if (userOrder.includes(number) || gameStatus) return; // Ignore if already pressed or game has ended
    		userOrder.push(number);

    		if (!checkOnEveryPress) {
    			// Add the "pressed" class to the pressed button
    			const pressedButton = document.querySelector(`button[data-number="${number}"]`);

    			pressedButton.classList.add("pressed");
    		} else {
    			checkOrder();
    		}
    	}

    	function checkOrder() {
    		for (let i = 0; i < userOrder.length; i++) {
    			if (userOrder[i] !== correctOrder[i]) {
    				$$invalidate(2, gameStatus = "incorrect");
    				return;
    			}
    		}

    		if (userOrder.length === correctOrder.length) {
    			$$invalidate(2, gameStatus = "correct");
    		}
    	}

    	function resetGame() {
    		$$invalidate(0, userOrder = []);
    		$$invalidate(2, gameStatus = "");
    		correctOrder.sort(() => 0.5 - Math.random()); // Shuffle for a new game

    		// Remove the "pressed" class from all buttons
    		const pressedButtons = document.querySelectorAll(".pressed");

    		pressedButtons.forEach(button => button.classList.remove("pressed"));
    	}

    	const writable_props = [];

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

    	function input_change_handler() {
    		checkOnEveryPress = this.checked;
    		$$invalidate(1, checkOnEveryPress);
    	}

    	const click_handler = i => handlePress(i + 1);

    	$$self.$capture_state = () => ({
    		gridSize,
    		correctOrder,
    		userOrder,
    		checkOnEveryPress,
    		gameStatus,
    		handlePress,
    		checkOrder,
    		resetGame
    	});

    	$$self.$inject_state = $$props => {
    		if ('gridSize' in $$props) $$invalidate(3, gridSize = $$props.gridSize);
    		if ('correctOrder' in $$props) correctOrder = $$props.correctOrder;
    		if ('userOrder' in $$props) $$invalidate(0, userOrder = $$props.userOrder);
    		if ('checkOnEveryPress' in $$props) $$invalidate(1, checkOnEveryPress = $$props.checkOnEveryPress);
    		if ('gameStatus' in $$props) $$invalidate(2, gameStatus = $$props.gameStatus);
    	};

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

    	return [
    		userOrder,
    		checkOnEveryPress,
    		gameStatus,
    		gridSize,
    		handlePress,
    		checkOrder,
    		resetGame,
    		input_change_handler,
    		click_handler
    	];
    }

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

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

    // themeConfig.js
    const themes = {
        'User Custom': {
            background: '/AutoGameBackgrounds/space_background.png',
            inventory: [
                { type: "weapon", name: "Random waepon", description: "A powerful weapon." },
                // ... more space items
            ],
            skills: [
                { branch: "Skill Group 1", name: "Skill One", learned: false },
                // ... more space skills
            ],
            objectives: [
                { id: "Mission 1", name: "Mission Details", complete: false },
                // ... more space objectives
            ],
            // ... and so on for targets
            storyparttargets: {
                0: [
                    { name: "Target 1", x: 50, y: 50, collisionType: "alert", collisiontext: "First Test"},
                ],
            }
        },
        'Default': {
            background: '/AutoGameBackgrounds/1stGameLoc123.png',
            inventory: [
                { type: "weapon", name: "Sword", description: "A sharp blade." },
                { type: "armor", name: "Shield", description: "Protects against attacks." },
                { type: "consumable", name: "Health Potion", description: "Restores health." },
                // ... more space items
            ],
            skills: [
                { branch: "Combat", name: "Basic Attack", learned: false },
                { branch: "Magic", name: "Fireball", learned: false },
                { branch: "Stealth", name: "Sneak", learned: false },
                // ... more space skills
            ],
            objectives: [
                { id: "Seperate", name: "Visit Mountain Peak", complete: false },
                { id: "Mission 1", name: "Intercept The Courier (Search the Locations)", complete: false },
                { id: "Mission 1", name: "Deliver the package to Market Stall", complete: false },
                // ... more space objectives
            ],
            // ... and so on for targets
            storyparttargets: {
                0: [
                    { name: "Target 1", x: 50, y: 50, collisionType: "alert", collisiontext: "First Test"},
                    { name: "Target 2", x: 100, y: 100, collisionType: "", collisiontext: ""},
                    { name: "Entrance", x: 995, y: 660, collisionType: "modal", modalConfig: {
                        title: "Entrance",
                        content: "You've reached the Entrance. What's your next step?",
                        actions: [
                            {label: "Ask for guidance on next move", action: "askforDirections"},
                            {label: "Buy an Axe", action: "buyAxeAlert"},
                            // ... more actions if necessary
                        ]},
                    },
                    { name: "Market Stall", x: 200, y: 300, collisionType: "", collisiontext: "" },   // A market stall in the bustling market area.
                    { name: "Inn Entrance", x: 400, y: 450, collisionType: "", collisiontext: "" },   // The entrance to the inn for rest or information.
                    { name: "Town Hall", x: 600, y: 350, collisionType: "", collisiontext: "" },      // The entrance to the town hall for quests.
                    { name: "Fountain", x: 500, y: 500, collisionType: "", collisiontext: "" },       // A fountain in the town square as a meeting point.
                    { name: "Bridge", x: 1100, y: 700, collisionType: "", collisiontext: "" },        // A bridge in the mystical forest area.
                    { name: "Waterfall", x: 1300, y: 800, collisionType: "", collisiontext: "" },     // A waterfall that could hide secrets or treasures.
                    { name: "Mountain Peak", x: 1500, y: 100, collisionType: "", collisiontext: "" },
                    //{ name: "Mysterious Stranger", x: 350, y: 550, collisionType: "alert", collisiontext: "Beware the hidden caves in the north." },
                    //{ name: "Hidden Cave", x: 1200, y: 400, collisionType: "changeBackgroundColor", color: "#0B3D91" },
                    //{ name: "Ancient Tree", x: 300, y: 700, collisionType: "playSound", soundUrl: "tree_whisper.mp3" },
                    //{ name: "Forgotten Monument", x: 700, y: 800, collisionType: "startAnimation", elementId: "monument", animationClass: "glow" },
                    //{ name: "Wizard's Tower", x: 950, y: 150, collisionType: "rotateDot" },
                    //{ name: "Lakeside", x: 1400, y: 600, collisionType: "changeDotColor", color: "#00BFFF" },
                    //{ name: "Dragon's Lair", x: 1600, y: 200, collisionType: "incrementScore", incrementValue: 50 },
                    //{ name: "Abandoned Shipwreck", x: 1300, y: 500, collisionType: "shrinkDot" },
                    
                    { name: "Switch Test 1", x: 700, y: 700, collisionType: "storypartchange",  collisiontext: "First Test", newStage: 1},
                ],
                1: [
                    { name: "Target 1", x: 50, y: 50, collisionType: "alert",  collisiontext: "First Test"},
                    { name: "Switch Back Test 1", x: 600, y: 400, collisionType: "storypartchange",  collisiontext: "First Test", newStage: 0},
                ],
            },
        },
        'Space Odyssey': {
            background: '/AutoGameBackgrounds/SpaceOdysseyGameLoc.png',
            inventory: [
                { type: "weapon", name: "Laser Gun", description: "A powerful laser weapon." },
                // ... more space items
            ],
            skills: [
                { branch: "Piloting", name: "Astro Navigation", learned: false },
                // ... more space skills
            ],
            objectives: [
                { id: 1, name: "Dock at the Space Station", complete: false, progress: 0 },
                { id: 2, name: "Repair the Communication Array", complete: false, progress: 0 },
                { id: 3, name: "Collect Rare Asteroid Minerals", complete: false, progress: 0 },
                { id: 4, name: "Negotiate Peace with the Alien Species", complete: false, progress: 0 },
                { id: 5, name: "Explore the Abandoned Spaceship", complete: false, progress: 0 },
                { id: 6, name: "Survive the Meteor Shower", complete: false, progress: 0 },
                { id: 7, name: "Decrypt the Ancient Space Map", complete: false, progress: 0 },
                { id: 8, name: "Win the Space Race", complete: false, progress: 0 },
                { id: 9, name: "Defend the Colony from Space Pirates", complete: false, progress: 0 },
                { id: 10, name: "Discover a New Lifeform", complete: false, progress: 0 }        
                // ... more space objectives
            ],
            storyparttargets: {
                0: [
                    { name: "Target 1", x: 50, y: 50, collisionType: "alert", collisiontext: "First Test"},
                ],
            },
        },
        'Medieval Fantasy': {
            background: '/AutoGameBackgrounds/MedievalFantasyGameLoc.png',
            inventory: [
                { type: "weapon", name: "Longsword", description: "A sturdy steel blade." },
                // ... more medieval items
            ],
            skills: [
                { branch: "Piloting", name: "Astro Navigation", learned: false },
                // ... more space skills
            ],
            objectives: [
                { id: 1, name: "Rescue the Captured Knight", complete: false, progress: 0 },
                { id: 2, name: "Find the Lost Artifact", complete: false, progress: 0 },
                { id: 3, name: "Defeat the Dragon", complete: false, progress: 0 },
                { id: 4, name: "Win the Archery Tournament", complete: false, progress: 0 },
                { id: 5, name: "Break the Evil Curse", complete: false, progress: 0 },
                { id: 6, name: "Uncover the Secret of the Ancient Ruins", complete: false, progress: 0 },
                { id: 7, name: "Protect the Village from Bandits", complete: false, progress: 0 },
                { id: 8, name: "Retrieve the Stolen Royal Jewels", complete: false, progress: 0 },
                { id: 9, name: "Discover the Hidden Enchanted Forest", complete: false, progress: 0 },
                { id: 10, name: "Master the Forbidden Magic Spell", complete: false, progress: 0 },        
                // ... more space objectives
            ],
            storyparttargets: {
                0: [
                    { name: "Castle", x: 940, y: 460, collisionType: "alert", collisiontext: "The King of this land has summoned you to find and release his champion Daryl the Knight. Find him and free him"},
                    { name: "Hidden Space", x: 460, y: 570, collisionType: "alert", collisiontext: "Seems like a hidden space. Nobody is here currently."},
                    { name: "Home", x: 640, y: 500, collisionType: "modal", modalConfig: {
                        title: "Your Space",
                        content: "Rest and prepare for your tasks. Sometimes you hear noises in the area but this is the area with least interference",
                        actions: [
                            {label: "Ask for guidance on next move", action: "askforDirections"},
                            {label: "Buy an Axe", action: "buyAxeAlert"},
                            // ... more actions if necessary
                        ]},
                    },
                    { name: "Marketplace", x: 1100, y: 470, collisionType: "modal", modalConfig: {
                        title: "Place to find information and items",
                        content: "A bustling marketplace",
                        actions: [
                            {label: "Ask for guidance on next move", action: "askforDirections"},
                            {label: "Buy an Axe", action: "buyAxeAlert"},
                            {label: "Ask about the knight", action: "knightalert", message: "The armourer said he went to see the mini waterfall for some relaxtion"},
                            // ... more actions if necessary
                        ]},
                    },
                    { name: "Mini Waterfall", x: 500, y: 640, collisionType: "alert", collisiontext: "A weird waterfall is upfront. It strangely gives a calming vibe. Nobody is here currently but there seems to be a trail of water leading to a closeby location .... "},
                ],
            },
            // ... skills, objectives, and targets for medieval theme
        },
        'Cyberpunk': {
            background: '/AutoGameBackgrounds/CyberpunkGameLoc.png',
            inventory: [
                { type: "weapon", name: "Plasma Rifle", description: "A high-tech firearm with plasma rounds." },
                { type: "armor", name: "NanoSuit", description: "Protects with reactive nano technology." },
                { type: "consumable", name: "Stim Pack", description: "Enhances reflexes temporarily." },
                // ... more cyberpunk items
            ],
            // ... skills, objectives, and targets for cyberpunk theme
            skills: [
                { branch: "Hacking", name: "Cyber Intrusion", learned: false },
                { branch: "Combat", name: "Gun Kata", learned: false },
                { branch: "Stealth", name: "Cloaking", learned: false },
                // ... more space skills
            ],
            objectives: [ 
                { id: 1, name: "Hack the Mainframe", complete: false, progress: 0 },
                { id: 2, name: "Escape the Megacorp Security", complete: false, progress: 0 },
                { id: 3, name: "Infiltrate the Underground Hacker Group", complete: false, progress: 0 },
                { id: 4, name: "Negotiate a Truce with the Rival Gang", complete: false, progress: 0 },
                { id: 5, name: "Expose the Corrupt Politician", complete: false, progress: 0 },
                { id: 6, name: "Survive the Drone Assault", complete: false, progress: 0 },
                { id: 7, name: "Retrieve the Stolen Cybernetic Tech", complete: false, progress: 0 },
                { id: 8, name: "Win the Street Race in Neo-Tokyo", complete: false, progress: 0 },
                { id: 9, name: "Decrypt the Corporate Data Files", complete: false, progress: 0 },
                { id: 10, name: "Disarm the City-Wide Neural Bomb", complete: false, progress: 0 }
       
                // ... more space objectives
            ],
            storyparttargets: { 
                0: [
                    { name: "Target 1", x: 50, y: 50, collisionType: "alert", collisiontext: "First Test"},
                    { name: "MegaCorp Server", x: 200, y: 50, collisionType: "alert", collisiontext: "First Test"},
                    { name: "City Police", x: 50, y: 250, collisionType: "alert", collisiontext: "First Test"},
                    { name: "Rival Gang", x: 550, y: 550, collisionType: "alert", collisiontext: "First Test"},
                ],
            },
        },
        'Super Teacher': {
            background: '/AutoGameBackgrounds/SuperTeacherGameLoc.png',
            inventory: [
                { type: "book", name: "Math Advice", description: "Useful topical knowledge." },
                { type: "book", name: "Science Advice", description: "Useful topical knowledge." },
                { type: "book", name: "English Advice", description: "Useful topical knowledge." },
                { type: "book", name: "Economics Advice", description: "Useful topical knowledge." },
                // ... more space items
            ],
            skills: [
                { branch: "Multitask", name: "Movement Speed", learned: false },
                { branch: "Multitask", name: "Stop Window Interference for 1 min", learned: false },
                // ... more space skills
            ],
            objectives: [
                { id: "Mission 1", name: "Get the children to grade one 1 level", complete: false },
                { id: "Mission 2", name: "Get the children to grade one 2 level", complete: false },
                { id: "Mission 3", name: "Get the children to grade one 3 level", complete: false },
                // ... more space objectives
            ],
            // ... and so on for targets
            storyparttargets: {
                0: [
                    { name: "Super Teacher Toolkit", x: 1000, y: 330, collisionType: "alert", collisiontext: "First Test"},
                    { name: "Random Noise Interference", x: 250, y: 110, collisionType: "alert", collisiontext: "First Test"},
                    { name: "Student 1", x: 310, y: 620, collisionType: "alert", collisiontext: "Attention fully restored. Needs reasoning help with english"},
                    { name: "Student 2", x: 660, y: 610, collisionType: "alert", collisiontext: "Attention fully restored. Doesnt speak english."},
                    { name: "Student 3", x: 1010, y: 620, collisionType: "alert", collisiontext: "Attention fully restored. Needs reasoning help with math"},
                ],
            }
        },
        'Fantasy Adventure': {
            background: '/AutoGameBackgrounds/eldoria_background.png',
            inventory: [
                { type: "book", name: "Book of Eldrak", description: "An ancient tome containing half of a map." },
                { type: "amulet", name: "Peculiar Amulet", description: "A mysterious amulet bought in Meridia, reveals the unseen." },
                { type: "map", name: "Tattered Map", description: "A map hinting at significant locations within the Whispering Woods." },
                { type: "artifact", name: "Magical Acorn", description: "A gift from the forest spirit, promising future aid." },
                { type: "relic", name: "Shrine Relic", description: "A powerful artifact that enhances magical abilities, found in the Ruined Shrine." },
                { type: "record", name: "Echoing Cave Echoes", description: "A recording of whispers from the Echoing Caves, revealing secrets and hidden paths." },    
                // ... more fantasy items
            ],
            skills: [
                { branch: "Combat", name: "Sword Mastery", learned: false },
                { branch: "Magic", name: "Elemental Control", learned: false },
                { branch: "Lore", name: "Ancient Lore", learned: true, description: "Ability to decipher old texts and understand magical artifacts, gained at the Ruined Shrine." },
                { branch: "Stealth", name: "Eavesdropping", learned: true, description: "Skill in using acoustics to eavesdrop, developed in the Echoing Caves." },
                { branch: "Stealth", name: "Stealth Movement", learned: true, description: "Improved stealth for moving unseen, honed in the Echoing Caves." },
                { branch: "Diplomacy", name: "Negotiation", learned: true, description: "Enhanced negotiation skills, honed through interaction with the spirits of the Forgotten Graveyard." },
                { branch: "Magic", name: "Artifact Mastery", learned: true, description: "Mastery over various magical artifacts collected throughout the journey." },
                // ... more fantasy skills
            ],
            objectives: [
                { id: "FindBook", name: "Find the Book of Eldrak", complete: false },
                { id: "GetAmulet", name: "Acquire the Peculiar Amulet", complete: false },
                { id: "DiscoverArtefact", name: "Uncover the Artefact of Vorin", complete: false },
                { id: "LeaveEldoria", name: "Leave Eldoria's Outskirts", complete: true },
                { id: "VisitAncientOak", name: "Visit the Ancient Oak", complete: true },
                { id: "ExploreCrystalClearing", name: "Explore the Crystal Clearing", complete: true },
                { id: "DiscoverRuinedShrine", name: "Discover the Ruined Shrine", complete: true },
                { id: "NavigateEchoingCaves", name: "Navigate the Echoing Caves", complete: true },
                { id: "UncoverForgottenGraveyard", name: "Uncover the Secrets of the Forgotten Graveyard", complete: true },
                { id: "MasterArtifacts", name: "Master the Use of Collected Artifacts", complete: true },    
                // ... more fantasy objectives
            ],
            storyparttargets: {
                0: [
                    { name: "Eldoria Main Square", x: 410, y: 590, collisionType: "requirementsgated", collisiontext: "The heart of Eldoria, bustling with townsfolk and traders.", requirements: (8)},
                    { name: "Lila's Home", x: 460, y: 600, collisionType: "alert", collisiontext: "A cozy cottage where Lila's quest for knowledge begins."},
                    { name: "Eldoria Library", x: 360, y: 620, collisionType: "alert", collisiontext: "A treasure trove of books and maps. Lila spends hours here."},
                    { name: "Whispering Forest Edge", x: 830, y: 700, collisionType: "alert", collisiontext: "The mysterious forest that borders Eldoria. Lila feels drawn to its secrets."},
                    { name: "Serene Hills", x: 520, y: 490, collisionType: "alert", collisiontext: "Gentle hills that promise adventure beyond Eldoria. Lila often gazes here, dreaming of what lies beyond."},
                    { name: "Marketplace", x: 360, y: 560, collisionType: "alert", collisiontext: "A place of trade and gossip. Lila hears rumors of ancient artifacts here."},
                    { name: "Eldoria", x: 490, y: 420, collisionType: "storypartchange", collisiontext: "Your journey begins in the quaint town of Eldoria.", newStage: 1},
                    { name: "Old Sage's Hut", x: 600, y: 480, collisionType: "alert", collisiontext: "The home of Eldoria's oldest sage. Lila seeks his wisdom for her journey."},
                    { name: "Eldoria's Outskirts", x: 100, y: 10, collisionType: "stats", collisiontext: "Your courage grows as you step into the unknown."},
                    { name: "Tattered Map", x: 200, y: 20, collisionType: "inventory", collisiontext: "You've found a map that hints at significant locations in the Whispering Woods."},
                ],
                1: [
                    { name: "Library of Eldrak", x: 620, y: 600, collisionType: "alert", collisiontext: "You discover the ancient Book of Eldrak."},
                    { name: "Meridia Market", x: 750, y: 590, collisionType: "alert", collisiontext: "A peculiar amulet catches your eye, promising to reveal the unseen."},
                    { name: "Suspicious Place", x: 810, y: 530, collisionType: "decision", collisiontext: "Do you know why you came here?"},
                    { name: "The Ancient Oak", x: 300, y: 130, collisionType: "modal", modalConfig: {
                        title: "The Ancient Oak Area",
                        content: "The Ancient Oak stands before you,",
                        actions: [
                            {label: "Talk to the Ancient Oak", action: "approachAncientOak"},
                            // ... more actions if necessary
                        ]} 
                    },
                    { name: "Magical Acorn", x: 400, y: 140, collisionType: "modal", modalConfig: {
                        title: "Magical Acorn Area",
                        content: "You are drawn to the acorn but as you near it a spirit appears",
                        actions: [
                            {label: "Talk to the spirit", action: "acquireMagicalAcorn"},
                            // ... more actions if necessary
                        ]} 
                    },
                ],
                2: [
                    { name: "Whispering Woods", x: 400, y: 300, collisionType: "modal", collisiontext: "The woods are dense and mysterious, hiding both allies and secrets."},
                    { name: "The Crystal Clearing", x: 500, y: 50, collisionType: "location", collisiontext: "Visions of potential futures flash before your eyes."},
                    { name: "The Ruined Shrine", x: 600, y: 60, collisionType: "location", collisiontext: "You discover a relic among the ruins, learning about a forgotten deity."},
                ],
                3: [
                    { name: "Shadowed Caverns", x: 600, y: 400, collisionType: "fight", collisiontext: "The lair of the Keepers. A test of strength and wit awaits."},
                    { name: "Ancient Lore Skill", x: 370, y: 70, collisionType: "skills", collisiontext: "You've gained the skill to decipher old texts and understand magical artifacts."},
                    { name: "Shrine Relic", x: 480, y: 80, collisionType: "inventory", collisiontext: "This powerful artifact enhances your magical abilities."},
                ],
                4: [
                    { name: "Return to Eldoria", x: 100, y: 500, collisionType: "end", collisiontext: "With the Artefact of Vorin, you return, forever changed by your journey."},
                    { name: "Echoing Cave Echoes", x: 90, y: 90, collisionType: "inventory", collisiontext: "You record the cave's whispers, a strategic item."},
                    { name: "Eavesdropping Skill", x: 100, y: 100, collisionType: "skills", collisiontext: "You learn to use the cave's acoustics to eavesdrop."},        
                ],
                5: [
                    { name: "Stealth Skill", x: 110, y: 110, collisionType: "skills", collisiontext: "Navigating the caves, you improve your stealth."},
                    { name: "Negotiation Skill", x: 120, y: 120, collisionType: "skills", collisiontext: "You've honed your negotiation skills with the spirits."},
                ],
                6: [
                    { name: "Endurance Increase", x: 130, y: 130, collisionType: "stats", collisiontext: "The trials in the graveyard boost your endurance."},
                    { name: "Intelligence Increase", x: 140, y: 140, collisionType: "stats", collisiontext: "Piecing together clues, your intelligence grows."},
                ],
                7: [
                    { name: "Artifact Mastery Skill", x: 150, y: 150, collisionType: "skills", collisiontext: "You master the use of the artifacts you've collected."},
                ]
                // ... additional story parts as needed
            }
        },    
    };

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

    const { Object: Object_1$2, console: console_1$5 } = globals;

    const file$7 = "src\\MovingDotSpacePortfromReact.svelte";

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

    function get_each_context_1$1(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[28] = list[i];
    	return child_ctx;
    }

    // (177:4) {#each themeKeys as key}
    function create_each_block_1$1(ctx) {
    	let option;
    	let t_value = /*key*/ ctx[28] + "";
    	let t;

    	const block = {
    		c: function create() {
    			option = element("option");
    			t = text(t_value);
    			option.__value = /*key*/ ctx[28];
    			option.value = option.__value;
    			add_location(option, file$7, 177, 8, 6933);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, option, anchor);
    			append_dev(option, t);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(option);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block_1$1.name,
    		type: "each",
    		source: "(177:4) {#each themeKeys as key}",
    		ctx
    	});

    	return block;
    }

    // (187:4) {#each $targets as target (target.name)}
    function create_each_block$4(key_1, ctx) {
    	let first;
    	let target;
    	let t0;
    	let span;
    	let t1_value = /*target*/ ctx[25].name + "";
    	let t1;
    	let current;

    	target = new MovingDotTargetPortfromReact({
    			props: { position: /*target*/ ctx[25] },
    			$$inline: true
    		});

    	const block = {
    		key: key_1,
    		first: null,
    		c: function create() {
    			first = empty();
    			create_component(target.$$.fragment);
    			t0 = space();
    			span = element("span");
    			t1 = text(t1_value);
    			set_style(span, "position", "absolute");
    			set_style(span, "left", /*target*/ ctx[25].x + "px");
    			set_style(span, "top", /*target*/ ctx[25].y + "px");
    			add_location(span, file$7, 188, 8, 7979);
    			this.first = first;
    		},
    		m: function mount(target$1, anchor) {
    			insert_dev(target$1, first, anchor);
    			mount_component(target, target$1, anchor);
    			insert_dev(target$1, t0, anchor);
    			insert_dev(target$1, span, anchor);
    			append_dev(span, t1);
    			current = true;
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			const target_changes = {};
    			if (dirty & /*$targets*/ 1024) target_changes.position = /*target*/ ctx[25];
    			target.$set(target_changes);
    			if ((!current || dirty & /*$targets*/ 1024) && t1_value !== (t1_value = /*target*/ ctx[25].name + "")) set_data_dev(t1, t1_value);

    			if (!current || dirty & /*$targets*/ 1024) {
    				set_style(span, "left", /*target*/ ctx[25].x + "px");
    			}

    			if (!current || dirty & /*$targets*/ 1024) {
    				set_style(span, "top", /*target*/ ctx[25].y + "px");
    			}
    		},
    		i: function intro(local) {
    			if (current) return;
    			transition_in(target.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(target.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(first);
    			destroy_component(target, detaching);
    			if (detaching) detach_dev(t0);
    			if (detaching) detach_dev(span);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$4.name,
    		type: "each",
    		source: "(187:4) {#each $targets as target (target.name)}",
    		ctx
    	});

    	return block;
    }

    // (193:4) {#if isModalOpen}
    function create_if_block$3(ctx) {
    	let modal;
    	let current;

    	modal = new MovingDotSpaceSimpleModal({
    			props: {
    				isOpen: /*isModalOpen*/ ctx[3],
    				onClose: /*handleModalClose*/ ctx[16],
    				title: /*currentcollisiontitletext*/ ctx[4],
    				content: /*currentcollisiontext*/ ctx[5],
    				items: /*currentcollisionitems*/ ctx[6],
    				currentTheme: /*currentTheme*/ ctx[8]
    			},
    			$$inline: true
    		});

    	const block = {
    		c: function create() {
    			create_component(modal.$$.fragment);
    		},
    		m: function mount(target, anchor) {
    			mount_component(modal, target, anchor);
    			current = true;
    		},
    		p: function update(ctx, dirty) {
    			const modal_changes = {};
    			if (dirty & /*isModalOpen*/ 8) modal_changes.isOpen = /*isModalOpen*/ ctx[3];
    			if (dirty & /*currentcollisiontitletext*/ 16) modal_changes.title = /*currentcollisiontitletext*/ ctx[4];
    			if (dirty & /*currentcollisiontext*/ 32) modal_changes.content = /*currentcollisiontext*/ ctx[5];
    			if (dirty & /*currentcollisionitems*/ 64) modal_changes.items = /*currentcollisionitems*/ ctx[6];
    			if (dirty & /*currentTheme*/ 256) modal_changes.currentTheme = /*currentTheme*/ ctx[8];
    			modal.$set(modal_changes);
    		},
    		i: function intro(local) {
    			if (current) return;
    			transition_in(modal.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(modal.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			destroy_component(modal, detaching);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$3.name,
    		type: "if",
    		source: "(193:4) {#if isModalOpen}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$7(ctx) {
    	let t0;
    	let select;
    	let t1;
    	let dotgamethememanager;
    	let t2;
    	let div1;
    	let canvas_1;
    	let t3;
    	let movingdot;
    	let t4;
    	let div0;
    	let t5;
    	let t6_value = /*$dotPosition*/ ctx[0].x + "";
    	let t6;
    	let t7;
    	let t8_value = /*$dotPosition*/ ctx[0].y + "";
    	let t8;
    	let t9;
    	let t10;
    	let each_blocks = [];
    	let each1_lookup = new Map();
    	let t11;
    	let t12;
    	let movingdotstats;
    	let t13;
    	let h10;
    	let t15;
    	let hr;
    	let t16;
    	let h11;
    	let t18;
    	let fighttest;
    	let t19;
    	let modaltest;
    	let t20;
    	let h12;
    	let t22;
    	let findtest;
    	let t23;
    	let h13;
    	let t25;
    	let ordertest;
    	let current;
    	let mounted;
    	let dispose;
    	let each_value_1 = /*themeKeys*/ ctx[13];
    	validate_each_argument(each_value_1);
    	let each_blocks_1 = [];

    	for (let i = 0; i < each_value_1.length; i += 1) {
    		each_blocks_1[i] = create_each_block_1$1(get_each_context_1$1(ctx, each_value_1, i));
    	}

    	dotgamethememanager = new MovingDotSpaceThemeManager({
    			props: {
    				ChangedContentPlaceholder: /*ChangedContentPlaceholdertoSend*/ ctx[1]
    			},
    			$$inline: true
    		});

    	let movingdot_props = {
    		position: /*$dotPosition*/ ctx[0],
    		boundaries: /*boundaries*/ ctx[12]
    	};

    	movingdot = new MovingDotPortfromReact({ props: movingdot_props, $$inline: true });
    	/*movingdot_binding*/ ctx[20](movingdot);
    	movingdot.$on("move", /*move_handler*/ ctx[21]);
    	let each_value = /*$targets*/ ctx[10];
    	validate_each_argument(each_value);
    	const get_key = ctx => /*target*/ ctx[25].name;
    	validate_each_keys(ctx, each_value, get_each_context$4, get_key);

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

    	let if_block = /*isModalOpen*/ ctx[3] && create_if_block$3(ctx);
    	movingdotstats = new MovingDotStatDisplay({ $$inline: true });
    	fighttest = new MovingDotSpaceGameFight({ $$inline: true });
    	modaltest = new MovingDotSpaceModalBrainstorm({ $$inline: true });
    	findtest = new MovingDotSpaceGameFind({ $$inline: true });
    	ordertest = new MovingDotSpaceGameOrder({ $$inline: true });

    	const block = {
    		c: function create() {
    			t0 = text("Game Selector\r\n");
    			select = element("select");

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

    			t1 = space();
    			create_component(dotgamethememanager.$$.fragment);
    			t2 = space();
    			div1 = element("div");
    			canvas_1 = element("canvas");
    			t3 = space();
    			create_component(movingdot.$$.fragment);
    			t4 = space();
    			div0 = element("div");
    			t5 = text("Minor Game Events Log for player ||| Position for Developer ");
    			t6 = text(t6_value);
    			t7 = space();
    			t8 = text(t8_value);
    			t9 = text(" - TODO - Story Line / Avatars? / Clock System ||| For Job Experience focused Stats can be Emotions Stress Frustration Relief Tiredness Confidence (Percieved Skill) Experience (Actual Skill)");
    			t10 = space();

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

    			t11 = space();
    			if (if_block) if_block.c();
    			t12 = space();
    			create_component(movingdotstats.$$.fragment);
    			t13 = space();
    			h10 = element("h1");
    			h10.textContent = "Game is normally just story with fighting and traversing mechanics repeated in between videos";
    			t15 = space();
    			hr = element("hr");
    			t16 = space();
    			h11 = element("h1");
    			h11.textContent = "Expand this to allow up to 100 fighters on each side";
    			t18 = space();
    			create_component(fighttest.$$.fragment);
    			t19 = space();
    			create_component(modaltest.$$.fragment);
    			t20 = space();
    			h12 = element("h1");
    			h12.textContent = "Find games are choices between similar looking items missing information with limited information (Luck = More Targets)";
    			t22 = space();
    			create_component(findtest.$$.fragment);
    			t23 = space();
    			h13 = element("h1");
    			h13.textContent = "Find out/ make sense / Resolve Conflict = order mixed up and";
    			t25 = space();
    			create_component(ordertest.$$.fragment);
    			if (/*currentTheme*/ ctx[8] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[18].call(select));
    			add_location(select, file$7, 175, 0, 6835);
    			set_style(canvas_1, "width", "100%");
    			set_style(canvas_1, "height", "100%");
    			attr_dev(canvas_1, "tabindex", "0");
    			add_location(canvas_1, file$7, 183, 4, 7315);
    			attr_dev(div0, "id", "overlayText");
    			attr_dev(div0, "class", "svelte-c2nwl9");
    			add_location(div0, file$7, 185, 4, 7573);
    			attr_dev(div1, "id", "game-container");
    			set_style(div1, "position", "relative");
    			set_style(div1, "width", "100%");
    			set_style(div1, "height", "100vh");
    			set_style(div1, "border", "1px solid black");
    			set_style(div1, "overflow", "hidden");
    			set_style(div1, "background-image", "url('" + /*CurrentGameBackground*/ ctx[9] + "')");
    			set_style(div1, "background-size", "cover");
    			set_style(div1, "background-position", "center");
    			add_location(div1, file$7, 182, 0, 7082);
    			add_location(h10, file$7, 199, 0, 8403);
    			add_location(hr, file$7, 200, 0, 8507);
    			add_location(h11, file$7, 201, 0, 8513);
    			add_location(h12, file$7, 204, 0, 8606);
    			add_location(h13, file$7, 206, 0, 8751);
    		},
    		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, t0, anchor);
    			insert_dev(target, select, anchor);

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

    			select_option(select, /*currentTheme*/ ctx[8], true);
    			insert_dev(target, t1, anchor);
    			mount_component(dotgamethememanager, target, anchor);
    			insert_dev(target, t2, anchor);
    			insert_dev(target, div1, anchor);
    			append_dev(div1, canvas_1);
    			/*canvas_1_binding*/ ctx[19](canvas_1);
    			append_dev(div1, t3);
    			mount_component(movingdot, div1, null);
    			append_dev(div1, t4);
    			append_dev(div1, div0);
    			append_dev(div0, t5);
    			append_dev(div0, t6);
    			append_dev(div0, t7);
    			append_dev(div0, t8);
    			append_dev(div0, t9);
    			append_dev(div1, t10);

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

    			append_dev(div1, t11);
    			if (if_block) if_block.m(div1, null);
    			insert_dev(target, t12, anchor);
    			mount_component(movingdotstats, target, anchor);
    			insert_dev(target, t13, anchor);
    			insert_dev(target, h10, anchor);
    			insert_dev(target, t15, anchor);
    			insert_dev(target, hr, anchor);
    			insert_dev(target, t16, anchor);
    			insert_dev(target, h11, anchor);
    			insert_dev(target, t18, anchor);
    			mount_component(fighttest, target, anchor);
    			insert_dev(target, t19, anchor);
    			mount_component(modaltest, target, anchor);
    			insert_dev(target, t20, anchor);
    			insert_dev(target, h12, anchor);
    			insert_dev(target, t22, anchor);
    			mount_component(findtest, target, anchor);
    			insert_dev(target, t23, anchor);
    			insert_dev(target, h13, anchor);
    			insert_dev(target, t25, anchor);
    			mount_component(ordertest, target, anchor);
    			current = true;

    			if (!mounted) {
    				dispose = [
    					listen_dev(select, "change", /*select_change_handler*/ ctx[18]),
    					listen_dev(select, "change", /*changeTheme*/ ctx[14], false, false, false, false),
    					listen_dev(canvas_1, "click", /*handleSpaceClick*/ ctx[15], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*themeKeys*/ 8192) {
    				each_value_1 = /*themeKeys*/ ctx[13];
    				validate_each_argument(each_value_1);
    				let i;

    				for (i = 0; i < each_value_1.length; i += 1) {
    					const child_ctx = get_each_context_1$1(ctx, each_value_1, i);

    					if (each_blocks_1[i]) {
    						each_blocks_1[i].p(child_ctx, dirty);
    					} else {
    						each_blocks_1[i] = create_each_block_1$1(child_ctx);
    						each_blocks_1[i].c();
    						each_blocks_1[i].m(select, null);
    					}
    				}

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

    				each_blocks_1.length = each_value_1.length;
    			}

    			if (dirty & /*currentTheme, themeKeys*/ 8448) {
    				select_option(select, /*currentTheme*/ ctx[8]);
    			}

    			const dotgamethememanager_changes = {};
    			if (dirty & /*ChangedContentPlaceholdertoSend*/ 2) dotgamethememanager_changes.ChangedContentPlaceholder = /*ChangedContentPlaceholdertoSend*/ ctx[1];
    			dotgamethememanager.$set(dotgamethememanager_changes);
    			const movingdot_changes = {};
    			if (dirty & /*$dotPosition*/ 1) movingdot_changes.position = /*$dotPosition*/ ctx[0];
    			movingdot.$set(movingdot_changes);
    			if ((!current || dirty & /*$dotPosition*/ 1) && t6_value !== (t6_value = /*$dotPosition*/ ctx[0].x + "")) set_data_dev(t6, t6_value);
    			if ((!current || dirty & /*$dotPosition*/ 1) && t8_value !== (t8_value = /*$dotPosition*/ ctx[0].y + "")) set_data_dev(t8, t8_value);

    			if (dirty & /*$targets*/ 1024) {
    				each_value = /*$targets*/ ctx[10];
    				validate_each_argument(each_value);
    				group_outros();
    				validate_each_keys(ctx, each_value, get_each_context$4, get_key);
    				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each1_lookup, div1, outro_and_destroy_block, create_each_block$4, t11, get_each_context$4);
    				check_outros();
    			}

    			if (/*isModalOpen*/ ctx[3]) {
    				if (if_block) {
    					if_block.p(ctx, dirty);

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

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

    				check_outros();
    			}

    			if (!current || dirty & /*CurrentGameBackground*/ 512) {
    				set_style(div1, "background-image", "url('" + /*CurrentGameBackground*/ ctx[9] + "')");
    			}
    		},
    		i: function intro(local) {
    			if (current) return;
    			transition_in(dotgamethememanager.$$.fragment, local);
    			transition_in(movingdot.$$.fragment, local);

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

    			transition_in(if_block);
    			transition_in(movingdotstats.$$.fragment, local);
    			transition_in(fighttest.$$.fragment, local);
    			transition_in(modaltest.$$.fragment, local);
    			transition_in(findtest.$$.fragment, local);
    			transition_in(ordertest.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(dotgamethememanager.$$.fragment, local);
    			transition_out(movingdot.$$.fragment, local);

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

    			transition_out(if_block);
    			transition_out(movingdotstats.$$.fragment, local);
    			transition_out(fighttest.$$.fragment, local);
    			transition_out(modaltest.$$.fragment, local);
    			transition_out(findtest.$$.fragment, local);
    			transition_out(ordertest.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(t0);
    			if (detaching) detach_dev(select);
    			destroy_each(each_blocks_1, detaching);
    			if (detaching) detach_dev(t1);
    			destroy_component(dotgamethememanager, detaching);
    			if (detaching) detach_dev(t2);
    			if (detaching) detach_dev(div1);
    			/*canvas_1_binding*/ ctx[19](null);
    			/*movingdot_binding*/ ctx[20](null);
    			destroy_component(movingdot);

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

    			if (if_block) if_block.d();
    			if (detaching) detach_dev(t12);
    			destroy_component(movingdotstats, detaching);
    			if (detaching) detach_dev(t13);
    			if (detaching) detach_dev(h10);
    			if (detaching) detach_dev(t15);
    			if (detaching) detach_dev(hr);
    			if (detaching) detach_dev(t16);
    			if (detaching) detach_dev(h11);
    			if (detaching) detach_dev(t18);
    			destroy_component(fighttest, detaching);
    			if (detaching) detach_dev(t19);
    			destroy_component(modaltest, detaching);
    			if (detaching) detach_dev(t20);
    			if (detaching) detach_dev(h12);
    			if (detaching) detach_dev(t22);
    			destroy_component(findtest, detaching);
    			if (detaching) detach_dev(t23);
    			if (detaching) detach_dev(h13);
    			if (detaching) detach_dev(t25);
    			destroy_component(ordertest, detaching);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function instance$7($$self, $$props, $$invalidate) {
    	let $dotPosition;
    	let $targets;
    	validate_store(targets, 'targets');
    	component_subscribe($$self, targets, $$value => $$invalidate(10, $targets = $$value));
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('MovingDotSpacePortfromReact', slots, []);
    	let ChangedContentPlaceholdertoSend = "No changes";
    	let canvas;
    	let dotPosition = writable({ x: 900, y: 450 });
    	validate_store(dotPosition, 'dotPosition');
    	component_subscribe($$self, dotPosition, value => $$invalidate(0, $dotPosition = value));
    	let boundaries = { maxX: 1835, maxY: 890, minX: 0, minY: 0 };
    	let isModalOpen = false;
    	let currentcollisiontitletext;
    	let currentcollisiontext;
    	let currentcollisionitems = [];
    	let movingDotElement;
    	let currentTheme = 'Medieval Fantasy'; // default theme
    	let currentThemeStage = 0;
    	let themeKeys = Object.keys(themes);
    	let CurrentGameBackground = themes[currentTheme].background; //GameBackgrounds[0].url;
    	inventory$1.set(themes[currentTheme].inventory);
    	skills$1.set(themes[currentTheme].skills);
    	objectives.set(themes[currentTheme].objectives);
    	targets.set(themes[currentTheme].storyparttargets[0]);

    	function changeTheme(event) {
    		$$invalidate(8, currentTheme = event.target.value);
    		const theme = themes[currentTheme];
    		inventory$1.set(theme.inventory);
    		skills$1.set(theme.skills);
    		objectives.set(theme.objectives);
    		currentThemeStage = 0; // Resetting currentThemeStage to 0
    		targets.set(theme.storyparttargets[0]);
    		$$invalidate(9, CurrentGameBackground = theme.background);
    		$$invalidate(1, ChangedContentPlaceholdertoSend = "TODO is all other variables to change");
    	}

    	function handleSpaceClick() {
    		//console.log('Container clicked!', event);
    		movingDotElement.focusDot();
    	}

    	function handleModalClose() {
    		$$invalidate(3, isModalOpen = false);
    		movingDotElement.focusDot();
    	}

    	function updateDotPosition(newX, newY) {
    		dotPosition.set({ x: newX, y: newY });
    	}

    	// Collision check function
    	const checkCollision = dotPos => {
    		$targets.forEach(target => {
    			if (dotPos.x < target.x + 10 && dotPos.x + 10 > target.x && dotPos.y < target.y + 10 && dotPos.y + 10 > target.y) {
    				handleCollision(target);
    			}
    		});
    	};

    	// Handle collision based on the target object
    	const handleCollision = target => {
    		switch (target.collisionType) {
    			case "":
    				console.log("Nothing Happenedddd");
    				break;
    			case "alert":
    				alert(target.collisiontext);
    				break;
    			case "decision":
    				if (confirm(target.collisiontext)) {
    					alert("You said yes");
    				} else {
    					alert("You said no");
    				}
    				break;
    			case "modal":
    				$$invalidate(3, isModalOpen = true);
    				$$invalidate(4, currentcollisiontitletext = target.modalConfig.title);
    				$$invalidate(5, currentcollisiontext = target.modalConfig.content);
    				$$invalidate(6, currentcollisionitems = target.modalConfig.actions);
    				break;
    			case "storypartchange":
    				currentThemeStage = target.newStage;
    				targets.set(themes[currentTheme].storyparttargets[currentThemeStage]);
    				break;
    			case "requirementsgated":
    				if (target.requirements > 5) {
    					alert(target.collisiontext);
    				} else {
    					alert("You have not journeyed enough to explore this area yet (Stats required: and an inventory item)");
    				}
    				break;
    		} // Handle other permanent UI elements here
    	}; // ...
    	//ChatGPT Suggested Options
    	// Change the background color of the canvas or a specific element.
    	// case "changeBackgroundColor":

    	const writable_props = [];

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

    	function select_change_handler() {
    		currentTheme = select_value(this);
    		$$invalidate(8, currentTheme);
    		$$invalidate(13, themeKeys);
    	}

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

    	function movingdot_binding($$value) {
    		binding_callbacks[$$value ? 'unshift' : 'push'](() => {
    			movingDotElement = $$value;
    			$$invalidate(7, movingDotElement);
    		});
    	}

    	const move_handler = e => updateDotPosition(e.detail.x, e.detail.y);

    	$$self.$capture_state = () => ({
    		onMount,
    		writable,
    		MovingDot: MovingDotPortfromReact,
    		Target: MovingDotTargetPortfromReact,
    		Modal: MovingDotSpaceSimpleModal,
    		MovingDotStats: MovingDotStatDisplay,
    		DotGameThemeManager: MovingDotSpaceThemeManager,
    		FightTest: MovingDotSpaceGameFight,
    		ModalTest: MovingDotSpaceModalBrainstorm,
    		FindTest: MovingDotSpaceGameFind,
    		OrderTest: MovingDotSpaceGameOrder,
    		themes,
    		inventory: inventory$1,
    		skills: skills$1,
    		objectives,
    		targets,
    		ChangedContentPlaceholdertoSend,
    		canvas,
    		dotPosition,
    		boundaries,
    		isModalOpen,
    		currentcollisiontitletext,
    		currentcollisiontext,
    		currentcollisionitems,
    		movingDotElement,
    		currentTheme,
    		currentThemeStage,
    		themeKeys,
    		CurrentGameBackground,
    		changeTheme,
    		handleSpaceClick,
    		handleModalClose,
    		updateDotPosition,
    		checkCollision,
    		handleCollision,
    		$dotPosition,
    		$targets
    	});

    	$$self.$inject_state = $$props => {
    		if ('ChangedContentPlaceholdertoSend' in $$props) $$invalidate(1, ChangedContentPlaceholdertoSend = $$props.ChangedContentPlaceholdertoSend);
    		if ('canvas' in $$props) $$invalidate(2, canvas = $$props.canvas);
    		if ('dotPosition' in $$props) $$invalidate(11, dotPosition = $$props.dotPosition);
    		if ('boundaries' in $$props) $$invalidate(12, boundaries = $$props.boundaries);
    		if ('isModalOpen' in $$props) $$invalidate(3, isModalOpen = $$props.isModalOpen);
    		if ('currentcollisiontitletext' in $$props) $$invalidate(4, currentcollisiontitletext = $$props.currentcollisiontitletext);
    		if ('currentcollisiontext' in $$props) $$invalidate(5, currentcollisiontext = $$props.currentcollisiontext);
    		if ('currentcollisionitems' in $$props) $$invalidate(6, currentcollisionitems = $$props.currentcollisionitems);
    		if ('movingDotElement' in $$props) $$invalidate(7, movingDotElement = $$props.movingDotElement);
    		if ('currentTheme' in $$props) $$invalidate(8, currentTheme = $$props.currentTheme);
    		if ('currentThemeStage' in $$props) currentThemeStage = $$props.currentThemeStage;
    		if ('themeKeys' in $$props) $$invalidate(13, themeKeys = $$props.themeKeys);
    		if ('CurrentGameBackground' in $$props) $$invalidate(9, CurrentGameBackground = $$props.CurrentGameBackground);
    	};

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

    	$$self.$$.update = () => {
    		if ($$self.$$.dirty & /*$dotPosition*/ 1) {
    			//     document.body.style.backgroundColor = target.color;
    			//     break;
    			// Play a sound effect. You'll need to pre-load these sounds.
    			// case "playSound":
    			//     new Audio(target.soundUrl).play();
    			//     break;
    			// Redirect the user to a different URL.
    			// case "redirect":
    			//     window.location.href = target.url;
    			//     break;
    			// Increase the size of the dot.
    			// case "enlargeDot":
    			//     dotElement.style.transform = "scale(1.5)";
    			//     break;
    			// Decrease the size of the dot.
    			// case "shrinkDot":
    			//     dotElement.style.transform = "scale(0.5)";
    			//     break;
    			// Apply a rotation to the dot.
    			// case "rotateDot":
    			//     dotElement.style.transform = "rotate(45deg)";
    			//     break;
    			// Toggle the visibility of a specific element on the page.
    			// case "toggleVisibility":
    			//     let elem = document.getElementById(target.elementId);
    			//     elem.style.display = elem.style.display === 'none' ? 'block' : 'none';
    			//     break;
    			// Trigger a CSS animation on a specific element.
    			// case "startAnimation":
    			//     let animElem = document.getElementById(target.elementId);
    			//     animElem.classList.add(target.animationClass);
    			//     break;
    			// Increase a score or counter displayed on the screen.
    			// case "incrementScore":
    			//     score += target.incrementValue;
    			//     updateScoreDisplay(); // Assuming you have a function to update the score display
    			//     break;
    			// Change the color of the dot.
    			// case "changeDotColor":
    			//     dotElement.style.backgroundColor = target.color;
    			//     break;
    			// Reactive statement to check collision whenever dotPosition changes
    			$dotPosition && checkCollision($dotPosition);
    		}
    	};

    	return [
    		$dotPosition,
    		ChangedContentPlaceholdertoSend,
    		canvas,
    		isModalOpen,
    		currentcollisiontitletext,
    		currentcollisiontext,
    		currentcollisionitems,
    		movingDotElement,
    		currentTheme,
    		CurrentGameBackground,
    		$targets,
    		dotPosition,
    		boundaries,
    		themeKeys,
    		changeTheme,
    		handleSpaceClick,
    		handleModalClose,
    		updateDotPosition,
    		select_change_handler,
    		canvas_1_binding,
    		movingdot_binding,
    		move_handler
    	];
    }

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

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

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

    const { console: console_1$4 } = globals;
    const file$6 = "src\\YoutubeIframeAPICustomInterface.svelte";

    function create_fragment$6(ctx) {
    	let h1;
    	let t1;
    	let label;
    	let t2;
    	let input0;
    	let t3;
    	let input1;
    	let t4;
    	let textarea;
    	let t5;
    	let button0;
    	let t7;
    	let pre;
    	let t8;
    	let t9;
    	let div3;
    	let div0;
    	let t10;
    	let div1;
    	let t11;
    	let t12_value = /*currentTime*/ ctx[4].toFixed(2) + "";
    	let t12;
    	let t13;
    	let t14;
    	let div2;
    	let t15;
    	let t16;
    	let br0;
    	let t17;
    	let t18;
    	let t19;
    	let div4;
    	let t21;
    	let button1;
    	let t25;
    	let button2;
    	let t29;
    	let t30;
    	let t31;
    	let t32_value = /*timestamps*/ ctx[11].length + "";
    	let t32;
    	let t33;
    	let br1;
    	let t34;
    	let button3;
    	let t36;
    	let button4;
    	let t37;
    	let button4_class_value;
    	let button4_disabled_value;
    	let t38;
    	let button5;
    	let t39;
    	let button5_class_value;
    	let button5_disabled_value;
    	let t40;
    	let button6;
    	let t41;
    	let button6_class_value;
    	let button6_disabled_value;
    	let t42;
    	let t43;
    	let t44;
    	let t45_value = /*userTimestamps*/ ctx[1].length + "";
    	let t45;
    	let t46;
    	let br2;
    	let t47;
    	let t48;
    	let t49;
    	let t50_value = /*r2userTimestamps*/ ctx[12].length + "";
    	let t50;
    	let t51;
    	let br3;
    	let t52;
    	let br4;
    	let t53;
    	let button7;
    	let t55;
    	let button8;
    	let t57;
    	let input2;
    	let t58;
    	let br5;
    	let t59;
    	let input3;
    	let t60;
    	let input4;
    	let t61;
    	let input5;
    	let t62;
    	let input6;
    	let mounted;
    	let dispose;

    	const block = {
    		c: function create() {
    			h1 = element("h1");
    			h1.textContent = "Custom Youtube Player for learning Video and music";
    			t1 = space();
    			label = element("label");
    			t2 = text("Sample Video Ids (mwO6v4BlgZQ | IVJkOHTBPn0 )\r\n    ");
    			input0 = element("input");
    			t3 = text("\r\n    Start/Stop Word Update (Dummy Transcript as default)\r\n    ");
    			input1 = element("input");
    			t4 = space();
    			textarea = element("textarea");
    			t5 = space();
    			button0 = element("button");
    			button0.textContent = "Convert to JSON";
    			t7 = space();
    			pre = element("pre");
    			t8 = text(/*jsonOutput*/ ctx[6]);
    			t9 = space();
    			div3 = element("div");
    			div0 = element("div");
    			t10 = space();
    			div1 = element("div");
    			t11 = text("Current Time: ");
    			t12 = text(t12_value);
    			t13 = text(" seconds");
    			t14 = space();
    			div2 = element("div");
    			t15 = text(/*line*/ ctx[8]);
    			t16 = space();
    			br0 = element("br");
    			t17 = space();
    			t18 = text(/*currentWord*/ ctx[7]);
    			t19 = space();
    			div4 = element("div");
    			div4.textContent = "Placeholder for incomplete idea of image subtitle - each word or each noun in the sentence as collage (Dall-E 3) or sentence meaning as an image";
    			t21 = space();
    			button1 = element("button");
    			button1.textContent = `Previous Auto Timestamp - ${/*interval*/ ctx[19]}s`;
    			t25 = space();
    			button2 = element("button");
    			button2.textContent = `Next Auto Timestamp - ${/*interval*/ ctx[19]}s`;
    			t29 = text("\r\nAuto Timestamps: ");
    			t30 = text(/*currentIndex*/ ctx[10]);
    			t31 = text(" / ");
    			t32 = text(t32_value);
    			t33 = space();
    			br1 = element("br");
    			t34 = space();
    			button3 = element("button");
    			button3.textContent = "Add Timestamp";
    			t36 = space();
    			button4 = element("button");
    			t37 = text("Current User Timestamp (incomplete)");
    			t38 = space();
    			button5 = element("button");
    			t39 = text("Previous User Timestamp");
    			t40 = space();
    			button6 = element("button");
    			t41 = text("Next User Timestamp");
    			t42 = text("\r\nUser Timestamps: ");
    			t43 = text(/*currentuserIndex*/ ctx[0]);
    			t44 = text(" / ");
    			t45 = text(t45_value);
    			t46 = space();
    			br2 = element("br");
    			t47 = text(" Round 2 (/n) User Timestamps: ");
    			t48 = text(/*currentuserIndex*/ ctx[0]);
    			t49 = text(" / ");
    			t50 = text(t50_value);
    			t51 = space();
    			br3 = element("br");
    			t52 = text("A list of one messes up the logic for the counter in conjuction with the user timestamp button reactivity ");
    			br4 = element("br");
    			t53 = space();
    			button7 = element("button");
    			button7.textContent = "Export Timestamps";
    			t55 = space();
    			button8 = element("button");
    			button8.textContent = "Export Round 2 Timestamps";
    			t57 = text(" Import Timestamps (Incomplete) ");
    			input2 = element("input");
    			t58 = space();
    			br5 = element("br");
    			t59 = text(" Interval Repeat ");
    			input3 = element("input");
    			t60 = text(" ||| Start ");
    			input4 = element("input");
    			t61 = text(" End ");
    			input5 = element("input");
    			t62 = text(" Reps ");
    			input6 = element("input");
    			add_location(h1, file$6, 333, 0, 11319);
    			attr_dev(input0, "type", "text");
    			add_location(input0, file$6, 337, 4, 11446);
    			attr_dev(input1, "type", "checkbox");
    			add_location(input1, file$6, 339, 4, 11557);
    			attr_dev(textarea, "placeholder", "Enter transcript here...");
    			add_location(textarea, file$6, 344, 4, 11880);
    			add_location(button0, file$6, 345, 4, 11970);
    			attr_dev(pre, "class", "transcriptpre svelte-udvqea");
    			add_location(pre, file$6, 346, 4, 12036);
    			add_location(label, file$6, 335, 0, 11382);
    			attr_dev(div0, "id", "youtube-player");
    			set_style(div0, "height", "90vh");
    			set_style(div0, "width", "90%");
    			add_location(div0, file$6, 350, 4, 12134);
    			set_style(div1, "position", "absolute");
    			set_style(div1, "top", "0%");
    			set_style(div1, "left", "40%");
    			set_style(div1, "color", "white");
    			set_style(div1, "background-color", "rgba(0, 0, 0, 0.5)");
    			add_location(div1, file$6, 351, 4, 12204);
    			add_location(br0, file$6, 355, 15, 12524);
    			set_style(div2, "position", "absolute");
    			set_style(div2, "top", "50%");
    			set_style(div2, "left", "20%");
    			set_style(div2, "color", "white");
    			set_style(div2, "background-color", "rgba(0, 0, 0, 0.5)");
    			set_style(div2, "font-size", "100px");
    			add_location(div2, file$6, 354, 4, 12383);
    			set_style(div3, "position", "relative");
    			add_location(div3, file$6, 349, 0, 12095);
    			attr_dev(div4, "class", "imagesubtitle svelte-udvqea");
    			add_location(div4, file$6, 359, 0, 12573);
    			add_location(button1, file$6, 364, 0, 12837);
    			add_location(button2, file$6, 365, 0, 12930);
    			add_location(br1, file$6, 368, 0, 13072);
    			add_location(button3, file$6, 369, 0, 13078);
    			attr_dev(button4, "class", button4_class_value = "" + (null_to_empty(/*currentindexButtonClass*/ ctx[16]) + " svelte-udvqea"));
    			button4.disabled = button4_disabled_value = /*currentuserIndex*/ ctx[0] <= 0;
    			add_location(button4, file$6, 370, 0, 13138);
    			attr_dev(button5, "class", button5_class_value = "" + (null_to_empty(/*previousindexButtonClass*/ ctx[17]) + " svelte-udvqea"));
    			button5.disabled = button5_disabled_value = /*currentuserIndex*/ ctx[0] <= 0;
    			add_location(button5, file$6, 371, 0, 13293);
    			attr_dev(button6, "class", button6_class_value = "" + (null_to_empty(/*nextindexButtonClass*/ ctx[18]) + " svelte-udvqea"));
    			button6.disabled = button6_disabled_value = /*currentuserIndex*/ ctx[0] >= /*userTimestamps*/ ctx[1].length - 1;
    			add_location(button6, file$6, 372, 0, 13438);
    			add_location(br2, file$6, 375, 0, 13661);
    			add_location(br3, file$6, 375, 82, 13743);
    			add_location(br4, file$6, 375, 192, 13853);
    			add_location(button7, file$6, 376, 0, 13859);
    			add_location(button8, file$6, 376, 63, 13922);
    			attr_dev(input2, "type", "file");
    			attr_dev(input2, "accept", ".json");
    			add_location(input2, file$6, 376, 167, 14026);
    			add_location(br5, file$6, 377, 0, 14091);
    			attr_dev(input3, "type", "checkbox");
    			add_location(input3, file$6, 377, 21, 14112);
    			attr_dev(input4, "type", "number");
    			attr_dev(input4, "class", "numberinput svelte-udvqea");
    			attr_dev(input4, "min", "0");
    			add_location(input4, file$6, 377, 82, 14173);
    			attr_dev(input5, "type", "number");
    			attr_dev(input5, "class", "numberinput svelte-udvqea");
    			attr_dev(input5, "min", "0");
    			add_location(input5, file$6, 377, 162, 14253);
    			attr_dev(input6, "type", "number");
    			attr_dev(input6, "class", "numberinput svelte-udvqea");
    			attr_dev(input6, "min", "0");
    			add_location(input6, file$6, 377, 241, 14332);
    		},
    		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, h1, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, label, anchor);
    			append_dev(label, t2);
    			append_dev(label, input0);
    			set_input_value(input0, /*currentvideoId*/ ctx[2]);
    			append_dev(label, t3);
    			append_dev(label, input1);
    			input1.checked = /*isUpdating*/ ctx[9];
    			append_dev(label, t4);
    			append_dev(label, textarea);
    			set_input_value(textarea, /*transcript*/ ctx[5]);
    			append_dev(label, t5);
    			append_dev(label, button0);
    			append_dev(label, t7);
    			append_dev(label, pre);
    			append_dev(pre, t8);
    			insert_dev(target, t9, anchor);
    			insert_dev(target, div3, anchor);
    			append_dev(div3, div0);
    			append_dev(div3, t10);
    			append_dev(div3, div1);
    			append_dev(div1, t11);
    			append_dev(div1, t12);
    			append_dev(div1, t13);
    			append_dev(div3, t14);
    			append_dev(div3, div2);
    			append_dev(div2, t15);
    			append_dev(div2, t16);
    			append_dev(div2, br0);
    			append_dev(div2, t17);
    			append_dev(div2, t18);
    			insert_dev(target, t19, anchor);
    			insert_dev(target, div4, anchor);
    			insert_dev(target, t21, anchor);
    			insert_dev(target, button1, anchor);
    			insert_dev(target, t25, anchor);
    			insert_dev(target, button2, anchor);
    			insert_dev(target, t29, anchor);
    			insert_dev(target, t30, anchor);
    			insert_dev(target, t31, anchor);
    			insert_dev(target, t32, anchor);
    			insert_dev(target, t33, anchor);
    			insert_dev(target, br1, anchor);
    			insert_dev(target, t34, anchor);
    			insert_dev(target, button3, anchor);
    			insert_dev(target, t36, anchor);
    			insert_dev(target, button4, anchor);
    			append_dev(button4, t37);
    			insert_dev(target, t38, anchor);
    			insert_dev(target, button5, anchor);
    			append_dev(button5, t39);
    			insert_dev(target, t40, anchor);
    			insert_dev(target, button6, anchor);
    			append_dev(button6, t41);
    			insert_dev(target, t42, anchor);
    			insert_dev(target, t43, anchor);
    			insert_dev(target, t44, anchor);
    			insert_dev(target, t45, anchor);
    			insert_dev(target, t46, anchor);
    			insert_dev(target, br2, anchor);
    			insert_dev(target, t47, anchor);
    			insert_dev(target, t48, anchor);
    			insert_dev(target, t49, anchor);
    			insert_dev(target, t50, anchor);
    			insert_dev(target, t51, anchor);
    			insert_dev(target, br3, anchor);
    			insert_dev(target, t52, anchor);
    			insert_dev(target, br4, anchor);
    			insert_dev(target, t53, anchor);
    			insert_dev(target, button7, anchor);
    			insert_dev(target, t55, anchor);
    			insert_dev(target, button8, anchor);
    			insert_dev(target, t57, anchor);
    			insert_dev(target, input2, anchor);
    			insert_dev(target, t58, anchor);
    			insert_dev(target, br5, anchor);
    			insert_dev(target, t59, anchor);
    			insert_dev(target, input3, anchor);
    			input3.checked = /*isRepeating*/ ctx[3];
    			insert_dev(target, t60, anchor);
    			insert_dev(target, input4, anchor);
    			set_input_value(input4, /*repstartTime*/ ctx[13]);
    			insert_dev(target, t61, anchor);
    			insert_dev(target, input5, anchor);
    			set_input_value(input5, /*rependTime*/ ctx[14]);
    			insert_dev(target, t62, anchor);
    			insert_dev(target, input6, anchor);
    			set_input_value(input6, /*repetitions*/ ctx[15]);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input0, "input", /*input0_input_handler*/ ctx[31]),
    					listen_dev(input1, "change", /*input1_change_handler*/ ctx[32]),
    					listen_dev(input1, "click", /*toggleUpdate*/ ctx[20], false, false, false, false),
    					listen_dev(textarea, "input", /*textarea_input_handler*/ ctx[33]),
    					listen_dev(button0, "click", /*transcriptToJson*/ ctx[30], false, false, false, false),
    					listen_dev(button1, "click", /*goToPreviousAutoTimestamp*/ ctx[22], false, false, false, false),
    					listen_dev(button2, "click", /*goToNextAutoTimestamp*/ ctx[21], false, false, false, false),
    					listen_dev(button3, "click", /*addUserTimestamp*/ ctx[23], false, false, false, false),
    					listen_dev(button4, "click", /*goToCurrentUserTimestamp*/ ctx[24], false, false, false, false),
    					listen_dev(button5, "click", /*goToPreviousUserTimestamp*/ ctx[26], false, false, false, false),
    					listen_dev(button6, "click", /*goToNextUserTimestamp*/ ctx[25], false, false, false, false),
    					listen_dev(button7, "click", /*exportTimestamps*/ ctx[27], false, false, false, false),
    					listen_dev(button8, "click", /*exportr2Timestamps*/ ctx[28], false, false, false, false),
    					listen_dev(input2, "change", /*importTimestamps*/ ctx[29], false, false, false, false),
    					listen_dev(input3, "change", /*input3_change_handler*/ ctx[34]),
    					listen_dev(input4, "input", /*input4_input_handler*/ ctx[35]),
    					listen_dev(input5, "input", /*input5_input_handler*/ ctx[36]),
    					listen_dev(input6, "input", /*input6_input_handler*/ ctx[37])
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, dirty) {
    			if (dirty[0] & /*currentvideoId*/ 4 && input0.value !== /*currentvideoId*/ ctx[2]) {
    				set_input_value(input0, /*currentvideoId*/ ctx[2]);
    			}

    			if (dirty[0] & /*isUpdating*/ 512) {
    				input1.checked = /*isUpdating*/ ctx[9];
    			}

    			if (dirty[0] & /*transcript*/ 32) {
    				set_input_value(textarea, /*transcript*/ ctx[5]);
    			}

    			if (dirty[0] & /*jsonOutput*/ 64) set_data_dev(t8, /*jsonOutput*/ ctx[6]);
    			if (dirty[0] & /*currentTime*/ 16 && t12_value !== (t12_value = /*currentTime*/ ctx[4].toFixed(2) + "")) set_data_dev(t12, t12_value);
    			if (dirty[0] & /*line*/ 256) set_data_dev(t15, /*line*/ ctx[8]);
    			if (dirty[0] & /*currentWord*/ 128) set_data_dev(t18, /*currentWord*/ ctx[7]);
    			if (dirty[0] & /*currentIndex*/ 1024) set_data_dev(t30, /*currentIndex*/ ctx[10]);
    			if (dirty[0] & /*timestamps*/ 2048 && t32_value !== (t32_value = /*timestamps*/ ctx[11].length + "")) set_data_dev(t32, t32_value);

    			if (dirty[0] & /*currentindexButtonClass*/ 65536 && button4_class_value !== (button4_class_value = "" + (null_to_empty(/*currentindexButtonClass*/ ctx[16]) + " svelte-udvqea"))) {
    				attr_dev(button4, "class", button4_class_value);
    			}

    			if (dirty[0] & /*currentuserIndex*/ 1 && button4_disabled_value !== (button4_disabled_value = /*currentuserIndex*/ ctx[0] <= 0)) {
    				prop_dev(button4, "disabled", button4_disabled_value);
    			}

    			if (dirty[0] & /*previousindexButtonClass*/ 131072 && button5_class_value !== (button5_class_value = "" + (null_to_empty(/*previousindexButtonClass*/ ctx[17]) + " svelte-udvqea"))) {
    				attr_dev(button5, "class", button5_class_value);
    			}

    			if (dirty[0] & /*currentuserIndex*/ 1 && button5_disabled_value !== (button5_disabled_value = /*currentuserIndex*/ ctx[0] <= 0)) {
    				prop_dev(button5, "disabled", button5_disabled_value);
    			}

    			if (dirty[0] & /*nextindexButtonClass*/ 262144 && button6_class_value !== (button6_class_value = "" + (null_to_empty(/*nextindexButtonClass*/ ctx[18]) + " svelte-udvqea"))) {
    				attr_dev(button6, "class", button6_class_value);
    			}

    			if (dirty[0] & /*currentuserIndex, userTimestamps*/ 3 && button6_disabled_value !== (button6_disabled_value = /*currentuserIndex*/ ctx[0] >= /*userTimestamps*/ ctx[1].length - 1)) {
    				prop_dev(button6, "disabled", button6_disabled_value);
    			}

    			if (dirty[0] & /*currentuserIndex*/ 1) set_data_dev(t43, /*currentuserIndex*/ ctx[0]);
    			if (dirty[0] & /*userTimestamps*/ 2 && t45_value !== (t45_value = /*userTimestamps*/ ctx[1].length + "")) set_data_dev(t45, t45_value);
    			if (dirty[0] & /*currentuserIndex*/ 1) set_data_dev(t48, /*currentuserIndex*/ ctx[0]);
    			if (dirty[0] & /*r2userTimestamps*/ 4096 && t50_value !== (t50_value = /*r2userTimestamps*/ ctx[12].length + "")) set_data_dev(t50, t50_value);

    			if (dirty[0] & /*isRepeating*/ 8) {
    				input3.checked = /*isRepeating*/ ctx[3];
    			}

    			if (dirty[0] & /*repstartTime*/ 8192 && to_number(input4.value) !== /*repstartTime*/ ctx[13]) {
    				set_input_value(input4, /*repstartTime*/ ctx[13]);
    			}

    			if (dirty[0] & /*rependTime*/ 16384 && to_number(input5.value) !== /*rependTime*/ ctx[14]) {
    				set_input_value(input5, /*rependTime*/ ctx[14]);
    			}

    			if (dirty[0] & /*repetitions*/ 32768 && to_number(input6.value) !== /*repetitions*/ ctx[15]) {
    				set_input_value(input6, /*repetitions*/ ctx[15]);
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(h1);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(label);
    			if (detaching) detach_dev(t9);
    			if (detaching) detach_dev(div3);
    			if (detaching) detach_dev(t19);
    			if (detaching) detach_dev(div4);
    			if (detaching) detach_dev(t21);
    			if (detaching) detach_dev(button1);
    			if (detaching) detach_dev(t25);
    			if (detaching) detach_dev(button2);
    			if (detaching) detach_dev(t29);
    			if (detaching) detach_dev(t30);
    			if (detaching) detach_dev(t31);
    			if (detaching) detach_dev(t32);
    			if (detaching) detach_dev(t33);
    			if (detaching) detach_dev(br1);
    			if (detaching) detach_dev(t34);
    			if (detaching) detach_dev(button3);
    			if (detaching) detach_dev(t36);
    			if (detaching) detach_dev(button4);
    			if (detaching) detach_dev(t38);
    			if (detaching) detach_dev(button5);
    			if (detaching) detach_dev(t40);
    			if (detaching) detach_dev(button6);
    			if (detaching) detach_dev(t42);
    			if (detaching) detach_dev(t43);
    			if (detaching) detach_dev(t44);
    			if (detaching) detach_dev(t45);
    			if (detaching) detach_dev(t46);
    			if (detaching) detach_dev(br2);
    			if (detaching) detach_dev(t47);
    			if (detaching) detach_dev(t48);
    			if (detaching) detach_dev(t49);
    			if (detaching) detach_dev(t50);
    			if (detaching) detach_dev(t51);
    			if (detaching) detach_dev(br3);
    			if (detaching) detach_dev(t52);
    			if (detaching) detach_dev(br4);
    			if (detaching) detach_dev(t53);
    			if (detaching) detach_dev(button7);
    			if (detaching) detach_dev(t55);
    			if (detaching) detach_dev(button8);
    			if (detaching) detach_dev(t57);
    			if (detaching) detach_dev(input2);
    			if (detaching) detach_dev(t58);
    			if (detaching) detach_dev(br5);
    			if (detaching) detach_dev(t59);
    			if (detaching) detach_dev(input3);
    			if (detaching) detach_dev(t60);
    			if (detaching) detach_dev(input4);
    			if (detaching) detach_dev(t61);
    			if (detaching) detach_dev(input5);
    			if (detaching) detach_dev(t62);
    			if (detaching) detach_dev(input6);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function getRandomWord(line) {
    	let words = line.split(" ");
    	return words[Math.floor(Math.random() * words.length)];
    }

    function instance$6($$self, $$props, $$invalidate) {
    	let nextindexButtonClass;
    	let previousindexButtonClass;
    	let currentindexButtonClass;
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('YoutubeIframeAPICustomInterface', slots, []);
    	let player;
    	let interval = 20; // Define your interval
    	let currentTime = 0;
    	let timeUpdateInterval;

    	// Assuming 'transcript' contains your video transcript
    	let transcript = `Line 1 of the transcript.
    Line 2 of the transcript.
    Line 3 food
    Line 4 foodest
    Line 5 foods
    Line 6 fooder
    Line 7 foodz
    Line 8 fooding
    ...`; // Replace with your actual transcript

    	let jsonOutput = '';
    	let lines = transcript.split("\n");
    	let currentWord = "";
    	let line = "";
    	let isUpdating = false;
    	let updateInterval;
    	let currentIndex = 0; // Assuming this is initialized appropriately
    	let currentuserIndex = 0; // Assuming this is initialized appropriately
    	let timestamps = []; // Array of timestamps
    	let userTimestamps = []; // Array of user timestamps
    	let r2userTimestamps = []; // Array of user timestamps
    	let currentvideoId = 'IVJkOHTBPn0';
    	let youTubeApiLoaded = false;
    	let currentvideoduration;
    	let regeneratedautotimestamps = false;
    	let repstartTime = 10;
    	let rependTime = 20;
    	let repetitions = 20;
    	let intervalId;
    	let isRepeating = false;

    	window.onYouTubeIframeAPIReady = function () {
    		youTubeApiLoaded = true;
    		initYouTubePlayer();
    	};

    	// Function to initialize the YouTube player
    	function initYouTubePlayer() {
    		if (!youTubeApiLoaded) {
    			console.error("YouTube API is not ready yet.");
    			return;
    		}

    		regeneratedautotimestamps = false;

    		// Clear existing interval
    		clearInterval(timeUpdateInterval);

    		// Reinitialize player with new video ID
    		if (player) {
    			player.loadVideoById(currentvideoId);
    		} else {
    			player = new YT.Player('youtube-player',
    			{
    					height: '360',
    					width: '640',
    					videoId: currentvideoId,
    					events: {
    						'onReady': onPlayerReady,
    						'onStateChange': onPlayerStateChange
    					}
    				});
    		}

    		// Reset and start the interval to update current time
    		timeUpdateInterval = setInterval(updateCurrentTime, 1000);
    	}

    	onMount(() => {
    		// Load the YouTube IFrame Player API
    		const tag = document.createElement('script');

    		tag.src = "https://www.youtube.com/iframe_api";
    		const firstScriptTag = document.getElementsByTagName('script')[0];
    		firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);

    		// Update the current time every second
    		timeUpdateInterval = setInterval(updateCurrentTime, 1000);
    	});

    	function autogeneratedtimestamps() {
    		currentvideoduration = player.getDuration();

    		//console.log("Video Duration: ", currentvideoduration);
    		const generatedTimestamps = [];

    		for (let i = interval; i < currentvideoduration; i += interval) {
    			generatedTimestamps.push(i);
    		}

    		$$invalidate(11, timestamps = generatedTimestamps);

    		// Do something with the timestamps
    		//console.log("Generated Timestamps: ", generatedTimestamps);
    		regeneratedautotimestamps = true;
    	}

    	// Event handler for when the player is ready
    	function onPlayerReady(event) {
    		autogeneratedtimestamps();
    	}

    	function onPlayerStateChange(event) {
    		if (event.data === YT.PlayerState.PLAYING || event.data === YT.PlayerState.PAUSED) {
    			updateCurrentIndex();
    		}

    		// Check if the video has just started playing
    		if (event.data === YT.PlayerState.PLAYING && !regeneratedautotimestamps) {
    			autogeneratedtimestamps();
    		}
    	}

    	function updateCurrentIndex() {
    		const currentTime = player.getCurrentTime();

    		// Find the closest timestamp
    		let closest = timestamps.reduce((prev, curr) => Math.abs(curr - currentTime) < Math.abs(prev - currentTime)
    		? curr
    		: prev);

    		$$invalidate(10, currentIndex = timestamps.indexOf(closest));
    	}

    	function updateCurrentTime() {
    		if (player && player.getCurrentTime) {
    			$$invalidate(4, currentTime = player.getCurrentTime());
    		}
    	}

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

    	function updateWord() {
    		if (isUpdating) {
    			$$invalidate(8, line = lines[Math.floor(Math.random() * lines.length)]);
    			$$invalidate(7, currentWord = getRandomWord(line));
    		}
    	}

    	function toggleUpdate() {
    		lines = transcript.split("\n");
    		$$invalidate(9, isUpdating = !isUpdating);

    		if (isUpdating) {
    			updateWord(); // Immediately update once
    			updateInterval = setInterval(updateWord, 3000); // Update every 3 seconds
    		} else {
    			clearInterval(updateInterval);
    			$$invalidate(8, line = '');
    			$$invalidate(7, currentWord = '');
    		}
    	}

    	function goToNextAutoTimestamp() {
    		if (currentIndex < timestamps.length - 1) {
    			$$invalidate(10, currentIndex += 1);
    			player.seekTo(timestamps[currentIndex], true);
    		}
    	}

    	function goToPreviousAutoTimestamp() {
    		if (currentIndex > 0) {
    			$$invalidate(10, currentIndex -= 1);
    			player.seekTo(timestamps[currentIndex], true);
    		}
    	}

    	function addUserTimestamp() {
    		const currentTime = Math.floor(player.getCurrentTime());
    		$$invalidate(1, userTimestamps = [...userTimestamps, currentTime].sort((a, b) => a - b));
    	}

    	function addr2UserTimestamp() {
    		const currentTime = Math.floor(player.getCurrentTime());
    		$$invalidate(12, r2userTimestamps = [...r2userTimestamps, currentTime].sort((a, b) => a - b));
    	}

    	function goToCurrentUserTimestamp() {
    		if (currentuserIndex === 0 && currentIndex < 0) {
    			player.seekTo(userTimestamps[currentIndex], true);
    		} else if (currentuserIndex < 0) {
    			player.seekTo(userTimestamps[currentuserIndex], true);
    		} else {
    			// Handle the end of the list here
    			console.log("No selected user timestamp.");
    		} // You can also disable the "next" button or loop to the start if needed.
    	}

    	function goToNextUserTimestamp() {
    		if (currentuserIndex < userTimestamps.length - 1) {
    			$$invalidate(0, currentuserIndex += 1);
    			player.seekTo(userTimestamps[currentuserIndex], true);
    		} else {
    			// Handle the end of the list here
    			console.log("Reached the end of user timestamps.");
    		} // You can also disable the "next" button or loop to the start if needed.
    	}

    	function goToPreviousUserTimestamp() {
    		if (currentuserIndex > 0) {
    			$$invalidate(0, currentuserIndex -= 1);
    			player.seekTo(userTimestamps[currentuserIndex], true);
    		} else {
    			// Handle the beginning of the list here
    			console.log("Reached the start of user timestamps.");
    		} // You can also disable the "previous" button or loop to the end if needed.
    	}

    	function exportTimestamps() {
    		const data = JSON.stringify({
    			currentvideoId,
    			timestamps: userTimestamps
    		});

    		const blob = new Blob([data], { type: 'application/json' });
    		const url = URL.createObjectURL(blob);
    		const a = document.createElement('a');
    		a.style.display = 'none';
    		const filename = `${currentvideoId}_timestamps.json`;
    		a.href = url;
    		a.download = filename;
    		document.body.appendChild(a);
    		a.click();
    		window.URL.revokeObjectURL(url);
    	}

    	function exportr2Timestamps() {
    		const data = JSON.stringify({
    			currentvideoId,
    			timestamps: r2userTimestamps
    		});

    		const blob = new Blob([data], { type: 'application/json' });
    		const url = URL.createObjectURL(blob);
    		const a = document.createElement('a');
    		a.style.display = 'none';
    		const filename = `${currentvideoId}_round2timestamps.json`;
    		a.href = url;
    		a.download = filename;
    		document.body.appendChild(a);
    		a.click();
    		window.URL.revokeObjectURL(url);
    	}

    	function importTimestamps(event) {
    		// Check if the file input is not empty
    		const file = event.target.files[0];

    		if (!event.target.files || event.target.files.length === 0) {
    			alert('No file selected.');
    			return;
    		}

    		// Check if the file is a Blob (File objects inherit from Blob)
    		if (!(file instanceof Blob)) {
    			alert('Selected item is not a file.');
    			return;
    		}

    		const reader = new FileReader();

    		reader.onload = e => {
    			try {
    				const data = JSON.parse(e.target.result);

    				if (!Array.isArray(data.timestamps)) {
    					alert('Invalid file structure: timestamps should be an array.');
    					return;
    				}

    				$$invalidate(2, currentvideoId = data.currentvideoId || '');
    				$$invalidate(1, userTimestamps = data.timestamps);
    			} catch(error) {
    				alert('An error occurred while importing timestamps.'); //regeneratedautotimestamps = false; = true
    			}
    		};

    		reader.readAsText(file);
    	}

    	function transcriptToJson() {
    		const lines = transcript.split('\n').filter(line => line.trim() !== '');
    		const result = [];

    		for (let i = 0; i < lines.length; i += 2) {
    			const timestampLine = lines[i];
    			const textLine = lines[i + 1] || ''; // Ensure there's a line for text
    			const timestampParts = timestampLine.split(' ');
    			const timestamp = timestampParts.shift();
    			const timeParts = timestamp.split(':');
    			const seconds = parseInt(timeParts[0], 10) * 60 + parseInt(timeParts[1], 10);
    			result.push({ time: seconds, text: textLine.trim() });
    		}

    		$$invalidate(6, jsonOutput = JSON.stringify(result, null, 2));
    	}

    	function startRepetition() {
    		let count = 0;
    		player.seekTo(repstartTime, true);
    		player.playVideo();

    		intervalId = setInterval(
    			() => {
    				if (count < repetitions) {
    					player.seekTo(repstartTime, true);
    					count++;
    				} else {
    					stopRepetition();
    				}
    			},
    			(rependTime - repstartTime) * 1000
    		);
    	}

    	function stopRepetition() {
    		clearInterval(intervalId);
    	} //player.pauseVideo();

    	const writable_props = [];

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

    	function input0_input_handler() {
    		currentvideoId = this.value;
    		$$invalidate(2, currentvideoId);
    	}

    	function input1_change_handler() {
    		isUpdating = this.checked;
    		$$invalidate(9, isUpdating);
    	}

    	function textarea_input_handler() {
    		transcript = this.value;
    		$$invalidate(5, transcript);
    	}

    	function input3_change_handler() {
    		isRepeating = this.checked;
    		$$invalidate(3, isRepeating);
    	}

    	function input4_input_handler() {
    		repstartTime = to_number(this.value);
    		$$invalidate(13, repstartTime);
    	}

    	function input5_input_handler() {
    		rependTime = to_number(this.value);
    		$$invalidate(14, rependTime);
    	}

    	function input6_input_handler() {
    		repetitions = to_number(this.value);
    		$$invalidate(15, repetitions);
    	}

    	$$self.$capture_state = () => ({
    		onMount,
    		onDestroy,
    		player,
    		interval,
    		currentTime,
    		timeUpdateInterval,
    		transcript,
    		jsonOutput,
    		lines,
    		currentWord,
    		line,
    		isUpdating,
    		updateInterval,
    		currentIndex,
    		currentuserIndex,
    		timestamps,
    		userTimestamps,
    		r2userTimestamps,
    		currentvideoId,
    		youTubeApiLoaded,
    		currentvideoduration,
    		regeneratedautotimestamps,
    		repstartTime,
    		rependTime,
    		repetitions,
    		intervalId,
    		isRepeating,
    		initYouTubePlayer,
    		autogeneratedtimestamps,
    		onPlayerReady,
    		onPlayerStateChange,
    		updateCurrentIndex,
    		updateCurrentTime,
    		getRandomWord,
    		updateWord,
    		toggleUpdate,
    		goToNextAutoTimestamp,
    		goToPreviousAutoTimestamp,
    		addUserTimestamp,
    		addr2UserTimestamp,
    		goToCurrentUserTimestamp,
    		goToNextUserTimestamp,
    		goToPreviousUserTimestamp,
    		exportTimestamps,
    		exportr2Timestamps,
    		importTimestamps,
    		transcriptToJson,
    		startRepetition,
    		stopRepetition,
    		currentindexButtonClass,
    		previousindexButtonClass,
    		nextindexButtonClass
    	});

    	$$self.$inject_state = $$props => {
    		if ('player' in $$props) player = $$props.player;
    		if ('interval' in $$props) $$invalidate(19, interval = $$props.interval);
    		if ('currentTime' in $$props) $$invalidate(4, currentTime = $$props.currentTime);
    		if ('timeUpdateInterval' in $$props) timeUpdateInterval = $$props.timeUpdateInterval;
    		if ('transcript' in $$props) $$invalidate(5, transcript = $$props.transcript);
    		if ('jsonOutput' in $$props) $$invalidate(6, jsonOutput = $$props.jsonOutput);
    		if ('lines' in $$props) lines = $$props.lines;
    		if ('currentWord' in $$props) $$invalidate(7, currentWord = $$props.currentWord);
    		if ('line' in $$props) $$invalidate(8, line = $$props.line);
    		if ('isUpdating' in $$props) $$invalidate(9, isUpdating = $$props.isUpdating);
    		if ('updateInterval' in $$props) updateInterval = $$props.updateInterval;
    		if ('currentIndex' in $$props) $$invalidate(10, currentIndex = $$props.currentIndex);
    		if ('currentuserIndex' in $$props) $$invalidate(0, currentuserIndex = $$props.currentuserIndex);
    		if ('timestamps' in $$props) $$invalidate(11, timestamps = $$props.timestamps);
    		if ('userTimestamps' in $$props) $$invalidate(1, userTimestamps = $$props.userTimestamps);
    		if ('r2userTimestamps' in $$props) $$invalidate(12, r2userTimestamps = $$props.r2userTimestamps);
    		if ('currentvideoId' in $$props) $$invalidate(2, currentvideoId = $$props.currentvideoId);
    		if ('youTubeApiLoaded' in $$props) youTubeApiLoaded = $$props.youTubeApiLoaded;
    		if ('currentvideoduration' in $$props) currentvideoduration = $$props.currentvideoduration;
    		if ('regeneratedautotimestamps' in $$props) regeneratedautotimestamps = $$props.regeneratedautotimestamps;
    		if ('repstartTime' in $$props) $$invalidate(13, repstartTime = $$props.repstartTime);
    		if ('rependTime' in $$props) $$invalidate(14, rependTime = $$props.rependTime);
    		if ('repetitions' in $$props) $$invalidate(15, repetitions = $$props.repetitions);
    		if ('intervalId' in $$props) intervalId = $$props.intervalId;
    		if ('isRepeating' in $$props) $$invalidate(3, isRepeating = $$props.isRepeating);
    		if ('currentindexButtonClass' in $$props) $$invalidate(16, currentindexButtonClass = $$props.currentindexButtonClass);
    		if ('previousindexButtonClass' in $$props) $$invalidate(17, previousindexButtonClass = $$props.previousindexButtonClass);
    		if ('nextindexButtonClass' in $$props) $$invalidate(18, nextindexButtonClass = $$props.nextindexButtonClass);
    	};

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

    	$$self.$$.update = () => {
    		if ($$self.$$.dirty[0] & /*currentvideoId*/ 4) {
    			if (currentvideoId) {
    				initYouTubePlayer();
    			}
    		}

    		if ($$self.$$.dirty[0] & /*currentuserIndex, userTimestamps*/ 3) {
    			$$invalidate(18, nextindexButtonClass = currentuserIndex >= userTimestamps.length - 1
    			? 'button-at-end'
    			: 'button');
    		}

    		if ($$self.$$.dirty[0] & /*currentuserIndex*/ 1) {
    			$$invalidate(17, previousindexButtonClass = currentuserIndex <= 0 ? 'button-at-end' : 'button');
    		}

    		if ($$self.$$.dirty[0] & /*currentuserIndex*/ 1) {
    			$$invalidate(16, currentindexButtonClass = currentuserIndex <= 0 ? 'button-at-end' : 'button');
    		}

    		if ($$self.$$.dirty[0] & /*isRepeating*/ 8) {
    			if (isRepeating) {
    				startRepetition();
    			} else {
    				stopRepetition();
    			}
    		}
    	};

    	return [
    		currentuserIndex,
    		userTimestamps,
    		currentvideoId,
    		isRepeating,
    		currentTime,
    		transcript,
    		jsonOutput,
    		currentWord,
    		line,
    		isUpdating,
    		currentIndex,
    		timestamps,
    		r2userTimestamps,
    		repstartTime,
    		rependTime,
    		repetitions,
    		currentindexButtonClass,
    		previousindexButtonClass,
    		nextindexButtonClass,
    		interval,
    		toggleUpdate,
    		goToNextAutoTimestamp,
    		goToPreviousAutoTimestamp,
    		addUserTimestamp,
    		goToCurrentUserTimestamp,
    		goToNextUserTimestamp,
    		goToPreviousUserTimestamp,
    		exportTimestamps,
    		exportr2Timestamps,
    		importTimestamps,
    		transcriptToJson,
    		input0_input_handler,
    		input1_change_handler,
    		textarea_input_handler,
    		input3_change_handler,
    		input4_input_handler,
    		input5_input_handler,
    		input6_input_handler
    	];
    }

    class YoutubeIframeAPICustomInterface extends SvelteComponentDev {
    	constructor(options) {
    		super(options);
    		init(this, options, instance$6, create_fragment$6, safe_not_equal, {}, null, [-1, -1]);

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

    // Unique ID creation requires a high quality random # generator. In the browser we therefore
    // require the crypto API and do not support built-in fallback to lower quality random number
    // generators (like Math.random()).
    let getRandomValues;
    const rnds8 = new Uint8Array(16);
    function rng() {
      // lazy load so that environments that need to polyfill have a chance to do so
      if (!getRandomValues) {
        // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
        getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);

        if (!getRandomValues) {
          throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
        }
      }

      return getRandomValues(rnds8);
    }

    /**
     * Convert array of 16 byte values to UUID string format of the form:
     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
     */

    const byteToHex = [];

    for (let i = 0; i < 256; ++i) {
      byteToHex.push((i + 0x100).toString(16).slice(1));
    }

    function unsafeStringify(arr, offset = 0) {
      // Note: Be careful editing this code!  It's been tuned for performance
      // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
      return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
    }

    const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
    var native = {
      randomUUID
    };

    function v4(options, buf, offset) {
      if (native.randomUUID && !buf && !options) {
        return native.randomUUID();
      }

      options = options || {};
      const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

      rnds[6] = rnds[6] & 0x0f | 0x40;
      rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided

      if (buf) {
        offset = offset || 0;

        for (let i = 0; i < 16; ++i) {
          buf[offset + i] = rnds[i];
        }

        return buf;
      }

      return unsafeStringify(rnds);
    }

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

    const { console: console_1$3 } = globals;
    const file$5 = "src\\RecursiveNestedCommentsElement.svelte";

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

    // (123:16) {#if showReplyInput[comment.id]}
    function create_if_block$2(ctx) {
    	let div;
    	let input;
    	let t0;
    	let button;
    	let mounted;
    	let dispose;

    	function input_input_handler() {
    		/*input_input_handler*/ ctx[11].call(input, /*comment*/ ctx[14]);
    	}

    	function click_handler_1() {
    		return /*click_handler_1*/ ctx[12](/*comment*/ ctx[14]);
    	}

    	const block = {
    		c: function create() {
    			div = element("div");
    			input = element("input");
    			t0 = space();
    			button = element("button");
    			button.textContent = "Post Reply";
    			attr_dev(input, "placeholder", "Write a reply...");
    			add_location(input, file$5, 124, 24, 4690);
    			add_location(button, file$5, 125, 24, 4791);
    			attr_dev(div, "class", "reply-input");
    			add_location(div, file$5, 123, 20, 4639);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    			append_dev(div, input);
    			set_input_value(input, /*replyText*/ ctx[2][/*comment*/ ctx[14].id]);
    			append_dev(div, t0);
    			append_dev(div, button);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input, "input", input_input_handler),
    					listen_dev(button, "click", click_handler_1, false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;

    			if (dirty & /*replyText, flattenedComments*/ 6 && input.value !== /*replyText*/ ctx[2][/*comment*/ ctx[14].id]) {
    				set_input_value(input, /*replyText*/ ctx[2][/*comment*/ ctx[14].id]);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$2.name,
    		type: "if",
    		source: "(123:16) {#if showReplyInput[comment.id]}",
    		ctx
    	});

    	return block;
    }

    // (119:8) {#each flattenedComments as comment}
    function create_each_block$3(ctx) {
    	let div;
    	let span;
    	let t0_value = /*comment*/ ctx[14].title + "";
    	let t0;
    	let t1;
    	let button;
    	let t3;
    	let t4;
    	let div_class_value;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[10](/*comment*/ ctx[14]);
    	}

    	let if_block = /*showReplyInput*/ ctx[3][/*comment*/ ctx[14].id] && create_if_block$2(ctx);

    	const block = {
    		c: function create() {
    			div = element("div");
    			span = element("span");
    			t0 = text(t0_value);
    			t1 = space();
    			button = element("button");
    			button.textContent = "Reply";
    			t3 = space();
    			if (if_block) if_block.c();
    			t4 = space();
    			add_location(span, file$5, 120, 16, 4453);
    			add_location(button, file$5, 121, 16, 4499);

    			attr_dev(div, "class", div_class_value = "" + (null_to_empty(/*comment*/ ctx[14].level === 0
    			? 'top-level-comment'
    			: 'comment') + " svelte-bsj1sx"));

    			set_style(div, "margin-left", /*comment*/ ctx[14].level * 20 + "px");
    			add_location(div, file$5, 119, 12, 4323);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    			append_dev(div, span);
    			append_dev(span, t0);
    			append_dev(div, t1);
    			append_dev(div, button);
    			append_dev(div, t3);
    			if (if_block) if_block.m(div, null);
    			append_dev(div, t4);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*flattenedComments*/ 2 && t0_value !== (t0_value = /*comment*/ ctx[14].title + "")) set_data_dev(t0, t0_value);

    			if (/*showReplyInput*/ ctx[3][/*comment*/ ctx[14].id]) {
    				if (if_block) {
    					if_block.p(ctx, dirty);
    				} else {
    					if_block = create_if_block$2(ctx);
    					if_block.c();
    					if_block.m(div, t4);
    				}
    			} else if (if_block) {
    				if_block.d(1);
    				if_block = null;
    			}

    			if (dirty & /*flattenedComments*/ 2 && div_class_value !== (div_class_value = "" + (null_to_empty(/*comment*/ ctx[14].level === 0
    			? 'top-level-comment'
    			: 'comment') + " svelte-bsj1sx"))) {
    				attr_dev(div, "class", div_class_value);
    			}

    			if (dirty & /*flattenedComments*/ 2) {
    				set_style(div, "margin-left", /*comment*/ ctx[14].level * 20 + "px");
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    			if (if_block) if_block.d();
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$3.name,
    		type: "each",
    		source: "(119:8) {#each flattenedComments as comment}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$5(ctx) {
    	let h1;
    	let t1;
    	let h4;
    	let t3;
    	let div2;
    	let div0;
    	let button0;
    	let t5;
    	let input0;
    	let t6;
    	let input1;
    	let t7;
    	let button1;
    	let t9;
    	let br;
    	let t10;
    	let div1;
    	let mounted;
    	let dispose;
    	let each_value = /*flattenedComments*/ ctx[1];
    	validate_each_argument(each_value);
    	let each_blocks = [];

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

    	const block = {
    		c: function create() {
    			h1 = element("h1");
    			h1.textContent = "Reddit based Nested Comments Idea for LMM responses that need further branching responses";
    			t1 = space();
    			h4 = element("h4");
    			h4.textContent = "Inspired by Vijay Bhati - https://github.com/vj98/Frontend-Machine-Coding/tree/main/nested-comments https://youtu.be/a4OA7QbHEho?list=PLBygUld3s6x8sI_H8UYROVMIVcuxUre1e";
    			t3 = space();
    			div2 = element("div");
    			div0 = element("div");
    			button0 = element("button");
    			button0.textContent = "Export Comments";
    			t5 = text("\r\n        | Import Exported Comments \r\n        ");
    			input0 = element("input");
    			t6 = text("\r\n        | \r\n        ");
    			input1 = element("input");
    			t7 = space();
    			button1 = element("button");
    			button1.textContent = "Post Comment";
    			t9 = space();
    			br = element("br");
    			t10 = space();
    			div1 = element("div");

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

    			add_location(h1, file$5, 104, 0, 3512);
    			add_location(h4, file$5, 105, 0, 3614);
    			add_location(button0, file$5, 108, 8, 3897);
    			attr_dev(input0, "type", "file");
    			add_location(input0, file$5, 110, 8, 4000);
    			attr_dev(input1, "placeholder", "Add a comment...");
    			add_location(input1, file$5, 112, 8, 4072);
    			add_location(button1, file$5, 113, 8, 4146);
    			add_location(div0, file$5, 107, 4, 3882);
    			add_location(br, file$5, 116, 4, 4225);
    			attr_dev(div1, "id", "comment-container");
    			add_location(div1, file$5, 117, 4, 4235);
    			attr_dev(div2, "class", "component-containter svelte-bsj1sx");
    			set_style(div2, "border", "1px solid black");
    			set_style(div2, "padding", "4px");
    			add_location(div2, file$5, 106, 0, 3795);
    		},
    		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, h1, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, h4, anchor);
    			insert_dev(target, t3, anchor);
    			insert_dev(target, div2, anchor);
    			append_dev(div2, div0);
    			append_dev(div0, button0);
    			append_dev(div0, t5);
    			append_dev(div0, input0);
    			append_dev(div0, t6);
    			append_dev(div0, input1);
    			set_input_value(input1, /*newComment*/ ctx[0]);
    			append_dev(div0, t7);
    			append_dev(div0, button1);
    			append_dev(div2, t9);
    			append_dev(div2, br);
    			append_dev(div2, t10);
    			append_dev(div2, div1);

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

    			if (!mounted) {
    				dispose = [
    					listen_dev(button0, "click", /*exportToJson*/ ctx[7], false, false, false, false),
    					listen_dev(input0, "change", /*handleFileUpload*/ ctx[8], false, false, false, false),
    					listen_dev(input1, "input", /*input1_input_handler*/ ctx[9]),
    					listen_dev(button1, "click", /*addComment*/ ctx[4], false, false, false, false)
    				];

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

    			if (dirty & /*flattenedComments, addReply, replyText, toggleReplyInput, showReplyInput*/ 110) {
    				each_value = /*flattenedComments*/ ctx[1];
    				validate_each_argument(each_value);
    				let i;

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

    					if (each_blocks[i]) {
    						each_blocks[i].p(child_ctx, dirty);
    					} else {
    						each_blocks[i] = create_each_block$3(child_ctx);
    						each_blocks[i].c();
    						each_blocks[i].m(div1, 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(h1);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(h4);
    			if (detaching) detach_dev(t3);
    			if (detaching) detach_dev(div2);
    			destroy_each(each_blocks, detaching);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function flattenStructure(items, level = 0, parentId = null, processedIds = new Set()) {
    	let result = [];

    	items.forEach(item => {
    		if (processedIds.has(item.id)) return;
    		result.push({ ...item, level, parentId });
    		processedIds.add(item.id);

    		if (item.items && Array.isArray(item.items)) {
    			const childItems = flattenStructure(item.items, level + 1, item.id, processedIds);
    			result = result.concat(childItems);
    		}
    	});

    	return result;
    }

    function instance$5($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('RecursiveNestedCommentsElement', slots, []);
    	let comments = [];
    	let newComment = '';
    	let flattenedComments = [];
    	let replyText = {};
    	let showReplyInput = {};

    	const addComment = () => {
    		comments = [
    			...comments,
    			{
    				id: v4(),
    				title: newComment,
    				items: []
    			}
    		];

    		$$invalidate(0, newComment = '');
    		$$invalidate(1, flattenedComments = flattenStructure(comments));
    	};

    	const addReply = (parentId, replyText) => {
    		const findAndAddReply = (items, id) => {
    			for (let item of items) {
    				if (item.id === id) {
    					item.items.push({
    						id: v4(),
    						title: replyText,
    						items: []
    					});

    					return true;
    				}

    				if (item.items.length && findAndAddReply(item.items, id)) {
    					return true;
    				}
    			}

    			return false;
    		};

    		findAndAddReply(comments, parentId);
    		$$invalidate(1, flattenedComments = flattenStructure(comments));
    	};

    	// Function to toggle reply input
    	function toggleReplyInput(commentId) {
    		$$invalidate(3, showReplyInput[commentId] = !showReplyInput[commentId], showReplyInput);
    	}

    	function exportToJson() {
    		const dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(comments));
    		const downloadAnchorNode = document.createElement('a');
    		downloadAnchorNode.setAttribute("href", dataStr);
    		downloadAnchorNode.setAttribute("download", "comments.json");
    		document.body.appendChild(downloadAnchorNode);
    		downloadAnchorNode.click();
    		downloadAnchorNode.remove();
    	}

    	function handleFileUpload(event) {
    		const file = event.target.files[0];
    		if (!file) return;
    		const reader = new FileReader();

    		reader.onload = e => {
    			const text = e.target.result;

    			try {
    				comments = JSON.parse(text);
    				$$invalidate(1, flattenedComments = flattenStructure(comments));
    			} catch(error) {
    				console.error("Error parsing JSON:", error);
    			}
    		};

    		reader.readAsText(file);
    	}

    	const writable_props = [];

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

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

    	const click_handler = comment => toggleReplyInput(comment.id);

    	function input_input_handler(comment) {
    		replyText[comment.id] = this.value;
    		$$invalidate(2, replyText);
    	}

    	const click_handler_1 = comment => {
    		addReply(comment.id, replyText[comment.id]);
    		toggleReplyInput(comment.id);
    	};

    	$$self.$capture_state = () => ({
    		uuidv4: v4,
    		comments,
    		newComment,
    		flattenedComments,
    		replyText,
    		showReplyInput,
    		flattenStructure,
    		addComment,
    		addReply,
    		toggleReplyInput,
    		exportToJson,
    		handleFileUpload
    	});

    	$$self.$inject_state = $$props => {
    		if ('comments' in $$props) comments = $$props.comments;
    		if ('newComment' in $$props) $$invalidate(0, newComment = $$props.newComment);
    		if ('flattenedComments' in $$props) $$invalidate(1, flattenedComments = $$props.flattenedComments);
    		if ('replyText' in $$props) $$invalidate(2, replyText = $$props.replyText);
    		if ('showReplyInput' in $$props) $$invalidate(3, showReplyInput = $$props.showReplyInput);
    	};

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

    	return [
    		newComment,
    		flattenedComments,
    		replyText,
    		showReplyInput,
    		addComment,
    		addReply,
    		toggleReplyInput,
    		exportToJson,
    		handleFileUpload,
    		input1_input_handler,
    		click_handler,
    		input_input_handler,
    		click_handler_1
    	];
    }

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

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

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

    const { console: console_1$2 } = globals;
    const file$4 = "src\\CopyandRemoveListComponent.svelte";

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

    // (26:0) {:else}
    function create_else_block(ctx) {
    	let each_blocks = [];
    	let each_1_lookup = new Map();
    	let each_1_anchor;
    	let each_value = /*items*/ ctx[1];
    	validate_each_argument(each_value);
    	const get_key = ctx => /*item*/ ctx[6].id;
    	validate_each_keys(ctx, each_value, get_each_context$2, get_key);

    	for (let i = 0; i < each_value.length; i += 1) {
    		let child_ctx = get_each_context$2(ctx, each_value, i);
    		let key = get_key(child_ctx);
    		each_1_lookup.set(key, each_blocks[i] = create_each_block$2(key, child_ctx));
    	}

    	const block = {
    		c: function create() {
    			for (let i = 0; i < each_blocks.length; i += 1) {
    				each_blocks[i].c();
    			}

    			each_1_anchor = empty();
    		},
    		m: function mount(target, anchor) {
    			for (let i = 0; i < each_blocks.length; i += 1) {
    				if (each_blocks[i]) {
    					each_blocks[i].m(target, anchor);
    				}
    			}

    			insert_dev(target, each_1_anchor, anchor);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*copyAndRemoveItem, items*/ 10) {
    				each_value = /*items*/ ctx[1];
    				validate_each_argument(each_value);
    				validate_each_keys(ctx, each_value, get_each_context$2, get_key);
    				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each_1_lookup, each_1_anchor.parentNode, destroy_block, create_each_block$2, each_1_anchor, get_each_context$2);
    			}
    		},
    		d: function destroy(detaching) {
    			for (let i = 0; i < each_blocks.length; i += 1) {
    				each_blocks[i].d(detaching);
    			}

    			if (detaching) detach_dev(each_1_anchor);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_else_block.name,
    		type: "else",
    		source: "(26:0) {:else}",
    		ctx
    	});

    	return block;
    }

    // (24:0) {#if items.length === 0}
    function create_if_block$1(ctx) {
    	let p;

    	const block = {
    		c: function create() {
    			p = element("p");
    			p.textContent = "All items have been copied! (or none entered yet)";
    			add_location(p, file$4, 24, 4, 732);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, p, anchor);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(p);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block$1.name,
    		type: "if",
    		source: "(24:0) {#if items.length === 0}",
    		ctx
    	});

    	return block;
    }

    // (27:4) {#each items as item (item.id)}
    function create_each_block$2(key_1, ctx) {
    	let button;
    	let t0_value = /*item*/ ctx[6].text + "";
    	let t0;
    	let t1;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[5](/*item*/ ctx[6]);
    	}

    	const block = {
    		key: key_1,
    		first: null,
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = space();
    			attr_dev(button, "class", "item svelte-bmbf24");
    			add_location(button, file$4, 27, 8, 844);
    			this.first = button;
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			append_dev(button, t1);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*items*/ 2 && t0_value !== (t0_value = /*item*/ ctx[6].text + "")) set_data_dev(t0, t0_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$2.name,
    		type: "each",
    		source: "(27:4) {#each items as item (item.id)}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$4(ctx) {
    	let h1;
    	let t1;
    	let textarea;
    	let t2;
    	let if_block_anchor;
    	let mounted;
    	let dispose;

    	function select_block_type(ctx, dirty) {
    		if (/*items*/ ctx[1].length === 0) return create_if_block$1;
    		return create_else_block;
    	}

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

    	const block = {
    		c: function create() {
    			h1 = element("h1");
    			h1.textContent = "Copy items for prompts by clicking buttons below";
    			t1 = space();
    			textarea = element("textarea");
    			t2 = space();
    			if_block.c();
    			if_block_anchor = empty();
    			add_location(h1, file$4, 19, 0, 537);
    			attr_dev(textarea, "placeholder", "Enter text here...");
    			attr_dev(textarea, "class", "svelte-bmbf24");
    			add_location(textarea, file$4, 21, 0, 598);
    		},
    		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, h1, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, textarea, anchor);
    			set_input_value(textarea, /*textInput*/ ctx[0]);
    			insert_dev(target, t2, anchor);
    			if_block.m(target, anchor);
    			insert_dev(target, if_block_anchor, anchor);

    			if (!mounted) {
    				dispose = [
    					listen_dev(textarea, "input", /*textarea_input_handler*/ ctx[4]),
    					listen_dev(textarea, "input", /*updateItems*/ ctx[2], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*textInput*/ 1) {
    				set_input_value(textarea, /*textInput*/ ctx[0]);
    			}

    			if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
    				if_block.p(ctx, dirty);
    			} else {
    				if_block.d(1);
    				if_block = current_block_type(ctx);

    				if (if_block) {
    					if_block.c();
    					if_block.m(if_block_anchor.parentNode, if_block_anchor);
    				}
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(h1);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(textarea);
    			if (detaching) detach_dev(t2);
    			if_block.d(detaching);
    			if (detaching) detach_dev(if_block_anchor);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function instance$4($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('CopyandRemoveListComponent', slots, []);
    	let textInput = '';
    	let items = [];

    	function updateItems() {
    		$$invalidate(1, items = textInput.split('\n').filter(line => line.trim() !== '').map((line, index) => ({ id: index + line, text: line })));
    	}

    	async function copyAndRemoveItem(item) {
    		try {
    			await navigator.clipboard.writeText(item.text);
    			$$invalidate(1, items = items.filter(i => i.id !== item.id));
    		} catch(err) {
    			console.error('Failed to copy text: ', err);
    		}
    	}

    	const writable_props = [];

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

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

    	const click_handler = item => copyAndRemoveItem(item);

    	$$self.$capture_state = () => ({
    		textInput,
    		items,
    		updateItems,
    		copyAndRemoveItem
    	});

    	$$self.$inject_state = $$props => {
    		if ('textInput' in $$props) $$invalidate(0, textInput = $$props.textInput);
    		if ('items' in $$props) $$invalidate(1, items = $$props.items);
    	};

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

    	return [
    		textInput,
    		items,
    		updateItems,
    		copyAndRemoveItem,
    		textarea_input_handler,
    		click_handler
    	];
    }

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

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

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

    const file$3 = "src\\ReadingStateCounter.svelte";

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

    // (66:4) {#each words as wordObj, index (wordObj.word)}
    function create_each_block$1(key_1, ctx) {
    	let button;
    	let t0_value = /*wordObj*/ ctx[8].word + "";
    	let t0;
    	let t1;
    	let t2_value = /*wordObj*/ ctx[8].count + "";
    	let t2;
    	let t3;
    	let mounted;
    	let dispose;

    	function click_handler() {
    		return /*click_handler*/ ctx[7](/*index*/ ctx[10]);
    	}

    	const block = {
    		key: key_1,
    		first: null,
    		c: function create() {
    			button = element("button");
    			t0 = text(t0_value);
    			t1 = text(" (");
    			t2 = text(t2_value);
    			t3 = text(")\r\n        ");
    			attr_dev(button, "class", "word-button svelte-13vjncp");
    			set_style(button, "background-color", getColor(/*wordObj*/ ctx[8].count));
    			add_location(button, file$3, 66, 8, 1940);
    			this.first = button;
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, button, anchor);
    			append_dev(button, t0);
    			append_dev(button, t1);
    			append_dev(button, t2);
    			append_dev(button, t3);

    			if (!mounted) {
    				dispose = listen_dev(button, "click", click_handler, false, false, false, false);
    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*words*/ 2 && t0_value !== (t0_value = /*wordObj*/ ctx[8].word + "")) set_data_dev(t0, t0_value);
    			if (dirty & /*words*/ 2 && t2_value !== (t2_value = /*wordObj*/ ctx[8].count + "")) set_data_dev(t2, t2_value);

    			if (dirty & /*words*/ 2) {
    				set_style(button, "background-color", getColor(/*wordObj*/ ctx[8].count));
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(button);
    			mounted = false;
    			dispose();
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block$1.name,
    		type: "each",
    		source: "(66:4) {#each words as wordObj, index (wordObj.word)}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$3(ctx) {
    	let div0;
    	let h1;
    	let t1;
    	let input0;
    	let t2;
    	let button0;
    	let t4;
    	let button1;
    	let t6;
    	let input1;
    	let t7;
    	let div1;
    	let each_blocks = [];
    	let each_1_lookup = new Map();
    	let mounted;
    	let dispose;
    	let each_value = /*words*/ ctx[1];
    	validate_each_argument(each_value);
    	const get_key = ctx => /*wordObj*/ ctx[8].word;
    	validate_each_keys(ctx, each_value, get_each_context$1, get_key);

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

    	const block = {
    		c: function create() {
    			div0 = element("div");
    			h1 = element("h1");
    			h1.textContent = "Stateful Reader Brainstorm";
    			t1 = space();
    			input0 = element("input");
    			t2 = space();
    			button0 = element("button");
    			button0.textContent = "Submit Text";
    			t4 = space();
    			button1 = element("button");
    			button1.textContent = "Export to JSON";
    			t6 = space();
    			input1 = element("input");
    			t7 = space();
    			div1 = element("div");

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

    			add_location(h1, file$3, 57, 4, 1576);
    			attr_dev(input0, "type", "text");
    			attr_dev(input0, "placeholder", "Enter text here");
    			attr_dev(input0, "class", "svelte-13vjncp");
    			add_location(input0, file$3, 58, 4, 1617);
    			attr_dev(button0, "class", "svelte-13vjncp");
    			add_location(button0, file$3, 59, 4, 1696);
    			attr_dev(button1, "class", "svelte-13vjncp");
    			add_location(button1, file$3, 60, 4, 1752);
    			attr_dev(input1, "type", "file");
    			attr_dev(input1, "class", "svelte-13vjncp");
    			add_location(input1, file$3, 61, 4, 1813);
    			add_location(div0, file$3, 56, 0, 1565);
    			add_location(div1, file$3, 64, 0, 1873);
    		},
    		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, div0, anchor);
    			append_dev(div0, h1);
    			append_dev(div0, t1);
    			append_dev(div0, input0);
    			set_input_value(input0, /*inputText*/ ctx[0]);
    			append_dev(div0, t2);
    			append_dev(div0, button0);
    			append_dev(div0, t4);
    			append_dev(div0, button1);
    			append_dev(div0, t6);
    			append_dev(div0, input1);
    			insert_dev(target, t7, anchor);
    			insert_dev(target, div1, anchor);

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

    			if (!mounted) {
    				dispose = [
    					listen_dev(input0, "input", /*input0_input_handler*/ ctx[6]),
    					listen_dev(button0, "click", /*submitText*/ ctx[2], false, false, false, false),
    					listen_dev(button1, "click", /*exportToJson*/ ctx[4], false, false, false, false),
    					listen_dev(input1, "change", /*importFromJson*/ ctx[5], false, false, false, false)
    				];

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

    			if (dirty & /*getColor, words, handleClick*/ 10) {
    				each_value = /*words*/ ctx[1];
    				validate_each_argument(each_value);
    				validate_each_keys(ctx, each_value, get_each_context$1, get_key);
    				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each_1_lookup, div1, destroy_block, create_each_block$1, null, get_each_context$1);
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div0);
    			if (detaching) detach_dev(t7);
    			if (detaching) detach_dev(div1);

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

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

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

    	return block;
    }

    function getColor(count) {
    	const colors = [
    		'#1a1a1a',
    		'#333333',
    		'#4d4d4d',
    		'#666666',
    		'#808080',
    		'#999999',
    		'#b3b3b3',
    		'#cccccc',
    		'#e6e6e6',
    		'#ffffff'
    	];

    	return colors[Math.min(Math.floor(count / 10), 9)];
    }

    function instance$3($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('ReadingStateCounter', slots, []);
    	let inputText = "";
    	let words = [];

    	function submitText() {
    		$$invalidate(1, words = inputText.split(/\s+/).map(word => ({ word, count: 0 })));
    	}

    	function handleClick(index) {
    		$$invalidate(1, words[index].count += 1, words);
    		$$invalidate(1, words = [...words]); // Ensures Svelte detects the change
    	}

    	// Function to export data to JSON
    	function exportToJson() {
    		const jsonData = JSON.stringify(words);
    		const blob = new Blob([jsonData], { type: "application/json" });
    		const url = URL.createObjectURL(blob);
    		const a = document.createElement('a');
    		a.href = url;
    		a.download = 'statefulwords.json';
    		a.click();
    		URL.revokeObjectURL(url);
    	}

    	// Function to handle file import
    	function importFromJson(event) {
    		const file = event.target.files[0];

    		if (file) {
    			const reader = new FileReader();

    			reader.onload = e => {
    				const json = e.target.result;
    				$$invalidate(1, words = JSON.parse(json));
    			};

    			reader.readAsText(file);
    		}
    	}

    	const writable_props = [];

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

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

    	const click_handler = index => handleClick(index);

    	$$self.$capture_state = () => ({
    		inputText,
    		words,
    		submitText,
    		handleClick,
    		getColor,
    		exportToJson,
    		importFromJson
    	});

    	$$self.$inject_state = $$props => {
    		if ('inputText' in $$props) $$invalidate(0, inputText = $$props.inputText);
    		if ('words' in $$props) $$invalidate(1, words = $$props.words);
    	};

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

    	return [
    		inputText,
    		words,
    		submitText,
    		handleClick,
    		exportToJson,
    		importFromJson,
    		input0_input_handler,
    		click_handler
    	];
    }

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

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

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

    const { Object: Object_1$1, console: console_1$1 } = globals;
    const file$2 = "src\\DeliberateSubconciousRepititionPractice.svelte";

    // (156:0) {#if selectedItem}
    function create_if_block_1(ctx) {
    	let div;
    	let strong0;
    	let t1;
    	let t2_value = /*selectedItem*/ ctx[1].text + "";
    	let t2;
    	let t3;
    	let strong1;
    	let t5;
    	let t6_value = /*counts*/ ctx[2][/*selectedItem*/ ctx[1].id] + "";
    	let t6;

    	const block = {
    		c: function create() {
    			div = element("div");
    			strong0 = element("strong");
    			strong0.textContent = "Current Word:";
    			t1 = space();
    			t2 = text(t2_value);
    			t3 = space();
    			strong1 = element("strong");
    			strong1.textContent = "Count:";
    			t5 = space();
    			t6 = text(t6_value);
    			add_location(strong0, file$2, 157, 8, 5744);
    			add_location(strong1, file$2, 158, 8, 5805);
    			add_location(div, file$2, 156, 4, 5729);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    			append_dev(div, strong0);
    			append_dev(div, t1);
    			append_dev(div, t2);
    			append_dev(div, t3);
    			append_dev(div, strong1);
    			append_dev(div, t5);
    			append_dev(div, t6);
    		},
    		p: function update(ctx, dirty) {
    			if (dirty & /*selectedItem*/ 2 && t2_value !== (t2_value = /*selectedItem*/ ctx[1].text + "")) set_data_dev(t2, t2_value);
    			if (dirty & /*counts, selectedItem*/ 6 && t6_value !== (t6_value = /*counts*/ ctx[2][/*selectedItem*/ ctx[1].id] + "")) set_data_dev(t6, t6_value);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block_1.name,
    		type: "if",
    		source: "(156:0) {#if selectedItem}",
    		ctx
    	});

    	return block;
    }

    // (163:0) {#if allWordsLimitReached}
    function create_if_block(ctx) {
    	let div;

    	const block = {
    		c: function create() {
    			div = element("div");
    			div.textContent = "All words have reached the count limit.";
    			attr_dev(div, "class", "alert svelte-fb2ql8");
    			add_location(div, file$2, 163, 4, 5910);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_if_block.name,
    		type: "if",
    		source: "(163:0) {#if allWordsLimitReached}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$2(ctx) {
    	let h1;
    	let t1;
    	let input0;
    	let t2;
    	let button0;
    	let t4;
    	let br;
    	let t5;
    	let textarea0;
    	let t6;
    	let hr0;
    	let t7;
    	let div;
    	let label;
    	let t9;
    	let input1;
    	let t10;
    	let t11;
    	let t12;
    	let button1;
    	let t14;
    	let button2;
    	let t16;
    	let hr1;
    	let t17;
    	let button3;
    	let t19;
    	let textarea1;
    	let mounted;
    	let dispose;
    	let if_block0 = /*selectedItem*/ ctx[1] && create_if_block_1(ctx);
    	let if_block1 = /*allWordsLimitReached*/ ctx[4] && create_if_block(ctx);

    	const block = {
    		c: function create() {
    			h1 = element("h1");
    			h1.textContent = "Random Word till appearance count reached for TTS";
    			t1 = space();
    			input0 = element("input");
    			t2 = space();
    			button0 = element("button");
    			button0.textContent = "Export Counts";
    			t4 = space();
    			br = element("br");
    			t5 = space();
    			textarea0 = element("textarea");
    			t6 = space();
    			hr0 = element("hr");
    			t7 = space();
    			div = element("div");
    			label = element("label");
    			label.textContent = "Total Count Limit:";
    			t9 = space();
    			input1 = element("input");
    			t10 = space();
    			if (if_block0) if_block0.c();
    			t11 = space();
    			if (if_block1) if_block1.c();
    			t12 = space();
    			button1 = element("button");
    			button1.textContent = "Start";
    			t14 = space();
    			button2 = element("button");
    			button2.textContent = "Stop";
    			t16 = space();
    			hr1 = element("hr");
    			t17 = space();
    			button3 = element("button");
    			button3.textContent = "Simulate one hour or limit Counts";
    			t19 = space();
    			textarea1 = element("textarea");
    			add_location(h1, file$2, 141, 0, 5255);
    			attr_dev(input0, "type", "file");
    			add_location(input0, file$2, 143, 0, 5317);
    			add_location(button0, file$2, 144, 0, 5365);
    			add_location(br, file$2, 145, 0, 5421);
    			attr_dev(textarea0, "placeholder", "Enter text here...");
    			add_location(textarea0, file$2, 146, 0, 5427);
    			add_location(hr0, file$2, 148, 0, 5531);
    			attr_dev(label, "for", "totalCountLimit");
    			add_location(label, file$2, 151, 4, 5550);
    			attr_dev(input1, "type", "number");
    			attr_dev(input1, "min", "1");
    			attr_dev(input1, "id", "totalCountLimit");
    			add_location(input1, file$2, 152, 4, 5612);
    			add_location(div, file$2, 150, 0, 5539);
    			add_location(button1, file$2, 168, 0, 6001);
    			add_location(button2, file$2, 169, 0, 6042);
    			add_location(hr1, file$2, 171, 0, 6083);
    			add_location(button3, file$2, 173, 0, 6091);
    			textarea1.readOnly = true;
    			attr_dev(textarea1, "placeholder", "Simulation result will be shown here...");
    			add_location(textarea1, file$2, 174, 0, 6168);
    		},
    		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, h1, anchor);
    			insert_dev(target, t1, anchor);
    			insert_dev(target, input0, anchor);
    			insert_dev(target, t2, anchor);
    			insert_dev(target, button0, anchor);
    			insert_dev(target, t4, anchor);
    			insert_dev(target, br, anchor);
    			insert_dev(target, t5, anchor);
    			insert_dev(target, textarea0, anchor);
    			set_input_value(textarea0, /*textInput*/ ctx[0]);
    			insert_dev(target, t6, anchor);
    			insert_dev(target, hr0, anchor);
    			insert_dev(target, t7, anchor);
    			insert_dev(target, div, anchor);
    			append_dev(div, label);
    			append_dev(div, t9);
    			append_dev(div, input1);
    			set_input_value(input1, /*totalCountLimit*/ ctx[3]);
    			insert_dev(target, t10, anchor);
    			if (if_block0) if_block0.m(target, anchor);
    			insert_dev(target, t11, anchor);
    			if (if_block1) if_block1.m(target, anchor);
    			insert_dev(target, t12, anchor);
    			insert_dev(target, button1, anchor);
    			insert_dev(target, t14, anchor);
    			insert_dev(target, button2, anchor);
    			insert_dev(target, t16, anchor);
    			insert_dev(target, hr1, anchor);
    			insert_dev(target, t17, anchor);
    			insert_dev(target, button3, anchor);
    			insert_dev(target, t19, anchor);
    			insert_dev(target, textarea1, anchor);
    			set_input_value(textarea1, /*simulationResult*/ ctx[5]);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input0, "change", /*importCounts*/ ctx[10], false, false, false, false),
    					listen_dev(button0, "click", /*exportCounts*/ ctx[9], false, false, false, false),
    					listen_dev(textarea0, "input", /*textarea0_input_handler*/ ctx[12]),
    					listen_dev(textarea0, "input", /*updateItems*/ ctx[6], false, false, false, false),
    					listen_dev(input1, "input", /*input1_input_handler*/ ctx[13]),
    					listen_dev(button1, "click", /*start*/ ctx[7], false, false, false, false),
    					listen_dev(button2, "click", /*stop*/ ctx[8], false, false, false, false),
    					listen_dev(button3, "click", /*simulateCount*/ ctx[11], false, false, false, false),
    					listen_dev(textarea1, "input", /*textarea1_input_handler*/ ctx[14])
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*textInput*/ 1) {
    				set_input_value(textarea0, /*textInput*/ ctx[0]);
    			}

    			if (dirty & /*totalCountLimit*/ 8 && to_number(input1.value) !== /*totalCountLimit*/ ctx[3]) {
    				set_input_value(input1, /*totalCountLimit*/ ctx[3]);
    			}

    			if (/*selectedItem*/ ctx[1]) {
    				if (if_block0) {
    					if_block0.p(ctx, dirty);
    				} else {
    					if_block0 = create_if_block_1(ctx);
    					if_block0.c();
    					if_block0.m(t11.parentNode, t11);
    				}
    			} else if (if_block0) {
    				if_block0.d(1);
    				if_block0 = null;
    			}

    			if (/*allWordsLimitReached*/ ctx[4]) {
    				if (if_block1) ; else {
    					if_block1 = create_if_block(ctx);
    					if_block1.c();
    					if_block1.m(t12.parentNode, t12);
    				}
    			} else if (if_block1) {
    				if_block1.d(1);
    				if_block1 = null;
    			}

    			if (dirty & /*simulationResult*/ 32) {
    				set_input_value(textarea1, /*simulationResult*/ ctx[5]);
    			}
    		},
    		i: noop,
    		o: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(h1);
    			if (detaching) detach_dev(t1);
    			if (detaching) detach_dev(input0);
    			if (detaching) detach_dev(t2);
    			if (detaching) detach_dev(button0);
    			if (detaching) detach_dev(t4);
    			if (detaching) detach_dev(br);
    			if (detaching) detach_dev(t5);
    			if (detaching) detach_dev(textarea0);
    			if (detaching) detach_dev(t6);
    			if (detaching) detach_dev(hr0);
    			if (detaching) detach_dev(t7);
    			if (detaching) detach_dev(div);
    			if (detaching) detach_dev(t10);
    			if (if_block0) if_block0.d(detaching);
    			if (detaching) detach_dev(t11);
    			if (if_block1) if_block1.d(detaching);
    			if (detaching) detach_dev(t12);
    			if (detaching) detach_dev(button1);
    			if (detaching) detach_dev(t14);
    			if (detaching) detach_dev(button2);
    			if (detaching) detach_dev(t16);
    			if (detaching) detach_dev(hr1);
    			if (detaching) detach_dev(t17);
    			if (detaching) detach_dev(button3);
    			if (detaching) detach_dev(t19);
    			if (detaching) detach_dev(textarea1);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

    function instance$2($$self, $$props, $$invalidate) {
    	let { $$slots: slots = {}, $$scope } = $$props;
    	validate_slots('DeliberateSubconciousRepititionPractice', slots, []);
    	let textInput = '';
    	let items = [];
    	let running = false;
    	let selectedItem = null;
    	let intervalId = null;
    	let counts = {};
    	let totalCountLimit = 10; // Default limit, can be changed by the user
    	let allWordsLimitReached = false;
    	let simulationResult = ''; // Variable to hold the result of the simulation

    	function updateItems() {
    		items = textInput.split(/\W+/).filter(word => word.trim() !== '').map(word => ({ id: word, text: word })); // Use word itself as the ID
    		$$invalidate(2, counts = items.reduce((acc, item) => ({ ...acc, [item.id]: 0 }), {}));
    	}

    	function start() {
    		if (!running && items.length > 0) {
    			running = true;

    			intervalId = setInterval(
    				() => {
    					// Filter out items that have reached the totalCountLimit
    					const eligibleItems = items.filter(item => counts[item.id] < totalCountLimit);

    					// If there are no eligible items left, stop the timer
    					if (eligibleItems.length === 0) {
    						stop();
    						$$invalidate(4, allWordsLimitReached = true); // Set when all words reach the limit
    						return;
    					}

    					// Select a random item from the eligible items
    					const randomIndex = Math.floor(Math.random() * eligibleItems.length);

    					$$invalidate(1, selectedItem = eligibleItems[randomIndex]);
    					$$invalidate(2, counts[selectedItem.id]++, counts);
    				},
    				1000
    			);
    		}
    	}

    	function stop() {
    		if (running) {
    			clearInterval(intervalId);
    			running = false;
    			intervalId = null;
    		}
    	}

    	function exportCounts() {
    		const dataStr = JSON.stringify(counts);
    		const blob = new Blob([dataStr], { type: "application/json" });
    		const url = URL.createObjectURL(blob);
    		const link = document.createElement("a");
    		link.download = "counts.json";
    		link.href = url;
    		link.click();
    	}

    	function importCounts(event) {
    		const fileReader = new FileReader();

    		fileReader.onload = e => {
    			const data = JSON.parse(e.target.result);
    			$$invalidate(2, counts = { ...counts, ...data });

    			items = Object.keys(data).map((word, index) => ({
    				id: word, // Use word itself as the ID
    				text: word
    			}));

    			// Ensure existing items are updated if they are not in the imported data
    			items.forEach(item => {
    				if (!counts[item.id]) {
    					$$invalidate(2, counts[item.id] = 0, counts);
    				}
    			});
    		};

    		fileReader.readAsText(event.target.files[0]);
    	}

    	// ... (other variables and functions remain unchanged)
    	function simulateCount() {
    		let simulatedTime = 0;
    		let maxSimulatedSeconds = 3600; // 3600 seconds = 1 hour
    		let simulationOutput = ""; // Accumulate output here

    		// Reset the allWordsLimitReached flag and simulationResult
    		$$invalidate(4, allWordsLimitReached = false);

    		$$invalidate(5, simulationResult = '');

    		// Simulate until max time is reached or all words hit the limit
    		while (simulatedTime < maxSimulatedSeconds && !allWordsLimitReached) {
    			const eligibleItems = items.filter(item => counts[item.id] < totalCountLimit);

    			if (eligibleItems.length === 0) {
    				$$invalidate(4, allWordsLimitReached = true); // Set when all words reach the limit
    				break; // Exit the loop if all words hit the limit
    			}

    			// Select a random item and increment its count
    			const randomIndex = Math.floor(Math.random() * eligibleItems.length);

    			$$invalidate(1, selectedItem = eligibleItems[randomIndex]);
    			$$invalidate(2, counts[selectedItem.id]++, counts);
    			simulationOutput += selectedItem.text + " "; // Append selected word to output

    			// Increment simulated time (equivalent to the time between iterations in the real scenario)
    			simulatedTime++;
    		}

    		// Update simulationResult with a message
    		if (allWordsLimitReached) {
    			$$invalidate(5, simulationResult = "All words have reached the count limit during simulation.");
    		} else {
    			$$invalidate(5, simulationResult = `Simulation finished after ${simulatedTime} seconds.`);
    		}

    		// Export the simulation output to a text file
    		exportSimulationOutput(simulationOutput);
    	}

    	function exportSimulationOutput(output) {
    		if (output) {
    			const blob = new Blob([output], { type: "text/plain" });
    			const url = URL.createObjectURL(blob);
    			const link = document.createElement("a");
    			link.download = "simulation_output.txt";
    			link.href = url;
    			link.click();
    		} else {
    			console.error("No simulation output to export.");
    			$$invalidate(5, simulationResult = "No simulation output to export.");
    		}
    	}

    	onDestroy(() => {
    		if (intervalId) {
    			clearInterval(intervalId);
    		}
    	});

    	const writable_props = [];

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

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

    	function input1_input_handler() {
    		totalCountLimit = to_number(this.value);
    		$$invalidate(3, totalCountLimit);
    	}

    	function textarea1_input_handler() {
    		simulationResult = this.value;
    		$$invalidate(5, simulationResult);
    	}

    	$$self.$capture_state = () => ({
    		onDestroy,
    		textInput,
    		items,
    		running,
    		selectedItem,
    		intervalId,
    		counts,
    		totalCountLimit,
    		allWordsLimitReached,
    		simulationResult,
    		updateItems,
    		start,
    		stop,
    		exportCounts,
    		importCounts,
    		simulateCount,
    		exportSimulationOutput
    	});

    	$$self.$inject_state = $$props => {
    		if ('textInput' in $$props) $$invalidate(0, textInput = $$props.textInput);
    		if ('items' in $$props) items = $$props.items;
    		if ('running' in $$props) running = $$props.running;
    		if ('selectedItem' in $$props) $$invalidate(1, selectedItem = $$props.selectedItem);
    		if ('intervalId' in $$props) intervalId = $$props.intervalId;
    		if ('counts' in $$props) $$invalidate(2, counts = $$props.counts);
    		if ('totalCountLimit' in $$props) $$invalidate(3, totalCountLimit = $$props.totalCountLimit);
    		if ('allWordsLimitReached' in $$props) $$invalidate(4, allWordsLimitReached = $$props.allWordsLimitReached);
    		if ('simulationResult' in $$props) $$invalidate(5, simulationResult = $$props.simulationResult);
    	};

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

    	return [
    		textInput,
    		selectedItem,
    		counts,
    		totalCountLimit,
    		allWordsLimitReached,
    		simulationResult,
    		updateItems,
    		start,
    		stop,
    		exportCounts,
    		importCounts,
    		simulateCount,
    		textarea0_input_handler,
    		input1_input_handler,
    		textarea1_input_handler
    	];
    }

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

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

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

    const { Object: Object_1, console: console_1 } = globals;
    const file$1 = "src\\LLMWorkflowTest.svelte";

    function get_each_context(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[10] = list[i];
    	child_ctx[11] = list;
    	child_ctx[12] = i;
    	return child_ctx;
    }

    function get_each_context_1(ctx, list, i) {
    	const child_ctx = ctx.slice();
    	child_ctx[13] = list[i];
    	return child_ctx;
    }

    // (87:4) {#each Object.keys(workflows) as workflow}
    function create_each_block_1(ctx) {
    	let option;
    	let t_value = /*workflow*/ ctx[13] + "";
    	let t;

    	const block = {
    		c: function create() {
    			option = element("option");
    			t = text(t_value);
    			option.__value = /*workflow*/ ctx[13];
    			option.value = option.__value;
    			add_location(option, file$1, 87, 6, 2693);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, option, anchor);
    			append_dev(option, t);
    		},
    		p: noop,
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(option);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block_1.name,
    		type: "each",
    		source: "(87:4) {#each Object.keys(workflows) as workflow}",
    		ctx
    	});

    	return block;
    }

    // (92:2) {#each placeholderInputs as placeholder}
    function create_each_block(ctx) {
    	let div;
    	let label;
    	let t0;
    	let t1_value = /*placeholder*/ ctx[10] + "";
    	let t1;
    	let t2;
    	let t3;
    	let input;
    	let mounted;
    	let dispose;

    	function input_input_handler() {
    		/*input_input_handler*/ ctx[8].call(input, /*placeholder*/ ctx[10]);
    	}

    	const block = {
    		c: function create() {
    			div = element("div");
    			label = element("label");
    			t0 = text("Enter word for <");
    			t1 = text(t1_value);
    			t2 = text(">");
    			t3 = space();
    			input = element("input");
    			add_location(label, file$1, 93, 6, 2828);
    			attr_dev(input, "type", "text");
    			add_location(input, file$1, 94, 6, 2887);
    			add_location(div, file$1, 92, 4, 2815);
    		},
    		m: function mount(target, anchor) {
    			insert_dev(target, div, anchor);
    			append_dev(div, label);
    			append_dev(label, t0);
    			append_dev(label, t1);
    			append_dev(label, t2);
    			append_dev(div, t3);
    			append_dev(div, input);
    			set_input_value(input, /*placeholderValues*/ ctx[1][/*placeholder*/ ctx[10]]);

    			if (!mounted) {
    				dispose = [
    					listen_dev(input, "input", input_input_handler),
    					listen_dev(input, "input", /*updateInputs*/ ctx[6], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(new_ctx, dirty) {
    			ctx = new_ctx;
    			if (dirty & /*placeholderInputs*/ 4 && t1_value !== (t1_value = /*placeholder*/ ctx[10] + "")) set_data_dev(t1, t1_value);

    			if (dirty & /*placeholderValues, placeholderInputs*/ 6 && input.value !== /*placeholderValues*/ ctx[1][/*placeholder*/ ctx[10]]) {
    				set_input_value(input, /*placeholderValues*/ ctx[1][/*placeholder*/ ctx[10]]);
    			}
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(div);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

    	dispatch_dev("SvelteRegisterBlock", {
    		block,
    		id: create_each_block.name,
    		type: "each",
    		source: "(92:2) {#each placeholderInputs as placeholder}",
    		ctx
    	});

    	return block;
    }

    function create_fragment$1(ctx) {
    	let div1;
    	let h1;
    	let t1;
    	let select;
    	let t2;
    	let t3;
    	let div0;
    	let t4;
    	let button;
    	let mounted;
    	let dispose;
    	let each_value_1 = Object.keys(/*workflows*/ ctx[3]);
    	validate_each_argument(each_value_1);
    	let each_blocks_1 = [];

    	for (let i = 0; i < each_value_1.length; i += 1) {
    		each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
    	}

    	let each_value = /*placeholderInputs*/ 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() {
    			div1 = element("div");
    			h1 = element("h1");
    			h1.textContent = "Incompelete Workflow Interface";
    			t1 = space();
    			select = element("select");

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

    			t2 = space();

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

    			t3 = space();
    			div0 = element("div");
    			t4 = space();
    			button = element("button");
    			button.textContent = "Submit";
    			add_location(h1, file$1, 84, 2, 2523);
    			if (/*selectedWorkflow*/ ctx[0] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[7].call(select));
    			add_location(select, file$1, 85, 2, 2566);
    			attr_dev(div0, "id", "input-group");
    			add_location(div0, file$1, 102, 2, 3039);
    			add_location(button, file$1, 104, 2, 3073);
    			add_location(div1, file$1, 83, 0, 2514);
    		},
    		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, div1, anchor);
    			append_dev(div1, h1);
    			append_dev(div1, t1);
    			append_dev(div1, select);

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

    			select_option(select, /*selectedWorkflow*/ ctx[0], true);
    			append_dev(div1, t2);

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

    			append_dev(div1, t3);
    			append_dev(div1, div0);
    			append_dev(div1, t4);
    			append_dev(div1, button);

    			if (!mounted) {
    				dispose = [
    					listen_dev(select, "change", /*select_change_handler*/ ctx[7]),
    					listen_dev(select, "change", /*handleWorkflowChange*/ ctx[4], false, false, false, false),
    					listen_dev(button, "click", /*processInputs*/ ctx[5], false, false, false, false)
    				];

    				mounted = true;
    			}
    		},
    		p: function update(ctx, [dirty]) {
    			if (dirty & /*Object, workflows*/ 8) {
    				each_value_1 = Object.keys(/*workflows*/ ctx[3]);
    				validate_each_argument(each_value_1);
    				let i;

    				for (i = 0; i < each_value_1.length; i += 1) {
    					const child_ctx = get_each_context_1(ctx, each_value_1, i);

    					if (each_blocks_1[i]) {
    						each_blocks_1[i].p(child_ctx, dirty);
    					} else {
    						each_blocks_1[i] = create_each_block_1(child_ctx);
    						each_blocks_1[i].c();
    						each_blocks_1[i].m(select, null);
    					}
    				}

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

    				each_blocks_1.length = each_value_1.length;
    			}

    			if (dirty & /*selectedWorkflow, Object, workflows*/ 9) {
    				select_option(select, /*selectedWorkflow*/ ctx[0]);
    			}

    			if (dirty & /*placeholderValues, placeholderInputs, updateInputs*/ 70) {
    				each_value = /*placeholderInputs*/ 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(div1, t3);
    					}
    				}

    				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(div1);
    			destroy_each(each_blocks_1, detaching);
    			destroy_each(each_blocks, detaching);
    			mounted = false;
    			run_all(dispose);
    		}
    	};

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

    	return block;
    }

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

    	let workflows = {
    		"Merged Spelling": {
    			steps: [
    				"Please make an image description the meaning of the word <word1>",
    				"next please find english words close in spelling to <word2>",
    				"great, next make an image description using those words",
    				"Thanks lets now merge the two seperate image descriptions together"
    			],
    			placeholders: { "<word1>": "much", "<word2>": "henduo" },
    			timeline: [[], 1, [1], [0, 2]]
    		},
    		"Another Workflow": {
    			steps: [
    				"Do something with <placeholder1>",
    				"Then do something else with <placeholder2>"
    			],
    			placeholders: {
    				"<placeholder1>": "value1",
    				"<placeholder2>": "value2"
    			},
    			timeline: [[], 1]
    		}
    	};

    	let selectedWorkflow = "Merged Spelling";
    	let placeholderValues = workflows[selectedWorkflow].placeholders;
    	let placeholderInputs = Object.keys(placeholderValues);
    	let timeline = workflows[selectedWorkflow].timeline;

    	function handleWorkflowChange() {
    		$$invalidate(1, placeholderValues = workflows[selectedWorkflow].placeholders);
    		$$invalidate(2, placeholderInputs = Object.keys(placeholderValues));
    		timeline = workflows[selectedWorkflow].timeline;
    		updateInputs();
    	}

    	function processInputs() {
    		const inputs = document.querySelectorAll('input[type="text"]');
    		console.log(`Workflow: ${selectedWorkflow}`);

    		inputs.forEach((input, i) => {
    			console.log(`Step ${i + 1}: ${input.value}`);
    		});
    	}

    	onMount(() => {
    		handleWorkflowChange();
    		updateInputs();
    	});

    	function updateInputs() {
    		const inputGroup = document.getElementById('input-group');
    		inputGroup.innerHTML = '';
    		const steps = workflows[selectedWorkflow].steps;

    		steps.forEach((step, i) => {
    			const label = placeholderInputs.reduce((updatedStep, placeholder) => updatedStep.replace(new RegExp(placeholder, 'g'), placeholderValues[placeholder]), step);

    			const dependencyText = Array.isArray(timeline[i])
    			? timeline[i].join(', ')
    			: timeline[i];

    			const inputBox = `
        <div>
          <label>${label}</label>
          <input type="text" />
          ${timeline[i].length > 0
			? `<span>Output depends on: ${dependencyText}</span>`
			: ''}
        </div>
      `;

    			inputGroup.innerHTML += inputBox;
    		});
    	}

    	const writable_props = [];

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

    	function select_change_handler() {
    		selectedWorkflow = select_value(this);
    		$$invalidate(0, selectedWorkflow);
    		$$invalidate(3, workflows);
    	}

    	function input_input_handler(placeholder) {
    		placeholderValues[placeholder] = this.value;
    		$$invalidate(1, placeholderValues);
    	}

    	$$self.$capture_state = () => ({
    		onMount,
    		workflows,
    		selectedWorkflow,
    		placeholderValues,
    		placeholderInputs,
    		timeline,
    		handleWorkflowChange,
    		processInputs,
    		updateInputs
    	});

    	$$self.$inject_state = $$props => {
    		if ('workflows' in $$props) $$invalidate(3, workflows = $$props.workflows);
    		if ('selectedWorkflow' in $$props) $$invalidate(0, selectedWorkflow = $$props.selectedWorkflow);
    		if ('placeholderValues' in $$props) $$invalidate(1, placeholderValues = $$props.placeholderValues);
    		if ('placeholderInputs' in $$props) $$invalidate(2, placeholderInputs = $$props.placeholderInputs);
    		if ('timeline' in $$props) timeline = $$props.timeline;
    	};

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

    	return [
    		selectedWorkflow,
    		placeholderValues,
    		placeholderInputs,
    		workflows,
    		handleWorkflowChange,
    		processInputs,
    		updateInputs,
    		select_change_handler,
    		input_input_handler
    	];
    }

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

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

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

    function create_fragment(ctx) {
    	let main;
    	let h10;
    	let t0;
    	let t1;
    	let t2;
    	let t3;
    	let p;
    	let t4;
    	let a;
    	let t6;
    	let t7;
    	let h11;
    	let t9;
    	let h30;
    	let t11;
    	let div4;
    	let div0;
    	let copyremove;
    	let t12;
    	let div1;
    	let llmwf;
    	let t13;
    	let div2;
    	let subrepprac;
    	let t14;
    	let div3;
    	let readingstatecounter;
    	let t15;
    	let h31;
    	let t17;
    	let nestedcommentssvelte;
    	let t18;
    	let myyoutube;
    	let t19;
    	let h12;
    	let t21;
    	let dotgame;
    	let current;
    	copyremove = new CopyandRemoveListComponent({ $$inline: true });
    	llmwf = new LLMWorkflowTest({ $$inline: true });
    	subrepprac = new DeliberateSubconciousRepititionPractice({ $$inline: true });
    	readingstatecounter = new ReadingStateCounter({ $$inline: true });
    	nestedcommentssvelte = new RecursiveNestedCommentsElement({ $$inline: true });
    	myyoutube = new YoutubeIframeAPICustomInterface({ $$inline: true });
    	dotgame = new MovingDotSpacePortfromReact({ $$inline: true });

    	const block = {
    		c: function create() {
    			main = element("main");
    			h10 = element("h1");
    			t0 = text("LLM Assisted Hello ");
    			t1 = text(/*name*/ ctx[0]);
    			t2 = text("!");
    			t3 = space();
    			p = element("p");
    			t4 = text("Visit the ");
    			a = element("a");
    			a.textContent = "Svelte tutorial";
    			t6 = text(" to learn how to build Svelte apps. (or ask Claude / GPT4 for help)");
    			t7 = space();
    			h11 = element("h1");
    			h11.textContent = "Brainstorm for Educational Interfaces to add LLM and other models into";
    			t9 = space();
    			h30 = element("h3");
    			h30.textContent = "(Through Gradio and Custom Components)";
    			t11 = space();
    			div4 = element("div");
    			div0 = element("div");
    			create_component(copyremove.$$.fragment);
    			t12 = space();
    			div1 = element("div");
    			create_component(llmwf.$$.fragment);
    			t13 = space();
    			div2 = element("div");
    			create_component(subrepprac.$$.fragment);
    			t14 = space();
    			div3 = element("div");
    			create_component(readingstatecounter.$$.fragment);
    			t15 = space();
    			h31 = element("h3");
    			h31.textContent = "Gradio client Test in another space due to incompatabilitiess with default svelte and @gradio/client";
    			t17 = space();
    			create_component(nestedcommentssvelte.$$.fragment);
    			t18 = space();
    			create_component(myyoutube.$$.fragment);
    			t19 = space();
    			h12 = element("h1");
    			h12.textContent = "Themeable Game Brainstorm - Image + Lists - Game as Universal Translator for any subject";
    			t21 = space();
    			create_component(dotgame.$$.fragment);
    			attr_dev(h10, "class", "svelte-192gzri");
    			add_location(h10, file, 25, 1, 714);
    			attr_dev(a, "href", "https://svelte.dev/tutorial");
    			add_location(a, file, 26, 14, 764);
    			add_location(p, file, 26, 1, 751);
    			attr_dev(h11, "class", "svelte-192gzri");
    			add_location(h11, file, 28, 1, 895);
    			add_location(h30, file, 29, 1, 978);
    			attr_dev(div0, "class", "componentborder svelte-192gzri");
    			add_location(div0, file, 32, 2, 1075);
    			attr_dev(div1, "class", "componentborder svelte-192gzri");
    			add_location(div1, file, 33, 2, 1127);
    			attr_dev(div2, "class", "componentborder svelte-192gzri");
    			add_location(div2, file, 34, 2, 1174);
    			attr_dev(div3, "class", "componentborder svelte-192gzri");
    			add_location(div3, file, 35, 2, 1226);
    			attr_dev(div4, "class", "grid-MultiComponentContainer svelte-192gzri");
    			add_location(div4, file, 31, 1, 1030);
    			add_location(h31, file, 38, 1, 1295);
    			attr_dev(h12, "class", "svelte-192gzri");
    			add_location(h12, file, 45, 1, 1500);
    			attr_dev(main, "class", "svelte-192gzri");
    			add_location(main, file, 23, 0, 705);
    		},
    		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, main, anchor);
    			append_dev(main, h10);
    			append_dev(h10, t0);
    			append_dev(h10, t1);
    			append_dev(h10, t2);
    			append_dev(main, t3);
    			append_dev(main, p);
    			append_dev(p, t4);
    			append_dev(p, a);
    			append_dev(p, t6);
    			append_dev(main, t7);
    			append_dev(main, h11);
    			append_dev(main, t9);
    			append_dev(main, h30);
    			append_dev(main, t11);
    			append_dev(main, div4);
    			append_dev(div4, div0);
    			mount_component(copyremove, div0, null);
    			append_dev(div4, t12);
    			append_dev(div4, div1);
    			mount_component(llmwf, div1, null);
    			append_dev(div4, t13);
    			append_dev(div4, div2);
    			mount_component(subrepprac, div2, null);
    			append_dev(div4, t14);
    			append_dev(div4, div3);
    			mount_component(readingstatecounter, div3, null);
    			append_dev(main, t15);
    			append_dev(main, h31);
    			append_dev(main, t17);
    			mount_component(nestedcommentssvelte, main, null);
    			append_dev(main, t18);
    			mount_component(myyoutube, main, null);
    			append_dev(main, t19);
    			append_dev(main, h12);
    			append_dev(main, t21);
    			mount_component(dotgame, main, null);
    			current = true;
    		},
    		p: function update(ctx, [dirty]) {
    			if (!current || dirty & /*name*/ 1) set_data_dev(t1, /*name*/ ctx[0]);
    		},
    		i: function intro(local) {
    			if (current) return;
    			transition_in(copyremove.$$.fragment, local);
    			transition_in(llmwf.$$.fragment, local);
    			transition_in(subrepprac.$$.fragment, local);
    			transition_in(readingstatecounter.$$.fragment, local);
    			transition_in(nestedcommentssvelte.$$.fragment, local);
    			transition_in(myyoutube.$$.fragment, local);
    			transition_in(dotgame.$$.fragment, local);
    			current = true;
    		},
    		o: function outro(local) {
    			transition_out(copyremove.$$.fragment, local);
    			transition_out(llmwf.$$.fragment, local);
    			transition_out(subrepprac.$$.fragment, local);
    			transition_out(readingstatecounter.$$.fragment, local);
    			transition_out(nestedcommentssvelte.$$.fragment, local);
    			transition_out(myyoutube.$$.fragment, local);
    			transition_out(dotgame.$$.fragment, local);
    			current = false;
    		},
    		d: function destroy(detaching) {
    			if (detaching) detach_dev(main);
    			destroy_component(copyremove);
    			destroy_component(llmwf);
    			destroy_component(subrepprac);
    			destroy_component(readingstatecounter);
    			destroy_component(nestedcommentssvelte);
    			destroy_component(myyoutube);
    			destroy_component(dotgame);
    		}
    	};

    	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, []);
    	let { name } = $$props;
    	let showModal = false;

    	function openModal() {
    		showModal = true;
    	}

    	function closeModal() {
    		showModal = false;
    	}

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

    	const writable_props = ['name'];

    	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.$$set = $$props => {
    		if ('name' in $$props) $$invalidate(0, name = $$props.name);
    	};

    	$$self.$capture_state = () => ({
    		name,
    		VideoGradioComponentBrainstorming,
    		DotGame: MovingDotSpacePortfromReact,
    		MyYoutube: YoutubeIframeAPICustomInterface,
    		NestedCommentsSvelte: RecursiveNestedCommentsElement,
    		CopyRemove: CopyandRemoveListComponent,
    		ReadingStateCounter,
    		SubRepPrac: DeliberateSubconciousRepititionPractice,
    		LLMWF: LLMWorkflowTest,
    		showModal,
    		openModal,
    		closeModal
    	});

    	$$self.$inject_state = $$props => {
    		if ('name' in $$props) $$invalidate(0, name = $$props.name);
    		if ('showModal' in $$props) showModal = $$props.showModal;
    	};

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

    	return [name];
    }

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

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

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

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

    const app = new App({
    	target: document.body,
    	props: {
    		name: 'world'
    	}
    });

    return app;

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