text: 
  (function(l, r) { if (l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (window.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(window.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');
      }
  
      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 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 === '' ? undefined : +value;
      }
      function children(element) {
          return Array.from(element.childNodes);
      }
      function set_input_value(input, value) {
          if (value != null || input.value) {
              input.value = value;
          }
      }
      function custom_event(type, detail) {
          const e = document.createEvent('CustomEvent');
          e.initCustomEvent(type, false, false, detail);
          return e;
      }
  
      let current_component;
      function set_current_component(component) {
          current_component = component;
      }
      // TODO figure out if we still want to support
      // shorthand events, or if we want to implement
      // a real bubbling mechanism
      function bubble(component, event) {
          const callbacks = component.$$.callbacks[event.type];
          if (callbacks) {
              callbacks.slice().forEach(fn => fn(event));
          }
      }
  
      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 add_flush_callback(fn) {
          flush_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.$$);
              }
              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 bind(component, name, callback) {
          const index = component.$$.props[name];
          if (index !== undefined) {
              component.$$.bound[index] = callback;
              callback(component.$$.ctx[index]);
          }
      }
      function create_component(block) {
          block && block.c();
      }
      function mount_component(component, target, anchor) {
          const { fragment, on_mount, on_destroy, after_update } = component.$$;
          fragment && fragment.m(target, anchor);
          // onMount happens before the initial afterUpdate
          add_render_callback(() => {
              const new_on_destroy = on_mount.map(run).filter(is_function);
              if (on_destroy) {
                  on_destroy.push(...new_on_destroy);
              }
              else {
                  // Edge case - component was destroyed immediately,
                  // most likely as a result of a binding initialising
                  run_all(new_on_destroy);
              }
              component.$$.on_mount = [];
          });
          after_update.forEach(add_render_callback);
      }
      function destroy_component(component, detaching) {
          const $$ = component.$$;
          if ($$.fragment !== null) {
              run_all($$.on_destroy);
              $$.fragment && $$.fragment.d(detaching);
              // TODO null out other refs, including component.$$ (but need to
              // preserve final state?)
              $$.on_destroy = $$.fragment = null;
              $$.ctx = [];
          }
      }
      function make_dirty(component, i) {
          if (component.$$.dirty[0] === -1) {
              dirty_components.push(component);
              schedule_update();
              component.$$.dirty.fill(0);
          }
          component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
      }
      function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
          const parent_component = current_component;
          set_current_component(component);
          const prop_values = options.props || {};
          const $$ = component.$$ = {
              fragment: null,
              ctx: null,
              // state
              props,
              update: noop,
              not_equal,
              bound: blank_object(),
              // lifecycle
              on_mount: [],
              on_destroy: [],
              before_update: [],
              after_update: [],
              context: new Map(parent_component ? parent_component.$$.context : []),
              // everything else
              callbacks: blank_object(),
              dirty
          };
          let ready = false;
          $$.ctx = instance
              ? instance(component, prop_values, (i, ret, ...rest) => {
                  const value = rest.length ? rest[0] : ret;
                  if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
                      if ($$.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);
              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
          }
      }
  
      function dispatch_dev(type, detail) {
          document.dispatchEvent(custom_event(type, Object.assign({ version: '3.20.1' }, detail)));
      }
      function append_dev(target, node) {
          dispatch_dev("SvelteDOMInsert", { target, node });
          append(target, node);
      }
      function insert_dev(target, node, anchor) {
          dispatch_dev("SvelteDOMInsert", { target, node, anchor });
          insert(target, node, anchor);
      }
      function detach_dev(node) {
          dispatch_dev("SvelteDOMRemove", { node });
          detach(node);
      }
      function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
          const modifiers = options === true ? ["capture"] : options ? Array.from(Object.keys(options)) : [];
          if (has_prevent_default)
              modifiers.push('preventDefault');
          if (has_stop_propagation)
              modifiers.push('stopPropagation');
          dispatch_dev("SvelteDOMAddEventListener", { node, event, handler, modifiers });
          const dispose = listen(node, event, handler, options);
          return () => {
              dispatch_dev("SvelteDOMRemoveEventListener", { node, event, handler, modifiers });
              dispose();
          };
      }
      function attr_dev(node, attribute, value) {
          attr(node, attribute, value);
          if (value == null)
              dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute });
          else
              dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value });
      }
      function set_data_dev(text, data) {
          data = '' + data;
          if (text.data === data)
              return;
          dispatch_dev("SvelteDOMSetData", { node: text, data });
          text.data = data;
      }
      function validate_slots(name, slot, keys) {
          for (const slot_key of Object.keys(slot)) {
              if (!~keys.indexOf(slot_key)) {
                  console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
              }
          }
      }
      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\InputRange.svelte generated by Svelte v3.20.1 */
  
      const file = "src\\InputRange.svelte";
  
      function create_fragment(ctx) {
      	let div;
      	let input;
      	let input_class_value;
      	let t0;
      	let output;
      	let t1;
      	let dispose;
  
      	const block = {
      		c: function create() {
      			div = element("div");
      			input = element("input");
      			t0 = space();
      			output = element("output");
      			t1 = text(/*value*/ ctx[0]);
      			attr_dev(input, "class", input_class_value = "input " + /*classes*/ ctx[3] + " svelte-1jegx0v");
      			attr_dev(input, "type", "range");
      			attr_dev(input, "min", /*min*/ ctx[1]);
      			attr_dev(input, "max", /*max*/ ctx[2]);
      			add_location(input, file, 76, 2, 1711);
      			attr_dev(output, "style", /*computedStyle*/ ctx[4]);
      			attr_dev(output, "class", "svelte-1jegx0v");
      			add_location(output, file, 77, 2, 1794);
      			attr_dev(div, "class", "range-control svelte-1jegx0v");
      			add_location(div, file, 75, 0, 1680);
      		},
      		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, remount) {
      			insert_dev(target, div, anchor);
      			append_dev(div, input);
      			set_input_value(input, /*value*/ ctx[0]);
      			append_dev(div, t0);
      			append_dev(div, output);
      			append_dev(output, t1);
      			if (remount) run_all(dispose);
  
      			dispose = [
      				listen_dev(input, "change", /*input_change_input_handler*/ ctx[6]),
      				listen_dev(input, "input", /*input_change_input_handler*/ ctx[6]),
      				listen_dev(input, "change", /*change_handler*/ ctx[5], false, false, false)
      			];
      		},
      		p: function update(ctx, [dirty]) {
      			if (dirty & /*classes*/ 8 && input_class_value !== (input_class_value = "input " + /*classes*/ ctx[3] + " svelte-1jegx0v")) {
      				attr_dev(input, "class", input_class_value);
      			}
  
      			if (dirty & /*min*/ 2) {
      				attr_dev(input, "min", /*min*/ ctx[1]);
      			}
  
      			if (dirty & /*max*/ 4) {
      				attr_dev(input, "max", /*max*/ ctx[2]);
      			}
  
      			if (dirty & /*value*/ 1) {
      				set_input_value(input, /*value*/ ctx[0]);
      			}
  
      			if (dirty & /*value*/ 1) set_data_dev(t1, /*value*/ ctx[0]);
  
      			if (dirty & /*computedStyle*/ 16) {
      				attr_dev(output, "style", /*computedStyle*/ ctx[4]);
      			}
      		},
      		i: noop,
      		o: noop,
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(div);
      			run_all(dispose);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_fragment.name,
      		type: "component",
      		source: "",
      		ctx
      	});
  
      	return block;
      }
  
      function instance($$self, $$props, $$invalidate) {
      	let { min = 0 } = $$props;
      	let { max = 100 } = $$props;
      	let { value = 50 } = $$props;
      	let { classes = "" } = $$props;
      	let computedStyle = "";
      	const writable_props = ["min", "max", "value", "classes"];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(`<InputRange> was created with unknown prop '${key}'`);
      	});
  
      	let { $$slots = {}, $$scope } = $$props;
      	validate_slots("InputRange", $$slots, []);
  
      	function change_handler(event) {
      		bubble($$self, event);
      	}
  
      	function input_change_input_handler() {
      		value = to_number(this.value);
      		$$invalidate(0, value);
      	}
  
      	$$self.$set = $$props => {
      		if ("min" in $$props) $$invalidate(1, min = $$props.min);
      		if ("max" in $$props) $$invalidate(2, max = $$props.max);
      		if ("value" in $$props) $$invalidate(0, value = $$props.value);
      		if ("classes" in $$props) $$invalidate(3, classes = $$props.classes);
      	};
  
      	$$self.$capture_state = () => ({ min, max, value, classes, computedStyle });
  
      	$$self.$inject_state = $$props => {
      		if ("min" in $$props) $$invalidate(1, min = $$props.min);
      		if ("max" in $$props) $$invalidate(2, max = $$props.max);
      		if ("value" in $$props) $$invalidate(0, value = $$props.value);
      		if ("classes" in $$props) $$invalidate(3, classes = $$props.classes);
      		if ("computedStyle" in $$props) $$invalidate(4, computedStyle = $$props.computedStyle);
      	};
  
      	if ($$props && "$$inject" in $$props) {
      		$$self.$inject_state($$props.$$inject);
      	}
  
      	$$self.$$.update = () => {
      		if ($$self.$$.dirty & /*max, min, value*/ 7) {
      			 {
      				let range = max - min;
      				let position = (value - min) / range * 100;
      				let positionOffset = Math.round(position * 0.4);
      				$$invalidate(4, computedStyle = `left:calc(${position}% - ${positionOffset}px`);
      			}
      		}
      	};
  
      	return [
      		value,
      		min,
      		max,
      		classes,
      		computedStyle,
      		change_handler,
      		input_change_input_handler
      	];
      }
  
      class InputRange extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance, create_fragment, safe_not_equal, { min: 1, max: 2, value: 0, classes: 3 });
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "InputRange",
      			options,
      			id: create_fragment.name
      		});
      	}
  
      	get min() {
      		throw new Error("<InputRange>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set min(value) {
      		throw new Error("<InputRange>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	get max() {
      		throw new Error("<InputRange>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set max(value) {
      		throw new Error("<InputRange>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	get value() {
      		throw new Error("<InputRange>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set value(value) {
      		throw new Error("<InputRange>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	get classes() {
      		throw new Error("<InputRange>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
  
      	set classes(value) {
      		throw new Error("<InputRange>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
      	}
      }
  
      /* dev\App.svelte generated by Svelte v3.20.1 */
      const file$1 = "dev\\App.svelte";
  
      function create_fragment$1(ctx) {
      	let div2;
      	let div0;
      	let updating_value;
      	let t0;
      	let div1;
      	let h1;
      	let t1;
      	let current;
  
      	function inputrange_value_binding(value) {
      		/*inputrange_value_binding*/ ctx[1].call(null, value);
      	}
  
      	let inputrange_props = {};
  
      	if (/*binded_value*/ ctx[0] !== void 0) {
      		inputrange_props.value = /*binded_value*/ ctx[0];
      	}
  
      	const inputrange = new InputRange({ props: inputrange_props, $$inline: true });
      	binding_callbacks.push(() => bind(inputrange, "value", inputrange_value_binding));
  
      	const block = {
      		c: function create() {
      			div2 = element("div");
      			div0 = element("div");
      			create_component(inputrange.$$.fragment);
      			t0 = space();
      			div1 = element("div");
      			h1 = element("h1");
      			t1 = text(/*binded_value*/ ctx[0]);
      			attr_dev(div0, "class", "column svelte-1molb72");
      			add_location(div0, file$1, 32, 1, 445);
      			attr_dev(h1, "class", "is-pmless svelte-1molb72");
      			add_location(h1, file$1, 36, 3, 547);
      			attr_dev(div1, "class", "column svelte-1molb72");
      			add_location(div1, file$1, 35, 1, 522);
      			attr_dev(div2, "class", "container svelte-1molb72");
      			add_location(div2, file$1, 31, 0, 419);
      		},
      		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, div2, anchor);
      			append_dev(div2, div0);
      			mount_component(inputrange, div0, null);
      			append_dev(div2, t0);
      			append_dev(div2, div1);
      			append_dev(div1, h1);
      			append_dev(h1, t1);
      			current = true;
      		},
      		p: function update(ctx, [dirty]) {
      			const inputrange_changes = {};
  
      			if (!updating_value && dirty & /*binded_value*/ 1) {
      				updating_value = true;
      				inputrange_changes.value = /*binded_value*/ ctx[0];
      				add_flush_callback(() => updating_value = false);
      			}
  
      			inputrange.$set(inputrange_changes);
      			if (!current || dirty & /*binded_value*/ 1) set_data_dev(t1, /*binded_value*/ ctx[0]);
      		},
      		i: function intro(local) {
      			if (current) return;
      			transition_in(inputrange.$$.fragment, local);
      			current = true;
      		},
      		o: function outro(local) {
      			transition_out(inputrange.$$.fragment, local);
      			current = false;
      		},
      		d: function destroy(detaching) {
      			if (detaching) detach_dev(div2);
      			destroy_component(inputrange);
      		}
      	};
  
      	dispatch_dev("SvelteRegisterBlock", {
      		block,
      		id: create_fragment$1.name,
      		type: "component",
      		source: "",
      		ctx
      	});
  
      	return block;
      }
  
      function instance$1($$self, $$props, $$invalidate) {
      	let binded_value = 0;
      	const writable_props = [];
  
      	Object.keys($$props).forEach(key => {
      		if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(`<App> was created with unknown prop '${key}'`);
      	});
  
      	let { $$slots = {}, $$scope } = $$props;
      	validate_slots("App", $$slots, []);
  
      	function inputrange_value_binding(value) {
      		binded_value = value;
      		$$invalidate(0, binded_value);
      	}
  
      	$$self.$capture_state = () => ({ InputRange, binded_value });
  
      	$$self.$inject_state = $$props => {
      		if ("binded_value" in $$props) $$invalidate(0, binded_value = $$props.binded_value);
      	};
  
      	if ($$props && "$$inject" in $$props) {
      		$$self.$inject_state($$props.$$inject);
      	}
  
      	return [binded_value, inputrange_value_binding];
      }
  
      class App extends SvelteComponentDev {
      	constructor(options) {
      		super(options);
      		init(this, options, instance$1, create_fragment$1, safe_not_equal, {});
  
      		dispatch_dev("SvelteRegisterComponent", {
      			component: this,
      			tagName: "App",
      			options,
      			id: create_fragment$1.name
      		});
      	}
      }
  
      const app = new App({
      	target: document.body,
      });
  
      return app;
  
  }());
  //# sourceMappingURL=bundle.js.map
  