text: 
  (function(l, i, v, e) { v = l.createElement(i); v.async = 1; v.src = '//' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; e = l.getElementsByTagName(i)[0]; e.parentNode.insertBefore(v, e)})(document, 'script');
  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');
      }
  
      function append(target, node) {
          target.appendChild(node);
      }
      function insert(target, node, anchor) {
          target.insertBefore(node, anchor || null);
      }
      function detach(node) {
          node.parentNode.removeChild(node);
      }
      function element(name) {
          return document.createElement(name);
      }
      function text(data) {
          return document.createTextNode(data);
      }
      function space() {
          return text(' ');
      }
      function attr(node, attribute, value) {
          if (value == null)
              node.removeAttribute(attribute);
          else
              node.setAttribute(attribute, value);
      }
      function children(element) {
          return Array.from(element.childNodes);
      }
      function set_data(text, data) {
          data = '' + data;
          if (text.data !== data)
              text.data = data;
      }
  
      let current_component;
      function set_current_component(component) {
          current_component = component;
      }
  
      const dirty_components = [];
      const binding_callbacks = [];
      const render_callbacks = [];
      const flush_callbacks = [];
      const resolved_promise = Promise.resolve();
      let update_scheduled = false;
      function schedule_update() {
          if (!update_scheduled) {
              update_scheduled = true;
              resolved_promise.then(flush);
          }
      }
      function add_render_callback(fn) {
          render_callbacks.push(fn);
      }
      function flush() {
          const seen_callbacks = new Set();
          do {
              // first, call beforeUpdate functions
              // and update components
              while (dirty_components.length) {
                  const component = dirty_components.shift();
                  set_current_component(component);
                  update(component.$$);
              }
              while (binding_callbacks.length)
                  binding_callbacks.pop()();
              // then, once components are updated, call
              // afterUpdate functions. This may cause
              // subsequent updates...
              while (render_callbacks.length) {
                  const callback = render_callbacks.pop();
                  if (!seen_callbacks.has(callback)) {
                      callback();
                      // ...so guard against infinite loops
                      seen_callbacks.add(callback);
                  }
              }
          } while (dirty_components.length);
          while (flush_callbacks.length) {
              flush_callbacks.pop()();
          }
          update_scheduled = false;
      }
      function update($$) {
          if ($$.fragment) {
              $$.update($$.dirty);
              run_all($$.before_render);
              $$.fragment.p($$.dirty, $$.ctx);
              $$.dirty = null;
              $$.after_render.forEach(add_render_callback);
          }
      }
      const outroing = new Set();
      function transition_in(block, local) {
          if (block && block.i) {
              outroing.delete(block);
              block.i(local);
          }
      }
      function mount_component(component, target, anchor) {
          const { fragment, on_mount, on_destroy, after_render } = component.$$;
          fragment.m(target, anchor);
          // onMount happens after the initial afterUpdate. Because
          // afterUpdate callbacks happen in reverse order (inner first)
          // we schedule onMount callbacks before afterUpdate callbacks
          add_render_callback(() => {
              const new_on_destroy = on_mount.map(run).filter(is_function);
              if (on_destroy) {
                  on_destroy.push(...new_on_destroy);
              }
              else {
                  // Edge case - component was destroyed immediately,
                  // most likely as a result of a binding initialising
                  run_all(new_on_destroy);
              }
              component.$$.on_mount = [];
          });
          after_render.forEach(add_render_callback);
      }
      function destroy_component(component, detaching) {
          if (component.$$.fragment) {
              run_all(component.$$.on_destroy);
              component.$$.fragment.d(detaching);
              // TODO null out other refs, including component.$$ (but need to
              // preserve final state?)
              component.$$.on_destroy = component.$$.fragment = null;
              component.$$.ctx = {};
          }
      }
      function make_dirty(component, key) {
          if (!component.$$.dirty) {
              dirty_components.push(component);
              schedule_update();
              component.$$.dirty = blank_object();
          }
          component.$$.dirty[key] = true;
      }
      function init(component, options, instance, create_fragment, not_equal$$1, prop_names) {
          const parent_component = current_component;
          set_current_component(component);
          const props = options.props || {};
          const $$ = component.$$ = {
              fragment: null,
              ctx: null,
              // state
              props: prop_names,
              update: noop,
              not_equal: not_equal$$1,
              bound: blank_object(),
              // lifecycle
              on_mount: [],
              on_destroy: [],
              before_render: [],
              after_render: [],
              context: new Map(parent_component ? parent_component.$$.context : []),
              // everything else
              callbacks: blank_object(),
              dirty: null
          };
          let ready = false;
          $$.ctx = instance
              ? instance(component, props, (key, value) => {
                  if ($$.ctx && not_equal$$1($$.ctx[key], $$.ctx[key] = value)) {
                      if ($$.bound[key])
                          $$.bound[key](value);
                      if (ready)
                          make_dirty(component, key);
                  }
              })
              : props;
          $$.update();
          ready = true;
          run_all($$.before_render);
          $$.fragment = create_fragment($$.ctx);
          if (options.target) {
              if (options.hydrate) {
                  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                  $$.fragment.l(children(options.target));
              }
              else {
                  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                  $$.fragment.c();
              }
              if (options.intro)
                  transition_in(component.$$.fragment);
              mount_component(component, options.target, options.anchor);
              flush();
          }
          set_current_component(parent_component);
      }
      class SvelteComponent {
          $destroy() {
              destroy_component(this, 1);
              this.$destroy = noop;
          }
          $on(type, callback) {
              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() {
              // overridden by instance, if it has props
          }
      }
      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
              };
          }
      }
  
      /* src/App.svelte generated by Svelte v3.6.3 */
  
      const file = "src/App.svelte";
  
      function create_fragment(ctx) {
      	var div, h1, t0, t1, t2, t3, h2;
  
      	return {
      		c: function create() {
      			div = element("div");
      			h1 = element("h1");
      			t0 = text("Hello ");
      			t1 = text(ctx.name);
      			t2 = text("!");
      			t3 = space();
      			h2 = element("h2");
      			h2.textContent = "One two three four";
      			attr(h1, "class", "text-purple-200 text-lg");
      			add_location(h1, file, 6, 0, 80);
      			add_location(h2, file, 7, 0, 135);
      			attr(div, "class", "antialiased");
      			add_location(div, file, 5, 0, 54);
      		},
  
      		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(target, div, anchor);
      			append(div, h1);
      			append(h1, t0);
      			append(h1, t1);
      			append(h1, t2);
      			append(div, t3);
      			append(div, h2);
      		},
  
      		p: function update(changed, ctx) {
      			if (changed.name) {
      				set_data(t1, ctx.name);
      			}
      		},
  
      		i: noop,
      		o: noop,
  
      		d: function destroy(detaching) {
      			if (detaching) {
      				detach(div);
      			}
      		}
      	};
      }
  
      function instance($$self, $$props, $$invalidate) {
      	let { name } = $$props;
  
      	const writable_props = ['name'];
      	Object.keys($$props).forEach(key => {
      		if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<App> was created with unknown prop '${key}'`);
      	});
  
      	$$self.$set = $$props => {
      		if ('name' in $$props) $$invalidate('name', name = $$props.name);
      	};
  
      	return { name };
      }
  
      class App extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance, create_fragment, safe_not_equal, ["name"]);
  
      		const { ctx } = this.$$;
      		const props = options.props || {};
      		if (ctx.name === undefined && !('name' in props)) {
      			console.warn("<App> was created without expected prop '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
  