commit 06b996f68a5b770f59506622c71fde17710a81b2 Author: Sarah Jamie Lewis Date: Sat Feb 29 10:21:22 2020 -0800 Init diff --git a/NunitoSans-Bold.woff2 b/NunitoSans-Bold.woff2 new file mode 100644 index 0000000..ddce076 Binary files /dev/null and b/NunitoSans-Bold.woff2 differ diff --git a/NunitoSans-Regular.woff2 b/NunitoSans-Regular.woff2 new file mode 100644 index 0000000..087b681 Binary files /dev/null and b/NunitoSans-Regular.woff2 differ diff --git a/SourceCodePro.woff2 b/SourceCodePro.woff2 new file mode 100644 index 0000000..8e0a989 Binary files /dev/null and b/SourceCodePro.woff2 differ diff --git a/bundle.css b/bundle.css new file mode 100644 index 0000000..1aed9dc --- /dev/null +++ b/bundle.css @@ -0,0 +1,19 @@ +div.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{width:100vw;height:40px;position:fixed;top:0px;left:0px;-webkit-app-region:drag;z-index:99998}div.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803:after{display:block;content:'';width:100vw;height:6px;position:absolute;top:0px;left:0px;-webkit-app-region:no-drag;z-index:2}nav.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{display:flex;width:100%;height:40px;align-items:center;justify-content:flex-end;padding:0 20px}button.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{margin-left:40px;width:21px;height:21px;background:none;border:none;cursor:pointer;-webkit-app-region:no-drag}button.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{-webkit-app-region:no-drag}svg.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{margin:3px;-webkit-app-region:no-drag}svg.svelte-1rjf803.svelte-1rjf803 path.svelte-1rjf803.svelte-1rjf803{fill:#000;-webkit-app-region:no-drag}button.svelte-1rjf803:hover svg.svelte-1rjf803 path.svelte-1rjf803{fill:#ccc}a.svelte-1rjf803.svelte-1rjf803.svelte-1rjf803{width:21px;height:21px;-webkit-app-region:no-drag;position:absolute;left:20px} +header.svelte-8reaa7{width:100%;height:80px;display:flex;align-items:center;background:#ac4545;color:#fff;text-align:center;padding-top:13px}span.svelte-8reaa7{font-size:14px;width:100%;padding:0px 20px 0px 20px}a.svelte-8reaa7{color:#fff} +header.svelte-1acygm2{width:100%;height:100px;display:flex;justify-content:space-between;align-items:center;padding:20px 40px 0}img.svelte-1acygm2{width:316px;height:73px}span.svelte-1acygm2{font-size:20px} +.wave.svelte-11vqf7m{display:block;position:relative;width:100%;height:200px;overflow:hidden}svg.svelte-11vqf7m{position:absolute;top:0px;left:0px;height:100%}svg.svelte-11vqf7m:last-of-type{left:-20%;opacity:0.75} +.svelte-1t6n4kr{box-sizing:border-box}.bg.svelte-1t6n4kr{position:fixed;z-index:1000;display:flex;flex-direction:column;justify-content:center;width:100vw;height:100vh;background:rgba(0, 0, 0, 0.66)}.window-wrap.svelte-1t6n4kr{position:relative;margin:2rem;max-height:100%}.window.svelte-1t6n4kr{position:relative;width:50rem;max-width:100%;max-height:100%;margin:2rem auto;color:black;border-radius:0.5rem;background:white}.content.svelte-1t6n4kr{position:relative;padding:1rem;max-height:calc(100vh - 4rem);overflow:auto} +button.svelte-4f7lfx{display:block;flex:1;background:#41dcf3;height:72px;font-weight:700;font-size:16px;cursor:pointer}button.inline.svelte-4f7lfx{border-radius:5px;margin:30px auto 0px;padding:0 40px;height:44px}button.dark.svelte-4f7lfx{background:#062332;color:#fff}button.disabled.svelte-4f7lfx{background:#5cb5d4;color:#408ea8;pointer-events:none}button.secondary.svelte-4f7lfx{background:#47819d;color:#fff}button.svelte-4f7lfx:hover{background:#3dd6ed}button.dark.svelte-4f7lfx:hover{background:#0b3043}button.secondary.svelte-4f7lfx:hover{background:#407792;color:#fff} +ul.svelte-zxam8t{margin-bottom:20px;overflow-wrap:break-word}li.svelte-zxam8t{list-style:none;margin:0 0 8px;user-select:all;cursor:text}article.svelte-zxam8t{max-height:calc(100vh - 400px);height:calc(100vh - 200px);display:block;position:relative;text-align:left;padding:20px 10px 20px 20px}p.svelte-zxam8t{margin:120px auto;text-align:center}strong.svelte-zxam8t{margin-right:7px} +article.svelte-1mwzk0f{position:relative;height:calc(100vh - 260px);width:640px;padding:0 30px;overflow:hidden}.ps__rail-y{display:block;position:absolute;top:0px;left:auto !important;right:7px;opacity:1;width:6px;border-radius:6px;transition:opacity 200ms cubic-bezier(0.55, 0, 0.1, 1)}.ps__thumb-y{cursor:pointer;border-radius:6px;background:#ccc;position:absolute;left:0px;width:6px}h1.svelte-1mwzk0f,h2.svelte-1mwzk0f{font-weight:600}h1.svelte-1mwzk0f{font-size:28px}h2.svelte-1mwzk0f{margin:30px 0} +p.svelte-jdmp6u{background:rgba(255, 255, 255, 0.3);padding:40px;border-radius:5px;margin-bottom:40px;width:100%}p.center.svelte-jdmp6u{text-align:center}p.left.svelte-jdmp6u{text-align:left}p.warning.svelte-jdmp6u{color:#10293b;border:1px solid #ac4545;padding:25px 20px 30px}p.error.svelte-jdmp6u{background:#ac4545;color:#fff;padding:25px 20px 30px}p.success.svelte-jdmp6u{border:1px solid #249357;padding:25px 20px 30px}p a{color:#2f94a9} +.dropzone.svelte-asgudu{display:flex;align-items:center;justify-content:center;width:100%;height:120px;border-radius:5px;border:2px dashed #fff;background:rgba(255, 255, 255, 0.3);margin-bottom:40px;margin-top:3px}content.svelte-asgudu{display:block;position:relative;cursor:pointer;font-weight:700;z-index:10}h6.svelte-asgudu{font-size:14px;text-align:center}h6.dropping.svelte-asgudu{pointer-events:none}svg.svelte-asgudu{display:block;margin:0 auto;margin-bottom:14px}input.svelte-asgudu{position:absolute;opacity:0}label.svelte-asgudu{display:block;font-size:14px;width:100%;position:relative} +input.svelte-cebvu0.svelte-cebvu0{width:100%;height:52px;background:#f7f8fa;border:1px solid #ced3dc;font-size:16px;border-radius:4px;padding:0 48px 0 14px;margin-bottom:36px;margin-top:3px}label.svelte-cebvu0.svelte-cebvu0{display:block;font-size:14px;width:100%;position:relative}strong.svelte-cebvu0.svelte-cebvu0{position:absolute;top:0px;right:0px;font-size:14px;font-weight:700}.score.svelte-cebvu0.svelte-cebvu0{position:absolute;top:6px;right:2px;display:flex}.score.svelte-cebvu0 span.svelte-cebvu0{display:block;height:4px;width:30px;background:#ac4545;margin-left:3px}.score.svelte-cebvu0 span.ok.svelte-cebvu0{background:#249357}.input.svelte-cebvu0.svelte-cebvu0{position:relative}.input.svelte-cebvu0 button.svelte-cebvu0{position:absolute;top:12px;right:12px;width:30px;height:30px;z-index:2;cursor:pointer;background:#f7f8fa} +@keyframes svelte-dexi8g-spin{0%{transform:rotateZ(0) scale(0.8)}50%{transform:rotate(-180deg) scale(1)}100%{transform:rotateZ(-360deg) scale(0.8)}}svg.svelte-dexi8g{display:block;margin:75px auto;animation:svelte-dexi8g-spin 16s linear infinite} +span.svelte-gr5q8j{color:#2f94a9;text-decoration:underline;cursor:pointer}p.svelte-gr5q8j{text-align:center} +div.svelte-or6u9x.svelte-or6u9x{height:calc(100vh - 300px);overflow-y:auto;overflow-x:hidden}ul.svelte-or6u9x.svelte-or6u9x{margin:0 auto 20px;width:420px;position:relative;background:rgba(255, 255, 255, 0.3);border:1px solid #ac4545;border-radius:5px;padding:20px 0 0 14px}li.svelte-or6u9x.svelte-or6u9x{position:relative;align-items:center;list-style:none;margin-bottom:8px;line-height:25px;margin:0px}button.svelte-or6u9x.svelte-or6u9x{cursor:pointer;position:absolute;right:-70px;top:50%;width:50px;height:50px}button.svelte-or6u9x.svelte-or6u9x:last-of-type{background:#41dcf3}button.svelte-or6u9x.svelte-or6u9x:first-of-type{transform:translate(0, -50px) rotateX(180deg)}button.svelte-or6u9x:first-of-type svg.svelte-or6u9x{opacity:0.3}button.svelte-or6u9x.svelte-or6u9x:hover{opacity:0.75}li.svelte-or6u9x strong.svelte-or6u9x{position:absolute;left:-50px;display:inline-block;background:#b5b6b6;color:#18373e;width:24px;height:24px;text-align:center;font-weight:400;font-size:14px;margin-right:45px}li.active.svelte-or6u9x strong.svelte-or6u9x{background:#88d4ff}span.svelte-or6u9x.svelte-or6u9x{display:inline-block;width:14px;height:23px;font-size:26px;margin:0 10px 20px;font-family:'Source Code Pro';color:#b5b6b6;-webkit-user-select:none}li.active.svelte-or6u9x span.svelte-or6u9x{color:#10293b}span.svelte-or6u9x.svelte-or6u9x:nth-of-type(3n){margin-right:50px}span.svelte-or6u9x.svelte-or6u9x:last-of-type{margin-right:0px}#paper-wallet.svelte-or6u9x.svelte-or6u9x{display:none}p.svelte-or6u9x.svelte-or6u9x{position:relative;text-align:center;color:#76838b;width:220px;margin:0 auto 60px;cursor:help}p.svelte-or6u9x strong.svelte-or6u9x{color:#10293b}p.svelte-or6u9x small.svelte-or6u9x{position:absolute;width:300px;color:#000;font-size:14px;line-height:21px;left:50%;bottom:100%;transform:translate(-50%, -10px);background:#fff;box-shadow:0px 0px 20px rgba(0, 0, 0, 0.25);padding:20px;border-radius:5px;opacity:0;transition:opacity 0.2s ease-in}p.svelte-or6u9x:hover small.svelte-or6u9x{opacity:1} +ul.svelte-1a475k0{display:flex;justify-content:center}li.svelte-1a475k0{width:220px;list-style:none;background:rgba(255, 255, 255, 0.3);border:1px solid rgba(0, 0, 0, 0.06);border-radius:5px;margin:0 6px;text-align:center;padding:40px 0 30px;cursor:pointer}li.disableWrite.svelte-1a475k0{opacity:0.3;pointer-events:none}li.svelte-1a475k0:hover{background:rgba(255, 255, 255, 0.4);border:1px solid rgba(0, 0, 0, 0.12)}img.svelte-1a475k0{display:block;margin:0 auto 20px} +ul.svelte-1t2sy5u.svelte-1t2sy5u{margin:50px auto;max-height:calc(100vh - 392px);overflow-y:auto;overflow-x:hidden;padding:20px 10px}p+ul.svelte-1t2sy5u.svelte-1t2sy5u{max-height:calc(100vh - 510px);margin-top:0}li.svelte-1t2sy5u.svelte-1t2sy5u{display:flex;align-items:center;list-style:none;border:2px #fff solid;background:rgba(255, 255, 255, 0.3);border-radius:5px;margin-bottom:20px;padding:20px 20px 20px 25px}.center.svelte-1t2sy5u.svelte-1t2sy5u{text-align:center;display:block}p.svelte-1t2sy5u.svelte-1t2sy5u:nth-child(1){flex:1}strong.svelte-1t2sy5u.svelte-1t2sy5u{display:block;margin-bottom:8px}span.svelte-1t2sy5u.svelte-1t2sy5u{text-decoration:underline;cursor:pointer}p.svelte-1t2sy5u.svelte-1t2sy5u:nth-child(2){font-size:24px}p.svelte-1t2sy5u.svelte-1t2sy5u:nth-child(3){display:block;height:44px;line-height:44px;width:150px;border-radius:5px;background:#249357;color:#fff;text-align:center;font-size:15px;margin-left:30px}p:nth-child(3).submitted.svelte-1t2sy5u.svelte-1t2sy5u{background:#ffcf71;color:#0d2131}p:nth-child(3).kyc.svelte-1t2sy5u.svelte-1t2sy5u{background:#ac4545}p:nth-child(3).loading.svelte-1t2sy5u.svelte-1t2sy5u{background:#cccc}p.svelte-1t2sy5u.svelte-1t2sy5u:nth-child(3){position:relative;cursor:help}p.svelte-1t2sy5u small.svelte-1t2sy5u{position:absolute;width:300px;color:#000;font-size:14px;line-height:21px;top:50%;right:100%;transform:translate(-10px, -50%);background:#fff;box-shadow:0px 0px 5px rgba(0, 0, 0, 0.25);padding:20px;border-radius:5px;opacity:0;transition:opacity 0.2s ease-in}p.svelte-1t2sy5u:nth-child(3):hover small.svelte-1t2sy5u{opacity:1} +div.svelte-1kfulz4{display:flex;width:22px;height:22px;border-width:1px;border-style:solid;border-radius:4px;margin-right:25px;background:#fff;align-items:center;justify-content:center}.checked.svelte-1kfulz4{border-color:#249357}img.svelte-1kfulz4{display:flex;width:20px;height:20px} +div.svelte-gyig3d{padding:10px 0px 10px 20px;display:flex;flex-direction:row;align-items:center;-webkit-user-select:none}span.svelte-gyig3d{display:flex;flex:1}section.svelte-gyig3d{display:flex;flex-direction:column;max-width:530px;margin:0 auto} +main.svelte-1vxhu4f{display:flex;align-items:center;justify-content:center;width:100%;min-height:calc(100% - 300px)}article.svelte-1vxhu4f{padding:20px;width:100%;max-width:680px} diff --git a/bundle.js b/bundle.js new file mode 100644 index 0000000..b351f44 --- /dev/null +++ b/bundle.js @@ -0,0 +1,78241 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 137); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* unused harmony export HtmlTag */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SvelteComponent; }); +/* unused harmony export SvelteComponentDev */ +/* unused harmony export SvelteElement */ +/* unused harmony export action_destroyer */ +/* unused harmony export add_attribute */ +/* unused harmony export add_classes */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return add_flush_callback; }); +/* unused harmony export add_location */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return add_render_callback; }); +/* unused harmony export add_resize_listener */ +/* unused harmony export add_transform */ +/* unused harmony export afterUpdate */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return append; }); +/* unused harmony export append_dev */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return assign; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return attr; }); +/* unused harmony export attr_dev */ +/* unused harmony export beforeUpdate */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return bind; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return binding_callbacks; }); +/* unused harmony export blank_object */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return bubble; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return check_outros; }); +/* unused harmony export children */ +/* unused harmony export claim_component */ +/* unused harmony export claim_element */ +/* unused harmony export claim_space */ +/* unused harmony export claim_text */ +/* unused harmony export clear_loops */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return component_subscribe; }); +/* unused harmony export createEventDispatcher */ +/* unused harmony export create_animation */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return create_bidirectional_transition; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return create_component; }); +/* unused harmony export create_in_transition */ +/* unused harmony export create_out_transition */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return create_slot; }); +/* unused harmony export create_ssr_component */ +/* unused harmony export current_component */ +/* unused harmony export custom_event */ +/* unused harmony export dataset_dev */ +/* unused harmony export debug */ +/* unused harmony export destroy_block */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return destroy_component; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return destroy_each; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return detach; }); +/* unused harmony export detach_after_dev */ +/* unused harmony export detach_before_dev */ +/* unused harmony export detach_between_dev */ +/* unused harmony export detach_dev */ +/* unused harmony export dirty_components */ +/* unused harmony export dispatch_dev */ +/* unused harmony export each */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return element; }); +/* unused harmony export element_is */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return empty; }); +/* unused harmony export escape */ +/* unused harmony export escaped */ +/* unused harmony export exclude_internal_props */ +/* unused harmony export fix_and_destroy_block */ +/* unused harmony export fix_and_outro_and_destroy_block */ +/* unused harmony export fix_position */ +/* unused harmony export flush */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return getContext; }); +/* unused harmony export get_binding_group_value */ +/* unused harmony export get_current_component */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "u", function() { return get_slot_changes; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "v", function() { return get_slot_context; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "w", function() { return get_spread_object; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return get_spread_update; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return get_store_value; }); +/* unused harmony export globals */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "z", function() { return group_outros; }); +/* unused harmony export handle_promise */ +/* unused harmony export has_prop */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "A", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "B", function() { return init; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "C", function() { return insert; }); +/* unused harmony export insert_dev */ +/* unused harmony export intros */ +/* unused harmony export invalid_attribute_name_character */ +/* unused harmony export is_client */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "D", function() { return is_function; }); +/* unused harmony export is_promise */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "E", function() { return listen; }); +/* unused harmony export listen_dev */ +/* unused harmony export loop */ +/* unused harmony export loop_guard */ +/* unused harmony export missing_component */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "F", function() { return mount_component; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "G", function() { return noop; }); +/* unused harmony export not_equal */ +/* unused harmony export now */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "H", function() { return null_to_empty; }); +/* unused harmony export object_without_properties */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "I", function() { return onDestroy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "J", function() { return onMount; }); +/* unused harmony export once */ +/* unused harmony export outro_and_destroy_block */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "K", function() { return prevent_default; }); +/* unused harmony export prop_dev */ +/* unused harmony export query_selector_all */ +/* unused harmony export raf */ +/* unused harmony export run */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "L", function() { return run_all; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "M", function() { return safe_not_equal; }); +/* unused harmony export schedule_update */ +/* unused harmony export select_multiple_value */ +/* unused harmony export select_option */ +/* unused harmony export select_options */ +/* unused harmony export select_value */ +/* unused harmony export self */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "N", function() { return setContext; }); +/* unused harmony export set_attributes */ +/* unused harmony export set_current_component */ +/* unused harmony export set_custom_element_data */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "O", function() { return set_data; }); +/* unused harmony export set_data_dev */ +/* unused harmony export set_input_type */ +/* unused harmony export set_input_value */ +/* unused harmony export set_now */ +/* unused harmony export set_raf */ +/* unused harmony export set_store_value */ +/* unused harmony export set_style */ +/* unused harmony export set_svg_attributes */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "P", function() { return space; }); +/* unused harmony export spread */ +/* unused harmony export stop_propagation */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Q", function() { return subscribe; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "R", function() { return svg_element; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "S", function() { return text; }); +/* unused harmony export tick */ +/* unused harmony export time_ranges_to_array */ +/* unused harmony export to_number */ +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "T", function() { return toggle_class; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "U", function() { return transition_in; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "V", function() { return transition_out; }); +/* unused harmony export update_keyed_each */ +/* unused harmony export validate_component */ +/* unused harmony export validate_each_keys */ +/* unused harmony export validate_store */ +/* unused harmony export xlink_attr */ +function noop() { } +const identity = x => x; +function assign(tar, src) { + // @ts-ignore + for (const k in src) + tar[k] = src[k]; + return tar; +} +function is_promise(value) { + return value && typeof value === 'object' && typeof value.then === 'function'; +} +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 not_equal(a, b) { + return a != a ? b == b : a !== b; +} +function validate_store(store, name) { + if (store != null && typeof store.subscribe !== 'function') { + throw new Error(`'${name}' is not a store with a 'subscribe' method`); + } +} +function subscribe(store, ...callbacks) { + if (store == null) { + return noop; + } + const unsub = store.subscribe(...callbacks); + return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub; +} +function get_store_value(store) { + let value; + subscribe(store, _ => value = _)(); + return value; +} +function component_subscribe(component, store, callback) { + component.$$.on_destroy.push(subscribe(store, callback)); +} +function create_slot(definition, ctx, $$scope, fn) { + if (definition) { + const slot_ctx = get_slot_context(definition, ctx, $$scope, fn); + return definition[0](slot_ctx); + } +} +function get_slot_context(definition, ctx, $$scope, fn) { + return definition[1] && fn + ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) + : $$scope.ctx; +} +function get_slot_changes(definition, $$scope, dirty, fn) { + if (definition[2] && fn) { + const lets = definition[2](fn(dirty)); + if (typeof $$scope.dirty === 'object') { + const merged = []; + const len = Math.max($$scope.dirty.length, lets.length); + for (let i = 0; i < len; i += 1) { + merged[i] = $$scope.dirty[i] | lets[i]; + } + return merged; + } + return $$scope.dirty | lets; + } + return $$scope.dirty; +} +function exclude_internal_props(props) { + const result = {}; + for (const k in props) + if (k[0] !== '$') + result[k] = props[k]; + return result; +} +function once(fn) { + let ran = false; + return function (...args) { + if (ran) + return; + ran = true; + fn.call(this, ...args); + }; +} +function null_to_empty(value) { + return value == null ? '' : value; +} +function set_store_value(store, ret, value = ret) { + store.set(value); + return ret; +} +const has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop); +function action_destroyer(action_result) { + return action_result && is_function(action_result.destroy) ? action_result.destroy : noop; +} + +const is_client = typeof window !== 'undefined'; +let now = is_client + ? () => window.performance.now() + : () => Date.now(); +let raf = is_client ? cb => requestAnimationFrame(cb) : noop; +// used internally for testing +function set_now(fn) { + now = fn; +} +function set_raf(fn) { + raf = fn; +} + +const tasks = new Set(); +function run_tasks(now) { + tasks.forEach(task => { + if (!task.c(now)) { + tasks.delete(task); + task.f(); + } + }); + if (tasks.size !== 0) + raf(run_tasks); +} +/** + * For testing purposes only! + */ +function clear_loops() { + tasks.clear(); +} +/** + * Creates a new task that runs on each raf frame + * until it returns a falsy value or is aborted + */ +function loop(callback) { + let task; + if (tasks.size === 0) + raf(run_tasks); + return { + promise: new Promise(fulfill => { + tasks.add(task = { c: callback, f: fulfill }); + }), + abort() { + tasks.delete(task); + } + }; +} + +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 element_is(name, is) { + return document.createElement(name, { is }); +} +function object_without_properties(obj, exclude) { + const target = {}; + for (const k in obj) { + if (has_prop(obj, k) + // @ts-ignore + && exclude.indexOf(k) === -1) { + // @ts-ignore + target[k] = obj[k]; + } + } + return target; +} +function svg_element(name) { + return document.createElementNS('http://www.w3.org/2000/svg', name); +} +function text(data) { + return document.createTextNode(data); +} +function space() { + return text(' '); +} +function empty() { + return text(''); +} +function listen(node, event, handler, options) { + node.addEventListener(event, handler, options); + return () => node.removeEventListener(event, handler, options); +} +function prevent_default(fn) { + return function (event) { + event.preventDefault(); + // @ts-ignore + return fn.call(this, event); + }; +} +function stop_propagation(fn) { + return function (event) { + event.stopPropagation(); + // @ts-ignore + return fn.call(this, event); + }; +} +function self(fn) { + return function (event) { + // @ts-ignore + if (event.target === this) + fn.call(this, event); + }; +} +function attr(node, attribute, value) { + if (value == null) + node.removeAttribute(attribute); + else if (node.getAttribute(attribute) !== value) + node.setAttribute(attribute, value); +} +function set_attributes(node, attributes) { + // @ts-ignore + const descriptors = Object.getOwnPropertyDescriptors(node.__proto__); + for (const key in attributes) { + if (attributes[key] == null) { + node.removeAttribute(key); + } + else if (key === 'style') { + node.style.cssText = attributes[key]; + } + else if (descriptors[key] && descriptors[key].set) { + node[key] = attributes[key]; + } + else { + attr(node, key, attributes[key]); + } + } +} +function set_svg_attributes(node, attributes) { + for (const key in attributes) { + attr(node, key, attributes[key]); + } +} +function set_custom_element_data(node, prop, value) { + if (prop in node) { + node[prop] = value; + } + else { + attr(node, prop, value); + } +} +function xlink_attr(node, attribute, value) { + node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value); +} +function get_binding_group_value(group) { + const value = []; + for (let i = 0; i < group.length; i += 1) { + if (group[i].checked) + value.push(group[i].__value); + } + return value; +} +function to_number(value) { + return value === '' ? undefined : +value; +} +function time_ranges_to_array(ranges) { + const array = []; + for (let i = 0; i < ranges.length; i += 1) { + array.push({ start: ranges.start(i), end: ranges.end(i) }); + } + return array; +} +function children(element) { + return Array.from(element.childNodes); +} +function claim_element(nodes, name, attributes, svg) { + for (let i = 0; i < nodes.length; i += 1) { + const node = nodes[i]; + if (node.nodeName === name) { + let j = 0; + while (j < node.attributes.length) { + const attribute = node.attributes[j]; + if (attributes[attribute.name]) { + j++; + } + else { + node.removeAttribute(attribute.name); + } + } + return nodes.splice(i, 1)[0]; + } + } + return svg ? svg_element(name) : element(name); +} +function claim_text(nodes, data) { + for (let i = 0; i < nodes.length; i += 1) { + const node = nodes[i]; + if (node.nodeType === 3) { + node.data = '' + data; + return nodes.splice(i, 1)[0]; + } + } + return text(data); +} +function claim_space(nodes) { + return claim_text(nodes, ' '); +} +function set_data(text, data) { + data = '' + data; + if (text.data !== data) + text.data = data; +} +function set_input_value(input, value) { + if (value != null || input.value) { + input.value = value; + } +} +function set_input_type(input, type) { + try { + input.type = type; + } + catch (e) { + // do nothing + } +} +function set_style(node, key, value, important) { + node.style.setProperty(key, value, important ? 'important' : ''); +} +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_options(select, value) { + for (let i = 0; i < select.options.length; i += 1) { + const option = select.options[i]; + option.selected = ~value.indexOf(option.__value); + } +} +function select_value(select) { + const selected_option = select.querySelector(':checked') || select.options[0]; + return selected_option && selected_option.__value; +} +function select_multiple_value(select) { + return [].map.call(select.querySelectorAll(':checked'), option => option.__value); +} +function add_resize_listener(element, fn) { + if (getComputedStyle(element).position === 'static') { + element.style.position = 'relative'; + } + const object = document.createElement('object'); + object.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1;'); + object.setAttribute('aria-hidden', 'true'); + object.type = 'text/html'; + object.tabIndex = -1; + let win; + object.onload = () => { + win = object.contentDocument.defaultView; + win.addEventListener('resize', fn); + }; + if (/Trident/.test(navigator.userAgent)) { + element.appendChild(object); + object.data = 'about:blank'; + } + else { + object.data = 'about:blank'; + element.appendChild(object); + } + return { + cancel: () => { + win && win.removeEventListener && win.removeEventListener('resize', fn); + element.removeChild(object); + } + }; +} +function toggle_class(element, name, toggle) { + element.classList[toggle ? 'add' : 'remove'](name); +} +function custom_event(type, detail) { + const e = document.createEvent('CustomEvent'); + e.initCustomEvent(type, false, false, detail); + return e; +} +function query_selector_all(selector, parent = document.body) { + return Array.from(parent.querySelectorAll(selector)); +} +class HtmlTag { + constructor(html, anchor = null) { + this.e = element('div'); + this.a = anchor; + this.u(html); + } + m(target, anchor = null) { + for (let i = 0; i < this.n.length; i += 1) { + insert(target, this.n[i], anchor); + } + this.t = target; + } + u(html) { + this.e.innerHTML = html; + this.n = Array.from(this.e.childNodes); + } + p(html) { + this.d(); + this.u(html); + this.m(this.t, this.a); + } + d() { + this.n.forEach(detach); + } +} + +let stylesheet; +let active = 0; +let current_rules = {}; +// https://github.com/darkskyapp/string-hash/blob/master/index.js +function hash(str) { + let hash = 5381; + let i = str.length; + while (i--) + hash = ((hash << 5) - hash) ^ str.charCodeAt(i); + return hash >>> 0; +} +function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) { + const step = 16.666 / duration; + let keyframes = '{\n'; + for (let p = 0; p <= 1; p += step) { + const t = a + (b - a) * ease(p); + keyframes += p * 100 + `%{${fn(t, 1 - t)}}\n`; + } + const rule = keyframes + `100% {${fn(b, 1 - b)}}\n}`; + const name = `__svelte_${hash(rule)}_${uid}`; + if (!current_rules[name]) { + if (!stylesheet) { + const style = element('style'); + document.head.appendChild(style); + stylesheet = style.sheet; + } + current_rules[name] = true; + stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length); + } + const animation = node.style.animation || ''; + node.style.animation = `${animation ? `${animation}, ` : ``}${name} ${duration}ms linear ${delay}ms 1 both`; + active += 1; + return name; +} +function delete_rule(node, name) { + node.style.animation = (node.style.animation || '') + .split(', ') + .filter(name + ? anim => anim.indexOf(name) < 0 // remove specific animation + : anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations + ) + .join(', '); + if (name && !--active) + clear_rules(); +} +function clear_rules() { + raf(() => { + if (active) + return; + let i = stylesheet.cssRules.length; + while (i--) + stylesheet.deleteRule(i); + current_rules = {}; + }); +} + +function create_animation(node, from, fn, params) { + if (!from) + return noop; + const to = node.getBoundingClientRect(); + if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom) + return noop; + const { delay = 0, duration = 300, easing = identity, + // @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation? + start: start_time = now() + delay, + // @ts-ignore todo: + end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params); + let running = true; + let started = false; + let name; + function start() { + if (css) { + name = create_rule(node, 0, 1, duration, delay, easing, css); + } + if (!delay) { + started = true; + } + } + function stop() { + if (css) + delete_rule(node, name); + running = false; + } + loop(now => { + if (!started && now >= start_time) { + started = true; + } + if (started && now >= end) { + tick(1, 0); + stop(); + } + if (!running) { + return false; + } + if (started) { + const p = now - start_time; + const t = 0 + 1 * easing(p / duration); + tick(t, 1 - t); + } + return true; + }); + start(); + tick(0, 1); + return stop; +} +function fix_position(node) { + const style = getComputedStyle(node); + if (style.position !== 'absolute' && style.position !== 'fixed') { + const { width, height } = style; + const a = node.getBoundingClientRect(); + node.style.position = 'absolute'; + node.style.width = width; + node.style.height = height; + add_transform(node, a); + } +} +function add_transform(node, a) { + const b = node.getBoundingClientRect(); + if (a.left !== b.left || a.top !== b.top) { + const style = getComputedStyle(node); + const transform = style.transform === 'none' ? '' : style.transform; + node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`; + } +} + +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 beforeUpdate(fn) { + get_current_component().$$.before_update.push(fn); +} +function onMount(fn) { + get_current_component().$$.on_mount.push(fn); +} +function afterUpdate(fn) { + get_current_component().$$.after_update.push(fn); +} +function onDestroy(fn) { + get_current_component().$$.on_destroy.push(fn); +} +function createEventDispatcher() { + const component = get_current_component(); + return (type, detail) => { + const callbacks = component.$$.callbacks[type]; + if (callbacks) { + // TODO are there situations where events could be dispatched + // in a server (non-DOM) environment? + const event = custom_event(type, detail); + callbacks.slice().forEach(fn => { + fn.call(component, event); + }); + } + }; +} +function setContext(key, context) { + get_current_component().$$.context.set(key, context); +} +function getContext(key) { + return get_current_component().$$.context.get(key); +} +// TODO figure out if we still want to support +// shorthand events, or if we want to implement +// a real bubbling mechanism +function bubble(component, event) { + const callbacks = component.$$.callbacks[event.type]; + if (callbacks) { + callbacks.slice().forEach(fn => fn(event)); + } +} + +const dirty_components = []; +const intros = { enabled: false }; +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 tick() { + schedule_update(); + return resolved_promise; +} +function add_render_callback(fn) { + render_callbacks.push(fn); +} +function add_flush_callback(fn) { + flush_callbacks.push(fn); +} +let flushing = false; +const seen_callbacks = new Set(); +function flush() { + if (flushing) + return; + flushing = true; + do { + // first, call beforeUpdate functions + // and update components + for (let i = 0; i < dirty_components.length; i += 1) { + const component = dirty_components[i]; + set_current_component(component); + update(component.$$); + } + dirty_components.length = 0; + while (binding_callbacks.length) + binding_callbacks.pop()(); + // then, once components are updated, call + // afterUpdate functions. This may cause + // subsequent updates... + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i]; + if (!seen_callbacks.has(callback)) { + // ...so guard against infinite loops + seen_callbacks.add(callback); + callback(); + } + } + render_callbacks.length = 0; + } while (dirty_components.length); + while (flush_callbacks.length) { + flush_callbacks.pop()(); + } + update_scheduled = false; + flushing = false; + seen_callbacks.clear(); +} +function update($$) { + if ($$.fragment !== null) { + $$.update(); + run_all($$.before_update); + const dirty = $$.dirty; + $$.dirty = [-1]; + $$.fragment && $$.fragment.p($$.ctx, dirty); + $$.after_update.forEach(add_render_callback); + } +} + +let promise; +function wait() { + if (!promise) { + promise = Promise.resolve(); + promise.then(() => { + promise = null; + }); + } + return promise; +} +function dispatch(node, direction, kind) { + node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`)); +} +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 null_transition = { duration: 0 }; +function create_in_transition(node, fn, params) { + let config = fn(node, params); + let running = false; + let animation_name; + let task; + let uid = 0; + function cleanup() { + if (animation_name) + delete_rule(node, animation_name); + } + function go() { + const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition; + if (css) + animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++); + tick(0, 1); + const start_time = now() + delay; + const end_time = start_time + duration; + if (task) + task.abort(); + running = true; + add_render_callback(() => dispatch(node, true, 'start')); + task = loop(now => { + if (running) { + if (now >= end_time) { + tick(1, 0); + dispatch(node, true, 'end'); + cleanup(); + return running = false; + } + if (now >= start_time) { + const t = easing((now - start_time) / duration); + tick(t, 1 - t); + } + } + return running; + }); + } + let started = false; + return { + start() { + if (started) + return; + delete_rule(node); + if (is_function(config)) { + config = config(); + wait().then(go); + } + else { + go(); + } + }, + invalidate() { + started = false; + }, + end() { + if (running) { + cleanup(); + running = false; + } + } + }; +} +function create_out_transition(node, fn, params) { + let config = fn(node, params); + let running = true; + let animation_name; + const group = outros; + group.r += 1; + function go() { + const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition; + if (css) + animation_name = create_rule(node, 1, 0, duration, delay, easing, css); + const start_time = now() + delay; + const end_time = start_time + duration; + add_render_callback(() => dispatch(node, false, 'start')); + loop(now => { + if (running) { + if (now >= end_time) { + tick(0, 1); + dispatch(node, false, 'end'); + if (!--group.r) { + // this will result in `end()` being called, + // so we don't need to clean up here + run_all(group.c); + } + return false; + } + if (now >= start_time) { + const t = easing((now - start_time) / duration); + tick(1 - t, t); + } + } + return running; + }); + } + if (is_function(config)) { + wait().then(() => { + // @ts-ignore + config = config(); + go(); + }); + } + else { + go(); + } + return { + end(reset) { + if (reset && config.tick) { + config.tick(1, 0); + } + if (running) { + if (animation_name) + delete_rule(node, animation_name); + running = false; + } + } + }; +} +function create_bidirectional_transition(node, fn, params, intro) { + let config = fn(node, params); + let t = intro ? 0 : 1; + let running_program = null; + let pending_program = null; + let animation_name = null; + function clear_animation() { + if (animation_name) + delete_rule(node, animation_name); + } + function init(program, duration) { + const d = program.b - t; + duration *= Math.abs(d); + return { + a: t, + b: program.b, + d, + duration, + start: program.start, + end: program.start + duration, + group: program.group + }; + } + function go(b) { + const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition; + const program = { + start: now() + delay, + b + }; + if (!b) { + // @ts-ignore todo: improve typings + program.group = outros; + outros.r += 1; + } + if (running_program) { + pending_program = program; + } + else { + // if this is an intro, and there's a delay, we need to do + // an initial tick and/or apply CSS animation immediately + if (css) { + clear_animation(); + animation_name = create_rule(node, t, b, duration, delay, easing, css); + } + if (b) + tick(0, 1); + running_program = init(program, duration); + add_render_callback(() => dispatch(node, b, 'start')); + loop(now => { + if (pending_program && now > pending_program.start) { + running_program = init(pending_program, duration); + pending_program = null; + dispatch(node, running_program.b, 'start'); + if (css) { + clear_animation(); + animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css); + } + } + if (running_program) { + if (now >= running_program.end) { + tick(t = running_program.b, 1 - t); + dispatch(node, running_program.b, 'end'); + if (!pending_program) { + // we're done + if (running_program.b) { + // intro — we can tidy up immediately + clear_animation(); + } + else { + // outro — needs to be coordinated + if (!--running_program.group.r) + run_all(running_program.group.c); + } + } + running_program = null; + } + else if (now >= running_program.start) { + const p = now - running_program.start; + t = running_program.a + running_program.d * easing(p / running_program.duration); + tick(t, 1 - t); + } + } + return !!(running_program || pending_program); + }); + } + } + return { + run(b) { + if (is_function(config)) { + wait().then(() => { + // @ts-ignore + config = config(); + go(b); + }); + } + else { + go(b); + } + }, + end() { + clear_animation(); + running_program = pending_program = null; + } + }; +} + +function handle_promise(promise, info) { + const token = info.token = {}; + function update(type, index, key, value) { + if (info.token !== token) + return; + info.resolved = value; + let child_ctx = info.ctx; + if (key !== undefined) { + child_ctx = child_ctx.slice(); + child_ctx[key] = value; + } + const block = type && (info.current = type)(child_ctx); + let needs_flush = false; + if (info.block) { + if (info.blocks) { + info.blocks.forEach((block, i) => { + if (i !== index && block) { + group_outros(); + transition_out(block, 1, 1, () => { + info.blocks[i] = null; + }); + check_outros(); + } + }); + } + else { + info.block.d(1); + } + block.c(); + transition_in(block, 1); + block.m(info.mount(), info.anchor); + needs_flush = true; + } + info.block = block; + if (info.blocks) + info.blocks[index] = block; + if (needs_flush) { + flush(); + } + } + if (is_promise(promise)) { + const current_component = get_current_component(); + promise.then(value => { + set_current_component(current_component); + update(info.then, 1, info.value, value); + set_current_component(null); + }, error => { + set_current_component(current_component); + update(info.catch, 2, info.error, error); + set_current_component(null); + }); + // if we previously had a then/catch block, destroy it + if (info.current !== info.pending) { + update(info.pending, 0); + return true; + } + } + else { + if (info.current !== info.then) { + update(info.then, 1, info.value, promise); + return true; + } + info.resolved = promise; + } +} + +const globals = (typeof window !== 'undefined' ? window : global); + +function destroy_block(block, lookup) { + block.d(1); + lookup.delete(block.key); +} +function outro_and_destroy_block(block, lookup) { + transition_out(block, 1, 1, () => { + lookup.delete(block.key); + }); +} +function fix_and_destroy_block(block, lookup) { + block.f(); + destroy_block(block, lookup); +} +function fix_and_outro_and_destroy_block(block, lookup) { + block.f(); + outro_and_destroy_block(block, lookup); +} +function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) { + let o = old_blocks.length; + let n = list.length; + let i = o; + const old_indexes = {}; + while (i--) + old_indexes[old_blocks[i].key] = i; + const new_blocks = []; + const new_lookup = new Map(); + const deltas = new Map(); + i = n; + while (i--) { + const child_ctx = get_context(ctx, list, i); + const key = get_key(child_ctx); + let block = lookup.get(key); + if (!block) { + block = create_each_block(key, child_ctx); + block.c(); + } + else if (dynamic) { + block.p(child_ctx, dirty); + } + new_lookup.set(key, new_blocks[i] = block); + if (key in old_indexes) + deltas.set(key, Math.abs(i - old_indexes[key])); + } + const will_move = new Set(); + const did_move = new Set(); + function insert(block) { + transition_in(block, 1); + block.m(node, next); + lookup.set(block.key, block); + next = block.first; + n--; + } + while (o && n) { + const new_block = new_blocks[n - 1]; + const old_block = old_blocks[o - 1]; + const new_key = new_block.key; + const old_key = old_block.key; + if (new_block === old_block) { + // do nothing + next = new_block.first; + o--; + n--; + } + else if (!new_lookup.has(old_key)) { + // remove old block + destroy(old_block, lookup); + o--; + } + else if (!lookup.has(new_key) || will_move.has(new_key)) { + insert(new_block); + } + else if (did_move.has(old_key)) { + o--; + } + else if (deltas.get(new_key) > deltas.get(old_key)) { + did_move.add(new_key); + insert(new_block); + } + else { + will_move.add(old_key); + o--; + } + } + while (o--) { + const old_block = old_blocks[o]; + if (!new_lookup.has(old_block.key)) + destroy(old_block, lookup); + } + while (n) + insert(new_blocks[n - 1]); + return new_blocks; +} +function validate_each_keys(ctx, list, get_context, get_key) { + const keys = new Set(); + for (let i = 0; i < list.length; i++) { + const key = get_key(get_context(ctx, list, i)); + if (keys.has(key)) { + throw new Error(`Cannot have duplicate keys in a keyed each`); + } + keys.add(key); + } +} + +function get_spread_update(levels, updates) { + const update = {}; + const to_null_out = {}; + const accounted_for = { $$scope: 1 }; + let i = levels.length; + while (i--) { + const o = levels[i]; + const n = updates[i]; + if (n) { + for (const key in o) { + if (!(key in n)) + to_null_out[key] = 1; + } + for (const key in n) { + if (!accounted_for[key]) { + update[key] = n[key]; + accounted_for[key] = 1; + } + } + levels[i] = n; + } + else { + for (const key in o) { + accounted_for[key] = 1; + } + } + } + for (const key in to_null_out) { + if (!(key in update)) + update[key] = undefined; + } + return update; +} +function get_spread_object(spread_props) { + return typeof spread_props === 'object' && spread_props !== null ? spread_props : {}; +} + +// source: https://html.spec.whatwg.org/multipage/indices.html +const boolean_attributes = new Set([ + 'allowfullscreen', + 'allowpaymentrequest', + 'async', + 'autofocus', + 'autoplay', + 'checked', + 'controls', + 'default', + 'defer', + 'disabled', + 'formnovalidate', + 'hidden', + 'ismap', + 'loop', + 'multiple', + 'muted', + 'nomodule', + 'novalidate', + 'open', + 'playsinline', + 'readonly', + 'required', + 'reversed', + 'selected' +]); + +const 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; +// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 +// https://infra.spec.whatwg.org/#noncharacter +function spread(args, classes_to_add) { + const attributes = Object.assign({}, ...args); + if (classes_to_add) { + if (attributes.class == null) { + attributes.class = classes_to_add; + } + else { + attributes.class += ' ' + classes_to_add; + } + } + let str = ''; + Object.keys(attributes).forEach(name => { + if (invalid_attribute_name_character.test(name)) + return; + const value = attributes[name]; + if (value === true) + str += " " + name; + else if (boolean_attributes.has(name.toLowerCase())) { + if (value) + str += " " + name; + } + else if (value != null) { + str += ` ${name}="${String(value).replace(/"/g, '"').replace(/'/g, ''')}"`; + } + }); + return str; +} +const escaped = { + '"': '"', + "'": ''', + '&': '&', + '<': '<', + '>': '>' +}; +function escape(html) { + return String(html).replace(/["'&<>]/g, match => escaped[match]); +} +function each(items, fn) { + let str = ''; + for (let i = 0; i < items.length; i += 1) { + str += fn(items[i], i); + } + return str; +} +const missing_component = { + $$render: () => '' +}; +function validate_component(component, name) { + if (!component || !component.$$render) { + if (name === 'svelte:component') + name += ' this={...}'; + 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`); + } + return component; +} +function debug(file, line, column, values) { + console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console + console.log(values); // eslint-disable-line no-console + return ''; +} +let on_destroy; +function create_ssr_component(fn) { + function $$render(result, props, bindings, slots) { + const parent_component = current_component; + const $$ = { + on_destroy, + context: new Map(parent_component ? parent_component.$$.context : []), + // these will be immediately discarded + on_mount: [], + before_update: [], + after_update: [], + callbacks: blank_object() + }; + set_current_component({ $$ }); + const html = fn(result, props, bindings, slots); + set_current_component(parent_component); + return html; + } + return { + render: (props = {}, options = {}) => { + on_destroy = []; + const result = { title: '', head: '', css: new Set() }; + const html = $$render(result, props, {}, options); + run_all(on_destroy); + return { + html, + css: { + code: Array.from(result.css).map(css => css.code).join('\n'), + map: null // TODO + }, + head: result.title + result.head + }; + }, + $$render + }; +} +function add_attribute(name, value, boolean) { + if (value == null || (boolean && !value)) + return ''; + return ` ${name}${value === true ? '' : `=${typeof value === 'string' ? JSON.stringify(escape(value)) : `"${value}"`}`}`; +} +function add_classes(classes) { + return classes ? ` class="${classes}"` : ``; +} + +function bind(component, name, callback) { + const index = component.$$.props[name]; + if (index !== undefined) { + component.$$.bound[index] = callback; + callback(component.$$.ctx[index]); + } +} +function create_component(block) { + block && block.c(); +} +function claim_component(block, parent_nodes) { + block && block.l(parent_nodes); +} +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) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + $$.fragment && $$.fragment.l(children(options.target)); + } + 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); +} +let SvelteElement; +if (typeof HTMLElement === 'function') { + SvelteElement = class extends HTMLElement { + constructor() { + super(); + this.attachShadow({ mode: 'open' }); + } + connectedCallback() { + // @ts-ignore todo: improve typings + for (const key in this.$$.slotted) { + // @ts-ignore todo: improve typings + this.appendChild(this.$$.slotted[key]); + } + } + attributeChangedCallback(attr, _oldValue, newValue) { + this[attr] = newValue; + } + $destroy() { + destroy_component(this, 1); + this.$destroy = noop; + } + $on(type, callback) { + // TODO should this delegate to addEventListener? + const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = [])); + callbacks.push(callback); + return () => { + const index = callbacks.indexOf(callback); + if (index !== -1) + callbacks.splice(index, 1); + }; + } + $set() { + // overridden by instance, if it has props + } + }; +} +class 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.18.2' }, 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 detach_between_dev(before, after) { + while (before.nextSibling && before.nextSibling !== after) { + detach_dev(before.nextSibling); + } +} +function detach_before_dev(after) { + while (after.previousSibling) { + detach_dev(after.previousSibling); + } +} +function detach_after_dev(before) { + while (before.nextSibling) { + detach_dev(before.nextSibling); + } +} +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 dataset_dev(node, property, value) { + node.dataset[property] = value; + dispatch_dev("SvelteDOMSetDataset", { 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; +} +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 + }; + } +} +function loop_guard(timeout) { + const start = Date.now(); + return () => { + if (Date.now() - start > timeout) { + throw new Error(`Infinite loop detected`); + } + }; +} + + + + +/***/ }), +/* 1 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return view; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return importSeed; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return exportSeed; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return activeMigrationLog; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return migrationLogs; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return seedFirstAddresses; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return lastFetchedStatesAt; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return errorLog; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return resetState; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return importError; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return prepareBundleError; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return hasExportedSeedVault; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return passwordHash; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return passwordSalt; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return hasReadPrivacyPolicy; }); +/* harmony import */ var _lib_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9); +/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10); +/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2); + + + +/** + * Current view + */ +const view = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(''); +/** + * Current imported seed + */ +const importSeed = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(null); +/** + * Current exported seed + */ +const exportSeed = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(null); +/** + * Active migration bundle hash + */ +const activeMigrationLog = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])({}); +/** + * Migration logs + */ +const migrationLogs = Object(_helpers__WEBPACK_IMPORTED_MODULE_2__[/* persistent */ "g"])('migrationLogs', {}); +/** + * First addresses (index 0) of every seed migrated from this tool. + * Stored to detect if a new imported seed has already migrated. + */ +const seedFirstAddresses = Object(_helpers__WEBPACK_IMPORTED_MODULE_2__[/* persistent */ "g"])('seedFirstAddresses', []); +/** + * Timestamp for last API call made to fetch states + */ +const lastFetchedStatesAt = Object(_helpers__WEBPACK_IMPORTED_MODULE_2__[/* persistent */ "g"])('lastFetchedStatesAt', null); +/** + * Error log for failed backend API calls + */ +const errorLog = Object(_helpers__WEBPACK_IMPORTED_MODULE_2__[/* persistent */ "g"])('errorLog', []); +/** + * Reset application state + */ +const resetState = () => { + importSeed.set(null); + exportSeed.set(null); + view.set(''); + importError.set(false); + prepareBundleError.set(false); + activeMigrationLog.set({}); + hasExportedSeedVault.set(false); + passwordHash.set(new Uint8Array(_lib_config__WEBPACK_IMPORTED_MODULE_0__[/* HASH_LENGTH */ "e"])); + passwordSalt.set(new Uint8Array(_lib_config__WEBPACK_IMPORTED_MODULE_0__[/* SALT_LENGTH */ "j"])); +}; +/** + * Import error + */ +const importError = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(false); +/** + * prepareBundleError error + */ +const prepareBundleError = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(false); +/** + * Determines whether a SeedVault has been exported + */ +const hasExportedSeedVault = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(false); +/** + * Password hash + */ +const passwordHash = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(new Uint8Array(_lib_config__WEBPACK_IMPORTED_MODULE_0__[/* HASH_LENGTH */ "e"])); +/** + * Password salt + */ +const passwordSalt = Object(svelte_store__WEBPACK_IMPORTED_MODULE_1__[/* writable */ "b"])(new Uint8Array(_lib_config__WEBPACK_IMPORTED_MODULE_0__[/* SALT_LENGTH */ "j"])); +/** + * Determines if privacy policy should be skipped on load + */ +const hasReadPrivacyPolicy = Object(_helpers__WEBPACK_IMPORTED_MODULE_2__[/* persistent */ "g"])(false); + + +/***/ }), +/* 2 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return formatTime; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return randomBytes; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return stringToBytes; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return bytesToString; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getSeedChecksum; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return formatIotas; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return persistent; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return toHumanReadableDate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return parseUint8ArrayString; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return withFallback; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return chunk; }); +/* harmony import */ var iota_lib_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46); +/* harmony import */ var iota_lib_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(iota_lib_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9); +/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10); + + + +/** + * Formats unix timestamp + * + * @method formatTime + * + * @param {number} unixTimestamp + * + * @returns {string} + */ +const formatTime = (unixTimestamp) => { + const date = new Date(unixTimestamp); + const year = date.getFullYear(); + const month = date.getMonth(); + const formattedMonth = month < 10 ? `0${month}` : month.toString(); + const day = date.getDate(); + const formattedDay = day < 10 ? `0${day}` : day.toString(); + const hours = ('0' + date.getHours()).slice(-2); + const minutes = '0' + date.getMinutes(); + return formattedDay + '-' + formattedMonth + '-' + year + ' ' + hours + ':' + minutes.substr(-2); +}; +/** + * Create random byte array + * @param {number} size - Random number array length. + * @param {number} max - Random byte max range + * @returns {array} Random number array + */ +const randomBytes = (size, max = 256) => { + if (size !== parseInt(size + '', 10) || size < 0) { + return null; + } + const rawBytes = new Uint8Array(size); + const bytes = global.crypto.getRandomValues(rawBytes); + for (let i = 0; i < bytes.length; i++) { + while (bytes[i] >= 256 - (256 % max)) { + bytes[i] = randomBytes(1, max)[0]; + } + } + return Array.from(bytes); +}; +/** + * Convert trit string to byte array + * @param {string} input - input trit string + * @returns {array} - byte array + */ +const stringToBytes = (input) => { + return input + .split('') + .map((char) => '9ABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(char.toUpperCase())) + .filter((byte) => byte > -1); +}; +/** + * Convert byte array to trit string + * @param {array} input - input byte array + * @returns {string} - trit string + */ +const bytesToString = (input) => { + return input.map((byte) => '9ABCDEFGHIJKLMNOPQRSTUVWXYZ'.charAt(byte % 27)).join(''); +}; +/** + * Tryte trit mapping + */ +const trytesTrits = [ + [0, 0, 0], + [1, 0, 0], + [-1, 1, 0], + [0, 1, 0], + [1, 1, 0], + [-1, -1, 1], + [0, -1, 1], + [1, -1, 1], + [-1, 0, 1], + [0, 0, 1], + [1, 0, 1], + [-1, 1, 1], + [0, 1, 1], + [1, 1, 1], + [-1, -1, -1], + [0, -1, -1], + [1, -1, -1], + [-1, 0, -1], + [0, 0, -1], + [1, 0, -1], + [-1, 1, -1], + [0, 1, -1], + [1, 1, -1], + [-1, -1, 0], + [0, -1, 0], + [1, -1, 0], + [-1, 0, 0] +]; +const tritStrings = trytesTrits.map((trit) => trit.toString()); +/** + * Converts tryte string to trits + * + * @method trytesToTrits + * @param {String} input - Tryte string to be converted. + * + * @return {array} trits + */ +const trytesToTrits = (input) => { + const result = Array(input.length * 3); + for (let i = 0; i < input.length; i++) { + const index = '9ABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(input.charAt(i)); + result[i * 3] = trytesTrits[index][0]; + result[i * 3 + 1] = trytesTrits[index][1]; + result[i * 3 + 2] = trytesTrits[index][2]; + } + return result; +}; +/** + * Convert trit array to string + * @param {array} trits - Input trit array + * @returns {string} Output string + */ +const tritsToChars = (trits) => { + if (!trits || !trits.length) { + return null; + } + let chars = ''; + for (let i = 0; i < trits.length; i += 3) { + const trit = trits.slice(i, i + 3).toString(); + for (let x = 0; x < tritStrings.length; x++) { + if (tritStrings[x] === trit) { + chars += '9ABCDEFGHIJKLMNOPQRSTUVWXYZ'.charAt(x); + } + } + } + return chars; +}; +/** + * Gets seed checksum. + * @param {string | array} input - seed trytes | seed trits + * @returns {string} + */ +const getSeedChecksum = (seed) => { + const seedString = typeof seed === 'object' ? bytesToString(seed) : seed; + if (!seedString.toUpperCase().match(/^[A-Z9]+$/)) { + return 'Invalid seed'; + } + const iota = new iota_lib_js__WEBPACK_IMPORTED_MODULE_0___default.a(); + const checksum = iota.utils.addChecksum(trytesToTrits(seedString.toUpperCase()), 9, false).slice(-9); + return tritsToChars(checksum); +}; +/** + * Gets relevant denomination for provided IOTA value + * + * @method formatIotas + * @param {number} value + * + * @returns {string} + */ +const formatIotas = (value) => { + if (value < 0) { + value = -value; + } + let unit = 'Ti'; + switch (true) { + case value < 1000: + unit = 'i'; + break; + case value < 1000000: + unit = 'Ki'; + break; + case value < 1000000000: + unit = 'Mi'; + break; + case value < 1000000000000: + unit = 'Gi'; + break; + default: + unit = 'Ti'; + } + switch (true) { + case value < 1000: + break; + case value < 1000000: + value /= 1000; + break; + case value < 1000000000: + value /= 1000000; + break; + case value < 1000000000000: + value /= 1000000000; + break; + default: + value /= 1000000000000; + } + return `${value}${unit}`; +}; +/** + * Persist a writable Svelte store to local storage + */ +const persistent = (key, initialValue) => { + let value = initialValue; + try { + const json = localStorage.getItem(key); + if (json) { + value = JSON.parse(json); + } + } + catch (err) { + console.error(err); + } + const state = Object(svelte_store__WEBPACK_IMPORTED_MODULE_2__[/* writable */ "b"])(value); + state.subscribe(($value) => { + localStorage.setItem(key, JSON.stringify($value)); + }); + return state; +}; +/** + * Converts migration log date to human readable format + * + * @method toHumanReadableDate + * @param {string} value + * + * @returns {string} + */ +const toHumanReadableDate = (migrationDate) => { + const dateComponents = migrationDate.split('-'); + return `${dateComponents[0]}/${dateComponents[1]}/${dateComponents[2]} ${dateComponents[3].substring(0, 2)}:${dateComponents[3].substring(2)}`; +}; +/** + * Takes a Uint8Array in string form and outputs a Uint8Array + * + * @method parseUint8ArrayString + * @param {string} Uint8Array string + * + * @returns {Uint8Array} + */ +const parseUint8ArrayString = (input) => { + const arr = input.split(','); + return Uint8Array.from(arr); +}; +/** + * Wrapper method to handle attempts on fallback node + * + * @method withFallback + * + * @param {function} promiseFunc + * + * @returns {function} + */ +const withFallback = (promiseFunc) => { + return (...args) => { + let node = _config__WEBPACK_IMPORTED_MODULE_1__[/* DEFAULT_NODE */ "b"]; + const execute = (provider) => { + return promiseFunc(provider)(...args).catch((error) => { + if (node !== _config__WEBPACK_IMPORTED_MODULE_1__[/* FALLBACK_NODE */ "d"]) { + node = _config__WEBPACK_IMPORTED_MODULE_1__[/* FALLBACK_NODE */ "d"]; + return execute(node); + } + throw error; + }); + }; + return execute(node); + }; +}; +/** + * Creates a chunk of array with + * + * @method chunk + * + * @param {string[]} array + * @param {number} len + * + * @returns {string[][]} + */ +const chunk = (array, len) => { + let chunks = []; + let i = 0; + let n = array.length; + while (i < n) { + chunks.push(array.slice(i, i += len)); + } + return chunks; +}; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(13))) + +/***/ }), +/* 3 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); +/* harmony import */ var _workdir_src_components_Button_svelte_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(181); +/* harmony import */ var _workdir_src_components_Button_svelte_css__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_workdir_src_components_Button_svelte_css__WEBPACK_IMPORTED_MODULE_1__); +/* src/components/Button.svelte generated by Svelte v3.18.2 */ + + +function create_fragment(ctx) { + let button; + let current; + let dispose; + const default_slot_template = /*$$slots*/ ctx[6].default; + const default_slot = Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* create_slot */ "n"])(default_slot_template, ctx, /*$$scope*/ ctx[5], null); + + return { + c() { + button = Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* element */ "r"])("button"); + if (default_slot) default_slot.c(); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* attr */ "f"])(button, "class", "svelte-4f7lfx"); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "secondary", /*secondary*/ ctx[4]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "dark", /*dark*/ ctx[2]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "inline", /*inline*/ ctx[3]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "disabled", /*disabled*/ ctx[1]); + }, + m(target, anchor) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* insert */ "C"])(target, button, anchor); + + if (default_slot) { + default_slot.m(button, null); + } + + current = true; + + dispose = Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* listen */ "E"])(button, "click", function () { + if (Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* is_function */ "D"])(/*onClick*/ ctx[0])) /*onClick*/ ctx[0].apply(this, arguments); + }); + }, + p(new_ctx, [dirty]) { + ctx = new_ctx; + + if (default_slot && default_slot.p && dirty & /*$$scope*/ 32) { + default_slot.p(Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* get_slot_context */ "v"])(default_slot_template, ctx, /*$$scope*/ ctx[5], null), Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* get_slot_changes */ "u"])(default_slot_template, /*$$scope*/ ctx[5], dirty, null)); + } + + if (dirty & /*secondary*/ 16) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "secondary", /*secondary*/ ctx[4]); + } + + if (dirty & /*dark*/ 4) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "dark", /*dark*/ ctx[2]); + } + + if (dirty & /*inline*/ 8) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "inline", /*inline*/ ctx[3]); + } + + if (dirty & /*disabled*/ 2) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(button, "disabled", /*disabled*/ ctx[1]); + } + }, + i(local) { + if (current) return; + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_in */ "U"])(default_slot, local); + current = true; + }, + o(local) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_out */ "V"])(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* detach */ "q"])(button); + if (default_slot) default_slot.d(detaching); + dispose(); + } + }; +} + +function instance($$self, $$props, $$invalidate) { + let { onClick } = $$props; + let { disabled = false } = $$props; + let { dark = false } = $$props; + let { inline = false } = $$props; + let { secondary = false } = $$props; + let { $$slots = {}, $$scope } = $$props; + + $$self.$set = $$props => { + if ("onClick" in $$props) $$invalidate(0, onClick = $$props.onClick); + if ("disabled" in $$props) $$invalidate(1, disabled = $$props.disabled); + if ("dark" in $$props) $$invalidate(2, dark = $$props.dark); + if ("inline" in $$props) $$invalidate(3, inline = $$props.inline); + if ("secondary" in $$props) $$invalidate(4, secondary = $$props.secondary); + if ("$$scope" in $$props) $$invalidate(5, $$scope = $$props.$$scope); + }; + + return [onClick, disabled, dark, inline, secondary, $$scope, $$slots]; +} + +class Button extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* SvelteComponent */ "a"] { + constructor(options) { + super(); + + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* init */ "B"])(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* safe_not_equal */ "M"], { + onClick: 0, + disabled: 1, + dark: 2, + inline: 3, + secondary: 4 + }); + } +} + +/* harmony default export */ __webpack_exports__["a"] = (Button); + + + +/***/ }), +/* 4 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); +/* harmony import */ var _workdir_src_components_Info_svelte_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(184); +/* harmony import */ var _workdir_src_components_Info_svelte_css__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_workdir_src_components_Info_svelte_css__WEBPACK_IMPORTED_MODULE_1__); +/* src/components/Info.svelte generated by Svelte v3.18.2 */ + + +function create_fragment(ctx) { + let p; + let current; + const default_slot_template = /*$$slots*/ ctx[6].default; + const default_slot = Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* create_slot */ "n"])(default_slot_template, ctx, /*$$scope*/ ctx[5], null); + + return { + c() { + p = Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* element */ "r"])("p"); + if (default_slot) default_slot.c(); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* attr */ "f"])(p, "class", "svelte-jdmp6u"); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "center", /*center*/ ctx[0]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "left", /*left*/ ctx[1]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "warning", /*warning*/ ctx[2]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "error", /*error*/ ctx[3]); + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "success", /*success*/ ctx[4]); + }, + m(target, anchor) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* insert */ "C"])(target, p, anchor); + + if (default_slot) { + default_slot.m(p, null); + } + + current = true; + }, + p(ctx, [dirty]) { + if (default_slot && default_slot.p && dirty & /*$$scope*/ 32) { + default_slot.p(Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* get_slot_context */ "v"])(default_slot_template, ctx, /*$$scope*/ ctx[5], null), Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* get_slot_changes */ "u"])(default_slot_template, /*$$scope*/ ctx[5], dirty, null)); + } + + if (dirty & /*center*/ 1) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "center", /*center*/ ctx[0]); + } + + if (dirty & /*left*/ 2) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "left", /*left*/ ctx[1]); + } + + if (dirty & /*warning*/ 4) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "warning", /*warning*/ ctx[2]); + } + + if (dirty & /*error*/ 8) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "error", /*error*/ ctx[3]); + } + + if (dirty & /*success*/ 16) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* toggle_class */ "T"])(p, "success", /*success*/ ctx[4]); + } + }, + i(local) { + if (current) return; + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_in */ "U"])(default_slot, local); + current = true; + }, + o(local) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_out */ "V"])(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* detach */ "q"])(p); + if (default_slot) default_slot.d(detaching); + } + }; +} + +function instance($$self, $$props, $$invalidate) { + let { center } = $$props; + let { left } = $$props; + let { warning } = $$props; + let { error } = $$props; + let { success } = $$props; + let { $$slots = {}, $$scope } = $$props; + + $$self.$set = $$props => { + if ("center" in $$props) $$invalidate(0, center = $$props.center); + if ("left" in $$props) $$invalidate(1, left = $$props.left); + if ("warning" in $$props) $$invalidate(2, warning = $$props.warning); + if ("error" in $$props) $$invalidate(3, error = $$props.error); + if ("success" in $$props) $$invalidate(4, success = $$props.success); + if ("$$scope" in $$props) $$invalidate(5, $$scope = $$props.$$scope); + }; + + return [center, left, warning, error, success, $$scope, $$slots]; +} + +class Info extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* SvelteComponent */ "a"] { + constructor(options) { + super(); + + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* init */ "B"])(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* safe_not_equal */ "M"], { + center: 0, + left: 1, + warning: 2, + error: 3, + success: 4 + }); + } +} + +/* harmony default export */ __webpack_exports__["a"] = (Info); + + + +/***/ }), +/* 5 */ +/***/ (function(module, exports) { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }) + } + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } + } +} + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +/* eslint-disable node/no-deprecated-api */ +var buffer = __webpack_require__(11) +var Buffer = buffer.Buffer + +// alternative to using Object.keys for old browsers +function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer +} + +function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.prototype = Object.create(Buffer.prototype) + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer) + +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf +} + +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) +} + +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) +} + + +/***/ }), +/* 7 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); +/* harmony import */ var _Button__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); +/* harmony import */ var _lib_state__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1); +/* src/components/Footer.svelte generated by Svelte v3.18.2 */ + + + + + +function create_if_block_1(ctx) { + let current; + + const button = new _Button__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]({ + props: { + onClick: /*onBack*/ ctx[2], + dark: true, + $$slots: { default: [create_default_slot_1] }, + $$scope: { ctx } + } + }); + + return { + c() { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* create_component */ "m"])(button.$$.fragment); + }, + m(target, anchor) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* mount_component */ "F"])(button, target, anchor); + current = true; + }, + p(ctx, dirty) { + const button_changes = {}; + if (dirty & /*onBack*/ 4) button_changes.onClick = /*onBack*/ ctx[2]; + + if (dirty & /*$$scope*/ 32) { + button_changes.$$scope = { dirty, ctx }; + } + + button.$set(button_changes); + }, + i(local) { + if (current) return; + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_in */ "U"])(button.$$.fragment, local); + current = true; + }, + o(local) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_out */ "V"])(button.$$.fragment, local); + current = false; + }, + d(detaching) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* destroy_component */ "o"])(button, detaching); + } + }; +} + +// (15:4) {#if cancel} +function create_if_block(ctx) { + let current; + + const button = new _Button__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"]({ + props: { + onClick: _lib_state__WEBPACK_IMPORTED_MODULE_2__[/* resetState */ "m"], + dark: true, + $$slots: { default: [create_default_slot] }, + $$scope: { ctx } + } + }); + + return { + c() { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* create_component */ "m"])(button.$$.fragment); + }, + m(target, anchor) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* mount_component */ "F"])(button, target, anchor); + current = true; + }, + p(ctx, dirty) { + const button_changes = {}; + + if (dirty & /*$$scope*/ 32) { + button_changes.$$scope = { dirty, ctx }; + } + + button.$set(button_changes); + }, + i(local) { + if (current) return; + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_in */ "U"])(button.$$.fragment, local); + current = true; + }, + o(local) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* transition_out */ "V"])(button.$$.fragment, local); + current = false; + }, + d(detaching) { + Object(svelte_internal__WEBPACK_IMPORTED_MODULE_0__[/* destroy_component */ "o"])(button, detaching); + } + }; +} + +// (18:8)