\n"
+ ],
+ "names": [],
+ "mappings": "AAiBI,UAAU,eAAC,CAAC,AACR,UAAU,CAAE,IAAI,cAAc,CAAC,CAC/B,aAAa,CAAE,IAAI,CACnB,OAAO,CAAE,IAAI,CAAC,GAAG,AACrB,CAAC;ACED,WAAW,cAAC,CAAC,AACT,OAAO,CAAE,IAAI,CACb,OAAO,CAAE,MAAM,CACf,aAAa,CAAE,GAAG,CAAC,IAAI,CAAC,MAAM,AAClC,CAAC,AAED,yBAAW,aAAa,GAAG,CAAC,AAAC,CAAC,AAC1B,gBAAgB,CAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,AACzC,CAAC,AAED,YAAY,cAAC,CAAC,AAEV,IAAI,CAAE,CAAC,AACX,CAAC,AAED,cAAc,cAAC,CAAC,AAEZ,IAAI,CAAE,CAAC,AACX,CAAC,AAED,QAAQ,cAAC,CAAC,AACN,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC,AAED,KAAK,cAAC,CAAC,AACH,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC,AAED,KAAK,cAAC,CAAC,AACH,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC,AAED,KAAK,cAAC,CAAC,AACH,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC,AAED,IAAI,cAAC,CAAC,AACF,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC,AAED,UAAU,cAAC,CAAC,AACR,UAAU,CAAE,OAAO,CACnB,KAAK,CAAE,IAAI,AACf,CAAC"
+}
\ No newline at end of file
diff --git a/dist/build/bundle.js b/dist/build/bundle.js
new file mode 100644
index 0000000..b0a9e1f
--- /dev/null
+++ b/dist/build/bundle.js
@@ -0,0 +1,3685 @@
+
+(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.head.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 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 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) {
+ if (value != null || input.value) {
+ input.value = value;
+ }
+ }
+ function select_option(select, value) {
+ for (let i = 0; i < select.options.length; i += 1) {
+ const option = select.options[i];
+ if (option.__value === value) {
+ option.selected = true;
+ return;
+ }
+ }
+ }
+ function select_value(select) {
+ const selected_option = select.querySelector(':checked') || select.options[0];
+ return selected_option && selected_option.__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;
+ }
+ function get_current_component() {
+ if (!current_component)
+ throw new Error(`Function called outside component initialization`);
+ return current_component;
+ }
+ function onMount(fn) {
+ get_current_component().$$.on_mount.push(fn);
+ }
+
+ 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.$$);
+ }
+ 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 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);
+ }
+ }
+
+ const globals = (typeof window !== 'undefined' ? window : global);
+ 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 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}".`);
+ }
+ }
+ }
+ 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() { }
+ }
+
+ const subscriber_queue = [];
+ /**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+ function writable(value, start = noop) {
+ let stop;
+ const subscribers = [];
+ 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 (let i = 0; i < subscribers.length; i += 1) {
+ const s = subscribers[i];
+ s[1]();
+ subscriber_queue.push(s, 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.push(subscriber);
+ if (subscribers.length === 1) {
+ stop = start(set) || noop;
+ }
+ run(value);
+ return () => {
+ const index = subscribers.indexOf(subscriber);
+ if (index !== -1) {
+ subscribers.splice(index, 1);
+ }
+ if (subscribers.length === 0) {
+ stop();
+ stop = null;
+ }
+ };
+ }
+ return { set, update, subscribe };
+ }
+
+ var bind = function bind(fn, thisArg) {
+ return function wrap() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ return fn.apply(thisArg, args);
+ };
+ };
+
+ /*global toString:true*/
+
+ // utils is a library of generic helper functions non-specific to axios
+
+ var toString = Object.prototype.toString;
+
+ /**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+ function isArray(val) {
+ return toString.call(val) === '[object Array]';
+ }
+
+ /**
+ * Determine if a value is undefined
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if the value is undefined, otherwise false
+ */
+ function isUndefined(val) {
+ return typeof val === 'undefined';
+ }
+
+ /**
+ * Determine if a value is a Buffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+ function isBuffer(val) {
+ return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
+ && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
+ }
+
+ /**
+ * Determine if a value is an ArrayBuffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+ */
+ function isArrayBuffer(val) {
+ return toString.call(val) === '[object ArrayBuffer]';
+ }
+
+ /**
+ * Determine if a value is a FormData
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an FormData, otherwise false
+ */
+ function isFormData(val) {
+ return (typeof FormData !== 'undefined') && (val instanceof FormData);
+ }
+
+ /**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+ function isArrayBufferView(val) {
+ var result;
+ if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
+ result = ArrayBuffer.isView(val);
+ } else {
+ result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
+ }
+ return result;
+ }
+
+ /**
+ * Determine if a value is a String
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a String, otherwise false
+ */
+ function isString(val) {
+ return typeof val === 'string';
+ }
+
+ /**
+ * Determine if a value is a Number
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Number, otherwise false
+ */
+ function isNumber(val) {
+ return typeof val === 'number';
+ }
+
+ /**
+ * Determine if a value is an Object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+ function isObject(val) {
+ return val !== null && typeof val === 'object';
+ }
+
+ /**
+ * Determine if a value is a Date
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+ function isDate(val) {
+ return toString.call(val) === '[object Date]';
+ }
+
+ /**
+ * Determine if a value is a File
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a File, otherwise false
+ */
+ function isFile(val) {
+ return toString.call(val) === '[object File]';
+ }
+
+ /**
+ * Determine if a value is a Blob
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Blob, otherwise false
+ */
+ function isBlob(val) {
+ return toString.call(val) === '[object Blob]';
+ }
+
+ /**
+ * Determine if a value is a Function
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Function, otherwise false
+ */
+ function isFunction(val) {
+ return toString.call(val) === '[object Function]';
+ }
+
+ /**
+ * Determine if a value is a Stream
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Stream, otherwise false
+ */
+ function isStream(val) {
+ return isObject(val) && isFunction(val.pipe);
+ }
+
+ /**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+ function isURLSearchParams(val) {
+ return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
+ }
+
+ /**
+ * Trim excess whitespace off the beginning and end of a string
+ *
+ * @param {String} str The String to trim
+ * @returns {String} The String freed of excess whitespace
+ */
+ function trim(str) {
+ return str.replace(/^\s*/, '').replace(/\s*$/, '');
+ }
+
+ /**
+ * Determine if we're running in a standard browser environment
+ *
+ * This allows axios to run in a web worker, and react-native.
+ * Both environments support XMLHttpRequest, but not fully standard globals.
+ *
+ * web workers:
+ * typeof window -> undefined
+ * typeof document -> undefined
+ *
+ * react-native:
+ * navigator.product -> 'ReactNative'
+ * nativescript
+ * navigator.product -> 'NativeScript' or 'NS'
+ */
+ function isStandardBrowserEnv() {
+ if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
+ navigator.product === 'NativeScript' ||
+ navigator.product === 'NS')) {
+ return false;
+ }
+ return (
+ typeof window !== 'undefined' &&
+ typeof document !== 'undefined'
+ );
+ }
+
+ /**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ */
+ function forEach(obj, fn) {
+ // Don't bother if no value provided
+ if (obj === null || typeof obj === 'undefined') {
+ return;
+ }
+
+ // Force an array if not already something iterable
+ if (typeof obj !== 'object') {
+ /*eslint no-param-reassign:0*/
+ obj = [obj];
+ }
+
+ if (isArray(obj)) {
+ // Iterate over array values
+ for (var i = 0, l = obj.length; i < l; i++) {
+ fn.call(null, obj[i], i, obj);
+ }
+ } else {
+ // Iterate over object keys
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ fn.call(null, obj[key], key, obj);
+ }
+ }
+ }
+ }
+
+ /**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * var result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+ function merge(/* obj1, obj2, obj3, ... */) {
+ var result = {};
+ function assignValue(val, key) {
+ if (typeof result[key] === 'object' && typeof val === 'object') {
+ result[key] = merge(result[key], val);
+ } else {
+ result[key] = val;
+ }
+ }
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ forEach(arguments[i], assignValue);
+ }
+ return result;
+ }
+
+ /**
+ * Function equal to merge with the difference being that no reference
+ * to original objects is kept.
+ *
+ * @see merge
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+ function deepMerge(/* obj1, obj2, obj3, ... */) {
+ var result = {};
+ function assignValue(val, key) {
+ if (typeof result[key] === 'object' && typeof val === 'object') {
+ result[key] = deepMerge(result[key], val);
+ } else if (typeof val === 'object') {
+ result[key] = deepMerge({}, val);
+ } else {
+ result[key] = val;
+ }
+ }
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ forEach(arguments[i], assignValue);
+ }
+ return result;
+ }
+
+ /**
+ * Extends object a by mutably adding to it the properties of object b.
+ *
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to copy properties from
+ * @param {Object} thisArg The object to bind function to
+ * @return {Object} The resulting value of object a
+ */
+ function extend(a, b, thisArg) {
+ forEach(b, function assignValue(val, key) {
+ if (thisArg && typeof val === 'function') {
+ a[key] = bind(val, thisArg);
+ } else {
+ a[key] = val;
+ }
+ });
+ return a;
+ }
+
+ var utils = {
+ isArray: isArray,
+ isArrayBuffer: isArrayBuffer,
+ isBuffer: isBuffer,
+ isFormData: isFormData,
+ isArrayBufferView: isArrayBufferView,
+ isString: isString,
+ isNumber: isNumber,
+ isObject: isObject,
+ isUndefined: isUndefined,
+ isDate: isDate,
+ isFile: isFile,
+ isBlob: isBlob,
+ isFunction: isFunction,
+ isStream: isStream,
+ isURLSearchParams: isURLSearchParams,
+ isStandardBrowserEnv: isStandardBrowserEnv,
+ forEach: forEach,
+ merge: merge,
+ deepMerge: deepMerge,
+ extend: extend,
+ trim: trim
+ };
+
+ function encode(val) {
+ return encodeURIComponent(val).
+ replace(/%40/gi, '@').
+ replace(/%3A/gi, ':').
+ replace(/%24/g, '$').
+ replace(/%2C/gi, ',').
+ replace(/%20/g, '+').
+ replace(/%5B/gi, '[').
+ replace(/%5D/gi, ']');
+ }
+
+ /**
+ * Build a URL by appending params to the end
+ *
+ * @param {string} url The base of the url (e.g., http://www.google.com)
+ * @param {object} [params] The params to be appended
+ * @returns {string} The formatted url
+ */
+ var buildURL = function buildURL(url, params, paramsSerializer) {
+ /*eslint no-param-reassign:0*/
+ if (!params) {
+ return url;
+ }
+
+ var serializedParams;
+ if (paramsSerializer) {
+ serializedParams = paramsSerializer(params);
+ } else if (utils.isURLSearchParams(params)) {
+ serializedParams = params.toString();
+ } else {
+ var parts = [];
+
+ utils.forEach(params, function serialize(val, key) {
+ if (val === null || typeof val === 'undefined') {
+ return;
+ }
+
+ if (utils.isArray(val)) {
+ key = key + '[]';
+ } else {
+ val = [val];
+ }
+
+ utils.forEach(val, function parseValue(v) {
+ if (utils.isDate(v)) {
+ v = v.toISOString();
+ } else if (utils.isObject(v)) {
+ v = JSON.stringify(v);
+ }
+ parts.push(encode(key) + '=' + encode(v));
+ });
+ });
+
+ serializedParams = parts.join('&');
+ }
+
+ if (serializedParams) {
+ var hashmarkIndex = url.indexOf('#');
+ if (hashmarkIndex !== -1) {
+ url = url.slice(0, hashmarkIndex);
+ }
+
+ url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+ }
+
+ return url;
+ };
+
+ function InterceptorManager() {
+ this.handlers = [];
+ }
+
+ /**
+ * Add a new interceptor to the stack
+ *
+ * @param {Function} fulfilled The function to handle `then` for a `Promise`
+ * @param {Function} rejected The function to handle `reject` for a `Promise`
+ *
+ * @return {Number} An ID used to remove interceptor later
+ */
+ InterceptorManager.prototype.use = function use(fulfilled, rejected) {
+ this.handlers.push({
+ fulfilled: fulfilled,
+ rejected: rejected
+ });
+ return this.handlers.length - 1;
+ };
+
+ /**
+ * Remove an interceptor from the stack
+ *
+ * @param {Number} id The ID that was returned by `use`
+ */
+ InterceptorManager.prototype.eject = function eject(id) {
+ if (this.handlers[id]) {
+ this.handlers[id] = null;
+ }
+ };
+
+ /**
+ * Iterate over all the registered interceptors
+ *
+ * This method is particularly useful for skipping over any
+ * interceptors that may have become `null` calling `eject`.
+ *
+ * @param {Function} fn The function to call for each interceptor
+ */
+ InterceptorManager.prototype.forEach = function forEach(fn) {
+ utils.forEach(this.handlers, function forEachHandler(h) {
+ if (h !== null) {
+ fn(h);
+ }
+ });
+ };
+
+ var InterceptorManager_1 = InterceptorManager;
+
+ /**
+ * Transform the data for a request or a response
+ *
+ * @param {Object|String} data The data to be transformed
+ * @param {Array} headers The headers for the request or response
+ * @param {Array|Function} fns A single function or Array of functions
+ * @returns {*} The resulting transformed data
+ */
+ var transformData = function transformData(data, headers, fns) {
+ /*eslint no-param-reassign:0*/
+ utils.forEach(fns, function transform(fn) {
+ data = fn(data, headers);
+ });
+
+ return data;
+ };
+
+ var isCancel = function isCancel(value) {
+ return !!(value && value.__CANCEL__);
+ };
+
+ var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
+ utils.forEach(headers, function processHeader(value, name) {
+ if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+ headers[normalizedName] = value;
+ delete headers[name];
+ }
+ });
+ };
+
+ /**
+ * Update an Error with the specified config, error code, and response.
+ *
+ * @param {Error} error The error to update.
+ * @param {Object} config The config.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ * @returns {Error} The error.
+ */
+ var enhanceError = function enhanceError(error, config, code, request, response) {
+ error.config = config;
+ if (code) {
+ error.code = code;
+ }
+
+ error.request = request;
+ error.response = response;
+ error.isAxiosError = true;
+
+ error.toJSON = function() {
+ return {
+ // Standard
+ message: this.message,
+ name: this.name,
+ // Microsoft
+ description: this.description,
+ number: this.number,
+ // Mozilla
+ fileName: this.fileName,
+ lineNumber: this.lineNumber,
+ columnNumber: this.columnNumber,
+ stack: this.stack,
+ // Axios
+ config: this.config,
+ code: this.code
+ };
+ };
+ return error;
+ };
+
+ /**
+ * Create an Error with the specified message, config, error code, request and response.
+ *
+ * @param {string} message The error message.
+ * @param {Object} config The config.
+ * @param {string} [code] The error code (for example, 'ECONNABORTED').
+ * @param {Object} [request] The request.
+ * @param {Object} [response] The response.
+ * @returns {Error} The created error.
+ */
+ var createError = function createError(message, config, code, request, response) {
+ var error = new Error(message);
+ return enhanceError(error, config, code, request, response);
+ };
+
+ /**
+ * Resolve or reject a Promise based on response status.
+ *
+ * @param {Function} resolve A function that resolves the promise.
+ * @param {Function} reject A function that rejects the promise.
+ * @param {object} response The response.
+ */
+ var settle = function settle(resolve, reject, response) {
+ var validateStatus = response.config.validateStatus;
+ if (!validateStatus || validateStatus(response.status)) {
+ resolve(response);
+ } else {
+ reject(createError(
+ 'Request failed with status code ' + response.status,
+ response.config,
+ null,
+ response.request,
+ response
+ ));
+ }
+ };
+
+ /**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+ var isAbsoluteURL = function isAbsoluteURL(url) {
+ // A URL is considered absolute if it begins with "://" or "//" (protocol-relative URL).
+ // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+ // by any combination of letters, digits, plus, period, or hyphen.
+ return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+ };
+
+ /**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ * @returns {string} The combined URL
+ */
+ var combineURLs = function combineURLs(baseURL, relativeURL) {
+ return relativeURL
+ ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+ : baseURL;
+ };
+
+ /**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ * @returns {string} The combined full path
+ */
+ var buildFullPath = function buildFullPath(baseURL, requestedURL) {
+ if (baseURL && !isAbsoluteURL(requestedURL)) {
+ return combineURLs(baseURL, requestedURL);
+ }
+ return requestedURL;
+ };
+
+ // Headers whose duplicates are ignored by node
+ // c.f. https://nodejs.org/api/http.html#http_message_headers
+ var ignoreDuplicateOf = [
+ 'age', 'authorization', 'content-length', 'content-type', 'etag',
+ 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
+ 'last-modified', 'location', 'max-forwards', 'proxy-authorization',
+ 'referer', 'retry-after', 'user-agent'
+ ];
+
+ /**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} headers Headers needing to be parsed
+ * @returns {Object} Headers parsed into an object
+ */
+ var parseHeaders = function parseHeaders(headers) {
+ var parsed = {};
+ var key;
+ var val;
+ var i;
+
+ if (!headers) { return parsed; }
+
+ utils.forEach(headers.split('\n'), function parser(line) {
+ i = line.indexOf(':');
+ key = utils.trim(line.substr(0, i)).toLowerCase();
+ val = utils.trim(line.substr(i + 1));
+
+ if (key) {
+ if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+ return;
+ }
+ if (key === 'set-cookie') {
+ parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+ } else {
+ parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+ }
+ }
+ });
+
+ return parsed;
+ };
+
+ var isURLSameOrigin = (
+ utils.isStandardBrowserEnv() ?
+
+ // Standard browser envs have full support of the APIs needed to test
+ // whether the request URL is of the same origin as current location.
+ (function standardBrowserEnv() {
+ var msie = /(msie|trident)/i.test(navigator.userAgent);
+ var urlParsingNode = document.createElement('a');
+ var originURL;
+
+ /**
+ * Parse a URL to discover it's components
+ *
+ * @param {String} url The URL to be parsed
+ * @returns {Object}
+ */
+ function resolveURL(url) {
+ var href = url;
+
+ if (msie) {
+ // IE needs attribute set twice to normalize properties
+ urlParsingNode.setAttribute('href', href);
+ href = urlParsingNode.href;
+ }
+
+ urlParsingNode.setAttribute('href', href);
+
+ // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
+ return {
+ href: urlParsingNode.href,
+ protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
+ host: urlParsingNode.host,
+ search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
+ hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
+ hostname: urlParsingNode.hostname,
+ port: urlParsingNode.port,
+ pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+ urlParsingNode.pathname :
+ '/' + urlParsingNode.pathname
+ };
+ }
+
+ originURL = resolveURL(window.location.href);
+
+ /**
+ * Determine if a URL shares the same origin as the current location
+ *
+ * @param {String} requestURL The URL to test
+ * @returns {boolean} True if URL shares the same origin, otherwise false
+ */
+ return function isURLSameOrigin(requestURL) {
+ var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
+ return (parsed.protocol === originURL.protocol &&
+ parsed.host === originURL.host);
+ };
+ })() :
+
+ // Non standard browser envs (web workers, react-native) lack needed support.
+ (function nonStandardBrowserEnv() {
+ return function isURLSameOrigin() {
+ return true;
+ };
+ })()
+ );
+
+ var cookies = (
+ utils.isStandardBrowserEnv() ?
+
+ // Standard browser envs support document.cookie
+ (function standardBrowserEnv() {
+ return {
+ write: function write(name, value, expires, path, domain, secure) {
+ var cookie = [];
+ cookie.push(name + '=' + encodeURIComponent(value));
+
+ if (utils.isNumber(expires)) {
+ cookie.push('expires=' + new Date(expires).toGMTString());
+ }
+
+ if (utils.isString(path)) {
+ cookie.push('path=' + path);
+ }
+
+ if (utils.isString(domain)) {
+ cookie.push('domain=' + domain);
+ }
+
+ if (secure === true) {
+ cookie.push('secure');
+ }
+
+ document.cookie = cookie.join('; ');
+ },
+
+ read: function read(name) {
+ var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+ return (match ? decodeURIComponent(match[3]) : null);
+ },
+
+ remove: function remove(name) {
+ this.write(name, '', Date.now() - 86400000);
+ }
+ };
+ })() :
+
+ // Non standard browser env (web workers, react-native) lack needed support.
+ (function nonStandardBrowserEnv() {
+ return {
+ write: function write() {},
+ read: function read() { return null; },
+ remove: function remove() {}
+ };
+ })()
+ );
+
+ var xhr = function xhrAdapter(config) {
+ return new Promise(function dispatchXhrRequest(resolve, reject) {
+ var requestData = config.data;
+ var requestHeaders = config.headers;
+
+ if (utils.isFormData(requestData)) {
+ delete requestHeaders['Content-Type']; // Let the browser set it
+ }
+
+ var request = new XMLHttpRequest();
+
+ // HTTP basic authentication
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password || '';
+ requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+ }
+
+ var fullPath = buildFullPath(config.baseURL, config.url);
+ request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+
+ // Set the request timeout in MS
+ request.timeout = config.timeout;
+
+ // Listen for ready state
+ request.onreadystatechange = function handleLoad() {
+ if (!request || request.readyState !== 4) {
+ return;
+ }
+
+ // The request errored out and we didn't get a response, this will be
+ // handled by onerror instead
+ // With one exception: request that using file: protocol, most browsers
+ // will return status as 0 even though it's a successful request
+ if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
+ return;
+ }
+
+ // Prepare the response
+ var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+ var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+ var response = {
+ data: responseData,
+ status: request.status,
+ statusText: request.statusText,
+ headers: responseHeaders,
+ config: config,
+ request: request
+ };
+
+ settle(resolve, reject, response);
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle browser request cancellation (as opposed to a manual cancellation)
+ request.onabort = function handleAbort() {
+ if (!request) {
+ return;
+ }
+
+ reject(createError('Request aborted', config, 'ECONNABORTED', request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle low level network errors
+ request.onerror = function handleError() {
+ // Real errors are hidden from us by the browser
+ // onerror should only fire if it's a network error
+ reject(createError('Network Error', config, null, request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Handle timeout
+ request.ontimeout = function handleTimeout() {
+ var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
+ if (config.timeoutErrorMessage) {
+ timeoutErrorMessage = config.timeoutErrorMessage;
+ }
+ reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',
+ request));
+
+ // Clean up request
+ request = null;
+ };
+
+ // Add xsrf header
+ // This is only done if running in a standard browser environment.
+ // Specifically not if we're in a web worker, or react-native.
+ if (utils.isStandardBrowserEnv()) {
+ var cookies$1 = cookies;
+
+ // Add xsrf header
+ var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
+ cookies$1.read(config.xsrfCookieName) :
+ undefined;
+
+ if (xsrfValue) {
+ requestHeaders[config.xsrfHeaderName] = xsrfValue;
+ }
+ }
+
+ // Add headers to the request
+ if ('setRequestHeader' in request) {
+ utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+ if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
+ // Remove Content-Type if data is undefined
+ delete requestHeaders[key];
+ } else {
+ // Otherwise add header to the request
+ request.setRequestHeader(key, val);
+ }
+ });
+ }
+
+ // Add withCredentials to request if needed
+ if (!utils.isUndefined(config.withCredentials)) {
+ request.withCredentials = !!config.withCredentials;
+ }
+
+ // Add responseType to request if needed
+ if (config.responseType) {
+ try {
+ request.responseType = config.responseType;
+ } catch (e) {
+ // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
+ // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
+ if (config.responseType !== 'json') {
+ throw e;
+ }
+ }
+ }
+
+ // Handle progress if needed
+ if (typeof config.onDownloadProgress === 'function') {
+ request.addEventListener('progress', config.onDownloadProgress);
+ }
+
+ // Not all browsers support upload events
+ if (typeof config.onUploadProgress === 'function' && request.upload) {
+ request.upload.addEventListener('progress', config.onUploadProgress);
+ }
+
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (!request) {
+ return;
+ }
+
+ request.abort();
+ reject(cancel);
+ // Clean up request
+ request = null;
+ });
+ }
+
+ if (requestData === undefined) {
+ requestData = null;
+ }
+
+ // Send the request
+ request.send(requestData);
+ });
+ };
+
+ var DEFAULT_CONTENT_TYPE = {
+ 'Content-Type': 'application/x-www-form-urlencoded'
+ };
+
+ function setContentTypeIfUnset(headers, value) {
+ if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
+ headers['Content-Type'] = value;
+ }
+ }
+
+ function getDefaultAdapter() {
+ var adapter;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ // For browsers use XHR adapter
+ adapter = xhr;
+ } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+ // For node use HTTP adapter
+ adapter = xhr;
+ }
+ return adapter;
+ }
+
+ var defaults = {
+ adapter: getDefaultAdapter(),
+
+ transformRequest: [function transformRequest(data, headers) {
+ normalizeHeaderName(headers, 'Accept');
+ normalizeHeaderName(headers, 'Content-Type');
+ if (utils.isFormData(data) ||
+ utils.isArrayBuffer(data) ||
+ utils.isBuffer(data) ||
+ utils.isStream(data) ||
+ utils.isFile(data) ||
+ utils.isBlob(data)
+ ) {
+ return data;
+ }
+ if (utils.isArrayBufferView(data)) {
+ return data.buffer;
+ }
+ if (utils.isURLSearchParams(data)) {
+ setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
+ return data.toString();
+ }
+ if (utils.isObject(data)) {
+ setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
+ return JSON.stringify(data);
+ }
+ return data;
+ }],
+
+ transformResponse: [function transformResponse(data) {
+ /*eslint no-param-reassign:0*/
+ if (typeof data === 'string') {
+ try {
+ data = JSON.parse(data);
+ } catch (e) { /* Ignore */ }
+ }
+ return data;
+ }],
+
+ /**
+ * A timeout in milliseconds to abort a request. If set to 0 (default) a
+ * timeout is not created.
+ */
+ timeout: 0,
+
+ xsrfCookieName: 'XSRF-TOKEN',
+ xsrfHeaderName: 'X-XSRF-TOKEN',
+
+ maxContentLength: -1,
+
+ validateStatus: function validateStatus(status) {
+ return status >= 200 && status < 300;
+ }
+ };
+
+ defaults.headers = {
+ common: {
+ 'Accept': 'application/json, text/plain, */*'
+ }
+ };
+
+ utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+ defaults.headers[method] = {};
+ });
+
+ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+ });
+
+ var defaults_1 = defaults;
+
+ /**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+ function throwIfCancellationRequested(config) {
+ if (config.cancelToken) {
+ config.cancelToken.throwIfRequested();
+ }
+ }
+
+ /**
+ * Dispatch a request to the server using the configured adapter.
+ *
+ * @param {object} config The config that is to be used for the request
+ * @returns {Promise} The Promise to be fulfilled
+ */
+ var dispatchRequest = function dispatchRequest(config) {
+ throwIfCancellationRequested(config);
+
+ // Ensure headers exist
+ config.headers = config.headers || {};
+
+ // Transform request data
+ config.data = transformData(
+ config.data,
+ config.headers,
+ config.transformRequest
+ );
+
+ // Flatten headers
+ config.headers = utils.merge(
+ config.headers.common || {},
+ config.headers[config.method] || {},
+ config.headers
+ );
+
+ utils.forEach(
+ ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
+ function cleanHeaderConfig(method) {
+ delete config.headers[method];
+ }
+ );
+
+ var adapter = config.adapter || defaults_1.adapter;
+
+ return adapter(config).then(function onAdapterResolution(response) {
+ throwIfCancellationRequested(config);
+
+ // Transform response data
+ response.data = transformData(
+ response.data,
+ response.headers,
+ config.transformResponse
+ );
+
+ return response;
+ }, function onAdapterRejection(reason) {
+ if (!isCancel(reason)) {
+ throwIfCancellationRequested(config);
+
+ // Transform response data
+ if (reason && reason.response) {
+ reason.response.data = transformData(
+ reason.response.data,
+ reason.response.headers,
+ config.transformResponse
+ );
+ }
+ }
+
+ return Promise.reject(reason);
+ });
+ };
+
+ /**
+ * Config-specific merge-function which creates a new config-object
+ * by merging two configuration objects together.
+ *
+ * @param {Object} config1
+ * @param {Object} config2
+ * @returns {Object} New object resulting from merging config2 to config1
+ */
+ var mergeConfig = function mergeConfig(config1, config2) {
+ // eslint-disable-next-line no-param-reassign
+ config2 = config2 || {};
+ var config = {};
+
+ var valueFromConfig2Keys = ['url', 'method', 'params', 'data'];
+ var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];
+ var defaultToConfig2Keys = [
+ 'baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer',
+ 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
+ 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress',
+ 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent',
+ 'httpsAgent', 'cancelToken', 'socketPath'
+ ];
+
+ utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ }
+ });
+
+ utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {
+ if (utils.isObject(config2[prop])) {
+ config[prop] = utils.deepMerge(config1[prop], config2[prop]);
+ } else if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (utils.isObject(config1[prop])) {
+ config[prop] = utils.deepMerge(config1[prop]);
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
+
+ utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
+
+ var axiosKeys = valueFromConfig2Keys
+ .concat(mergeDeepPropertiesKeys)
+ .concat(defaultToConfig2Keys);
+
+ var otherKeys = Object
+ .keys(config2)
+ .filter(function filterAxiosKeys(key) {
+ return axiosKeys.indexOf(key) === -1;
+ });
+
+ utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
+
+ return config;
+ };
+
+ /**
+ * Create a new instance of Axios
+ *
+ * @param {Object} instanceConfig The default config for the instance
+ */
+ function Axios(instanceConfig) {
+ this.defaults = instanceConfig;
+ this.interceptors = {
+ request: new InterceptorManager_1(),
+ response: new InterceptorManager_1()
+ };
+ }
+
+ /**
+ * Dispatch a request
+ *
+ * @param {Object} config The config specific for this request (merged with this.defaults)
+ */
+ Axios.prototype.request = function request(config) {
+ /*eslint no-param-reassign:0*/
+ // Allow for axios('example/url'[, config]) a la fetch API
+ if (typeof config === 'string') {
+ config = arguments[1] || {};
+ config.url = arguments[0];
+ } else {
+ config = config || {};
+ }
+
+ config = mergeConfig(this.defaults, config);
+
+ // Set config.method
+ if (config.method) {
+ config.method = config.method.toLowerCase();
+ } else if (this.defaults.method) {
+ config.method = this.defaults.method.toLowerCase();
+ } else {
+ config.method = 'get';
+ }
+
+ // Hook up interceptors middleware
+ var chain = [dispatchRequest, undefined];
+ var promise = Promise.resolve(config);
+
+ this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+ chain.unshift(interceptor.fulfilled, interceptor.rejected);
+ });
+
+ this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+ chain.push(interceptor.fulfilled, interceptor.rejected);
+ });
+
+ while (chain.length) {
+ promise = promise.then(chain.shift(), chain.shift());
+ }
+
+ return promise;
+ };
+
+ Axios.prototype.getUri = function getUri(config) {
+ config = mergeConfig(this.defaults, config);
+ return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
+ };
+
+ // Provide aliases for supported request methods
+ utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
+ /*eslint func-names:0*/
+ Axios.prototype[method] = function(url, config) {
+ return this.request(utils.merge(config || {}, {
+ method: method,
+ url: url
+ }));
+ };
+ });
+
+ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ /*eslint func-names:0*/
+ Axios.prototype[method] = function(url, data, config) {
+ return this.request(utils.merge(config || {}, {
+ method: method,
+ url: url,
+ data: data
+ }));
+ };
+ });
+
+ var Axios_1 = Axios;
+
+ /**
+ * A `Cancel` is an object that is thrown when an operation is canceled.
+ *
+ * @class
+ * @param {string=} message The message.
+ */
+ function Cancel(message) {
+ this.message = message;
+ }
+
+ Cancel.prototype.toString = function toString() {
+ return 'Cancel' + (this.message ? ': ' + this.message : '');
+ };
+
+ Cancel.prototype.__CANCEL__ = true;
+
+ var Cancel_1 = Cancel;
+
+ /**
+ * A `CancelToken` is an object that can be used to request cancellation of an operation.
+ *
+ * @class
+ * @param {Function} executor The executor function.
+ */
+ function CancelToken(executor) {
+ if (typeof executor !== 'function') {
+ throw new TypeError('executor must be a function.');
+ }
+
+ var resolvePromise;
+ this.promise = new Promise(function promiseExecutor(resolve) {
+ resolvePromise = resolve;
+ });
+
+ var token = this;
+ executor(function cancel(message) {
+ if (token.reason) {
+ // Cancellation has already been requested
+ return;
+ }
+
+ token.reason = new Cancel_1(message);
+ resolvePromise(token.reason);
+ });
+ }
+
+ /**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+ CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+ if (this.reason) {
+ throw this.reason;
+ }
+ };
+
+ /**
+ * Returns an object that contains a new `CancelToken` and a function that, when called,
+ * cancels the `CancelToken`.
+ */
+ CancelToken.source = function source() {
+ var cancel;
+ var token = new CancelToken(function executor(c) {
+ cancel = c;
+ });
+ return {
+ token: token,
+ cancel: cancel
+ };
+ };
+
+ var CancelToken_1 = CancelToken;
+
+ /**
+ * Syntactic sugar for invoking a function and expanding an array for arguments.
+ *
+ * Common use case would be to use `Function.prototype.apply`.
+ *
+ * ```js
+ * function f(x, y, z) {}
+ * var args = [1, 2, 3];
+ * f.apply(null, args);
+ * ```
+ *
+ * With `spread` this example can be re-written.
+ *
+ * ```js
+ * spread(function(x, y, z) {})([1, 2, 3]);
+ * ```
+ *
+ * @param {Function} callback
+ * @returns {Function}
+ */
+ var spread = function spread(callback) {
+ return function wrap(arr) {
+ return callback.apply(null, arr);
+ };
+ };
+
+ /**
+ * Create an instance of Axios
+ *
+ * @param {Object} defaultConfig The default config for the instance
+ * @return {Axios} A new instance of Axios
+ */
+ function createInstance(defaultConfig) {
+ var context = new Axios_1(defaultConfig);
+ var instance = bind(Axios_1.prototype.request, context);
+
+ // Copy axios.prototype to instance
+ utils.extend(instance, Axios_1.prototype, context);
+
+ // Copy context to instance
+ utils.extend(instance, context);
+
+ return instance;
+ }
+
+ // Create the default instance to be exported
+ var axios = createInstance(defaults_1);
+
+ // Expose Axios class to allow class inheritance
+ axios.Axios = Axios_1;
+
+ // Factory for creating new instances
+ axios.create = function create(instanceConfig) {
+ return createInstance(mergeConfig(axios.defaults, instanceConfig));
+ };
+
+ // Expose Cancel & CancelToken
+ axios.Cancel = Cancel_1;
+ axios.CancelToken = CancelToken_1;
+ axios.isCancel = isCancel;
+
+ // Expose all/spread
+ axios.all = function all(promises) {
+ return Promise.all(promises);
+ };
+ axios.spread = spread;
+
+ var axios_1 = axios;
+
+ // Allow use of default import syntax in TypeScript
+ var default_1 = axios;
+ axios_1.default = default_1;
+
+ var axios$1 = axios_1;
+
+ const url = 'http://localhost:3000/recipes';
+
+ function Filter() {
+ const { subscribe, set, update } = writable({
+ 'meat':'0',
+ 'meal':'0'
+ });
+
+ return {
+ subscribe,
+ 'updateMeat': (newVal) => update(v => {
+ return {
+ ...v, ...{ 'meat':newVal }
+ };
+ }),
+ 'updateMeal': (newVal) => update(v => {
+ return {
+ ...v, ...{ 'meal':newVal }
+ };
+ })
+ };
+ }
+
+ function Recipes() {
+ const { subscribe, set, update } = writable([]);
+
+ return {
+ subscribe,
+ set,
+ update
+ };
+ }
+
+ function EditMode() {
+ const { subscribe, set, update } = writable(false);
+
+ return {
+ subscribe,
+ 'newRecipe': () => update(v => true),
+ 'closeEditor': () => update( v => false)
+ };
+ }
+
+ function CurrentItem() {
+ const { subscribe, set, update } = writable({
+ 'name': '',
+ 'url': '',
+ 'md': '',
+ 'meat': '',
+ 'mealtype': '',
+ '_id': '',
+ 'short': '',
+ 'hash': '',
+ 'lastused': ''
+ });
+
+ return {
+ subscribe,
+ 'clearItem': () => update(v => {
+ return {
+ 'name': '',
+ 'url': '',
+ 'md': '',
+ 'meat': '',
+ 'mealtype': '',
+ '_id': '',
+ 'short': '',
+ 'hash': '',
+ 'lastused': ''
+ };
+ }),
+ 'updateItem': (payload) => update(v => {
+ return payload;
+ })
+ };
+ }
+
+ const state = {
+ 'editMode': EditMode(),
+ 'currentItem': CurrentItem(),
+ 'recipes': Recipes(),
+ 'filter': Filter(),
+
+ newRecipe() {
+ console.log('>> Action:newRecipe');
+ this.editMode.newRecipe();
+ this.currentItem.clearItem();
+ },
+ async editRecipe(hash) {
+ const response = await axios$1.get(`${url}/${hash}`).catch((err) => {
+ console.error(err);
+ });
+
+ this.currentItem.updateItem(response.data);
+ this.editMode.newRecipe();
+ },
+ async saveRecipe(payload) {
+ console.log('>> Action:saveRecipe');
+ const data = { ...payload };
+
+ let response;
+
+ if (data.hash === '') {
+ console.log('Create new');
+ response = await axios$1.post(`${url}`, data).catch((err) => {
+ console.error(err);
+ });
+ }
+ else {
+ console.log('Update existing');
+ response = await axios$1.put(`${url}/${data.hash}`, data).catch((err) => {
+ console.error(err);
+ });
+ }
+
+ if (response.data.changes > 0 || response.data.msg === 'Row inserted') {
+ this.closeEditor();
+ this.fetchRecipes();
+ }
+ },
+ async fetchRecipes() {
+ const response = await axios$1.get(url);
+ this.recipes.set(response.data);
+ },
+ closeEditor() {
+ this.editMode.closeEditor();
+ this.currentItem.clearItem();
+ },
+ updateMeatFilter(newVal) {
+ this.filter.updateMeat(newVal);
+ },
+ updateMealFilter(newVal) {
+ this.filter.updateMeal(newVal);
+ }
+ };
+
+ /* src/components/Header.svelte generated by Svelte v3.20.1 */
+
+ const { console: console_1 } = globals;
+ const file = "src/components/Header.svelte";
+
+ function create_fragment(ctx) {
+ let header;
+ let h2;
+ let t1;
+ let ul;
+ let li;
+ let button;
+ let dispose;
+
+ const block = {
+ c: function create() {
+ header = element("header");
+ h2 = element("h2");
+ h2.textContent = "Recipes";
+ t1 = space();
+ ul = element("ul");
+ li = element("li");
+ button = element("button");
+ button.textContent = "New Recipe";
+ add_location(h2, file, 14, 4, 223);
+ attr_dev(button, "class", "btn btn-sm");
+ attr_dev(button, "type", "button");
+ add_location(button, file, 19, 12, 288);
+ add_location(li, file, 18, 8, 271);
+ add_location(ul, file, 17, 4, 258);
+ attr_dev(header, "class", "navbar bg-primary");
+ add_location(header, file, 13, 0, 184);
+ },
+ 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, header, anchor);
+ append_dev(header, h2);
+ append_dev(header, t1);
+ append_dev(header, ul);
+ append_dev(ul, li);
+ append_dev(li, button);
+ if (remount) dispose();
+ dispose = listen_dev(button, "click", handleNewRecipe, false, false, false);
+ },
+ p: noop,
+ i: noop,
+ o: noop,
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(header);
+ dispose();
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function handleNewRecipe() {
+ console.log("newRecipe");
+ state.newRecipe();
+ }
+
+ function instance($$self, $$props, $$invalidate) {
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console_1.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("Header", $$slots, []);
+ $$self.$capture_state = () => ({ state, handleNewRecipe });
+ return [];
+ }
+
+ class Header extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance, create_fragment, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "Header",
+ options,
+ id: create_fragment.name
+ });
+ }
+ }
+
+ /**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing. The function also has a property 'clear'
+ * that is a function which will clear the timer to prevent previously scheduled executions.
+ *
+ * @source underscore.js
+ * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
+ * @param {Function} function to wrap
+ * @param {Number} timeout in ms (`100`)
+ * @param {Boolean} whether to execute at the beginning (`false`)
+ * @api public
+ */
+ function debounce(func, wait, immediate){
+ var timeout, args, context, timestamp, result;
+ if (null == wait) wait = 100;
+
+ function later() {
+ var last = Date.now() - timestamp;
+
+ if (last < wait && last >= 0) {
+ timeout = setTimeout(later, wait - last);
+ } else {
+ timeout = null;
+ if (!immediate) {
+ result = func.apply(context, args);
+ context = args = null;
+ }
+ }
+ }
+ var debounced = function(){
+ context = this;
+ args = arguments;
+ timestamp = Date.now();
+ var callNow = immediate && !timeout;
+ if (!timeout) timeout = setTimeout(later, wait);
+ if (callNow) {
+ result = func.apply(context, args);
+ context = args = null;
+ }
+
+ return result;
+ };
+
+ debounced.clear = function() {
+ if (timeout) {
+ clearTimeout(timeout);
+ timeout = null;
+ }
+ };
+
+ debounced.flush = function() {
+ if (timeout) {
+ result = func.apply(context, args);
+ context = args = null;
+
+ clearTimeout(timeout);
+ timeout = null;
+ }
+ };
+
+ return debounced;
+ }
+ // Adds compatibility for ES modules
+ debounce.debounce = debounce;
+
+ var debounce_1 = debounce;
+
+ /* src/components/Editor.svelte generated by Svelte v3.20.1 */
+
+ const { console: console_1$1 } = globals;
+ const file$1 = "src/components/Editor.svelte";
+
+ // (108:0) {#if _editMode}
+ function create_if_block(ctx) {
+ let div1;
+ let form;
+ let label0;
+ let t1;
+ let input0;
+ let t2;
+ let label1;
+ let t4;
+ let input1;
+ let t5;
+ let label2;
+ let t7;
+ let textarea;
+ let t8;
+ let label3;
+ let t10;
+ let select0;
+ let option0;
+ let option1;
+ let option2;
+ let option3;
+ let option4;
+ let option5;
+ let option6;
+ let t17;
+ let label4;
+ let t19;
+ let select1;
+ let option7;
+ let option8;
+ let option9;
+ let option10;
+ let t23;
+ let input2;
+ let t24;
+ let input3;
+ let t25;
+ let input4;
+ let t26;
+ let input5;
+ let t27;
+ let div0;
+ let button0;
+ let t28;
+ let t29;
+ let button1;
+ let t31;
+ let button2;
+ let dispose;
+
+ const block = {
+ c: function create() {
+ div1 = element("div");
+ form = element("form");
+ label0 = element("label");
+ label0.textContent = "Name:";
+ t1 = space();
+ input0 = element("input");
+ t2 = space();
+ label1 = element("label");
+ label1.textContent = "Url:";
+ t4 = space();
+ input1 = element("input");
+ t5 = space();
+ label2 = element("label");
+ label2.textContent = "Markdown:";
+ t7 = space();
+ textarea = element("textarea");
+ t8 = space();
+ label3 = element("label");
+ label3.textContent = "Meat";
+ t10 = space();
+ select0 = element("select");
+ option0 = element("option");
+ option1 = element("option");
+ option1.textContent = "Chicken";
+ option2 = element("option");
+ option2.textContent = "Beef";
+ option3 = element("option");
+ option3.textContent = "Pork";
+ option4 = element("option");
+ option4.textContent = "Fish";
+ option5 = element("option");
+ option5.textContent = "Egg";
+ option6 = element("option");
+ option6.textContent = "Vegetable";
+ t17 = space();
+ label4 = element("label");
+ label4.textContent = "Meal type";
+ t19 = space();
+ select1 = element("select");
+ option7 = element("option");
+ option8 = element("option");
+ option8.textContent = "Main";
+ option9 = element("option");
+ option9.textContent = "Soup";
+ option10 = element("option");
+ option10.textContent = "Note";
+ t23 = space();
+ input2 = element("input");
+ t24 = space();
+ input3 = element("input");
+ t25 = space();
+ input4 = element("input");
+ t26 = space();
+ input5 = element("input");
+ t27 = space();
+ div0 = element("div");
+ button0 = element("button");
+ t28 = text("Delete");
+ t29 = space();
+ button1 = element("button");
+ button1.textContent = "Close";
+ t31 = space();
+ button2 = element("button");
+ button2.textContent = "Save";
+ attr_dev(label0, "for", "name");
+ add_location(label0, file$1, 110, 12, 2679);
+ attr_dev(input0, "type", "text");
+ attr_dev(input0, "name", "name");
+ attr_dev(input0, "id", "name");
+ input0.required = true;
+ add_location(input0, file$1, 111, 12, 2723);
+ attr_dev(label1, "for", "url");
+ add_location(label1, file$1, 113, 12, 2819);
+ attr_dev(input1, "type", "text");
+ attr_dev(input1, "name", "url");
+ attr_dev(input1, "id", "url");
+ input1.required = true;
+ add_location(input1, file$1, 114, 12, 2861);
+ attr_dev(label2, "for", "md");
+ add_location(label2, file$1, 116, 12, 2954);
+ attr_dev(textarea, "id", "md");
+ attr_dev(textarea, "name", "md");
+ attr_dev(textarea, "cols", "50");
+ attr_dev(textarea, "rows", "10");
+ add_location(textarea, file$1, 117, 12, 3000);
+ attr_dev(label3, "for", "meat");
+ add_location(label3, file$1, 119, 12, 3126);
+ option0.__value = "";
+ option0.value = option0.__value;
+ add_location(option0, file$1, 121, 16, 3243);
+ option1.__value = "1";
+ option1.value = option1.__value;
+ add_location(option1, file$1, 122, 16, 3277);
+ option2.__value = "2";
+ option2.value = option2.__value;
+ add_location(option2, file$1, 123, 16, 3328);
+ option3.__value = "3";
+ option3.value = option3.__value;
+ add_location(option3, file$1, 124, 16, 3376);
+ option4.__value = "4";
+ option4.value = option4.__value;
+ add_location(option4, file$1, 125, 16, 3424);
+ option5.__value = "5";
+ option5.value = option5.__value;
+ add_location(option5, file$1, 126, 16, 3472);
+ option6.__value = "6";
+ option6.value = option6.__value;
+ add_location(option6, file$1, 127, 16, 3519);
+ attr_dev(select0, "id", "meat");
+ attr_dev(select0, "name", "meat");
+ select0.required = true;
+ if (/*meat*/ ctx[2] === void 0) add_render_callback(() => /*select0_change_handler*/ ctx[12].call(select0));
+ add_location(select0, file$1, 120, 12, 3169);
+ attr_dev(label4, "for", "mealtype");
+ add_location(label4, file$1, 130, 12, 3591);
+ option7.__value = "";
+ option7.value = option7.__value;
+ add_location(option7, file$1, 132, 16, 3729);
+ option8.__value = "1";
+ option8.value = option8.__value;
+ add_location(option8, file$1, 133, 16, 3763);
+ option9.__value = "2";
+ option9.value = option9.__value;
+ add_location(option9, file$1, 134, 16, 3811);
+ option10.__value = "128";
+ option10.value = option10.__value;
+ add_location(option10, file$1, 135, 16, 3859);
+ attr_dev(select1, "id", "mealtype");
+ attr_dev(select1, "name", "mealtype");
+ select1.required = true;
+ if (/*mealtype*/ ctx[3] === void 0) add_render_callback(() => /*select1_change_handler*/ ctx[13].call(select1));
+ add_location(select1, file$1, 131, 12, 3643);
+ attr_dev(input2, "id", "_id");
+ attr_dev(input2, "name", "id");
+ attr_dev(input2, "type", "hidden");
+ input2.disabled = true;
+ add_location(input2, file$1, 138, 12, 3928);
+ attr_dev(input3, "type", "hidden");
+ attr_dev(input3, "id", "short");
+ attr_dev(input3, "name", "short");
+ input3.disabled = true;
+ add_location(input3, file$1, 139, 12, 4021);
+ attr_dev(input4, "type", "hidden");
+ attr_dev(input4, "id", "hash");
+ attr_dev(input4, "name", "hash");
+ input4.disabled = true;
+ add_location(input4, file$1, 140, 12, 4121);
+ attr_dev(input5, "type", "hidden");
+ attr_dev(input5, "id", "lastused");
+ attr_dev(input5, "name", "lastused");
+ input5.disabled = true;
+ add_location(input5, file$1, 141, 12, 4218);
+ attr_dev(button0, "class", "btn btn-danger btn-sm");
+ attr_dev(button0, "id", "delete");
+ attr_dev(button0, "type", "button");
+ button0.disabled = /*deleteEnabled*/ ctx[4];
+ add_location(button0, file$1, 144, 16, 4372);
+ attr_dev(button1, "class", "btn btn-sm");
+ attr_dev(button1, "type", "button");
+ add_location(button1, file$1, 147, 16, 4553);
+ attr_dev(button2, "class", "btn btn-primary btn-sm");
+ attr_dev(button2, "id", "save");
+ attr_dev(button2, "type", "button");
+ add_location(button2, file$1, 150, 16, 4686);
+ attr_dev(div0, "class", "my text-right");
+ add_location(div0, file$1, 143, 12, 4328);
+ attr_dev(form, "autocomplete", "off");
+ add_location(form, file$1, 109, 8, 2641);
+ attr_dev(div1, "class", "container");
+ add_location(div1, file$1, 108, 4, 2609);
+ },
+ m: function mount(target, anchor, remount) {
+ insert_dev(target, div1, anchor);
+ append_dev(div1, form);
+ append_dev(form, label0);
+ append_dev(form, t1);
+ append_dev(form, input0);
+ set_input_value(input0, /*_currentItem*/ ctx[1].name);
+ append_dev(form, t2);
+ append_dev(form, label1);
+ append_dev(form, t4);
+ append_dev(form, input1);
+ set_input_value(input1, /*_currentItem*/ ctx[1].url);
+ append_dev(form, t5);
+ append_dev(form, label2);
+ append_dev(form, t7);
+ append_dev(form, textarea);
+ set_input_value(textarea, /*_currentItem*/ ctx[1].md);
+ append_dev(form, t8);
+ append_dev(form, label3);
+ append_dev(form, t10);
+ append_dev(form, select0);
+ append_dev(select0, option0);
+ append_dev(select0, option1);
+ append_dev(select0, option2);
+ append_dev(select0, option3);
+ append_dev(select0, option4);
+ append_dev(select0, option5);
+ append_dev(select0, option6);
+ select_option(select0, /*meat*/ ctx[2]);
+ append_dev(form, t17);
+ append_dev(form, label4);
+ append_dev(form, t19);
+ append_dev(form, select1);
+ append_dev(select1, option7);
+ append_dev(select1, option8);
+ append_dev(select1, option9);
+ append_dev(select1, option10);
+ select_option(select1, /*mealtype*/ ctx[3]);
+ append_dev(form, t23);
+ append_dev(form, input2);
+ set_input_value(input2, /*_currentItem*/ ctx[1]._id);
+ append_dev(form, t24);
+ append_dev(form, input3);
+ set_input_value(input3, /*_currentItem*/ ctx[1].short);
+ append_dev(form, t25);
+ append_dev(form, input4);
+ set_input_value(input4, /*_currentItem*/ ctx[1].hash);
+ append_dev(form, t26);
+ append_dev(form, input5);
+ set_input_value(input5, /*_currentItem*/ ctx[1].lastused);
+ append_dev(form, t27);
+ append_dev(form, div0);
+ append_dev(div0, button0);
+ append_dev(button0, t28);
+ append_dev(div0, t29);
+ append_dev(div0, button1);
+ append_dev(div0, t31);
+ append_dev(div0, button2);
+ if (remount) run_all(dispose);
+
+ dispose = [
+ listen_dev(input0, "input", /*input0_input_handler*/ ctx[9]),
+ listen_dev(input1, "input", /*input1_input_handler*/ ctx[10]),
+ listen_dev(textarea, "input", /*textarea_input_handler*/ ctx[11]),
+ listen_dev(textarea, "paste", /*pasteHandler*/ ctx[6], false, false, false),
+ listen_dev(select0, "change", /*select0_change_handler*/ ctx[12]),
+ listen_dev(select1, "change", /*select1_change_handler*/ ctx[13]),
+ listen_dev(input2, "input", /*input2_input_handler*/ ctx[14]),
+ listen_dev(input3, "input", /*input3_input_handler*/ ctx[15]),
+ listen_dev(input4, "input", /*input4_input_handler*/ ctx[16]),
+ listen_dev(input5, "input", /*input5_input_handler*/ ctx[17]),
+ listen_dev(button0, "click", deleteItem, false, false, false),
+ listen_dev(button1, "click", closeEditor, false, false, false),
+ listen_dev(button2, "click", /*saveRecipe*/ ctx[5], false, false, false)
+ ];
+ },
+ p: function update(ctx, dirty) {
+ if (dirty & /*_currentItem*/ 2 && input0.value !== /*_currentItem*/ ctx[1].name) {
+ set_input_value(input0, /*_currentItem*/ ctx[1].name);
+ }
+
+ if (dirty & /*_currentItem*/ 2 && input1.value !== /*_currentItem*/ ctx[1].url) {
+ set_input_value(input1, /*_currentItem*/ ctx[1].url);
+ }
+
+ if (dirty & /*_currentItem*/ 2) {
+ set_input_value(textarea, /*_currentItem*/ ctx[1].md);
+ }
+
+ if (dirty & /*meat*/ 4) {
+ select_option(select0, /*meat*/ ctx[2]);
+ }
+
+ if (dirty & /*mealtype*/ 8) {
+ select_option(select1, /*mealtype*/ ctx[3]);
+ }
+
+ if (dirty & /*_currentItem*/ 2) {
+ set_input_value(input2, /*_currentItem*/ ctx[1]._id);
+ }
+
+ if (dirty & /*_currentItem*/ 2) {
+ set_input_value(input3, /*_currentItem*/ ctx[1].short);
+ }
+
+ if (dirty & /*_currentItem*/ 2) {
+ set_input_value(input4, /*_currentItem*/ ctx[1].hash);
+ }
+
+ if (dirty & /*_currentItem*/ 2) {
+ set_input_value(input5, /*_currentItem*/ ctx[1].lastused);
+ }
+
+ if (dirty & /*deleteEnabled*/ 16) {
+ prop_dev(button0, "disabled", /*deleteEnabled*/ ctx[4]);
+ }
+ },
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(div1);
+ run_all(dispose);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_if_block.name,
+ type: "if",
+ source: "(108:0) {#if _editMode}",
+ ctx
+ });
+
+ return block;
+ }
+
+ function create_fragment$1(ctx) {
+ let if_block_anchor;
+ let if_block = /*_editMode*/ ctx[0] && create_if_block(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 (/*_editMode*/ ctx[0]) {
+ if (if_block) {
+ if_block.p(ctx, dirty);
+ } else {
+ if_block = create_if_block(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$1.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function deleteItem() {
+ console.log(">> DELETE");
+ }
+
+ function closeEditor() {
+ state.closeEditor();
+ }
+
+ function instance$1($$self, $$props, $$invalidate) {
+ let _editMode;
+ let _currentItem;
+ let meat;
+ let mealtype;
+ let deleteEnabled = false;
+
+ state.editMode.subscribe(async v => {
+ $$invalidate(0, _editMode = v);
+ });
+
+ state.currentItem.subscribe(async v => {
+ $$invalidate(1, _currentItem = v);
+ });
+
+ async function saveRecipe() {
+ await state.saveRecipe(_currentItem);
+ }
+
+ function pasteHandler(v) {
+ debouncedPasteProcessor(v);
+ }
+
+ function pasteProcessor(item) {
+ const meats = ["x", "chicken", "beef", "pork", "fish", "egg", "vegetable"];
+ const newFragment = {};
+ const titleRegEx = /(?:#\s)(.*)(?:\n)/;
+ const linkRegEx = /(?:\[.*]\()(.*)(?:\))/;
+ const foodRegEx = /([vV]egetable|[pP]ork|[cC]hicken|[bB]eef|[fF]ish|[eE]gg)/g;
+ const mealTypeRegEx = /([sS]oup)/g;
+ const foodCount = {};
+ let winnerVal = 0;
+ let winnerId = 0;
+ const newTitle = titleRegEx.exec(item.target.value);
+ const newLink = linkRegEx.exec(item.target.value);
+ if (newTitle !== null) newFragment.name = newTitle[1];
+ if (newLink !== null) newFragment.url = newLink[1];
+ const matchedFoods = [...item.target.value.matchAll(foodRegEx)];
+ const mealTypes = [...item.target.value.matchAll(mealTypeRegEx)];
+
+ if (matchedFoods.length > 0) {
+ const deboxed = matchedFoods.map(fooditem => {
+ return fooditem[0].toLowerCase();
+ });
+
+ deboxed.forEach(el => {
+ foodCount[el] = foodCount[el] + 1 || 1;
+ });
+
+ for (const key in foodCount) if (foodCount[key] > winnerVal) {
+ winnerVal = foodCount[key];
+ winnerId = meats.indexOf(key);
+ }
+
+ newFragment.meat = winnerId;
+ }
+
+ if (mealTypes.length > 0) newFragment.mealtype = 2; else newFragment.mealtype = 1;
+ $$invalidate(1, _currentItem = { ..._currentItem, ...newFragment });
+ }
+
+ const debouncedPasteProcessor = debounce_1(pasteProcessor, 250);
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console_1$1.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("Editor", $$slots, []);
+
+ function input0_input_handler() {
+ _currentItem.name = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function input1_input_handler() {
+ _currentItem.url = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function textarea_input_handler() {
+ _currentItem.md = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function select0_change_handler() {
+ meat = select_value(this);
+ ($$invalidate(2, meat), $$invalidate(1, _currentItem));
+ }
+
+ function select1_change_handler() {
+ mealtype = select_value(this);
+ ($$invalidate(3, mealtype), $$invalidate(1, _currentItem));
+ }
+
+ function input2_input_handler() {
+ _currentItem._id = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function input3_input_handler() {
+ _currentItem.short = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function input4_input_handler() {
+ _currentItem.hash = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ function input5_input_handler() {
+ _currentItem.lastused = this.value;
+ $$invalidate(1, _currentItem);
+ }
+
+ $$self.$capture_state = () => ({
+ state,
+ debounce: debounce_1,
+ _editMode,
+ _currentItem,
+ meat,
+ mealtype,
+ deleteEnabled,
+ deleteItem,
+ closeEditor,
+ saveRecipe,
+ pasteHandler,
+ pasteProcessor,
+ debouncedPasteProcessor
+ });
+
+ $$self.$inject_state = $$props => {
+ if ("_editMode" in $$props) $$invalidate(0, _editMode = $$props._editMode);
+ if ("_currentItem" in $$props) $$invalidate(1, _currentItem = $$props._currentItem);
+ if ("meat" in $$props) $$invalidate(2, meat = $$props.meat);
+ if ("mealtype" in $$props) $$invalidate(3, mealtype = $$props.mealtype);
+ if ("deleteEnabled" in $$props) $$invalidate(4, deleteEnabled = $$props.deleteEnabled);
+ };
+
+ if ($$props && "$$inject" in $$props) {
+ $$self.$inject_state($$props.$$inject);
+ }
+
+ $$self.$$.update = () => {
+ if ($$self.$$.dirty & /*_currentItem*/ 2) {
+ {
+ $$invalidate(2, meat = _currentItem.meat.toString());
+ $$invalidate(3, mealtype = _currentItem.mealtype.toString());
+ }
+ }
+
+ if ($$self.$$.dirty & /*_currentItem*/ 2) {
+ $$invalidate(4, deleteEnabled = _currentItem.hash === "");
+ }
+ };
+
+ return [
+ _editMode,
+ _currentItem,
+ meat,
+ mealtype,
+ deleteEnabled,
+ saveRecipe,
+ pasteHandler,
+ pasteProcessor,
+ debouncedPasteProcessor,
+ input0_input_handler,
+ input1_input_handler,
+ textarea_input_handler,
+ select0_change_handler,
+ select1_change_handler,
+ input2_input_handler,
+ input3_input_handler,
+ input4_input_handler,
+ input5_input_handler
+ ];
+ }
+
+ class Editor extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$1, create_fragment$1, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "Editor",
+ options,
+ id: create_fragment$1.name
+ });
+ }
+ }
+
+ /* src/components/FilterBar.svelte generated by Svelte v3.20.1 */
+ const file$2 = "src/components/FilterBar.svelte";
+
+ function create_fragment$2(ctx) {
+ let div1;
+ let div0;
+ let select0;
+ let option0;
+ let option1;
+ let option2;
+ let option3;
+ let option4;
+ let option5;
+ let option6;
+ let t7;
+ let select1;
+ let option7;
+ let option8;
+ let option9;
+ let option10;
+ let dispose;
+
+ const block = {
+ c: function create() {
+ div1 = element("div");
+ div0 = element("div");
+ select0 = element("select");
+ option0 = element("option");
+ option0.textContent = "All";
+ option1 = element("option");
+ option1.textContent = "Chicken";
+ option2 = element("option");
+ option2.textContent = "Beef";
+ option3 = element("option");
+ option3.textContent = "Pork";
+ option4 = element("option");
+ option4.textContent = "Fish";
+ option5 = element("option");
+ option5.textContent = "Egg";
+ option6 = element("option");
+ option6.textContent = "Vegetable";
+ t7 = space();
+ select1 = element("select");
+ option7 = element("option");
+ option7.textContent = "All";
+ option8 = element("option");
+ option8.textContent = "Mains";
+ option9 = element("option");
+ option9.textContent = "Soups";
+ option10 = element("option");
+ option10.textContent = "Notes";
+ option0.__value = "0";
+ option0.value = option0.__value;
+ add_location(option0, file$2, 27, 12, 561);
+ option1.__value = "1";
+ option1.value = option1.__value;
+ add_location(option1, file$2, 28, 12, 604);
+ option2.__value = "2";
+ option2.value = option2.__value;
+ add_location(option2, file$2, 29, 12, 651);
+ option3.__value = "3";
+ option3.value = option3.__value;
+ add_location(option3, file$2, 30, 12, 695);
+ option4.__value = "4";
+ option4.value = option4.__value;
+ add_location(option4, file$2, 31, 12, 739);
+ option5.__value = "5";
+ option5.value = option5.__value;
+ add_location(option5, file$2, 32, 12, 783);
+ option6.__value = "6";
+ option6.value = option6.__value;
+ add_location(option6, file$2, 33, 12, 826);
+ add_location(select0, file$2, 26, 8, 517);
+ option7.__value = "0";
+ option7.value = option7.__value;
+ add_location(option7, file$2, 37, 12, 934);
+ option8.__value = "1";
+ option8.value = option8.__value;
+ add_location(option8, file$2, 38, 12, 977);
+ option9.__value = "2";
+ option9.value = option9.__value;
+ add_location(option9, file$2, 39, 12, 1022);
+ option10.__value = "128";
+ option10.value = option10.__value;
+ add_location(option10, file$2, 40, 12, 1067);
+ add_location(select1, file$2, 36, 8, 890);
+ attr_dev(div0, "class", "filterBar grid-4 svelte-17lzm0a");
+ add_location(div0, file$2, 25, 4, 478);
+ attr_dev(div1, "class", "container");
+ add_location(div1, file$2, 24, 0, 450);
+ },
+ 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, div1, anchor);
+ append_dev(div1, div0);
+ append_dev(div0, select0);
+ append_dev(select0, option0);
+ append_dev(select0, option1);
+ append_dev(select0, option2);
+ append_dev(select0, option3);
+ append_dev(select0, option4);
+ append_dev(select0, option5);
+ append_dev(select0, option6);
+ append_dev(div0, t7);
+ append_dev(div0, select1);
+ append_dev(select1, option7);
+ append_dev(select1, option8);
+ append_dev(select1, option9);
+ append_dev(select1, option10);
+ if (remount) run_all(dispose);
+
+ dispose = [
+ listen_dev(select0, "change", updateMeat, false, false, false),
+ listen_dev(select1, "change", updateMeal, false, false, false)
+ ];
+ },
+ p: noop,
+ i: noop,
+ o: noop,
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(div1);
+ run_all(dispose);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment$2.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function updateMeat(event) {
+ const newVal = event.target.value;
+ state.updateMeatFilter(newVal);
+ }
+
+ function updateMeal(event) {
+ const newVal = event.target.value;
+ state.updateMealFilter(newVal);
+ }
+
+ function instance$2($$self, $$props, $$invalidate) {
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("FilterBar", $$slots, []);
+ $$self.$capture_state = () => ({ state, updateMeat, updateMeal });
+ return [];
+ }
+
+ class FilterBar extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$2, create_fragment$2, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "FilterBar",
+ options,
+ id: create_fragment$2.name
+ });
+ }
+ }
+
+ /* src/components/RecipeItem.svelte generated by Svelte v3.20.1 */
+ const file$3 = "src/components/RecipeItem.svelte";
+
+ // (80:44)
+ function create_if_block_1(ctx) {
+ let span;
+
+ const block = {
+ c: function create() {
+ span = element("span");
+ span.textContent = "Note";
+ attr_dev(span, "class", "badge badge-dark");
+ add_location(span, file$3, 80, 12, 1501);
+ },
+ m: function mount(target, anchor) {
+ insert_dev(target, span, anchor);
+ },
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(span);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_if_block_1.name,
+ type: "if",
+ source: "(80:44) ",
+ ctx
+ });
+
+ return block;
+ }
+
+ // (78:8) {#if recipeItem.mealtype ===2}
+ function create_if_block$1(ctx) {
+ let span;
+
+ const block = {
+ c: function create() {
+ span = element("span");
+ span.textContent = "Soup";
+ attr_dev(span, "class", "badge badge-light");
+ add_location(span, file$3, 78, 12, 1400);
+ },
+ m: function mount(target, anchor) {
+ insert_dev(target, span, anchor);
+ },
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(span);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_if_block$1.name,
+ type: "if",
+ source: "(78:8) {#if recipeItem.mealtype ===2}",
+ ctx
+ });
+
+ return block;
+ }
+
+ function create_fragment$3(ctx) {
+ let div3;
+ let div0;
+ let a;
+ let t0_value = /*recipeItem*/ ctx[0].name + "";
+ let t0;
+ let t1;
+ let div1;
+ let t2;
+ let span;
+ let t3;
+ let span_class_value;
+ let t4;
+ let div2;
+ let button;
+ let dispose;
+
+ function select_block_type(ctx, dirty) {
+ if (/*recipeItem*/ ctx[0].mealtype === 2) return create_if_block$1;
+ if (/*recipeItem*/ ctx[0].mealtype === 128) return create_if_block_1;
+ }
+
+ let current_block_type = select_block_type(ctx);
+ let if_block = current_block_type && current_block_type(ctx);
+
+ const block = {
+ c: function create() {
+ div3 = element("div");
+ div0 = element("div");
+ a = element("a");
+ t0 = text(t0_value);
+ t1 = space();
+ div1 = element("div");
+ if (if_block) if_block.c();
+ t2 = space();
+ span = element("span");
+ t3 = text(/*meatText*/ ctx[2]);
+ t4 = space();
+ div2 = element("div");
+ button = element("button");
+ button.textContent = "Edit";
+ attr_dev(a, "href", /*url*/ ctx[3]);
+ add_location(a, file$3, 75, 29, 1275);
+ attr_dev(div0, "class", "listItemSix svelte-qibu9a");
+ add_location(div0, file$3, 75, 4, 1250);
+ attr_dev(span, "class", span_class_value = "badge " + /*meatClass*/ ctx[1] + " svelte-qibu9a");
+ add_location(span, file$3, 83, 8, 1567);
+ attr_dev(div1, "class", "listItemThree svelte-qibu9a");
+ add_location(div1, file$3, 76, 4, 1321);
+ attr_dev(button, "class", "btn btn-primary btn-sm");
+ attr_dev(button, "type", "button");
+ add_location(button, file$3, 86, 8, 1679);
+ attr_dev(div2, "class", "listItemThree all-center svelte-qibu9a");
+ add_location(div2, file$3, 85, 4, 1632);
+ attr_dev(div3, "class", "recipeItem svelte-qibu9a");
+ add_location(div3, file$3, 74, 0, 1221);
+ },
+ 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, div3, anchor);
+ append_dev(div3, div0);
+ append_dev(div0, a);
+ append_dev(a, t0);
+ append_dev(div3, t1);
+ append_dev(div3, div1);
+ if (if_block) if_block.m(div1, null);
+ append_dev(div1, t2);
+ append_dev(div1, span);
+ append_dev(span, t3);
+ append_dev(div3, t4);
+ append_dev(div3, div2);
+ append_dev(div2, button);
+ if (remount) dispose();
+
+ dispose = listen_dev(
+ button,
+ "click",
+ function () {
+ if (is_function(editRecipe(/*recipeItem*/ ctx[0].hash))) editRecipe(/*recipeItem*/ ctx[0].hash).apply(this, arguments);
+ },
+ false,
+ false,
+ false
+ );
+ },
+ p: function update(new_ctx, [dirty]) {
+ ctx = new_ctx;
+ if (dirty & /*recipeItem*/ 1 && t0_value !== (t0_value = /*recipeItem*/ ctx[0].name + "")) set_data_dev(t0, t0_value);
+
+ if (dirty & /*url*/ 8) {
+ attr_dev(a, "href", /*url*/ ctx[3]);
+ }
+
+ if (current_block_type !== (current_block_type = select_block_type(ctx))) {
+ if (if_block) if_block.d(1);
+ if_block = current_block_type && current_block_type(ctx);
+
+ if (if_block) {
+ if_block.c();
+ if_block.m(div1, t2);
+ }
+ }
+
+ if (dirty & /*meatText*/ 4) set_data_dev(t3, /*meatText*/ ctx[2]);
+
+ if (dirty & /*meatClass*/ 2 && span_class_value !== (span_class_value = "badge " + /*meatClass*/ ctx[1] + " svelte-qibu9a")) {
+ attr_dev(span, "class", span_class_value);
+ }
+ },
+ i: noop,
+ o: noop,
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(div3);
+
+ if (if_block) {
+ if_block.d();
+ }
+
+ dispose();
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment$3.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function editRecipe(hash) {
+ state.editRecipe(hash);
+ }
+
+ function instance$3($$self, $$props, $$invalidate) {
+ let { recipeItem = {} } = $$props;
+ let meatClass;
+ let meatText;
+ let url;
+ const meats = ["x", "Chicken", "Beef", "Pork", "Fish", "Egg", "Vegetable"];
+ const writable_props = ["recipeItem"];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("RecipeItem", $$slots, []);
+
+ $$self.$set = $$props => {
+ if ("recipeItem" in $$props) $$invalidate(0, recipeItem = $$props.recipeItem);
+ };
+
+ $$self.$capture_state = () => ({
+ state,
+ recipeItem,
+ meatClass,
+ meatText,
+ url,
+ meats,
+ editRecipe
+ });
+
+ $$self.$inject_state = $$props => {
+ if ("recipeItem" in $$props) $$invalidate(0, recipeItem = $$props.recipeItem);
+ if ("meatClass" in $$props) $$invalidate(1, meatClass = $$props.meatClass);
+ if ("meatText" in $$props) $$invalidate(2, meatText = $$props.meatText);
+ if ("url" in $$props) $$invalidate(3, url = $$props.url);
+ };
+
+ if ($$props && "$$inject" in $$props) {
+ $$self.$inject_state($$props.$$inject);
+ }
+
+ $$self.$$.update = () => {
+ if ($$self.$$.dirty & /*recipeItem*/ 1) {
+ {
+ $$invalidate(2, meatText = meats[recipeItem.meat]);
+
+ $$invalidate(1, meatClass = recipeItem.meat === ""
+ ? ""
+ : meats[recipeItem.meat].toLowerCase());
+
+ $$invalidate(3, url = `/view/${recipeItem.short}`);
+ }
+ }
+ };
+
+ return [recipeItem, meatClass, meatText, url];
+ }
+
+ class RecipeItem extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$3, create_fragment$3, safe_not_equal, { recipeItem: 0 });
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "RecipeItem",
+ options,
+ id: create_fragment$3.name
+ });
+ }
+
+ get recipeItem() {
+ throw new Error(": Props cannot be read directly from the component instance unless compiling with 'accessors: true' or ''");
+ }
+
+ set recipeItem(value) {
+ throw new Error(": Props cannot be set directly on the component instance unless compiling with 'accessors: true' or ''");
+ }
+ }
+
+ /* src/components/Recipes.svelte generated by Svelte v3.20.1 */
+ const file$4 = "src/components/Recipes.svelte";
+
+ function get_each_context(ctx, list, i) {
+ const child_ctx = ctx.slice();
+ child_ctx[4] = list[i];
+ return child_ctx;
+ }
+
+ // (58:4) {#each _recipes as item}
+ function create_each_block(ctx) {
+ let current;
+
+ const recipeitem = new RecipeItem({
+ props: { recipeItem: /*item*/ ctx[4] },
+ $$inline: true
+ });
+
+ const block = {
+ c: function create() {
+ create_component(recipeitem.$$.fragment);
+ },
+ m: function mount(target, anchor) {
+ mount_component(recipeitem, target, anchor);
+ current = true;
+ },
+ p: function update(ctx, dirty) {
+ const recipeitem_changes = {};
+ if (dirty & /*_recipes*/ 1) recipeitem_changes.recipeItem = /*item*/ ctx[4];
+ recipeitem.$set(recipeitem_changes);
+ },
+ i: function intro(local) {
+ if (current) return;
+ transition_in(recipeitem.$$.fragment, local);
+ current = true;
+ },
+ o: function outro(local) {
+ transition_out(recipeitem.$$.fragment, local);
+ current = false;
+ },
+ d: function destroy(detaching) {
+ destroy_component(recipeitem, detaching);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_each_block.name,
+ type: "each",
+ source: "(58:4) {#each _recipes as item}",
+ ctx
+ });
+
+ return block;
+ }
+
+ function create_fragment$4(ctx) {
+ let div;
+ let current;
+ let each_value = /*_recipes*/ ctx[0];
+ 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 out = i => transition_out(each_blocks[i], 1, 1, () => {
+ each_blocks[i] = null;
+ });
+
+ const block = {
+ c: function create() {
+ div = element("div");
+
+ for (let i = 0; i < each_blocks.length; i += 1) {
+ each_blocks[i].c();
+ }
+
+ attr_dev(div, "class", "container ");
+ add_location(div, file$4, 56, 0, 1369);
+ },
+ 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);
+
+ for (let i = 0; i < each_blocks.length; i += 1) {
+ each_blocks[i].m(div, null);
+ }
+
+ current = true;
+ },
+ p: function update(ctx, [dirty]) {
+ if (dirty & /*_recipes*/ 1) {
+ each_value = /*_recipes*/ ctx[0];
+ 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);
+ transition_in(each_blocks[i], 1);
+ } else {
+ each_blocks[i] = create_each_block(child_ctx);
+ each_blocks[i].c();
+ transition_in(each_blocks[i], 1);
+ each_blocks[i].m(div, null);
+ }
+ }
+
+ group_outros();
+
+ for (i = each_value.length; i < each_blocks.length; i += 1) {
+ out(i);
+ }
+
+ check_outros();
+ }
+ },
+ i: function intro(local) {
+ if (current) return;
+
+ for (let i = 0; i < each_value.length; i += 1) {
+ transition_in(each_blocks[i]);
+ }
+
+ current = true;
+ },
+ o: function outro(local) {
+ each_blocks = each_blocks.filter(Boolean);
+
+ for (let i = 0; i < each_blocks.length; i += 1) {
+ transition_out(each_blocks[i]);
+ }
+
+ current = false;
+ },
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(div);
+ destroy_each(each_blocks, detaching);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment$4.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function instance$4($$self, $$props, $$invalidate) {
+ let _storedRecipes = [];
+ let _recipes = [];
+ let _filter = { "meat": "0", "meal": "0" };
+
+ state.recipes.subscribe(async v => {
+ _storedRecipes = v;
+ $$invalidate(0, _recipes = doFilter(_storedRecipes));
+ });
+
+ state.filter.subscribe(async v => {
+ _filter = v;
+ $$invalidate(0, _recipes = doFilter(_storedRecipes));
+ });
+
+ onMount(async () => {
+ await state.fetchRecipes();
+ });
+
+ function doFilter(v) {
+ const meatFilterMode = parseInt(_filter.meat, 10);
+ const mealFilterMode = parseInt(_filter.meal, 10);
+ const mealsFilter = v.filter(item => mealFilterMode === 0 || item.mealtype === mealFilterMode);
+ const meatsFilter = mealsFilter.filter(item => meatFilterMode === 0 || item.meat === meatFilterMode);
+
+ return meatsFilter.sort((a, b) => {
+ var shortA = a.short; // ignore upper and lowercase
+ var shortB = b.short; // ignore upper and lowercase
+
+ if (shortA < shortB) {
+ return -1;
+ }
+
+ if (shortA > shortB) {
+ return 1;
+ }
+
+ // names must be equal
+ return 0;
+ });
+ }
+
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("Recipes", $$slots, []);
+
+ $$self.$capture_state = () => ({
+ state,
+ onMount,
+ RecipeItem,
+ _storedRecipes,
+ _recipes,
+ _filter,
+ doFilter
+ });
+
+ $$self.$inject_state = $$props => {
+ if ("_storedRecipes" in $$props) _storedRecipes = $$props._storedRecipes;
+ if ("_recipes" in $$props) $$invalidate(0, _recipes = $$props._recipes);
+ if ("_filter" in $$props) _filter = $$props._filter;
+ };
+
+ if ($$props && "$$inject" in $$props) {
+ $$self.$inject_state($$props.$$inject);
+ }
+
+ return [_recipes];
+ }
+
+ class Recipes$1 extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$4, create_fragment$4, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "Recipes",
+ options,
+ id: create_fragment$4.name
+ });
+ }
+ }
+
+ /* src/components/Debug.svelte generated by Svelte v3.20.1 */
+
+ const { console: console_1$2 } = globals;
+
+ function create_fragment$5(ctx) {
+ const block = {
+ c: noop,
+ l: function claim(nodes) {
+ throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
+ },
+ m: noop,
+ p: noop,
+ i: noop,
+ o: noop,
+ d: noop
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment$5.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function instance$5($$self, $$props, $$invalidate) {
+ state.recipes.subscribe(async v => {
+ console.log(">> recipes", v);
+ });
+
+ state.currentItem.subscribe(async v => {
+ console.log(">> currentItem", v);
+ });
+
+ state.filter.subscribe(async v => {
+ console.log(">> filter", v);
+ });
+
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console_1$2.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("Debug", $$slots, []);
+ $$self.$capture_state = () => ({ state });
+ return [];
+ }
+
+ class Debug extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$5, create_fragment$5, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "Debug",
+ options,
+ id: create_fragment$5.name
+ });
+ }
+ }
+
+ /* src/App.svelte generated by Svelte v3.20.1 */
+ const file$5 = "src/App.svelte";
+
+ function create_fragment$6(ctx) {
+ let main;
+ let t0;
+ let t1;
+ let t2;
+ let current;
+ const header = new Header({ $$inline: true });
+ const editor = new Editor({ $$inline: true });
+ const filterbar = new FilterBar({ $$inline: true });
+ const recipes = new Recipes$1({ $$inline: true });
+
+ const block = {
+ c: function create() {
+ main = element("main");
+ create_component(header.$$.fragment);
+ t0 = space();
+ create_component(editor.$$.fragment);
+ t1 = space();
+ create_component(filterbar.$$.fragment);
+ t2 = space();
+ create_component(recipes.$$.fragment);
+ add_location(main, file$5, 15, 0, 313);
+ },
+ 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(header, main, null);
+ append_dev(main, t0);
+ mount_component(editor, main, null);
+ append_dev(main, t1);
+ mount_component(filterbar, main, null);
+ append_dev(main, t2);
+ mount_component(recipes, main, null);
+ current = true;
+ },
+ p: noop,
+ i: function intro(local) {
+ if (current) return;
+ transition_in(header.$$.fragment, local);
+ transition_in(editor.$$.fragment, local);
+ transition_in(filterbar.$$.fragment, local);
+ transition_in(recipes.$$.fragment, local);
+ current = true;
+ },
+ o: function outro(local) {
+ transition_out(header.$$.fragment, local);
+ transition_out(editor.$$.fragment, local);
+ transition_out(filterbar.$$.fragment, local);
+ transition_out(recipes.$$.fragment, local);
+ current = false;
+ },
+ d: function destroy(detaching) {
+ if (detaching) detach_dev(main);
+ destroy_component(header);
+ destroy_component(editor);
+ destroy_component(filterbar);
+ destroy_component(recipes);
+ }
+ };
+
+ dispatch_dev("SvelteRegisterBlock", {
+ block,
+ id: create_fragment$6.name,
+ type: "component",
+ source: "",
+ ctx
+ });
+
+ return block;
+ }
+
+ function instance$6($$self, $$props, $$invalidate) {
+ const writable_props = [];
+
+ Object.keys($$props).forEach(key => {
+ if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(` was created with unknown prop '${key}'`);
+ });
+
+ let { $$slots = {}, $$scope } = $$props;
+ validate_slots("App", $$slots, []);
+
+ $$self.$capture_state = () => ({
+ Header,
+ Editor,
+ FilterBar,
+ Recipes: Recipes$1,
+ Debug
+ });
+
+ return [];
+ }
+
+ class App extends SvelteComponentDev {
+ constructor(options) {
+ super(options);
+ init(this, options, instance$6, create_fragment$6, safe_not_equal, {});
+
+ dispatch_dev("SvelteRegisterComponent", {
+ component: this,
+ tagName: "App",
+ options,
+ id: create_fragment$6.name
+ });
+ }
+ }
+
+ const app = new App({
+ target: document.body,
+ props: {
+ name: 'world'
+ }
+ });
+
+ return app;
+
+}());
+//# sourceMappingURL=bundle.js.map
diff --git a/dist/build/bundle.js.map b/dist/build/bundle.js.map
new file mode 100644
index 0000000..49f4db3
--- /dev/null
+++ b/dist/build/bundle.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sources":["../../node_modules/svelte/internal/index.mjs","../../node_modules/svelte/store/index.mjs","../../node_modules/axios/lib/helpers/bind.js","../../node_modules/axios/lib/utils.js","../../node_modules/axios/lib/helpers/buildURL.js","../../node_modules/axios/lib/core/InterceptorManager.js","../../node_modules/axios/lib/core/transformData.js","../../node_modules/axios/lib/cancel/isCancel.js","../../node_modules/axios/lib/helpers/normalizeHeaderName.js","../../node_modules/axios/lib/core/enhanceError.js","../../node_modules/axios/lib/core/createError.js","../../node_modules/axios/lib/core/settle.js","../../node_modules/axios/lib/helpers/isAbsoluteURL.js","../../node_modules/axios/lib/helpers/combineURLs.js","../../node_modules/axios/lib/core/buildFullPath.js","../../node_modules/axios/lib/helpers/parseHeaders.js","../../node_modules/axios/lib/helpers/isURLSameOrigin.js","../../node_modules/axios/lib/helpers/cookies.js","../../node_modules/axios/lib/adapters/xhr.js","../../node_modules/axios/lib/defaults.js","../../node_modules/axios/lib/core/dispatchRequest.js","../../node_modules/axios/lib/core/mergeConfig.js","../../node_modules/axios/lib/core/Axios.js","../../node_modules/axios/lib/cancel/Cancel.js","../../node_modules/axios/lib/cancel/CancelToken.js","../../node_modules/axios/lib/helpers/spread.js","../../node_modules/axios/lib/axios.js","../../node_modules/axios/index.js","../../src/store/store.js","../../src/components/Header.svelte","../../node_modules/debounce/index.js","../../src/components/Editor.svelte","../../src/components/FilterBar.svelte","../../src/components/RecipeItem.svelte","../../src/components/Recipes.svelte","../../src/components/Debug.svelte","../../src/main.js"],"sourcesContent":["function noop() { }\nconst identity = x => x;\nfunction assign(tar, src) {\n // @ts-ignore\n for (const k in src)\n tar[k] = src[k];\n return tar;\n}\nfunction is_promise(value) {\n return value && typeof value === 'object' && typeof value.then === 'function';\n}\nfunction add_location(element, file, line, column, char) {\n element.__svelte_meta = {\n loc: { file, line, column, char }\n };\n}\nfunction run(fn) {\n return fn();\n}\nfunction blank_object() {\n return Object.create(null);\n}\nfunction run_all(fns) {\n fns.forEach(run);\n}\nfunction is_function(thing) {\n return typeof thing === 'function';\n}\nfunction safe_not_equal(a, b) {\n return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');\n}\nfunction not_equal(a, b) {\n return a != a ? b == b : a !== b;\n}\nfunction validate_store(store, name) {\n if (store != null && typeof store.subscribe !== 'function') {\n throw new Error(`'${name}' is not a store with a 'subscribe' method`);\n }\n}\nfunction subscribe(store, ...callbacks) {\n if (store == null) {\n return noop;\n }\n const unsub = store.subscribe(...callbacks);\n return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;\n}\nfunction get_store_value(store) {\n let value;\n subscribe(store, _ => value = _)();\n return value;\n}\nfunction component_subscribe(component, store, callback) {\n component.$$.on_destroy.push(subscribe(store, callback));\n}\nfunction create_slot(definition, ctx, $$scope, fn) {\n if (definition) {\n const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);\n return definition[0](slot_ctx);\n }\n}\nfunction get_slot_context(definition, ctx, $$scope, fn) {\n return definition[1] && fn\n ? assign($$scope.ctx.slice(), definition[1](fn(ctx)))\n : $$scope.ctx;\n}\nfunction get_slot_changes(definition, $$scope, dirty, fn) {\n if (definition[2] && fn) {\n const lets = definition[2](fn(dirty));\n if ($$scope.dirty === undefined) {\n return lets;\n }\n if (typeof lets === 'object') {\n const merged = [];\n const len = Math.max($$scope.dirty.length, lets.length);\n for (let i = 0; i < len; i += 1) {\n merged[i] = $$scope.dirty[i] | lets[i];\n }\n return merged;\n }\n return $$scope.dirty | lets;\n }\n return $$scope.dirty;\n}\nfunction exclude_internal_props(props) {\n const result = {};\n for (const k in props)\n if (k[0] !== '$')\n result[k] = props[k];\n return result;\n}\nfunction compute_rest_props(props, keys) {\n const rest = {};\n keys = new Set(keys);\n for (const k in props)\n if (!keys.has(k) && k[0] !== '$')\n rest[k] = props[k];\n return rest;\n}\nfunction once(fn) {\n let ran = false;\n return function (...args) {\n if (ran)\n return;\n ran = true;\n fn.call(this, ...args);\n };\n}\nfunction null_to_empty(value) {\n return value == null ? '' : value;\n}\nfunction set_store_value(store, ret, value = ret) {\n store.set(value);\n return ret;\n}\nconst has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);\nfunction action_destroyer(action_result) {\n return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;\n}\n\nconst is_client = typeof window !== 'undefined';\nlet now = is_client\n ? () => window.performance.now()\n : () => Date.now();\nlet raf = is_client ? cb => requestAnimationFrame(cb) : noop;\n// used internally for testing\nfunction set_now(fn) {\n now = fn;\n}\nfunction set_raf(fn) {\n raf = fn;\n}\n\nconst tasks = new Set();\nfunction run_tasks(now) {\n tasks.forEach(task => {\n if (!task.c(now)) {\n tasks.delete(task);\n task.f();\n }\n });\n if (tasks.size !== 0)\n raf(run_tasks);\n}\n/**\n * For testing purposes only!\n */\nfunction clear_loops() {\n tasks.clear();\n}\n/**\n * Creates a new task that runs on each raf frame\n * until it returns a falsy value or is aborted\n */\nfunction loop(callback) {\n let task;\n if (tasks.size === 0)\n raf(run_tasks);\n return {\n promise: new Promise(fulfill => {\n tasks.add(task = { c: callback, f: fulfill });\n }),\n abort() {\n tasks.delete(task);\n }\n };\n}\n\nfunction append(target, node) {\n target.appendChild(node);\n}\nfunction insert(target, node, anchor) {\n target.insertBefore(node, anchor || null);\n}\nfunction detach(node) {\n node.parentNode.removeChild(node);\n}\nfunction destroy_each(iterations, detaching) {\n for (let i = 0; i < iterations.length; i += 1) {\n if (iterations[i])\n iterations[i].d(detaching);\n }\n}\nfunction element(name) {\n return document.createElement(name);\n}\nfunction element_is(name, is) {\n return document.createElement(name, { is });\n}\nfunction object_without_properties(obj, exclude) {\n const target = {};\n for (const k in obj) {\n if (has_prop(obj, k)\n // @ts-ignore\n && exclude.indexOf(k) === -1) {\n // @ts-ignore\n target[k] = obj[k];\n }\n }\n return target;\n}\nfunction svg_element(name) {\n return document.createElementNS('http://www.w3.org/2000/svg', name);\n}\nfunction text(data) {\n return document.createTextNode(data);\n}\nfunction space() {\n return text(' ');\n}\nfunction empty() {\n return text('');\n}\nfunction listen(node, event, handler, options) {\n node.addEventListener(event, handler, options);\n return () => node.removeEventListener(event, handler, options);\n}\nfunction prevent_default(fn) {\n return function (event) {\n event.preventDefault();\n // @ts-ignore\n return fn.call(this, event);\n };\n}\nfunction stop_propagation(fn) {\n return function (event) {\n event.stopPropagation();\n // @ts-ignore\n return fn.call(this, event);\n };\n}\nfunction self(fn) {\n return function (event) {\n // @ts-ignore\n if (event.target === this)\n fn.call(this, event);\n };\n}\nfunction attr(node, attribute, value) {\n if (value == null)\n node.removeAttribute(attribute);\n else if (node.getAttribute(attribute) !== value)\n node.setAttribute(attribute, value);\n}\nfunction set_attributes(node, attributes) {\n // @ts-ignore\n const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);\n for (const key in attributes) {\n if (attributes[key] == null) {\n node.removeAttribute(key);\n }\n else if (key === 'style') {\n node.style.cssText = attributes[key];\n }\n else if (key === '__value' || descriptors[key] && descriptors[key].set) {\n node[key] = attributes[key];\n }\n else {\n attr(node, key, attributes[key]);\n }\n }\n}\nfunction set_svg_attributes(node, attributes) {\n for (const key in attributes) {\n attr(node, key, attributes[key]);\n }\n}\nfunction set_custom_element_data(node, prop, value) {\n if (prop in node) {\n node[prop] = value;\n }\n else {\n attr(node, prop, value);\n }\n}\nfunction xlink_attr(node, attribute, value) {\n node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);\n}\nfunction get_binding_group_value(group) {\n const value = [];\n for (let i = 0; i < group.length; i += 1) {\n if (group[i].checked)\n value.push(group[i].__value);\n }\n return value;\n}\nfunction to_number(value) {\n return value === '' ? undefined : +value;\n}\nfunction time_ranges_to_array(ranges) {\n const array = [];\n for (let i = 0; i < ranges.length; i += 1) {\n array.push({ start: ranges.start(i), end: ranges.end(i) });\n }\n return array;\n}\nfunction children(element) {\n return Array.from(element.childNodes);\n}\nfunction claim_element(nodes, name, attributes, svg) {\n for (let i = 0; i < nodes.length; i += 1) {\n const node = nodes[i];\n if (node.nodeName === name) {\n let j = 0;\n while (j < node.attributes.length) {\n const attribute = node.attributes[j];\n if (attributes[attribute.name]) {\n j++;\n }\n else {\n node.removeAttribute(attribute.name);\n }\n }\n return nodes.splice(i, 1)[0];\n }\n }\n return svg ? svg_element(name) : element(name);\n}\nfunction claim_text(nodes, data) {\n for (let i = 0; i < nodes.length; i += 1) {\n const node = nodes[i];\n if (node.nodeType === 3) {\n node.data = '' + data;\n return nodes.splice(i, 1)[0];\n }\n }\n return text(data);\n}\nfunction claim_space(nodes) {\n return claim_text(nodes, ' ');\n}\nfunction set_data(text, data) {\n data = '' + data;\n if (text.data !== data)\n text.data = data;\n}\nfunction set_input_value(input, value) {\n if (value != null || input.value) {\n input.value = value;\n }\n}\nfunction set_input_type(input, type) {\n try {\n input.type = type;\n }\n catch (e) {\n // do nothing\n }\n}\nfunction set_style(node, key, value, important) {\n node.style.setProperty(key, value, important ? 'important' : '');\n}\nfunction select_option(select, value) {\n for (let i = 0; i < select.options.length; i += 1) {\n const option = select.options[i];\n if (option.__value === value) {\n option.selected = true;\n return;\n }\n }\n}\nfunction select_options(select, value) {\n for (let i = 0; i < select.options.length; i += 1) {\n const option = select.options[i];\n option.selected = ~value.indexOf(option.__value);\n }\n}\nfunction select_value(select) {\n const selected_option = select.querySelector(':checked') || select.options[0];\n return selected_option && selected_option.__value;\n}\nfunction select_multiple_value(select) {\n return [].map.call(select.querySelectorAll(':checked'), option => option.__value);\n}\nfunction add_resize_listener(element, fn) {\n if (getComputedStyle(element).position === 'static') {\n element.style.position = 'relative';\n }\n const object = document.createElement('object');\n object.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1;');\n object.setAttribute('aria-hidden', 'true');\n object.type = 'text/html';\n object.tabIndex = -1;\n let win;\n object.onload = () => {\n win = object.contentDocument.defaultView;\n win.addEventListener('resize', fn);\n };\n if (/Trident/.test(navigator.userAgent)) {\n element.appendChild(object);\n object.data = 'about:blank';\n }\n else {\n object.data = 'about:blank';\n element.appendChild(object);\n }\n return {\n cancel: () => {\n win && win.removeEventListener && win.removeEventListener('resize', fn);\n element.removeChild(object);\n }\n };\n}\nfunction toggle_class(element, name, toggle) {\n element.classList[toggle ? 'add' : 'remove'](name);\n}\nfunction custom_event(type, detail) {\n const e = document.createEvent('CustomEvent');\n e.initCustomEvent(type, false, false, detail);\n return e;\n}\nfunction query_selector_all(selector, parent = document.body) {\n return Array.from(parent.querySelectorAll(selector));\n}\nclass HtmlTag {\n constructor(html, anchor = null) {\n this.e = element('div');\n this.a = anchor;\n this.u(html);\n }\n m(target, anchor = null) {\n for (let i = 0; i < this.n.length; i += 1) {\n insert(target, this.n[i], anchor);\n }\n this.t = target;\n }\n u(html) {\n this.e.innerHTML = html;\n this.n = Array.from(this.e.childNodes);\n }\n p(html) {\n this.d();\n this.u(html);\n this.m(this.t, this.a);\n }\n d() {\n this.n.forEach(detach);\n }\n}\n\nconst active_docs = new Set();\nlet active = 0;\n// https://github.com/darkskyapp/string-hash/blob/master/index.js\nfunction hash(str) {\n let hash = 5381;\n let i = str.length;\n while (i--)\n hash = ((hash << 5) - hash) ^ str.charCodeAt(i);\n return hash >>> 0;\n}\nfunction create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {\n const step = 16.666 / duration;\n let keyframes = '{\\n';\n for (let p = 0; p <= 1; p += step) {\n const t = a + (b - a) * ease(p);\n keyframes += p * 100 + `%{${fn(t, 1 - t)}}\\n`;\n }\n const rule = keyframes + `100% {${fn(b, 1 - b)}}\\n}`;\n const name = `__svelte_${hash(rule)}_${uid}`;\n const doc = node.ownerDocument;\n active_docs.add(doc);\n const stylesheet = doc.__svelte_stylesheet || (doc.__svelte_stylesheet = doc.head.appendChild(element('style')).sheet);\n const current_rules = doc.__svelte_rules || (doc.__svelte_rules = {});\n if (!current_rules[name]) {\n current_rules[name] = true;\n stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);\n }\n const animation = node.style.animation || '';\n node.style.animation = `${animation ? `${animation}, ` : ``}${name} ${duration}ms linear ${delay}ms 1 both`;\n active += 1;\n return name;\n}\nfunction delete_rule(node, name) {\n const previous = (node.style.animation || '').split(', ');\n const next = previous.filter(name\n ? anim => anim.indexOf(name) < 0 // remove specific animation\n : anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations\n );\n const deleted = previous.length - next.length;\n if (deleted) {\n node.style.animation = next.join(', ');\n active -= deleted;\n if (!active)\n clear_rules();\n }\n}\nfunction clear_rules() {\n raf(() => {\n if (active)\n return;\n active_docs.forEach(doc => {\n const stylesheet = doc.__svelte_stylesheet;\n let i = stylesheet.cssRules.length;\n while (i--)\n stylesheet.deleteRule(i);\n doc.__svelte_rules = {};\n });\n active_docs.clear();\n });\n}\n\nfunction create_animation(node, from, fn, params) {\n if (!from)\n return noop;\n const to = node.getBoundingClientRect();\n if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom)\n return noop;\n const { delay = 0, duration = 300, easing = identity, \n // @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?\n start: start_time = now() + delay, \n // @ts-ignore todo:\n end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params);\n let running = true;\n let started = false;\n let name;\n function start() {\n if (css) {\n name = create_rule(node, 0, 1, duration, delay, easing, css);\n }\n if (!delay) {\n started = true;\n }\n }\n function stop() {\n if (css)\n delete_rule(node, name);\n running = false;\n }\n loop(now => {\n if (!started && now >= start_time) {\n started = true;\n }\n if (started && now >= end) {\n tick(1, 0);\n stop();\n }\n if (!running) {\n return false;\n }\n if (started) {\n const p = now - start_time;\n const t = 0 + 1 * easing(p / duration);\n tick(t, 1 - t);\n }\n return true;\n });\n start();\n tick(0, 1);\n return stop;\n}\nfunction fix_position(node) {\n const style = getComputedStyle(node);\n if (style.position !== 'absolute' && style.position !== 'fixed') {\n const { width, height } = style;\n const a = node.getBoundingClientRect();\n node.style.position = 'absolute';\n node.style.width = width;\n node.style.height = height;\n add_transform(node, a);\n }\n}\nfunction add_transform(node, a) {\n const b = node.getBoundingClientRect();\n if (a.left !== b.left || a.top !== b.top) {\n const style = getComputedStyle(node);\n const transform = style.transform === 'none' ? '' : style.transform;\n node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;\n }\n}\n\nlet current_component;\nfunction set_current_component(component) {\n current_component = component;\n}\nfunction get_current_component() {\n if (!current_component)\n throw new Error(`Function called outside component initialization`);\n return current_component;\n}\nfunction beforeUpdate(fn) {\n get_current_component().$$.before_update.push(fn);\n}\nfunction onMount(fn) {\n get_current_component().$$.on_mount.push(fn);\n}\nfunction afterUpdate(fn) {\n get_current_component().$$.after_update.push(fn);\n}\nfunction onDestroy(fn) {\n get_current_component().$$.on_destroy.push(fn);\n}\nfunction createEventDispatcher() {\n const component = get_current_component();\n return (type, detail) => {\n const callbacks = component.$$.callbacks[type];\n if (callbacks) {\n // TODO are there situations where events could be dispatched\n // in a server (non-DOM) environment?\n const event = custom_event(type, detail);\n callbacks.slice().forEach(fn => {\n fn.call(component, event);\n });\n }\n };\n}\nfunction setContext(key, context) {\n get_current_component().$$.context.set(key, context);\n}\nfunction getContext(key) {\n return get_current_component().$$.context.get(key);\n}\n// TODO figure out if we still want to support\n// shorthand events, or if we want to implement\n// a real bubbling mechanism\nfunction bubble(component, event) {\n const callbacks = component.$$.callbacks[event.type];\n if (callbacks) {\n callbacks.slice().forEach(fn => fn(event));\n }\n}\n\nconst dirty_components = [];\nconst intros = { enabled: false };\nconst binding_callbacks = [];\nconst render_callbacks = [];\nconst flush_callbacks = [];\nconst resolved_promise = Promise.resolve();\nlet update_scheduled = false;\nfunction schedule_update() {\n if (!update_scheduled) {\n update_scheduled = true;\n resolved_promise.then(flush);\n }\n}\nfunction tick() {\n schedule_update();\n return resolved_promise;\n}\nfunction add_render_callback(fn) {\n render_callbacks.push(fn);\n}\nfunction add_flush_callback(fn) {\n flush_callbacks.push(fn);\n}\nlet flushing = false;\nconst seen_callbacks = new Set();\nfunction flush() {\n if (flushing)\n return;\n flushing = true;\n do {\n // first, call beforeUpdate functions\n // and update components\n for (let i = 0; i < dirty_components.length; i += 1) {\n const component = dirty_components[i];\n set_current_component(component);\n update(component.$$);\n }\n dirty_components.length = 0;\n while (binding_callbacks.length)\n binding_callbacks.pop()();\n // then, once components are updated, call\n // afterUpdate functions. This may cause\n // subsequent updates...\n for (let i = 0; i < render_callbacks.length; i += 1) {\n const callback = render_callbacks[i];\n if (!seen_callbacks.has(callback)) {\n // ...so guard against infinite loops\n seen_callbacks.add(callback);\n callback();\n }\n }\n render_callbacks.length = 0;\n } while (dirty_components.length);\n while (flush_callbacks.length) {\n flush_callbacks.pop()();\n }\n update_scheduled = false;\n flushing = false;\n seen_callbacks.clear();\n}\nfunction update($$) {\n if ($$.fragment !== null) {\n $$.update();\n run_all($$.before_update);\n const dirty = $$.dirty;\n $$.dirty = [-1];\n $$.fragment && $$.fragment.p($$.ctx, dirty);\n $$.after_update.forEach(add_render_callback);\n }\n}\n\nlet promise;\nfunction wait() {\n if (!promise) {\n promise = Promise.resolve();\n promise.then(() => {\n promise = null;\n });\n }\n return promise;\n}\nfunction dispatch(node, direction, kind) {\n node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));\n}\nconst outroing = new Set();\nlet outros;\nfunction group_outros() {\n outros = {\n r: 0,\n c: [],\n p: outros // parent group\n };\n}\nfunction check_outros() {\n if (!outros.r) {\n run_all(outros.c);\n }\n outros = outros.p;\n}\nfunction transition_in(block, local) {\n if (block && block.i) {\n outroing.delete(block);\n block.i(local);\n }\n}\nfunction transition_out(block, local, detach, callback) {\n if (block && block.o) {\n if (outroing.has(block))\n return;\n outroing.add(block);\n outros.c.push(() => {\n outroing.delete(block);\n if (callback) {\n if (detach)\n block.d(1);\n callback();\n }\n });\n block.o(local);\n }\n}\nconst null_transition = { duration: 0 };\nfunction create_in_transition(node, fn, params) {\n let config = fn(node, params);\n let running = false;\n let animation_name;\n let task;\n let uid = 0;\n function cleanup() {\n if (animation_name)\n delete_rule(node, animation_name);\n }\n function go() {\n const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n if (css)\n animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);\n tick(0, 1);\n const start_time = now() + delay;\n const end_time = start_time + duration;\n if (task)\n task.abort();\n running = true;\n add_render_callback(() => dispatch(node, true, 'start'));\n task = loop(now => {\n if (running) {\n if (now >= end_time) {\n tick(1, 0);\n dispatch(node, true, 'end');\n cleanup();\n return running = false;\n }\n if (now >= start_time) {\n const t = easing((now - start_time) / duration);\n tick(t, 1 - t);\n }\n }\n return running;\n });\n }\n let started = false;\n return {\n start() {\n if (started)\n return;\n delete_rule(node);\n if (is_function(config)) {\n config = config();\n wait().then(go);\n }\n else {\n go();\n }\n },\n invalidate() {\n started = false;\n },\n end() {\n if (running) {\n cleanup();\n running = false;\n }\n }\n };\n}\nfunction create_out_transition(node, fn, params) {\n let config = fn(node, params);\n let running = true;\n let animation_name;\n const group = outros;\n group.r += 1;\n function go() {\n const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n if (css)\n animation_name = create_rule(node, 1, 0, duration, delay, easing, css);\n const start_time = now() + delay;\n const end_time = start_time + duration;\n add_render_callback(() => dispatch(node, false, 'start'));\n loop(now => {\n if (running) {\n if (now >= end_time) {\n tick(0, 1);\n dispatch(node, false, 'end');\n if (!--group.r) {\n // this will result in `end()` being called,\n // so we don't need to clean up here\n run_all(group.c);\n }\n return false;\n }\n if (now >= start_time) {\n const t = easing((now - start_time) / duration);\n tick(1 - t, t);\n }\n }\n return running;\n });\n }\n if (is_function(config)) {\n wait().then(() => {\n // @ts-ignore\n config = config();\n go();\n });\n }\n else {\n go();\n }\n return {\n end(reset) {\n if (reset && config.tick) {\n config.tick(1, 0);\n }\n if (running) {\n if (animation_name)\n delete_rule(node, animation_name);\n running = false;\n }\n }\n };\n}\nfunction create_bidirectional_transition(node, fn, params, intro) {\n let config = fn(node, params);\n let t = intro ? 0 : 1;\n let running_program = null;\n let pending_program = null;\n let animation_name = null;\n function clear_animation() {\n if (animation_name)\n delete_rule(node, animation_name);\n }\n function init(program, duration) {\n const d = program.b - t;\n duration *= Math.abs(d);\n return {\n a: t,\n b: program.b,\n d,\n duration,\n start: program.start,\n end: program.start + duration,\n group: program.group\n };\n }\n function go(b) {\n const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n const program = {\n start: now() + delay,\n b\n };\n if (!b) {\n // @ts-ignore todo: improve typings\n program.group = outros;\n outros.r += 1;\n }\n if (running_program) {\n pending_program = program;\n }\n else {\n // if this is an intro, and there's a delay, we need to do\n // an initial tick and/or apply CSS animation immediately\n if (css) {\n clear_animation();\n animation_name = create_rule(node, t, b, duration, delay, easing, css);\n }\n if (b)\n tick(0, 1);\n running_program = init(program, duration);\n add_render_callback(() => dispatch(node, b, 'start'));\n loop(now => {\n if (pending_program && now > pending_program.start) {\n running_program = init(pending_program, duration);\n pending_program = null;\n dispatch(node, running_program.b, 'start');\n if (css) {\n clear_animation();\n animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);\n }\n }\n if (running_program) {\n if (now >= running_program.end) {\n tick(t = running_program.b, 1 - t);\n dispatch(node, running_program.b, 'end');\n if (!pending_program) {\n // we're done\n if (running_program.b) {\n // intro — we can tidy up immediately\n clear_animation();\n }\n else {\n // outro — needs to be coordinated\n if (!--running_program.group.r)\n run_all(running_program.group.c);\n }\n }\n running_program = null;\n }\n else if (now >= running_program.start) {\n const p = now - running_program.start;\n t = running_program.a + running_program.d * easing(p / running_program.duration);\n tick(t, 1 - t);\n }\n }\n return !!(running_program || pending_program);\n });\n }\n }\n return {\n run(b) {\n if (is_function(config)) {\n wait().then(() => {\n // @ts-ignore\n config = config();\n go(b);\n });\n }\n else {\n go(b);\n }\n },\n end() {\n clear_animation();\n running_program = pending_program = null;\n }\n };\n}\n\nfunction handle_promise(promise, info) {\n const token = info.token = {};\n function update(type, index, key, value) {\n if (info.token !== token)\n return;\n info.resolved = value;\n let child_ctx = info.ctx;\n if (key !== undefined) {\n child_ctx = child_ctx.slice();\n child_ctx[key] = value;\n }\n const block = type && (info.current = type)(child_ctx);\n let needs_flush = false;\n if (info.block) {\n if (info.blocks) {\n info.blocks.forEach((block, i) => {\n if (i !== index && block) {\n group_outros();\n transition_out(block, 1, 1, () => {\n info.blocks[i] = null;\n });\n check_outros();\n }\n });\n }\n else {\n info.block.d(1);\n }\n block.c();\n transition_in(block, 1);\n block.m(info.mount(), info.anchor);\n needs_flush = true;\n }\n info.block = block;\n if (info.blocks)\n info.blocks[index] = block;\n if (needs_flush) {\n flush();\n }\n }\n if (is_promise(promise)) {\n const current_component = get_current_component();\n promise.then(value => {\n set_current_component(current_component);\n update(info.then, 1, info.value, value);\n set_current_component(null);\n }, error => {\n set_current_component(current_component);\n update(info.catch, 2, info.error, error);\n set_current_component(null);\n });\n // if we previously had a then/catch block, destroy it\n if (info.current !== info.pending) {\n update(info.pending, 0);\n return true;\n }\n }\n else {\n if (info.current !== info.then) {\n update(info.then, 1, info.value, promise);\n return true;\n }\n info.resolved = promise;\n }\n}\n\nconst globals = (typeof window !== 'undefined' ? window : global);\n\nfunction destroy_block(block, lookup) {\n block.d(1);\n lookup.delete(block.key);\n}\nfunction outro_and_destroy_block(block, lookup) {\n transition_out(block, 1, 1, () => {\n lookup.delete(block.key);\n });\n}\nfunction fix_and_destroy_block(block, lookup) {\n block.f();\n destroy_block(block, lookup);\n}\nfunction fix_and_outro_and_destroy_block(block, lookup) {\n block.f();\n outro_and_destroy_block(block, lookup);\n}\nfunction update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {\n let o = old_blocks.length;\n let n = list.length;\n let i = o;\n const old_indexes = {};\n while (i--)\n old_indexes[old_blocks[i].key] = i;\n const new_blocks = [];\n const new_lookup = new Map();\n const deltas = new Map();\n i = n;\n while (i--) {\n const child_ctx = get_context(ctx, list, i);\n const key = get_key(child_ctx);\n let block = lookup.get(key);\n if (!block) {\n block = create_each_block(key, child_ctx);\n block.c();\n }\n else if (dynamic) {\n block.p(child_ctx, dirty);\n }\n new_lookup.set(key, new_blocks[i] = block);\n if (key in old_indexes)\n deltas.set(key, Math.abs(i - old_indexes[key]));\n }\n const will_move = new Set();\n const did_move = new Set();\n function insert(block) {\n transition_in(block, 1);\n block.m(node, next, lookup.has(block.key));\n lookup.set(block.key, block);\n next = block.first;\n n--;\n }\n while (o && n) {\n const new_block = new_blocks[n - 1];\n const old_block = old_blocks[o - 1];\n const new_key = new_block.key;\n const old_key = old_block.key;\n if (new_block === old_block) {\n // do nothing\n next = new_block.first;\n o--;\n n--;\n }\n else if (!new_lookup.has(old_key)) {\n // remove old block\n destroy(old_block, lookup);\n o--;\n }\n else if (!lookup.has(new_key) || will_move.has(new_key)) {\n insert(new_block);\n }\n else if (did_move.has(old_key)) {\n o--;\n }\n else if (deltas.get(new_key) > deltas.get(old_key)) {\n did_move.add(new_key);\n insert(new_block);\n }\n else {\n will_move.add(old_key);\n o--;\n }\n }\n while (o--) {\n const old_block = old_blocks[o];\n if (!new_lookup.has(old_block.key))\n destroy(old_block, lookup);\n }\n while (n)\n insert(new_blocks[n - 1]);\n return new_blocks;\n}\nfunction validate_each_keys(ctx, list, get_context, get_key) {\n const keys = new Set();\n for (let i = 0; i < list.length; i++) {\n const key = get_key(get_context(ctx, list, i));\n if (keys.has(key)) {\n throw new Error(`Cannot have duplicate keys in a keyed each`);\n }\n keys.add(key);\n }\n}\n\nfunction get_spread_update(levels, updates) {\n const update = {};\n const to_null_out = {};\n const accounted_for = { $$scope: 1 };\n let i = levels.length;\n while (i--) {\n const o = levels[i];\n const n = updates[i];\n if (n) {\n for (const key in o) {\n if (!(key in n))\n to_null_out[key] = 1;\n }\n for (const key in n) {\n if (!accounted_for[key]) {\n update[key] = n[key];\n accounted_for[key] = 1;\n }\n }\n levels[i] = n;\n }\n else {\n for (const key in o) {\n accounted_for[key] = 1;\n }\n }\n }\n for (const key in to_null_out) {\n if (!(key in update))\n update[key] = undefined;\n }\n return update;\n}\nfunction get_spread_object(spread_props) {\n return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};\n}\n\n// source: https://html.spec.whatwg.org/multipage/indices.html\nconst boolean_attributes = new Set([\n 'allowfullscreen',\n 'allowpaymentrequest',\n 'async',\n 'autofocus',\n 'autoplay',\n 'checked',\n 'controls',\n 'default',\n 'defer',\n 'disabled',\n 'formnovalidate',\n 'hidden',\n 'ismap',\n 'loop',\n 'multiple',\n 'muted',\n 'nomodule',\n 'novalidate',\n 'open',\n 'playsinline',\n 'readonly',\n 'required',\n 'reversed',\n 'selected'\n]);\n\nconst invalid_attribute_name_character = /[\\s'\">/=\\u{FDD0}-\\u{FDEF}\\u{FFFE}\\u{FFFF}\\u{1FFFE}\\u{1FFFF}\\u{2FFFE}\\u{2FFFF}\\u{3FFFE}\\u{3FFFF}\\u{4FFFE}\\u{4FFFF}\\u{5FFFE}\\u{5FFFF}\\u{6FFFE}\\u{6FFFF}\\u{7FFFE}\\u{7FFFF}\\u{8FFFE}\\u{8FFFF}\\u{9FFFE}\\u{9FFFF}\\u{AFFFE}\\u{AFFFF}\\u{BFFFE}\\u{BFFFF}\\u{CFFFE}\\u{CFFFF}\\u{DFFFE}\\u{DFFFF}\\u{EFFFE}\\u{EFFFF}\\u{FFFFE}\\u{FFFFF}\\u{10FFFE}\\u{10FFFF}]/u;\n// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n// https://infra.spec.whatwg.org/#noncharacter\nfunction spread(args, classes_to_add) {\n const attributes = Object.assign({}, ...args);\n if (classes_to_add) {\n if (attributes.class == null) {\n attributes.class = classes_to_add;\n }\n else {\n attributes.class += ' ' + classes_to_add;\n }\n }\n let str = '';\n Object.keys(attributes).forEach(name => {\n if (invalid_attribute_name_character.test(name))\n return;\n const value = attributes[name];\n if (value === true)\n str += \" \" + name;\n else if (boolean_attributes.has(name.toLowerCase())) {\n if (value)\n str += \" \" + name;\n }\n else if (value != null) {\n str += ` ${name}=\"${String(value).replace(/\"/g, '"').replace(/'/g, ''')}\"`;\n }\n });\n return str;\n}\nconst escaped = {\n '\"': '"',\n \"'\": ''',\n '&': '&',\n '<': '<',\n '>': '>'\n};\nfunction escape(html) {\n return String(html).replace(/[\"'&<>]/g, match => escaped[match]);\n}\nfunction each(items, fn) {\n let str = '';\n for (let i = 0; i < items.length; i += 1) {\n str += fn(items[i], i);\n }\n return str;\n}\nconst missing_component = {\n $$render: () => ''\n};\nfunction validate_component(component, name) {\n if (!component || !component.$$render) {\n if (name === 'svelte:component')\n name += ' this={...}';\n throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);\n }\n return component;\n}\nfunction debug(file, line, column, values) {\n console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console\n console.log(values); // eslint-disable-line no-console\n return '';\n}\nlet on_destroy;\nfunction create_ssr_component(fn) {\n function $$render(result, props, bindings, slots) {\n const parent_component = current_component;\n const $$ = {\n on_destroy,\n context: new Map(parent_component ? parent_component.$$.context : []),\n // these will be immediately discarded\n on_mount: [],\n before_update: [],\n after_update: [],\n callbacks: blank_object()\n };\n set_current_component({ $$ });\n const html = fn(result, props, bindings, slots);\n set_current_component(parent_component);\n return html;\n }\n return {\n render: (props = {}, options = {}) => {\n on_destroy = [];\n const result = { title: '', head: '', css: new Set() };\n const html = $$render(result, props, {}, options);\n run_all(on_destroy);\n return {\n html,\n css: {\n code: Array.from(result.css).map(css => css.code).join('\\n'),\n map: null // TODO\n },\n head: result.title + result.head\n };\n },\n $$render\n };\n}\nfunction add_attribute(name, value, boolean) {\n if (value == null || (boolean && !value))\n return '';\n return ` ${name}${value === true ? '' : `=${typeof value === 'string' ? JSON.stringify(escape(value)) : `\"${value}\"`}`}`;\n}\nfunction add_classes(classes) {\n return classes ? ` class=\"${classes}\"` : ``;\n}\n\nfunction bind(component, name, callback) {\n const index = component.$$.props[name];\n if (index !== undefined) {\n component.$$.bound[index] = callback;\n callback(component.$$.ctx[index]);\n }\n}\nfunction create_component(block) {\n block && block.c();\n}\nfunction claim_component(block, parent_nodes) {\n block && block.l(parent_nodes);\n}\nfunction mount_component(component, target, anchor) {\n const { fragment, on_mount, on_destroy, after_update } = component.$$;\n fragment && fragment.m(target, anchor);\n // onMount happens before the initial afterUpdate\n add_render_callback(() => {\n const new_on_destroy = on_mount.map(run).filter(is_function);\n if (on_destroy) {\n on_destroy.push(...new_on_destroy);\n }\n else {\n // Edge case - component was destroyed immediately,\n // most likely as a result of a binding initialising\n run_all(new_on_destroy);\n }\n component.$$.on_mount = [];\n });\n after_update.forEach(add_render_callback);\n}\nfunction destroy_component(component, detaching) {\n const $$ = component.$$;\n if ($$.fragment !== null) {\n run_all($$.on_destroy);\n $$.fragment && $$.fragment.d(detaching);\n // TODO null out other refs, including component.$$ (but need to\n // preserve final state?)\n $$.on_destroy = $$.fragment = null;\n $$.ctx = [];\n }\n}\nfunction make_dirty(component, i) {\n if (component.$$.dirty[0] === -1) {\n dirty_components.push(component);\n schedule_update();\n component.$$.dirty.fill(0);\n }\n component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));\n}\nfunction init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {\n const parent_component = current_component;\n set_current_component(component);\n const prop_values = options.props || {};\n const $$ = component.$$ = {\n fragment: null,\n ctx: null,\n // state\n props,\n update: noop,\n not_equal,\n bound: blank_object(),\n // lifecycle\n on_mount: [],\n on_destroy: [],\n before_update: [],\n after_update: [],\n context: new Map(parent_component ? parent_component.$$.context : []),\n // everything else\n callbacks: blank_object(),\n dirty\n };\n let ready = false;\n $$.ctx = instance\n ? instance(component, prop_values, (i, ret, ...rest) => {\n const value = rest.length ? rest[0] : ret;\n if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {\n if ($$.bound[i])\n $$.bound[i](value);\n if (ready)\n make_dirty(component, i);\n }\n return ret;\n })\n : [];\n $$.update();\n ready = true;\n run_all($$.before_update);\n // `false` as a special case of no DOM component\n $$.fragment = create_fragment ? create_fragment($$.ctx) : false;\n if (options.target) {\n if (options.hydrate) {\n const nodes = children(options.target);\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n $$.fragment && $$.fragment.l(nodes);\n nodes.forEach(detach);\n }\n else {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n $$.fragment && $$.fragment.c();\n }\n if (options.intro)\n transition_in(component.$$.fragment);\n mount_component(component, options.target, options.anchor);\n flush();\n }\n set_current_component(parent_component);\n}\nlet SvelteElement;\nif (typeof HTMLElement === 'function') {\n SvelteElement = class extends HTMLElement {\n constructor() {\n super();\n this.attachShadow({ mode: 'open' });\n }\n connectedCallback() {\n // @ts-ignore todo: improve typings\n for (const key in this.$$.slotted) {\n // @ts-ignore todo: improve typings\n this.appendChild(this.$$.slotted[key]);\n }\n }\n attributeChangedCallback(attr, _oldValue, newValue) {\n this[attr] = newValue;\n }\n $destroy() {\n destroy_component(this, 1);\n this.$destroy = noop;\n }\n $on(type, callback) {\n // TODO should this delegate to addEventListener?\n const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n callbacks.push(callback);\n return () => {\n const index = callbacks.indexOf(callback);\n if (index !== -1)\n callbacks.splice(index, 1);\n };\n }\n $set() {\n // overridden by instance, if it has props\n }\n };\n}\nclass SvelteComponent {\n $destroy() {\n destroy_component(this, 1);\n this.$destroy = noop;\n }\n $on(type, callback) {\n const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n callbacks.push(callback);\n return () => {\n const index = callbacks.indexOf(callback);\n if (index !== -1)\n callbacks.splice(index, 1);\n };\n }\n $set() {\n // overridden by instance, if it has props\n }\n}\n\nfunction dispatch_dev(type, detail) {\n document.dispatchEvent(custom_event(type, Object.assign({ version: '3.20.1' }, detail)));\n}\nfunction append_dev(target, node) {\n dispatch_dev(\"SvelteDOMInsert\", { target, node });\n append(target, node);\n}\nfunction insert_dev(target, node, anchor) {\n dispatch_dev(\"SvelteDOMInsert\", { target, node, anchor });\n insert(target, node, anchor);\n}\nfunction detach_dev(node) {\n dispatch_dev(\"SvelteDOMRemove\", { node });\n detach(node);\n}\nfunction detach_between_dev(before, after) {\n while (before.nextSibling && before.nextSibling !== after) {\n detach_dev(before.nextSibling);\n }\n}\nfunction detach_before_dev(after) {\n while (after.previousSibling) {\n detach_dev(after.previousSibling);\n }\n}\nfunction detach_after_dev(before) {\n while (before.nextSibling) {\n detach_dev(before.nextSibling);\n }\n}\nfunction listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {\n const modifiers = options === true ? [\"capture\"] : options ? Array.from(Object.keys(options)) : [];\n if (has_prevent_default)\n modifiers.push('preventDefault');\n if (has_stop_propagation)\n modifiers.push('stopPropagation');\n dispatch_dev(\"SvelteDOMAddEventListener\", { node, event, handler, modifiers });\n const dispose = listen(node, event, handler, options);\n return () => {\n dispatch_dev(\"SvelteDOMRemoveEventListener\", { node, event, handler, modifiers });\n dispose();\n };\n}\nfunction attr_dev(node, attribute, value) {\n attr(node, attribute, value);\n if (value == null)\n dispatch_dev(\"SvelteDOMRemoveAttribute\", { node, attribute });\n else\n dispatch_dev(\"SvelteDOMSetAttribute\", { node, attribute, value });\n}\nfunction prop_dev(node, property, value) {\n node[property] = value;\n dispatch_dev(\"SvelteDOMSetProperty\", { node, property, value });\n}\nfunction dataset_dev(node, property, value) {\n node.dataset[property] = value;\n dispatch_dev(\"SvelteDOMSetDataset\", { node, property, value });\n}\nfunction set_data_dev(text, data) {\n data = '' + data;\n if (text.data === data)\n return;\n dispatch_dev(\"SvelteDOMSetData\", { node: text, data });\n text.data = data;\n}\nfunction validate_each_argument(arg) {\n if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {\n let msg = '{#each} only iterates over array-like objects.';\n if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {\n msg += ' You can use a spread to convert this iterable into an array.';\n }\n throw new Error(msg);\n }\n}\nfunction validate_slots(name, slot, keys) {\n for (const slot_key of Object.keys(slot)) {\n if (!~keys.indexOf(slot_key)) {\n console.warn(`<${name}> received an unexpected slot \"${slot_key}\".`);\n }\n }\n}\nclass SvelteComponentDev extends SvelteComponent {\n constructor(options) {\n if (!options || (!options.target && !options.$$inline)) {\n throw new Error(`'target' is a required option`);\n }\n super();\n }\n $destroy() {\n super.$destroy();\n this.$destroy = () => {\n console.warn(`Component was already destroyed`); // eslint-disable-line no-console\n };\n }\n $capture_state() { }\n $inject_state() { }\n}\nfunction loop_guard(timeout) {\n const start = Date.now();\n return () => {\n if (Date.now() - start > timeout) {\n throw new Error(`Infinite loop detected`);\n }\n };\n}\n\nexport { HtmlTag, SvelteComponent, SvelteComponentDev, SvelteElement, action_destroyer, add_attribute, add_classes, add_flush_callback, add_location, add_render_callback, add_resize_listener, add_transform, afterUpdate, append, append_dev, assign, attr, attr_dev, beforeUpdate, bind, binding_callbacks, blank_object, bubble, check_outros, children, claim_component, claim_element, claim_space, claim_text, clear_loops, component_subscribe, compute_rest_props, createEventDispatcher, create_animation, create_bidirectional_transition, create_component, create_in_transition, create_out_transition, create_slot, create_ssr_component, current_component, custom_event, dataset_dev, debug, destroy_block, destroy_component, destroy_each, detach, detach_after_dev, detach_before_dev, detach_between_dev, detach_dev, dirty_components, dispatch_dev, each, element, element_is, empty, escape, escaped, exclude_internal_props, fix_and_destroy_block, fix_and_outro_and_destroy_block, fix_position, flush, getContext, get_binding_group_value, get_current_component, get_slot_changes, get_slot_context, get_spread_object, get_spread_update, get_store_value, globals, group_outros, handle_promise, has_prop, identity, init, insert, insert_dev, intros, invalid_attribute_name_character, is_client, is_function, is_promise, listen, listen_dev, loop, loop_guard, missing_component, mount_component, noop, not_equal, now, null_to_empty, object_without_properties, onDestroy, onMount, once, outro_and_destroy_block, prevent_default, prop_dev, query_selector_all, raf, run, run_all, safe_not_equal, schedule_update, select_multiple_value, select_option, select_options, select_value, self, setContext, set_attributes, set_current_component, set_custom_element_data, set_data, set_data_dev, set_input_type, set_input_value, set_now, set_raf, set_store_value, set_style, set_svg_attributes, space, spread, stop_propagation, subscribe, svg_element, text, tick, time_ranges_to_array, to_number, toggle_class, transition_in, transition_out, update_keyed_each, validate_component, validate_each_argument, validate_each_keys, validate_slots, validate_store, xlink_attr };\n","import { noop, safe_not_equal, subscribe, run_all, is_function } from '../internal';\nexport { get_store_value as get } from '../internal';\n\nconst subscriber_queue = [];\n/**\n * Creates a `Readable` store that allows reading by subscription.\n * @param value initial value\n * @param {StartStopNotifier}start start and stop notifications for subscriptions\n */\nfunction readable(value, start) {\n return {\n subscribe: writable(value, start).subscribe,\n };\n}\n/**\n * Create a `Writable` store that allows both updating and reading by subscription.\n * @param {*=}value initial value\n * @param {StartStopNotifier=}start start and stop notifications for subscriptions\n */\nfunction writable(value, start = noop) {\n let stop;\n const subscribers = [];\n function set(new_value) {\n if (safe_not_equal(value, new_value)) {\n value = new_value;\n if (stop) { // store is ready\n const run_queue = !subscriber_queue.length;\n for (let i = 0; i < subscribers.length; i += 1) {\n const s = subscribers[i];\n s[1]();\n subscriber_queue.push(s, value);\n }\n if (run_queue) {\n for (let i = 0; i < subscriber_queue.length; i += 2) {\n subscriber_queue[i][0](subscriber_queue[i + 1]);\n }\n subscriber_queue.length = 0;\n }\n }\n }\n }\n function update(fn) {\n set(fn(value));\n }\n function subscribe(run, invalidate = noop) {\n const subscriber = [run, invalidate];\n subscribers.push(subscriber);\n if (subscribers.length === 1) {\n stop = start(set) || noop;\n }\n run(value);\n return () => {\n const index = subscribers.indexOf(subscriber);\n if (index !== -1) {\n subscribers.splice(index, 1);\n }\n if (subscribers.length === 0) {\n stop();\n stop = null;\n }\n };\n }\n return { set, update, subscribe };\n}\nfunction derived(stores, fn, initial_value) {\n const single = !Array.isArray(stores);\n const stores_array = single\n ? [stores]\n : stores;\n const auto = fn.length < 2;\n return readable(initial_value, (set) => {\n let inited = false;\n const values = [];\n let pending = 0;\n let cleanup = noop;\n const sync = () => {\n if (pending) {\n return;\n }\n cleanup();\n const result = fn(single ? values[0] : values, set);\n if (auto) {\n set(result);\n }\n else {\n cleanup = is_function(result) ? result : noop;\n }\n };\n const unsubscribers = stores_array.map((store, i) => subscribe(store, (value) => {\n values[i] = value;\n pending &= ~(1 << i);\n if (inited) {\n sync();\n }\n }, () => {\n pending |= (1 << i);\n }));\n inited = true;\n sync();\n return function stop() {\n run_all(unsubscribers);\n cleanup();\n };\n });\n}\n\nexport { derived, readable, writable };\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","'use strict';\n\nvar bind = require('./helpers/bind');\n\n/*global toString:true*/\n\n// utils is a library of generic helper functions non-specific to axios\n\nvar toString = Object.prototype.toString;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Array, otherwise false\n */\nfunction isArray(val) {\n return toString.call(val) === '[object Array]';\n}\n\n/**\n * Determine if a value is undefined\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nfunction isUndefined(val) {\n return typeof val === 'undefined';\n}\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nfunction isArrayBuffer(val) {\n return toString.call(val) === '[object ArrayBuffer]';\n}\n\n/**\n * Determine if a value is a FormData\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nfunction isFormData(val) {\n return (typeof FormData !== 'undefined') && (val instanceof FormData);\n}\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n var result;\n if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n result = ArrayBuffer.isView(val);\n } else {\n result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);\n }\n return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a String, otherwise false\n */\nfunction isString(val) {\n return typeof val === 'string';\n}\n\n/**\n * Determine if a value is a Number\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Number, otherwise false\n */\nfunction isNumber(val) {\n return typeof val === 'number';\n}\n\n/**\n * Determine if a value is an Object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is an Object, otherwise false\n */\nfunction isObject(val) {\n return val !== null && typeof val === 'object';\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Date, otherwise false\n */\nfunction isDate(val) {\n return toString.call(val) === '[object Date]';\n}\n\n/**\n * Determine if a value is a File\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a File, otherwise false\n */\nfunction isFile(val) {\n return toString.call(val) === '[object File]';\n}\n\n/**\n * Determine if a value is a Blob\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nfunction isBlob(val) {\n return toString.call(val) === '[object Blob]';\n}\n\n/**\n * Determine if a value is a Function\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nfunction isFunction(val) {\n return toString.call(val) === '[object Function]';\n}\n\n/**\n * Determine if a value is a Stream\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nfunction isStream(val) {\n return isObject(val) && isFunction(val.pipe);\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {Object} val The value to test\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nfunction isURLSearchParams(val) {\n return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;\n}\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n * @returns {String} The String freed of excess whitespace\n */\nfunction trim(str) {\n return str.replace(/^\\s*/, '').replace(/\\s*$/, '');\n}\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n * typeof window -> undefined\n * typeof document -> undefined\n *\n * react-native:\n * navigator.product -> 'ReactNative'\n * nativescript\n * navigator.product -> 'NativeScript' or 'NS'\n */\nfunction isStandardBrowserEnv() {\n if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||\n navigator.product === 'NativeScript' ||\n navigator.product === 'NS')) {\n return false;\n }\n return (\n typeof window !== 'undefined' &&\n typeof document !== 'undefined'\n );\n}\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n */\nfunction forEach(obj, fn) {\n // Don't bother if no value provided\n if (obj === null || typeof obj === 'undefined') {\n return;\n }\n\n // Force an array if not already something iterable\n if (typeof obj !== 'object') {\n /*eslint no-param-reassign:0*/\n obj = [obj];\n }\n\n if (isArray(obj)) {\n // Iterate over array values\n for (var i = 0, l = obj.length; i < l; i++) {\n fn.call(null, obj[i], i, obj);\n }\n } else {\n // Iterate over object keys\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n fn.call(null, obj[key], key, obj);\n }\n }\n }\n}\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = merge(result[key], val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Function equal to merge with the difference being that no reference\n * to original objects is kept.\n *\n * @see merge\n * @param {Object} obj1 Object to merge\n * @returns {Object} Result of all merge properties\n */\nfunction deepMerge(/* obj1, obj2, obj3, ... */) {\n var result = {};\n function assignValue(val, key) {\n if (typeof result[key] === 'object' && typeof val === 'object') {\n result[key] = deepMerge(result[key], val);\n } else if (typeof val === 'object') {\n result[key] = deepMerge({}, val);\n } else {\n result[key] = val;\n }\n }\n\n for (var i = 0, l = arguments.length; i < l; i++) {\n forEach(arguments[i], assignValue);\n }\n return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n * @return {Object} The resulting value of object a\n */\nfunction extend(a, b, thisArg) {\n forEach(b, function assignValue(val, key) {\n if (thisArg && typeof val === 'function') {\n a[key] = bind(val, thisArg);\n } else {\n a[key] = val;\n }\n });\n return a;\n}\n\nmodule.exports = {\n isArray: isArray,\n isArrayBuffer: isArrayBuffer,\n isBuffer: isBuffer,\n isFormData: isFormData,\n isArrayBufferView: isArrayBufferView,\n isString: isString,\n isNumber: isNumber,\n isObject: isObject,\n isUndefined: isUndefined,\n isDate: isDate,\n isFile: isFile,\n isBlob: isBlob,\n isFunction: isFunction,\n isStream: isStream,\n isURLSearchParams: isURLSearchParams,\n isStandardBrowserEnv: isStandardBrowserEnv,\n forEach: forEach,\n merge: merge,\n deepMerge: deepMerge,\n extend: extend,\n trim: trim\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction encode(val) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace(/%20/g, '+').\n replace(/%5B/gi, '[').\n replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @returns {string} The formatted url\n */\nmodule.exports = function buildURL(url, params, paramsSerializer) {\n /*eslint no-param-reassign:0*/\n if (!params) {\n return url;\n }\n\n var serializedParams;\n if (paramsSerializer) {\n serializedParams = paramsSerializer(params);\n } else if (utils.isURLSearchParams(params)) {\n serializedParams = params.toString();\n } else {\n var parts = [];\n\n utils.forEach(params, function serialize(val, key) {\n if (val === null || typeof val === 'undefined') {\n return;\n }\n\n if (utils.isArray(val)) {\n key = key + '[]';\n } else {\n val = [val];\n }\n\n utils.forEach(val, function parseValue(v) {\n if (utils.isDate(v)) {\n v = v.toISOString();\n } else if (utils.isObject(v)) {\n v = JSON.stringify(v);\n }\n parts.push(encode(key) + '=' + encode(v));\n });\n });\n\n serializedParams = parts.join('&');\n }\n\n if (serializedParams) {\n var hashmarkIndex = url.indexOf('#');\n if (hashmarkIndex !== -1) {\n url = url.slice(0, hashmarkIndex);\n }\n\n url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n }\n\n return url;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nfunction InterceptorManager() {\n this.handlers = [];\n}\n\n/**\n * Add a new interceptor to the stack\n *\n * @param {Function} fulfilled The function to handle `then` for a `Promise`\n * @param {Function} rejected The function to handle `reject` for a `Promise`\n *\n * @return {Number} An ID used to remove interceptor later\n */\nInterceptorManager.prototype.use = function use(fulfilled, rejected) {\n this.handlers.push({\n fulfilled: fulfilled,\n rejected: rejected\n });\n return this.handlers.length - 1;\n};\n\n/**\n * Remove an interceptor from the stack\n *\n * @param {Number} id The ID that was returned by `use`\n */\nInterceptorManager.prototype.eject = function eject(id) {\n if (this.handlers[id]) {\n this.handlers[id] = null;\n }\n};\n\n/**\n * Iterate over all the registered interceptors\n *\n * This method is particularly useful for skipping over any\n * interceptors that may have become `null` calling `eject`.\n *\n * @param {Function} fn The function to call for each interceptor\n */\nInterceptorManager.prototype.forEach = function forEach(fn) {\n utils.forEach(this.handlers, function forEachHandler(h) {\n if (h !== null) {\n fn(h);\n }\n });\n};\n\nmodule.exports = InterceptorManager;\n","'use strict';\n\nvar utils = require('./../utils');\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Object|String} data The data to be transformed\n * @param {Array} headers The headers for the request or response\n * @param {Array|Function} fns A single function or Array of functions\n * @returns {*} The resulting transformed data\n */\nmodule.exports = function transformData(data, headers, fns) {\n /*eslint no-param-reassign:0*/\n utils.forEach(fns, function transform(fn) {\n data = fn(data, headers);\n });\n\n return data;\n};\n","'use strict';\n\nmodule.exports = function isCancel(value) {\n return !!(value && value.__CANCEL__);\n};\n","'use strict';\n\nvar utils = require('../utils');\n\nmodule.exports = function normalizeHeaderName(headers, normalizedName) {\n utils.forEach(headers, function processHeader(value, name) {\n if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {\n headers[normalizedName] = value;\n delete headers[name];\n }\n });\n};\n","'use strict';\n\n/**\n * Update an Error with the specified config, error code, and response.\n *\n * @param {Error} error The error to update.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The error.\n */\nmodule.exports = function enhanceError(error, config, code, request, response) {\n error.config = config;\n if (code) {\n error.code = code;\n }\n\n error.request = request;\n error.response = response;\n error.isAxiosError = true;\n\n error.toJSON = function() {\n return {\n // Standard\n message: this.message,\n name: this.name,\n // Microsoft\n description: this.description,\n number: this.number,\n // Mozilla\n fileName: this.fileName,\n lineNumber: this.lineNumber,\n columnNumber: this.columnNumber,\n stack: this.stack,\n // Axios\n config: this.config,\n code: this.code\n };\n };\n return error;\n};\n","'use strict';\n\nvar enhanceError = require('./enhanceError');\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {Object} config The config.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n * @returns {Error} The created error.\n */\nmodule.exports = function createError(message, config, code, request, response) {\n var error = new Error(message);\n return enhanceError(error, config, code, request, response);\n};\n","'use strict';\n\nvar createError = require('./createError');\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n */\nmodule.exports = function settle(resolve, reject, response) {\n var validateStatus = response.config.validateStatus;\n if (!validateStatus || validateStatus(response.status)) {\n resolve(response);\n } else {\n reject(createError(\n 'Request failed with status code ' + response.status,\n response.config,\n null,\n response.request,\n response\n ));\n }\n};\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nmodule.exports = function isAbsoluteURL(url) {\n // A URL is considered absolute if it begins with \"://\" or \"//\" (protocol-relative URL).\n // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n // by any combination of letters, digits, plus, period, or hyphen.\n return /^([a-z][a-z\\d\\+\\-\\.]*:)?\\/\\//i.test(url);\n};\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n * @returns {string} The combined URL\n */\nmodule.exports = function combineURLs(baseURL, relativeURL) {\n return relativeURL\n ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n : baseURL;\n};\n","'use strict';\n\nvar isAbsoluteURL = require('../helpers/isAbsoluteURL');\nvar combineURLs = require('../helpers/combineURLs');\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n * @returns {string} The combined full path\n */\nmodule.exports = function buildFullPath(baseURL, requestedURL) {\n if (baseURL && !isAbsoluteURL(requestedURL)) {\n return combineURLs(baseURL, requestedURL);\n }\n return requestedURL;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\n// Headers whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nvar ignoreDuplicateOf = [\n 'age', 'authorization', 'content-length', 'content-type', 'etag',\n 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n 'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n 'referer', 'retry-after', 'user-agent'\n];\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} headers Headers needing to be parsed\n * @returns {Object} Headers parsed into an object\n */\nmodule.exports = function parseHeaders(headers) {\n var parsed = {};\n var key;\n var val;\n var i;\n\n if (!headers) { return parsed; }\n\n utils.forEach(headers.split('\\n'), function parser(line) {\n i = line.indexOf(':');\n key = utils.trim(line.substr(0, i)).toLowerCase();\n val = utils.trim(line.substr(i + 1));\n\n if (key) {\n if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {\n return;\n }\n if (key === 'set-cookie') {\n parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);\n } else {\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n }\n }\n });\n\n return parsed;\n};\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs have full support of the APIs needed to test\n // whether the request URL is of the same origin as current location.\n (function standardBrowserEnv() {\n var msie = /(msie|trident)/i.test(navigator.userAgent);\n var urlParsingNode = document.createElement('a');\n var originURL;\n\n /**\n * Parse a URL to discover it's components\n *\n * @param {String} url The URL to be parsed\n * @returns {Object}\n */\n function resolveURL(url) {\n var href = url;\n\n if (msie) {\n // IE needs attribute set twice to normalize properties\n urlParsingNode.setAttribute('href', href);\n href = urlParsingNode.href;\n }\n\n urlParsingNode.setAttribute('href', href);\n\n // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n return {\n href: urlParsingNode.href,\n protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n host: urlParsingNode.host,\n search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n hostname: urlParsingNode.hostname,\n port: urlParsingNode.port,\n pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n urlParsingNode.pathname :\n '/' + urlParsingNode.pathname\n };\n }\n\n originURL = resolveURL(window.location.href);\n\n /**\n * Determine if a URL shares the same origin as the current location\n *\n * @param {String} requestURL The URL to test\n * @returns {boolean} True if URL shares the same origin, otherwise false\n */\n return function isURLSameOrigin(requestURL) {\n var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n return (parsed.protocol === originURL.protocol &&\n parsed.host === originURL.host);\n };\n })() :\n\n // Non standard browser envs (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return function isURLSameOrigin() {\n return true;\n };\n })()\n);\n","'use strict';\n\nvar utils = require('./../utils');\n\nmodule.exports = (\n utils.isStandardBrowserEnv() ?\n\n // Standard browser envs support document.cookie\n (function standardBrowserEnv() {\n return {\n write: function write(name, value, expires, path, domain, secure) {\n var cookie = [];\n cookie.push(name + '=' + encodeURIComponent(value));\n\n if (utils.isNumber(expires)) {\n cookie.push('expires=' + new Date(expires).toGMTString());\n }\n\n if (utils.isString(path)) {\n cookie.push('path=' + path);\n }\n\n if (utils.isString(domain)) {\n cookie.push('domain=' + domain);\n }\n\n if (secure === true) {\n cookie.push('secure');\n }\n\n document.cookie = cookie.join('; ');\n },\n\n read: function read(name) {\n var match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n return (match ? decodeURIComponent(match[3]) : null);\n },\n\n remove: function remove(name) {\n this.write(name, '', Date.now() - 86400000);\n }\n };\n })() :\n\n // Non standard browser env (web workers, react-native) lack needed support.\n (function nonStandardBrowserEnv() {\n return {\n write: function write() {},\n read: function read() { return null; },\n remove: function remove() {}\n };\n })()\n);\n","'use strict';\n\nvar utils = require('./../utils');\nvar settle = require('./../core/settle');\nvar buildURL = require('./../helpers/buildURL');\nvar buildFullPath = require('../core/buildFullPath');\nvar parseHeaders = require('./../helpers/parseHeaders');\nvar isURLSameOrigin = require('./../helpers/isURLSameOrigin');\nvar createError = require('../core/createError');\n\nmodule.exports = function xhrAdapter(config) {\n return new Promise(function dispatchXhrRequest(resolve, reject) {\n var requestData = config.data;\n var requestHeaders = config.headers;\n\n if (utils.isFormData(requestData)) {\n delete requestHeaders['Content-Type']; // Let the browser set it\n }\n\n var request = new XMLHttpRequest();\n\n // HTTP basic authentication\n if (config.auth) {\n var username = config.auth.username || '';\n var password = config.auth.password || '';\n requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);\n }\n\n var fullPath = buildFullPath(config.baseURL, config.url);\n request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n // Set the request timeout in MS\n request.timeout = config.timeout;\n\n // Listen for ready state\n request.onreadystatechange = function handleLoad() {\n if (!request || request.readyState !== 4) {\n return;\n }\n\n // The request errored out and we didn't get a response, this will be\n // handled by onerror instead\n // With one exception: request that using file: protocol, most browsers\n // will return status as 0 even though it's a successful request\n if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n return;\n }\n\n // Prepare the response\n var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;\n var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;\n var response = {\n data: responseData,\n status: request.status,\n statusText: request.statusText,\n headers: responseHeaders,\n config: config,\n request: request\n };\n\n settle(resolve, reject, response);\n\n // Clean up request\n request = null;\n };\n\n // Handle browser request cancellation (as opposed to a manual cancellation)\n request.onabort = function handleAbort() {\n if (!request) {\n return;\n }\n\n reject(createError('Request aborted', config, 'ECONNABORTED', request));\n\n // Clean up request\n request = null;\n };\n\n // Handle low level network errors\n request.onerror = function handleError() {\n // Real errors are hidden from us by the browser\n // onerror should only fire if it's a network error\n reject(createError('Network Error', config, null, request));\n\n // Clean up request\n request = null;\n };\n\n // Handle timeout\n request.ontimeout = function handleTimeout() {\n var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';\n if (config.timeoutErrorMessage) {\n timeoutErrorMessage = config.timeoutErrorMessage;\n }\n reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',\n request));\n\n // Clean up request\n request = null;\n };\n\n // Add xsrf header\n // This is only done if running in a standard browser environment.\n // Specifically not if we're in a web worker, or react-native.\n if (utils.isStandardBrowserEnv()) {\n var cookies = require('./../helpers/cookies');\n\n // Add xsrf header\n var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?\n cookies.read(config.xsrfCookieName) :\n undefined;\n\n if (xsrfValue) {\n requestHeaders[config.xsrfHeaderName] = xsrfValue;\n }\n }\n\n // Add headers to the request\n if ('setRequestHeader' in request) {\n utils.forEach(requestHeaders, function setRequestHeader(val, key) {\n if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {\n // Remove Content-Type if data is undefined\n delete requestHeaders[key];\n } else {\n // Otherwise add header to the request\n request.setRequestHeader(key, val);\n }\n });\n }\n\n // Add withCredentials to request if needed\n if (!utils.isUndefined(config.withCredentials)) {\n request.withCredentials = !!config.withCredentials;\n }\n\n // Add responseType to request if needed\n if (config.responseType) {\n try {\n request.responseType = config.responseType;\n } catch (e) {\n // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.\n // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.\n if (config.responseType !== 'json') {\n throw e;\n }\n }\n }\n\n // Handle progress if needed\n if (typeof config.onDownloadProgress === 'function') {\n request.addEventListener('progress', config.onDownloadProgress);\n }\n\n // Not all browsers support upload events\n if (typeof config.onUploadProgress === 'function' && request.upload) {\n request.upload.addEventListener('progress', config.onUploadProgress);\n }\n\n if (config.cancelToken) {\n // Handle cancellation\n config.cancelToken.promise.then(function onCanceled(cancel) {\n if (!request) {\n return;\n }\n\n request.abort();\n reject(cancel);\n // Clean up request\n request = null;\n });\n }\n\n if (requestData === undefined) {\n requestData = null;\n }\n\n // Send the request\n request.send(requestData);\n });\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar normalizeHeaderName = require('./helpers/normalizeHeaderName');\n\nvar DEFAULT_CONTENT_TYPE = {\n 'Content-Type': 'application/x-www-form-urlencoded'\n};\n\nfunction setContentTypeIfUnset(headers, value) {\n if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {\n headers['Content-Type'] = value;\n }\n}\n\nfunction getDefaultAdapter() {\n var adapter;\n if (typeof XMLHttpRequest !== 'undefined') {\n // For browsers use XHR adapter\n adapter = require('./adapters/xhr');\n } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {\n // For node use HTTP adapter\n adapter = require('./adapters/http');\n }\n return adapter;\n}\n\nvar defaults = {\n adapter: getDefaultAdapter(),\n\n transformRequest: [function transformRequest(data, headers) {\n normalizeHeaderName(headers, 'Accept');\n normalizeHeaderName(headers, 'Content-Type');\n if (utils.isFormData(data) ||\n utils.isArrayBuffer(data) ||\n utils.isBuffer(data) ||\n utils.isStream(data) ||\n utils.isFile(data) ||\n utils.isBlob(data)\n ) {\n return data;\n }\n if (utils.isArrayBufferView(data)) {\n return data.buffer;\n }\n if (utils.isURLSearchParams(data)) {\n setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');\n return data.toString();\n }\n if (utils.isObject(data)) {\n setContentTypeIfUnset(headers, 'application/json;charset=utf-8');\n return JSON.stringify(data);\n }\n return data;\n }],\n\n transformResponse: [function transformResponse(data) {\n /*eslint no-param-reassign:0*/\n if (typeof data === 'string') {\n try {\n data = JSON.parse(data);\n } catch (e) { /* Ignore */ }\n }\n return data;\n }],\n\n /**\n * A timeout in milliseconds to abort a request. If set to 0 (default) a\n * timeout is not created.\n */\n timeout: 0,\n\n xsrfCookieName: 'XSRF-TOKEN',\n xsrfHeaderName: 'X-XSRF-TOKEN',\n\n maxContentLength: -1,\n\n validateStatus: function validateStatus(status) {\n return status >= 200 && status < 300;\n }\n};\n\ndefaults.headers = {\n common: {\n 'Accept': 'application/json, text/plain, */*'\n }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nmodule.exports = defaults;\n","'use strict';\n\nvar utils = require('./../utils');\nvar transformData = require('./transformData');\nvar isCancel = require('../cancel/isCancel');\nvar defaults = require('../defaults');\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nfunction throwIfCancellationRequested(config) {\n if (config.cancelToken) {\n config.cancelToken.throwIfRequested();\n }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n * @returns {Promise} The Promise to be fulfilled\n */\nmodule.exports = function dispatchRequest(config) {\n throwIfCancellationRequested(config);\n\n // Ensure headers exist\n config.headers = config.headers || {};\n\n // Transform request data\n config.data = transformData(\n config.data,\n config.headers,\n config.transformRequest\n );\n\n // Flatten headers\n config.headers = utils.merge(\n config.headers.common || {},\n config.headers[config.method] || {},\n config.headers\n );\n\n utils.forEach(\n ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n function cleanHeaderConfig(method) {\n delete config.headers[method];\n }\n );\n\n var adapter = config.adapter || defaults.adapter;\n\n return adapter(config).then(function onAdapterResolution(response) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n response.data = transformData(\n response.data,\n response.headers,\n config.transformResponse\n );\n\n return response;\n }, function onAdapterRejection(reason) {\n if (!isCancel(reason)) {\n throwIfCancellationRequested(config);\n\n // Transform response data\n if (reason && reason.response) {\n reason.response.data = transformData(\n reason.response.data,\n reason.response.headers,\n config.transformResponse\n );\n }\n }\n\n return Promise.reject(reason);\n });\n};\n","'use strict';\n\nvar utils = require('../utils');\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n * @returns {Object} New object resulting from merging config2 to config1\n */\nmodule.exports = function mergeConfig(config1, config2) {\n // eslint-disable-next-line no-param-reassign\n config2 = config2 || {};\n var config = {};\n\n var valueFromConfig2Keys = ['url', 'method', 'params', 'data'];\n var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];\n var defaultToConfig2Keys = [\n 'baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer',\n 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',\n 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress',\n 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent',\n 'httpsAgent', 'cancelToken', 'socketPath'\n ];\n\n utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {\n if (typeof config2[prop] !== 'undefined') {\n config[prop] = config2[prop];\n }\n });\n\n utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {\n if (utils.isObject(config2[prop])) {\n config[prop] = utils.deepMerge(config1[prop], config2[prop]);\n } else if (typeof config2[prop] !== 'undefined') {\n config[prop] = config2[prop];\n } else if (utils.isObject(config1[prop])) {\n config[prop] = utils.deepMerge(config1[prop]);\n } else if (typeof config1[prop] !== 'undefined') {\n config[prop] = config1[prop];\n }\n });\n\n utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {\n if (typeof config2[prop] !== 'undefined') {\n config[prop] = config2[prop];\n } else if (typeof config1[prop] !== 'undefined') {\n config[prop] = config1[prop];\n }\n });\n\n var axiosKeys = valueFromConfig2Keys\n .concat(mergeDeepPropertiesKeys)\n .concat(defaultToConfig2Keys);\n\n var otherKeys = Object\n .keys(config2)\n .filter(function filterAxiosKeys(key) {\n return axiosKeys.indexOf(key) === -1;\n });\n\n utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {\n if (typeof config2[prop] !== 'undefined') {\n config[prop] = config2[prop];\n } else if (typeof config1[prop] !== 'undefined') {\n config[prop] = config1[prop];\n }\n });\n\n return config;\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = arguments[1] || {};\n config.url = arguments[0];\n } else {\n config = config || {};\n }\n\n config = mergeConfig(this.defaults, config);\n\n // Set config.method\n if (config.method) {\n config.method = config.method.toLowerCase();\n } else if (this.defaults.method) {\n config.method = this.defaults.method.toLowerCase();\n } else {\n config.method = 'get';\n }\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n config = mergeConfig(this.defaults, config);\n return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\\?/, '');\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","'use strict';\n\n/**\n * A `Cancel` is an object that is thrown when an operation is canceled.\n *\n * @class\n * @param {string=} message The message.\n */\nfunction Cancel(message) {\n this.message = message;\n}\n\nCancel.prototype.toString = function toString() {\n return 'Cancel' + (this.message ? ': ' + this.message : '');\n};\n\nCancel.prototype.__CANCEL__ = true;\n\nmodule.exports = Cancel;\n","'use strict';\n\nvar Cancel = require('./Cancel');\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @class\n * @param {Function} executor The executor function.\n */\nfunction CancelToken(executor) {\n if (typeof executor !== 'function') {\n throw new TypeError('executor must be a function.');\n }\n\n var resolvePromise;\n this.promise = new Promise(function promiseExecutor(resolve) {\n resolvePromise = resolve;\n });\n\n var token = this;\n executor(function cancel(message) {\n if (token.reason) {\n // Cancellation has already been requested\n return;\n }\n\n token.reason = new Cancel(message);\n resolvePromise(token.reason);\n });\n}\n\n/**\n * Throws a `Cancel` if cancellation has been requested.\n */\nCancelToken.prototype.throwIfRequested = function throwIfRequested() {\n if (this.reason) {\n throw this.reason;\n }\n};\n\n/**\n * Returns an object that contains a new `CancelToken` and a function that, when called,\n * cancels the `CancelToken`.\n */\nCancelToken.source = function source() {\n var cancel;\n var token = new CancelToken(function executor(c) {\n cancel = c;\n });\n return {\n token: token,\n cancel: cancel\n };\n};\n\nmodule.exports = CancelToken;\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar bind = require('./helpers/bind');\nvar Axios = require('./core/Axios');\nvar mergeConfig = require('./core/mergeConfig');\nvar defaults = require('./defaults');\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n * @return {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n var context = new Axios(defaultConfig);\n var instance = bind(Axios.prototype.request, context);\n\n // Copy axios.prototype to instance\n utils.extend(instance, Axios.prototype, context);\n\n // Copy context to instance\n utils.extend(instance, context);\n\n return instance;\n}\n\n// Create the default instance to be exported\nvar axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Factory for creating new instances\naxios.create = function create(instanceConfig) {\n return createInstance(mergeConfig(axios.defaults, instanceConfig));\n};\n\n// Expose Cancel & CancelToken\naxios.Cancel = require('./cancel/Cancel');\naxios.CancelToken = require('./cancel/CancelToken');\naxios.isCancel = require('./cancel/isCancel');\n\n// Expose all/spread\naxios.all = function all(promises) {\n return Promise.all(promises);\n};\naxios.spread = require('./helpers/spread');\n\nmodule.exports = axios;\n\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = axios;\n","module.exports = require('./lib/axios');","import { writable } from 'svelte/store';\nimport axios from 'axios';\n\nconst url = (ENV === 'production') ? 'https://menu.silvrtree.co.uk/recipes' : 'http://localhost:3000/recipes';\n\nconst oldstate = writable({\n 'recipes': [],\n 'currentItem': {\n 'name': '',\n 'url': '',\n 'md': '',\n 'meat': '',\n 'mealtype': '',\n '_id': '',\n 'short': '',\n 'hash': '',\n 'lastused': ''\n },\n 'editMode': false,\n 'meatFilterMode':0,\n 'mealFilterMode':0\n\n});\n\nfunction Filter() {\n const { subscribe, set, update } = writable({ \n 'meat':'0',\n 'meal':'0'\n });\n\n return {\n subscribe,\n 'updateMeat': (newVal) => update(v => {\n return {\n ...v, ...{ 'meat':newVal }\n };\n }),\n 'updateMeal': (newVal) => update(v => {\n return {\n ...v, ...{ 'meal':newVal }\n };\n })\n };\n}\n\nfunction Recipes() {\n const { subscribe, set, update } = writable([]);\n \n return {\n subscribe,\n set,\n update\n };\n}\n\nfunction EditMode() {\n const { subscribe, set, update } = writable(false);\n\n return {\n subscribe,\n 'newRecipe': () => update(v => true),\n 'closeEditor': () => update( v => false)\n };\n}\n\nfunction CurrentItem() {\n const { subscribe, set, update } = writable({\n 'name': '',\n 'url': '',\n 'md': '',\n 'meat': '',\n 'mealtype': '',\n '_id': '',\n 'short': '',\n 'hash': '',\n 'lastused': ''\n });\n\n return {\n subscribe,\n 'clearItem': () => update(v => {\n return {\n 'name': '',\n 'url': '',\n 'md': '',\n 'meat': '',\n 'mealtype': '',\n '_id': '',\n 'short': '',\n 'hash': '',\n 'lastused': ''\n };\n }),\n 'updateItem': (payload) => update(v => {\n return payload;\n })\n };\n}\n\nconst state = {\n 'editMode': EditMode(),\n 'currentItem': CurrentItem(),\n 'recipes': Recipes(),\n 'filter': Filter(),\n \n newRecipe() {\n console.log('>> Action:newRecipe');\n this.editMode.newRecipe();\n this.currentItem.clearItem();\n },\n async editRecipe(hash) {\n const response = await axios.get(`${url}/${hash}`).catch((err) => {\n console.error(err);\n });\n\n this.currentItem.updateItem(response.data);\n this.editMode.newRecipe();\n },\n async saveRecipe(payload) {\n console.log('>> Action:saveRecipe');\n const data = { ...payload };\n\n let response;\n\n if (data.hash === '') {\n console.log('Create new');\n response = await axios.post(`${url}`, data).catch((err) => {\n console.error(err);\n });\n }\n else {\n console.log('Update existing');\n response = await axios.put(`${url}/${data.hash}`, data).catch((err) => {\n console.error(err);\n });\n }\n\n if (response.data.changes > 0 || response.data.msg === 'Row inserted') {\n this.closeEditor();\n this.fetchRecipes();\n }\n },\n async fetchRecipes() {\n const response = await axios.get(url);\n this.recipes.set(response.data);\n },\n closeEditor() {\n this.editMode.closeEditor();\n this.currentItem.clearItem();\n },\n updateMeatFilter(newVal) {\n this.filter.updateMeat(newVal);\n }, \n updateMealFilter(newVal) {\n this.filter.updateMeal(newVal);\n }\n};\n\n// export { currentItem, editMode, actions, state };\n\nexport { state };\n\n","\n\n\n\n\n
\n Recipes\n
\n
\n
\n \n
\n
\n\n","/**\n * Returns a function, that, as long as it continues to be invoked, will not\n * be triggered. The function will be called after it stops being called for\n * N milliseconds. If `immediate` is passed, trigger the function on the\n * leading edge, instead of the trailing. The function also has a property 'clear' \n * that is a function which will clear the timer to prevent previously scheduled executions. \n *\n * @source underscore.js\n * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/\n * @param {Function} function to wrap\n * @param {Number} timeout in ms (`100`)\n * @param {Boolean} whether to execute at the beginning (`false`)\n * @api public\n */\nfunction debounce(func, wait, immediate){\n var timeout, args, context, timestamp, result;\n if (null == wait) wait = 100;\n\n function later() {\n var last = Date.now() - timestamp;\n\n if (last < wait && last >= 0) {\n timeout = setTimeout(later, wait - last);\n } else {\n timeout = null;\n if (!immediate) {\n result = func.apply(context, args);\n context = args = null;\n }\n }\n };\n\n var debounced = function(){\n context = this;\n args = arguments;\n timestamp = Date.now();\n var callNow = immediate && !timeout;\n if (!timeout) timeout = setTimeout(later, wait);\n if (callNow) {\n result = func.apply(context, args);\n context = args = null;\n }\n\n return result;\n };\n\n debounced.clear = function() {\n if (timeout) {\n clearTimeout(timeout);\n timeout = null;\n }\n };\n \n debounced.flush = function() {\n if (timeout) {\n result = func.apply(context, args);\n context = args = null;\n \n clearTimeout(timeout);\n timeout = null;\n }\n };\n\n return debounced;\n};\n\n// Adds compatibility for ES modules\ndebounce.debounce = debounce;\n\nmodule.exports = debounce;\n","\n\n\n\n{#if _editMode}\n