text: 
  (function(l, r) { if (!l || l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (self.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(self.document);
  var app = (function () {
      'use strict';
  
      function noop() { }
      function assign(tar, src) {
          // @ts-ignore
          for (const k in src)
              tar[k] = src[k];
          return tar;
      }
      function add_location(element, file, line, column, char) {
          element.__svelte_meta = {
              loc: { file, line, column, char }
          };
      }
      function run(fn) {
          return fn();
      }
      function blank_object() {
          return Object.create(null);
      }
      function run_all(fns) {
          fns.forEach(run);
      }
      function is_function(thing) {
          return typeof thing === 'function';
      }
      function safe_not_equal(a, b) {
          return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
      }
      function is_empty(obj) {
          return Object.keys(obj).length === 0;
      }
      function create_slot(definition, ctx, $$scope, fn) {
          if (definition) {
              const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
              return definition[0](slot_ctx);
          }
      }
      function get_slot_context(definition, ctx, $$scope, fn) {
          return definition[1] && fn
              ? assign($$scope.ctx.slice(), definition[1](fn(ctx)))
              : $$scope.ctx;
      }
      function get_slot_changes(definition, $$scope, dirty, fn) {
          if (definition[2] && fn) {
              const lets = definition[2](fn(dirty));
              if ($$scope.dirty === undefined) {
                  return lets;
              }
              if (typeof lets === 'object') {
                  const merged = [];
                  const len = Math.max($$scope.dirty.length, lets.length);
                  for (let i = 0; i < len; i += 1) {
                      merged[i] = $$scope.dirty[i] | lets[i];
                  }
                  return merged;
              }
              return $$scope.dirty | lets;
          }
          return $$scope.dirty;
      }
      function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
          if (slot_changes) {
              const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
              slot.p(slot_context, slot_changes);
          }
      }
      function get_all_dirty_from_scope($$scope) {
          if ($$scope.ctx.length > 32) {
              const dirty = [];
              const length = $$scope.ctx.length / 32;
              for (let i = 0; i < length; i++) {
                  dirty[i] = -1;
              }
              return dirty;
          }
          return -1;
      }
      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 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 children(element) {
          return Array.from(element.childNodes);
      }
      function set_input_value(input, value) {
          input.value = value == null ? '' : value;
      }
      function custom_event(type, detail, bubbles = false) {
          const e = document.createEvent('CustomEvent');
          e.initCustomEvent(type, bubbles, false, detail);
          return e;
      }
  
      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);
      }
      let flushing = false;
      const seen_callbacks = new Set();
      function flush() {
          if (flushing)
              return;
          flushing = true;
          do {
              // first, call beforeUpdate functions
              // and update components
              for (let i = 0; i < dirty_components.length; i += 1) {
                  const component = dirty_components[i];
                  set_current_component(component);
                  update(component.$$);
              }
              set_current_component(null);
              dirty_components.length = 0;
              while (binding_callbacks.length)
                  binding_callbacks.pop()();
              // then, once components are updated, call
              // afterUpdate functions. This may cause
              // subsequent updates...
              for (let i = 0; i < render_callbacks.length; i += 1) {
                  const callback = render_callbacks[i];
                  if (!seen_callbacks.has(callback)) {
                      // ...so guard against infinite loops
                      seen_callbacks.add(callback);
                      callback();
                  }
              }
              render_callbacks.length = 0;
          } while (dirty_components.length);
          while (flush_callbacks.length) {
              flush_callbacks.pop()();
          }
          update_scheduled = false;
          flushing = false;
          seen_callbacks.clear();
      }
      function update($$) {
          if ($$.fragment !== null) {
              $$.update();
              run_all($$.before_update);
              const dirty = $$.dirty;
              $$.dirty = [-1];
              $$.fragment && $$.fragment.p($$.ctx, dirty);
              $$.after_update.forEach(add_render_callback);
          }
      }
      const outroing = new Set();
      let outros;
      function transition_in(block, local) {
          if (block && block.i) {
              outroing.delete(block);
              block.i(local);
          }
      }
      function transition_out(block, local, detach, callback) {
          if (block && block.o) {
              if (outroing.has(block))
                  return;
              outroing.add(block);
              outros.c.push(() => {
                  outroing.delete(block);
                  if (callback) {
                      if (detach)
                          block.d(1);
                      callback();
                  }
              });
              block.o(local);
          }
      }
  
      function destroy_block(block, lookup) {
          block.d(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();
          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) {
                  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]);
          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, on_mount, on_destroy, after_update } = component.$$;
          fragment && fragment.m(target, anchor);
          if (!customElement) {
              // onMount happens before the initial afterUpdate
              add_render_callback(() => {
                  const new_on_destroy = on_mount.map(run).filter(is_function);
                  if (on_destroy) {
                      on_destroy.push(...new_on_destroy);
                  }
                  else {
                      // Edge case - component was destroyed immediately,
                      // most likely as a result of a binding initialising
                      run_all(new_on_destroy);
                  }
                  component.$$.on_mount = [];
              });
          }
          after_update.forEach(add_render_callback);
      }
      function destroy_component(component, detaching) {
          const $$ = component.$$;
          if ($$.fragment !== null) {
              run_all($$.on_destroy);
              $$.fragment && $$.fragment.d(detaching);
              // TODO null out other refs, including component.$$ (but need to
              // preserve final state?)
              $$.on_destroy = $$.fragment = null;
              $$.ctx = [];
          }
      }
      function make_dirty(component, i) {
          if (component.$$.dirty[0] === -1) {
              dirty_components.push(component);
              schedule_update();
              component.$$.dirty.fill(0);
          }
          component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
      }
      function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
          const parent_component = current_component;
          set_current_component(component);
          const $$ = component.$$ = {
              fragment: null,
              ctx: null,
              // state
              props,
              update: noop,
              not_equal,
              bound: blank_object(),
              // lifecycle
              on_mount: [],
              on_destroy: [],
              on_disconnect: [],
              before_update: [],
              after_update: [],
              context: new Map(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) {
              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.44.2' }, detail), 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) {
          const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
          if (has_prevent_default)
              modifiers.push('preventDefault');
          if (has_stop_propagation)
              modifiers.push('stopPropagation');
          dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
          const dispose = listen(node, event, handler, options);
          return () => {
              dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
              dispose();
          };
      }
      function attr_dev(node, attribute, value) {
          attr(node, attribute, value);
          if (value == null)
              dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
          else
              dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
      }
      function set_data_dev(text, data) {
          data = '' + data;
          if (text.wholeText === data)
              return;
          dispatch_dev('SvelteDOMSetData', { node: text, data });
          text.data = data;
      }
      function validate_each_argument(arg) {
          if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
              let msg = '{#each} only iterates over array-like objects.';
              if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
                  msg += ' You can use a spread to convert this iterable into an array.';
              }
              throw new Error(msg);
          }
      }
      function validate_slots(name, slot, keys) {
          for (const slot_key of Object.keys(slot)) {
              if (!~keys.indexOf(slot_key)) {
                  console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
              }
          }
      }
      /**
       * 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/components/NewItem.svelte generated by Svelte v3.44.2 */
  
      const file$3 = "src/components/NewItem.svelte";
  
      function create_fragment$3(ctx) {
      	let form;
      	let div0;
      	let label0;
      	let t1;
      	let input0;
      	let t2;
      	let div1;
      	let label1;
      	let t4;
      	let input1;
      	let t5;
      	let button;
      	let mounted;
      	let dispose;
  
      	const block = {
      		c: function create() {
      			form = element("form");
      			div0 = element("div");
      			label0 = element("label");
      			label0.textContent = "Title";
      			t1 = space();
      			input0 = element("input");
      			t2 = space();
      			div1 = element("div");
      			label1 = element("label");
      			label1.textContent = "Contents";
      			t4 = space();
      			input1 = element("input");
      			t5 = space();
      			button = element("button");
      			button.textContent = "Add Item";
      			attr_dev(label0, "for", "title");
      			attr_dev(label0, "class", "svelte-9o73gs");
      			add_location(label0, file$3, 12, 4, 254);
      			attr_dev(input0, "type", "text");
      			attr_dev(input0, "name", "title");
      			attr_dev(input0, "class", "svelte-9o73gs");
      			add_location(input0, file$3, 13, 4, 291);
      			attr_dev(div0, "class", "svelte-9o73gs");
      			add_location(div0, file$3, 11, 2, 244);
      			attr_dev(label1, "for", "contents");
      			attr_dev(label1, "class", "svelte-9o73gs");
      			add_location(label1, file$3, 16, 4, 366);
      			attr_dev(input1, "type", "text");
      			attr_dev(input1, "name", "contents");
      			attr_dev(input1, "class", "svelte-9o73gs");
      			add_location(input1, file$3, 17, 4, 409);
      			attr_dev(div1, "class", "svelte-9o73gs");
      			add_location(div1, file$3, 15, 2, 356);
      			attr_dev(button, "type", "submit");
      			add_location(button, file$3, 19, 2, 480);
      			attr_dev(form, "class", "form svelte-9o73gs");
      			add_location(form, file$3, 10, 0, 182);
      		},
      		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, form, anchor);
      			append_dev(form, div0);
      			append_dev(div0, label0);
      			append_dev(div0, t1);
      			append_dev(div0, input0);
      			set_input_value(input0, /*title*/ ctx[0]);
      			append_dev(form, t2);
      			append_dev(form, div1);
      			append_dev(div1, label1);
      			append_dev(div1, t4);
      			append_dev(div1, input1);
      			set_input_value(input1, /*contents*/ ctx[1]);
      			append_dev(form, t5);
      			append_dev(form, button);
  
      			if (!mounted) {
      				dispose = [
      					listen_dev(input0, "input", /*input0_input_handler*/ ctx[4]),
      					listen_dev(input1, "input", /*input1_input_handler*/ ctx[5]),
      					listen_dev(form, "submit", prevent_default(/*handleSubmit*/ ctx[2]), false, true, false)
      				];
  
      				mounted = true;
      			}
      		},
      		p: function update(ctx, [dirty]) {
      			if (dirty & /*title*/ 1 && input0.value !== /*title*/ ctx[0]) {
      				set_input_value(input0, /*title*/ ctx[0]);
      			}
  
      			if (dirty & /*contents*/ 2 && input1.value !== /*contents*/ ctx[1]) {
      				set_input_value(input1, /*contents*/ ctx[1]);
      			}
      		},
      		i: noop,
      		o: noop,
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(form);
      			mounted = false;
      			run_all(dispose);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_fragment$3.name,
      		type: "component",
      		source: "",
      		ctx
      	});
  
      	return block;
      }
  
      function instance$3($$self, $$props, $$invalidate) {
      	let { $$slots: slots = {}, $$scope } = $$props;
      	validate_slots('NewItem', slots, []);
      	let { addNewItem } = $$props;
      	let title;
      	let contents;
  
      	const handleSubmit = event => {
      		addNewItem(title, contents);
      		$$invalidate(0, title = "");
      		$$invalidate(1, contents = "");
      	};
  
      	const writable_props = ['addNewItem'];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<NewItem> was created with unknown prop '${key}'`);
      	});
  
      	function input0_input_handler() {
      		title = this.value;
      		$$invalidate(0, title);
      	}
  
      	function input1_input_handler() {
      		contents = this.value;
      		$$invalidate(1, contents);
      	}
  
      	$$self.$$set = $$props => {
      		if ('addNewItem' in $$props) $$invalidate(3, addNewItem = $$props.addNewItem);
      	};
  
      	$$self.$capture_state = () => ({
      		addNewItem,
      		title,
      		contents,
      		handleSubmit
      	});
  
      	$$self.$inject_state = $$props => {
      		if ('addNewItem' in $$props) $$invalidate(3, addNewItem = $$props.addNewItem);
      		if ('title' in $$props) $$invalidate(0, title = $$props.title);
      		if ('contents' in $$props) $$invalidate(1, contents = $$props.contents);
      	};
  
      	if ($$props && "$$inject" in $$props) {
      		$$self.$inject_state($$props.$$inject);
      	}
  
      	return [
      		title,
      		contents,
      		handleSubmit,
      		addNewItem,
      		input0_input_handler,
      		input1_input_handler
      	];
      }
  
      class NewItem extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance$3, create_fragment$3, safe_not_equal, { addNewItem: 3 });
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "NewItem",
      			options,
      			id: create_fragment$3.name
      		});
  
      		const { ctx } = this.$$;
      		const props = options.props || {};
  
      		if (/*addNewItem*/ ctx[3] === undefined && !('addNewItem' in props)) {
      			console.warn("<NewItem> was created without expected prop 'addNewItem'");
      		}
      	}
  
      	get addNewItem() {
      		throw new Error("<NewItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set addNewItem(value) {
      		throw new Error("<NewItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
      }
  
      /* src/components/UI/Card.svelte generated by Svelte v3.44.2 */
  
      const file$2 = "src/components/UI/Card.svelte";
  
      function create_fragment$2(ctx) {
      	let div;
      	let current;
      	const default_slot_template = /*#slots*/ ctx[1].default;
      	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[0], null);
  
      	const block = {
      		c: function create() {
      			div = element("div");
      			if (default_slot) default_slot.c();
      			attr_dev(div, "class", "card svelte-10dm889");
      			add_location(div, file$2, 0, 0, 0);
      		},
      		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);
  
      			if (default_slot) {
      				default_slot.m(div, null);
      			}
  
      			current = true;
      		},
      		p: function update(ctx, [dirty]) {
      			if (default_slot) {
      				if (default_slot.p && (!current || dirty & /*$$scope*/ 1)) {
      					update_slot_base(
      						default_slot,
      						default_slot_template,
      						ctx,
      						/*$$scope*/ ctx[0],
      						!current
      						? get_all_dirty_from_scope(/*$$scope*/ ctx[0])
      						: get_slot_changes(default_slot_template, /*$$scope*/ ctx[0], dirty, null),
      						null
      					);
      				}
      			}
      		},
      		i: function intro(local) {
      			if (current) return;
      			transition_in(default_slot, local);
      			current = true;
      		},
      		o: function outro(local) {
      			transition_out(default_slot, local);
      			current = false;
      		},
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(div);
      			if (default_slot) default_slot.d(detaching);
      		}
      	};
  
      	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('Card', slots, ['default']);
      	const writable_props = [];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Card> was created with unknown prop '${key}'`);
      	});
  
      	$$self.$$set = $$props => {
      		if ('$$scope' in $$props) $$invalidate(0, $$scope = $$props.$$scope);
      	};
  
      	return [$$scope, slots];
      }
  
      class Card extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance$2, create_fragment$2, safe_not_equal, {});
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "Card",
      			options,
      			id: create_fragment$2.name
      		});
      	}
      }
  
      /* src/components/ItemList.svelte generated by Svelte v3.44.2 */
  
      const file$1 = "src/components/ItemList.svelte";
  
      function get_each_context(ctx, list, i) {
      	const child_ctx = ctx.slice();
      	child_ctx[2] = list[i];
      	return child_ctx;
      }
  
      // (8:2) {:else}
      function create_else_block(ctx) {
      	let ul;
      	let each_blocks = [];
      	let each_1_lookup = new Map();
      	let each_value = /*list*/ ctx[0];
      	validate_each_argument(each_value);
      	const get_key = ctx => /*item*/ ctx[2].id;
      	validate_each_keys(ctx, each_value, get_each_context, get_key);
  
      	for (let i = 0; i < each_value.length; i += 1) {
      		let child_ctx = get_each_context(ctx, each_value, i);
      		let key = get_key(child_ctx);
      		each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx));
      	}
  
      	const block = {
      		c: function create() {
      			ul = element("ul");
  
      			for (let i = 0; i < each_blocks.length; i += 1) {
      				each_blocks[i].c();
      			}
  
      			attr_dev(ul, "class", "svelte-1uml6gv");
      			add_location(ul, file$1, 8, 2, 137);
      		},
      		m: function mount(target, anchor) {
      			insert_dev(target, ul, anchor);
  
      			for (let i = 0; i < each_blocks.length; i += 1) {
      				each_blocks[i].m(ul, null);
      			}
      		},
      		p: function update(ctx, dirty) {
      			if (dirty & /*list*/ 1) {
      				each_value = /*list*/ ctx[0];
      				validate_each_argument(each_value);
      				validate_each_keys(ctx, each_value, get_each_context, get_key);
      				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each_1_lookup, ul, destroy_block, create_each_block, null, get_each_context);
      			}
      		},
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(ul);
  
      			for (let i = 0; i < each_blocks.length; i += 1) {
      				each_blocks[i].d();
      			}
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_else_block.name,
      		type: "else",
      		source: "(8:2) {:else}",
      		ctx
      	});
  
      	return block;
      }
  
      // (6:2) {#if isEmpty}
      function create_if_block(ctx) {
      	let p;
  
      	const block = {
      		c: function create() {
      			p = element("p");
      			p.textContent = "No Items in List";
      			add_location(p, file$1, 6, 2, 101);
      		},
      		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.name,
      		type: "if",
      		source: "(6:2) {#if isEmpty}",
      		ctx
      	});
  
      	return block;
      }
  
      // (10:4) {#each list as item (item.id)}
      function create_each_block(key_1, ctx) {
      	let li;
      	let h3;
      	let t0_value = /*item*/ ctx[2].title + "";
      	let t0;
      	let t1;
      	let p;
      	let t2_value = /*item*/ ctx[2].contents + "";
      	let t2;
      	let t3;
  
      	const block = {
      		key: key_1,
      		first: null,
      		c: function create() {
      			li = element("li");
      			h3 = element("h3");
      			t0 = text(t0_value);
      			t1 = space();
      			p = element("p");
      			t2 = text(t2_value);
      			t3 = space();
      			attr_dev(h3, "class", "svelte-1uml6gv");
      			add_location(h3, file$1, 11, 6, 192);
      			add_location(p, file$1, 12, 6, 220);
      			attr_dev(li, "class", "svelte-1uml6gv");
      			add_location(li, file$1, 10, 4, 181);
      			this.first = li;
      		},
      		m: function mount(target, anchor) {
      			insert_dev(target, li, anchor);
      			append_dev(li, h3);
      			append_dev(h3, t0);
      			append_dev(li, t1);
      			append_dev(li, p);
      			append_dev(p, t2);
      			append_dev(li, t3);
      		},
      		p: function update(new_ctx, dirty) {
      			ctx = new_ctx;
      			if (dirty & /*list*/ 1 && t0_value !== (t0_value = /*item*/ ctx[2].title + "")) set_data_dev(t0, t0_value);
      			if (dirty & /*list*/ 1 && t2_value !== (t2_value = /*item*/ ctx[2].contents + "")) set_data_dev(t2, t2_value);
      		},
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(li);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_each_block.name,
      		type: "each",
      		source: "(10:4) {#each list as item (item.id)}",
      		ctx
      	});
  
      	return block;
      }
  
      function create_fragment$1(ctx) {
      	let section;
  
      	function select_block_type(ctx, dirty) {
      		if (/*isEmpty*/ ctx[1]) return create_if_block;
      		return create_else_block;
      	}
  
      	let current_block_type = select_block_type(ctx);
      	let if_block = current_block_type(ctx);
  
      	const block = {
      		c: function create() {
      			section = element("section");
      			if_block.c();
      			add_location(section, file$1, 4, 0, 73);
      		},
      		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, section, anchor);
      			if_block.m(section, null);
      		},
      		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(section, null);
      				}
      			}
      		},
      		i: noop,
      		o: noop,
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(section);
      			if_block.d();
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_fragment$1.name,
      		type: "component",
      		source: "",
      		ctx
      	});
  
      	return block;
      }
  
      function instance$1($$self, $$props, $$invalidate) {
      	let isEmpty;
      	let { $$slots: slots = {}, $$scope } = $$props;
      	validate_slots('ItemList', slots, []);
      	let { list } = $$props;
      	const writable_props = ['list'];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<ItemList> was created with unknown prop '${key}'`);
      	});
  
      	$$self.$$set = $$props => {
      		if ('list' in $$props) $$invalidate(0, list = $$props.list);
      	};
  
      	$$self.$capture_state = () => ({ list, isEmpty });
  
      	$$self.$inject_state = $$props => {
      		if ('list' in $$props) $$invalidate(0, list = $$props.list);
      		if ('isEmpty' in $$props) $$invalidate(1, isEmpty = $$props.isEmpty);
      	};
  
      	if ($$props && "$$inject" in $$props) {
      		$$self.$inject_state($$props.$$inject);
      	}
  
      	$$self.$$.update = () => {
      		if ($$self.$$.dirty & /*list*/ 1) {
      			$$invalidate(1, isEmpty = !list.length);
      		}
      	};
  
      	return [list, isEmpty];
      }
  
      class ItemList extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance$1, create_fragment$1, safe_not_equal, { list: 0 });
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "ItemList",
      			options,
      			id: create_fragment$1.name
      		});
  
      		const { ctx } = this.$$;
      		const props = options.props || {};
  
      		if (/*list*/ ctx[0] === undefined && !('list' in props)) {
      			console.warn("<ItemList> was created without expected prop 'list'");
      		}
      	}
  
      	get list() {
      		throw new Error("<ItemList>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set list(value) {
      		throw new Error("<ItemList>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
      }
  
      /* src/App.svelte generated by Svelte v3.44.2 */
      const file = "src/App.svelte";
  
      // (11:2) <Card>
      function create_default_slot_1(ctx) {
      	let newitem;
      	let current;
  
      	newitem = new NewItem({
      			props: { addNewItem: /*addNewItem*/ ctx[1] },
      			$$inline: true
      		});
  
      	const block = {
      		c: function create() {
      			create_component(newitem.$$.fragment);
      		},
      		m: function mount(target, anchor) {
      			mount_component(newitem, target, anchor);
      			current = true;
      		},
      		p: noop,
      		i: function intro(local) {
      			if (current) return;
      			transition_in(newitem.$$.fragment, local);
      			current = true;
      		},
      		o: function outro(local) {
      			transition_out(newitem.$$.fragment, local);
      			current = false;
      		},
      		d: function destroy(detaching) {
      			destroy_component(newitem, detaching);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_default_slot_1.name,
      		type: "slot",
      		source: "(11:2) <Card>",
      		ctx
      	});
  
      	return block;
      }
  
      // (14:1) <Card>
      function create_default_slot(ctx) {
      	let itemlist;
      	let current;
  
      	itemlist = new ItemList({
      			props: { list: /*list*/ ctx[0] },
      			$$inline: true
      		});
  
      	const block = {
      		c: function create() {
      			create_component(itemlist.$$.fragment);
      		},
      		m: function mount(target, anchor) {
      			mount_component(itemlist, target, anchor);
      			current = true;
      		},
      		p: function update(ctx, dirty) {
      			const itemlist_changes = {};
      			if (dirty & /*list*/ 1) itemlist_changes.list = /*list*/ ctx[0];
      			itemlist.$set(itemlist_changes);
      		},
      		i: function intro(local) {
      			if (current) return;
      			transition_in(itemlist.$$.fragment, local);
      			current = true;
      		},
      		o: function outro(local) {
      			transition_out(itemlist.$$.fragment, local);
      			current = false;
      		},
      		d: function destroy(detaching) {
      			destroy_component(itemlist, detaching);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_default_slot.name,
      		type: "slot",
      		source: "(14:1) <Card>",
      		ctx
      	});
  
      	return block;
      }
  
      function create_fragment(ctx) {
      	let main;
      	let card0;
      	let t;
      	let card1;
      	let current;
  
      	card0 = new Card({
      			props: {
      				$$slots: { default: [create_default_slot_1] },
      				$$scope: { ctx }
      			},
      			$$inline: true
      		});
  
      	card1 = new Card({
      			props: {
      				$$slots: { default: [create_default_slot] },
      				$$scope: { ctx }
      			},
      			$$inline: true
      		});
  
      	const block = {
      		c: function create() {
      			main = element("main");
      			create_component(card0.$$.fragment);
      			t = space();
      			create_component(card1.$$.fragment);
      			attr_dev(main, "class", "svelte-1gmv5eg");
      			add_location(main, file, 9, 0, 316);
      		},
      		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);
      			mount_component(card0, main, null);
      			append_dev(main, t);
      			mount_component(card1, main, null);
      			current = true;
      		},
      		p: function update(ctx, [dirty]) {
      			const card0_changes = {};
  
      			if (dirty & /*$$scope*/ 4) {
      				card0_changes.$$scope = { dirty, ctx };
      			}
  
      			card0.$set(card0_changes);
      			const card1_changes = {};
  
      			if (dirty & /*$$scope, list*/ 5) {
      				card1_changes.$$scope = { dirty, ctx };
      			}
  
      			card1.$set(card1_changes);
      		},
      		i: function intro(local) {
      			if (current) return;
      			transition_in(card0.$$.fragment, local);
      			transition_in(card1.$$.fragment, local);
      			current = true;
      		},
      		o: function outro(local) {
      			transition_out(card0.$$.fragment, local);
      			transition_out(card1.$$.fragment, local);
      			current = false;
      		},
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(main);
      			destroy_component(card0);
      			destroy_component(card1);
      		}
      	};
  
      	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 list = [];
  
      	const addNewItem = (title, contents) => {
      		$$invalidate(0, list = [
      			...list,
      			{
      				id: Math.random().toString(12),
      				title,
      				contents
      			}
      		]);
      	};
  
      	const writable_props = [];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<App> was created with unknown prop '${key}'`);
      	});
  
      	$$self.$capture_state = () => ({
      		NewItem,
      		Card,
      		ItemList,
      		list,
      		addNewItem
      	});
  
      	$$self.$inject_state = $$props => {
      		if ('list' in $$props) $$invalidate(0, list = $$props.list);
      	};
  
      	if ($$props && "$$inject" in $$props) {
      		$$self.$inject_state($$props.$$inject);
      	}
  
      	return [list, addNewItem];
      }
  
      class App extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance, create_fragment, safe_not_equal, {});
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "App",
      			options,
      			id: create_fragment.name
      		});
      	}
      }
  
      const app = new App({
          target: document.body,
      });
  
      return app;
  
  })();
  //# sourceMappingURL=bundle.js.map
  