1988 lines
66 KiB
JavaScript
1988 lines
66 KiB
JavaScript
|
||
(function(l, r) { if (!l || l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (self.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(self.document);
|
||
var app = (function () {
|
||
'use strict';
|
||
|
||
function noop() { }
|
||
function assign(tar, src) {
|
||
// @ts-ignore
|
||
for (const k in src)
|
||
tar[k] = src[k];
|
||
return tar;
|
||
}
|
||
function add_location(element, file, line, column, char) {
|
||
element.__svelte_meta = {
|
||
loc: { file, line, column, char }
|
||
};
|
||
}
|
||
function run(fn) {
|
||
return fn();
|
||
}
|
||
function blank_object() {
|
||
return Object.create(null);
|
||
}
|
||
function run_all(fns) {
|
||
fns.forEach(run);
|
||
}
|
||
function is_function(thing) {
|
||
return typeof thing === 'function';
|
||
}
|
||
function safe_not_equal(a, b) {
|
||
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
|
||
}
|
||
let src_url_equal_anchor;
|
||
function src_url_equal(element_src, url) {
|
||
if (!src_url_equal_anchor) {
|
||
src_url_equal_anchor = document.createElement('a');
|
||
}
|
||
src_url_equal_anchor.href = url;
|
||
return element_src === src_url_equal_anchor.href;
|
||
}
|
||
function is_empty(obj) {
|
||
return Object.keys(obj).length === 0;
|
||
}
|
||
function exclude_internal_props(props) {
|
||
const result = {};
|
||
for (const k in props)
|
||
if (k[0] !== '$')
|
||
result[k] = props[k];
|
||
return result;
|
||
}
|
||
function action_destroyer(action_result) {
|
||
return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
|
||
}
|
||
function append(target, node) {
|
||
target.appendChild(node);
|
||
}
|
||
function insert(target, node, anchor) {
|
||
target.insertBefore(node, anchor || null);
|
||
}
|
||
function detach(node) {
|
||
if (node.parentNode) {
|
||
node.parentNode.removeChild(node);
|
||
}
|
||
}
|
||
function element(name) {
|
||
return document.createElement(name);
|
||
}
|
||
function text(data) {
|
||
return document.createTextNode(data);
|
||
}
|
||
function space() {
|
||
return text(' ');
|
||
}
|
||
function empty() {
|
||
return text('');
|
||
}
|
||
function listen(node, event, handler, options) {
|
||
node.addEventListener(event, handler, options);
|
||
return () => node.removeEventListener(event, handler, options);
|
||
}
|
||
function attr(node, attribute, value) {
|
||
if (value == null)
|
||
node.removeAttribute(attribute);
|
||
else if (node.getAttribute(attribute) !== value)
|
||
node.setAttribute(attribute, value);
|
||
}
|
||
function children(element) {
|
||
return Array.from(element.childNodes);
|
||
}
|
||
function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
|
||
const e = document.createEvent('CustomEvent');
|
||
e.initCustomEvent(type, bubbles, cancelable, detail);
|
||
return e;
|
||
}
|
||
|
||
let current_component;
|
||
function set_current_component(component) {
|
||
current_component = component;
|
||
}
|
||
function get_current_component() {
|
||
if (!current_component)
|
||
throw new Error('Function called outside component initialization');
|
||
return current_component;
|
||
}
|
||
/**
|
||
* The `onMount` function schedules a callback to run as soon as the component has been mounted to the DOM.
|
||
* It must be called during the component's initialisation (but doesn't need to live *inside* the component;
|
||
* it can be called from an external module).
|
||
*
|
||
* `onMount` does not run inside a [server-side component](/docs#run-time-server-side-component-api).
|
||
*
|
||
* https://svelte.dev/docs#run-time-svelte-onmount
|
||
*/
|
||
function onMount(fn) {
|
||
get_current_component().$$.on_mount.push(fn);
|
||
}
|
||
/**
|
||
* Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).
|
||
* Event dispatchers are functions that can take two arguments: `name` and `detail`.
|
||
*
|
||
* Component events created with `createEventDispatcher` create a
|
||
* [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
|
||
* These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
|
||
* The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
|
||
* property and can contain any type of data.
|
||
*
|
||
* https://svelte.dev/docs#run-time-svelte-createeventdispatcher
|
||
*/
|
||
function createEventDispatcher() {
|
||
const component = get_current_component();
|
||
return (type, detail, { cancelable = false } = {}) => {
|
||
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, { cancelable });
|
||
callbacks.slice().forEach(fn => {
|
||
fn.call(component, event);
|
||
});
|
||
return !event.defaultPrevented;
|
||
}
|
||
return true;
|
||
};
|
||
}
|
||
|
||
const dirty_components = [];
|
||
const binding_callbacks = [];
|
||
let render_callbacks = [];
|
||
const flush_callbacks = [];
|
||
const resolved_promise = /* @__PURE__ */ Promise.resolve();
|
||
let update_scheduled = false;
|
||
function schedule_update() {
|
||
if (!update_scheduled) {
|
||
update_scheduled = true;
|
||
resolved_promise.then(flush);
|
||
}
|
||
}
|
||
function add_render_callback(fn) {
|
||
render_callbacks.push(fn);
|
||
}
|
||
// flush() calls callbacks in this order:
|
||
// 1. All beforeUpdate callbacks, in order: parents before children
|
||
// 2. All bind:this callbacks, in reverse order: children before parents.
|
||
// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
|
||
// for afterUpdates called during the initial onMount, which are called in
|
||
// reverse order: children before parents.
|
||
// Since callbacks might update component values, which could trigger another
|
||
// call to flush(), the following steps guard against this:
|
||
// 1. During beforeUpdate, any updated components will be added to the
|
||
// dirty_components array and will cause a reentrant call to flush(). Because
|
||
// the flush index is kept outside the function, the reentrant call will pick
|
||
// up where the earlier call left off and go through all dirty components. The
|
||
// current_component value is saved and restored so that the reentrant call will
|
||
// not interfere with the "parent" flush() call.
|
||
// 2. bind:this callbacks cannot trigger new flush() calls.
|
||
// 3. During afterUpdate, any updated components will NOT have their afterUpdate
|
||
// callback called a second time; the seen_callbacks set, outside the flush()
|
||
// function, guarantees this behavior.
|
||
const seen_callbacks = new Set();
|
||
let flushidx = 0; // Do *not* move this inside the flush() function
|
||
function flush() {
|
||
// Do not reenter flush while dirty components are updated, as this can
|
||
// result in an infinite loop. Instead, let the inner flush handle it.
|
||
// Reentrancy is ok afterwards for bindings etc.
|
||
if (flushidx !== 0) {
|
||
return;
|
||
}
|
||
const saved_component = current_component;
|
||
do {
|
||
// first, call beforeUpdate functions
|
||
// and update components
|
||
try {
|
||
while (flushidx < dirty_components.length) {
|
||
const component = dirty_components[flushidx];
|
||
flushidx++;
|
||
set_current_component(component);
|
||
update(component.$$);
|
||
}
|
||
}
|
||
catch (e) {
|
||
// reset dirty state to not end up in a deadlocked state and then rethrow
|
||
dirty_components.length = 0;
|
||
flushidx = 0;
|
||
throw e;
|
||
}
|
||
set_current_component(null);
|
||
dirty_components.length = 0;
|
||
flushidx = 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;
|
||
seen_callbacks.clear();
|
||
set_current_component(saved_component);
|
||
}
|
||
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);
|
||
}
|
||
}
|
||
/**
|
||
* Useful for example to execute remaining `afterUpdate` callbacks before executing `destroy`.
|
||
*/
|
||
function flush_render_callbacks(fns) {
|
||
const filtered = [];
|
||
const targets = [];
|
||
render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
|
||
targets.forEach((c) => c());
|
||
render_callbacks = filtered;
|
||
}
|
||
const outroing = new Set();
|
||
let outros;
|
||
function transition_in(block, local) {
|
||
if (block && block.i) {
|
||
outroing.delete(block);
|
||
block.i(local);
|
||
}
|
||
}
|
||
function transition_out(block, local, detach, callback) {
|
||
if (block && block.o) {
|
||
if (outroing.has(block))
|
||
return;
|
||
outroing.add(block);
|
||
outros.c.push(() => {
|
||
outroing.delete(block);
|
||
if (callback) {
|
||
if (detach)
|
||
block.d(1);
|
||
callback();
|
||
}
|
||
});
|
||
block.o(local);
|
||
}
|
||
else if (callback) {
|
||
callback();
|
||
}
|
||
}
|
||
function create_component(block) {
|
||
block && block.c();
|
||
}
|
||
function mount_component(component, target, anchor, customElement) {
|
||
const { fragment, after_update } = component.$$;
|
||
fragment && fragment.m(target, anchor);
|
||
if (!customElement) {
|
||
// onMount happens before the initial afterUpdate
|
||
add_render_callback(() => {
|
||
const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
|
||
// if the component was destroyed immediately
|
||
// it will update the `$$.on_destroy` reference to `null`.
|
||
// the destructured on_destroy may still reference to the old array
|
||
if (component.$$.on_destroy) {
|
||
component.$$.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) {
|
||
flush_render_callbacks($$.after_update);
|
||
run_all($$.on_destroy);
|
||
$$.fragment && $$.fragment.d(detaching);
|
||
// TODO null out other refs, including component.$$ (but need to
|
||
// preserve final state?)
|
||
$$.on_destroy = $$.fragment = null;
|
||
$$.ctx = [];
|
||
}
|
||
}
|
||
function make_dirty(component, i) {
|
||
if (component.$$.dirty[0] === -1) {
|
||
dirty_components.push(component);
|
||
schedule_update();
|
||
component.$$.dirty.fill(0);
|
||
}
|
||
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
|
||
}
|
||
function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
|
||
const parent_component = current_component;
|
||
set_current_component(component);
|
||
const $$ = component.$$ = {
|
||
fragment: null,
|
||
ctx: [],
|
||
// state
|
||
props,
|
||
update: noop,
|
||
not_equal,
|
||
bound: blank_object(),
|
||
// lifecycle
|
||
on_mount: [],
|
||
on_destroy: [],
|
||
on_disconnect: [],
|
||
before_update: [],
|
||
after_update: [],
|
||
context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
|
||
// everything else
|
||
callbacks: blank_object(),
|
||
dirty,
|
||
skip_bound: false,
|
||
root: options.target || parent_component.$$.root
|
||
};
|
||
append_styles && append_styles($$.root);
|
||
let ready = false;
|
||
$$.ctx = instance
|
||
? instance(component, options.props || {}, (i, ret, ...rest) => {
|
||
const value = rest.length ? rest[0] : ret;
|
||
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
|
||
if (!$$.skip_bound && $$.bound[i])
|
||
$$.bound[i](value);
|
||
if (ready)
|
||
make_dirty(component, i);
|
||
}
|
||
return ret;
|
||
})
|
||
: [];
|
||
$$.update();
|
||
ready = true;
|
||
run_all($$.before_update);
|
||
// `false` as a special case of no DOM component
|
||
$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
|
||
if (options.target) {
|
||
if (options.hydrate) {
|
||
const nodes = children(options.target);
|
||
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
||
$$.fragment && $$.fragment.l(nodes);
|
||
nodes.forEach(detach);
|
||
}
|
||
else {
|
||
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
||
$$.fragment && $$.fragment.c();
|
||
}
|
||
if (options.intro)
|
||
transition_in(component.$$.fragment);
|
||
mount_component(component, options.target, options.anchor, options.customElement);
|
||
flush();
|
||
}
|
||
set_current_component(parent_component);
|
||
}
|
||
/**
|
||
* Base class for Svelte components. Used when dev=false.
|
||
*/
|
||
class SvelteComponent {
|
||
$destroy() {
|
||
destroy_component(this, 1);
|
||
this.$destroy = noop;
|
||
}
|
||
$on(type, callback) {
|
||
if (!is_function(callback)) {
|
||
return noop;
|
||
}
|
||
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
|
||
callbacks.push(callback);
|
||
return () => {
|
||
const index = callbacks.indexOf(callback);
|
||
if (index !== -1)
|
||
callbacks.splice(index, 1);
|
||
};
|
||
}
|
||
$set($$props) {
|
||
if (this.$$set && !is_empty($$props)) {
|
||
this.$$.skip_bound = true;
|
||
this.$$set($$props);
|
||
this.$$.skip_bound = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
function dispatch_dev(type, detail) {
|
||
document.dispatchEvent(custom_event(type, Object.assign({ version: '3.59.2' }, detail), { bubbles: true }));
|
||
}
|
||
function append_dev(target, node) {
|
||
dispatch_dev('SvelteDOMInsert', { target, node });
|
||
append(target, node);
|
||
}
|
||
function insert_dev(target, node, anchor) {
|
||
dispatch_dev('SvelteDOMInsert', { target, node, anchor });
|
||
insert(target, node, anchor);
|
||
}
|
||
function detach_dev(node) {
|
||
dispatch_dev('SvelteDOMRemove', { node });
|
||
detach(node);
|
||
}
|
||
function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation, has_stop_immediate_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');
|
||
if (has_stop_immediate_propagation)
|
||
modifiers.push('stopImmediatePropagation');
|
||
dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
|
||
const dispose = listen(node, event, handler, options);
|
||
return () => {
|
||
dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
|
||
dispose();
|
||
};
|
||
}
|
||
function attr_dev(node, attribute, value) {
|
||
attr(node, attribute, value);
|
||
if (value == null)
|
||
dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
|
||
else
|
||
dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
|
||
}
|
||
function set_data_dev(text, data) {
|
||
data = '' + data;
|
||
if (text.data === data)
|
||
return;
|
||
dispatch_dev('SvelteDOMSetData', { node: text, data });
|
||
text.data = data;
|
||
}
|
||
function validate_slots(name, slot, keys) {
|
||
for (const slot_key of Object.keys(slot)) {
|
||
if (!~keys.indexOf(slot_key)) {
|
||
console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* Base class for Svelte components with some minor dev-enhancements. Used when dev=true.
|
||
*/
|
||
class SvelteComponentDev extends SvelteComponent {
|
||
constructor(options) {
|
||
if (!options || (!options.target && !options.$$inline)) {
|
||
throw new Error("'target' is a required option");
|
||
}
|
||
super();
|
||
}
|
||
$destroy() {
|
||
super.$destroy();
|
||
this.$destroy = () => {
|
||
console.warn('Component was already destroyed'); // eslint-disable-line no-console
|
||
};
|
||
}
|
||
$capture_state() { }
|
||
$inject_state() { }
|
||
}
|
||
|
||
/* src\TailwindCSS\TailwindCSS.svelte generated by Svelte v3.59.2 */
|
||
|
||
function create_fragment$3(ctx) {
|
||
const block = {
|
||
c: noop,
|
||
l: function claim(nodes) {
|
||
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
||
},
|
||
m: noop,
|
||
p: noop,
|
||
i: noop,
|
||
o: noop,
|
||
d: noop
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$3.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function instance$3($$self, $$props) {
|
||
let { $$slots: slots = {}, $$scope } = $$props;
|
||
validate_slots('TailwindCSS', slots, []);
|
||
const writable_props = [];
|
||
|
||
Object.keys($$props).forEach(key => {
|
||
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<TailwindCSS> was created with unknown prop '${key}'`);
|
||
});
|
||
|
||
return [];
|
||
}
|
||
|
||
class TailwindCSS extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options);
|
||
init(this, options, instance$3, create_fragment$3, safe_not_equal, {});
|
||
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "TailwindCSS",
|
||
options,
|
||
id: create_fragment$3.name
|
||
});
|
||
}
|
||
}
|
||
|
||
/* node_modules\svelte-turnstile\dist\Turnstile.svelte generated by Svelte v3.59.2 */
|
||
const file$1 = "node_modules\\svelte-turnstile\\dist\\Turnstile.svelte";
|
||
|
||
// (78:4) {#if mounted && !loaded}
|
||
function create_if_block_1$1(ctx) {
|
||
let script;
|
||
let script_src_value;
|
||
let mounted;
|
||
let dispose;
|
||
|
||
const block = {
|
||
c: function create() {
|
||
script = element("script");
|
||
if (!src_url_equal(script.src, script_src_value = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit")) attr_dev(script, "src", script_src_value);
|
||
script.async = true;
|
||
add_location(script, file$1, 78, 8, 1840);
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, script, anchor);
|
||
|
||
if (!mounted) {
|
||
dispose = listen_dev(script, "load", /*loadCallback*/ ctx[2], false, false, false, false);
|
||
mounted = true;
|
||
}
|
||
},
|
||
p: noop,
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(script);
|
||
mounted = false;
|
||
dispose();
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_1$1.name,
|
||
type: "if",
|
||
source: "(78:4) {#if mounted && !loaded}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
// (86:0) {#if loaded && mounted}
|
||
function create_if_block$1(ctx) {
|
||
let previous_key = /*$$props*/ ctx[4];
|
||
let key_block_anchor;
|
||
let key_block = create_key_block(ctx);
|
||
|
||
const block = {
|
||
c: function create() {
|
||
key_block.c();
|
||
key_block_anchor = empty();
|
||
},
|
||
m: function mount(target, anchor) {
|
||
key_block.m(target, anchor);
|
||
insert_dev(target, key_block_anchor, anchor);
|
||
},
|
||
p: function update(ctx, dirty) {
|
||
if (dirty & /*$$props*/ 16 && safe_not_equal(previous_key, previous_key = /*$$props*/ ctx[4])) {
|
||
key_block.d(1);
|
||
key_block = create_key_block(ctx);
|
||
key_block.c();
|
||
key_block.m(key_block_anchor.parentNode, key_block_anchor);
|
||
} else {
|
||
key_block.p(ctx, dirty);
|
||
}
|
||
},
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(key_block_anchor);
|
||
key_block.d(detaching);
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block$1.name,
|
||
type: "if",
|
||
source: "(86:0) {#if loaded && mounted}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
// (87:4) {#key $$props}
|
||
function create_key_block(ctx) {
|
||
let div;
|
||
let mounted;
|
||
let dispose;
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div");
|
||
add_location(div, file$1, 87, 8, 2076);
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor);
|
||
|
||
if (!mounted) {
|
||
dispose = action_destroyer(/*turnstile*/ ctx[3].call(null, div));
|
||
mounted = true;
|
||
}
|
||
},
|
||
p: noop,
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(div);
|
||
mounted = false;
|
||
dispose();
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_key_block.name,
|
||
type: "key",
|
||
source: "(87:4) {#key $$props}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function create_fragment$2(ctx) {
|
||
let if_block0_anchor;
|
||
let t;
|
||
let if_block1_anchor;
|
||
let if_block0 = /*mounted*/ ctx[1] && !/*loaded*/ ctx[0] && create_if_block_1$1(ctx);
|
||
let if_block1 = /*loaded*/ ctx[0] && /*mounted*/ ctx[1] && create_if_block$1(ctx);
|
||
|
||
const block = {
|
||
c: function create() {
|
||
if (if_block0) if_block0.c();
|
||
if_block0_anchor = empty();
|
||
t = space();
|
||
if (if_block1) if_block1.c();
|
||
if_block1_anchor = empty();
|
||
},
|
||
l: function claim(nodes) {
|
||
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
||
},
|
||
m: function mount(target, anchor) {
|
||
if (if_block0) if_block0.m(document.head, null);
|
||
append_dev(document.head, if_block0_anchor);
|
||
insert_dev(target, t, anchor);
|
||
if (if_block1) if_block1.m(target, anchor);
|
||
insert_dev(target, if_block1_anchor, anchor);
|
||
},
|
||
p: function update(ctx, [dirty]) {
|
||
if (/*mounted*/ ctx[1] && !/*loaded*/ ctx[0]) {
|
||
if (if_block0) {
|
||
if_block0.p(ctx, dirty);
|
||
} else {
|
||
if_block0 = create_if_block_1$1(ctx);
|
||
if_block0.c();
|
||
if_block0.m(if_block0_anchor.parentNode, if_block0_anchor);
|
||
}
|
||
} else if (if_block0) {
|
||
if_block0.d(1);
|
||
if_block0 = null;
|
||
}
|
||
|
||
if (/*loaded*/ ctx[0] && /*mounted*/ ctx[1]) {
|
||
if (if_block1) {
|
||
if_block1.p(ctx, dirty);
|
||
} else {
|
||
if_block1 = create_if_block$1(ctx);
|
||
if_block1.c();
|
||
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
||
}
|
||
} else if (if_block1) {
|
||
if_block1.d(1);
|
||
if_block1 = null;
|
||
}
|
||
},
|
||
i: noop,
|
||
o: noop,
|
||
d: function destroy(detaching) {
|
||
if (if_block0) if_block0.d(detaching);
|
||
detach_dev(if_block0_anchor);
|
||
if (detaching) detach_dev(t);
|
||
if (if_block1) if_block1.d(detaching);
|
||
if (detaching) detach_dev(if_block1_anchor);
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$2.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function hasTurnstile() {
|
||
if (typeof window == 'undefined') return null;
|
||
return 'turnstile' in window;
|
||
}
|
||
|
||
function instance$2($$self, $$props, $$invalidate) {
|
||
let { $$slots: slots = {}, $$scope } = $$props;
|
||
validate_slots('Turnstile', slots, []);
|
||
const dispatch = createEventDispatcher();
|
||
let loaded = hasTurnstile();
|
||
let mounted = false;
|
||
let widgetId;
|
||
let { siteKey } = $$props;
|
||
let { appearance = 'always' } = $$props;
|
||
let { language = 'auto' } = $$props;
|
||
let { formsField = 'cf-turnstile-response' } = $$props;
|
||
let { execution = 'render' } = $$props;
|
||
let { action = undefined } = $$props;
|
||
let { cData = undefined } = $$props;
|
||
let { retryInterval = 8000 } = $$props;
|
||
let { retry = 'auto' } = $$props;
|
||
let { theme = 'auto' } = $$props;
|
||
let { size = 'normal' } = $$props;
|
||
let { forms = true } = $$props;
|
||
let { tabIndex = 0 } = $$props;
|
||
|
||
onMount(() => {
|
||
$$invalidate(1, mounted = true);
|
||
|
||
return () => {
|
||
$$invalidate(1, mounted = false);
|
||
};
|
||
});
|
||
|
||
function loadCallback() {
|
||
$$invalidate(0, loaded = true);
|
||
}
|
||
|
||
function error() {
|
||
dispatch('turnstile-error', {});
|
||
}
|
||
|
||
function expired() {
|
||
dispatch('turnstile-expired', {});
|
||
}
|
||
|
||
function timeout() {
|
||
dispatch('turnstile-timeout', {});
|
||
}
|
||
|
||
function callback(token) {
|
||
dispatch('turnstile-callback', { token });
|
||
}
|
||
|
||
function reset() {
|
||
window.turnstile.reset(widgetId);
|
||
}
|
||
|
||
const turnstile = node => {
|
||
const id = window.turnstile.render(node, {
|
||
'timeout-callback': timeout,
|
||
'expired-callback': expired,
|
||
'error-callback': error,
|
||
callback,
|
||
sitekey: siteKey,
|
||
'response-field-name': formsField,
|
||
'retry-interval': retryInterval,
|
||
'response-field': forms,
|
||
tabindex: tabIndex,
|
||
appearance,
|
||
execution,
|
||
language,
|
||
action,
|
||
retry,
|
||
theme,
|
||
cData,
|
||
size
|
||
});
|
||
|
||
widgetId = id;
|
||
|
||
return {
|
||
destroy: () => {
|
||
window.turnstile.remove(id);
|
||
}
|
||
};
|
||
};
|
||
|
||
$$self.$$.on_mount.push(function () {
|
||
if (siteKey === undefined && !('siteKey' in $$props || $$self.$$.bound[$$self.$$.props['siteKey']])) {
|
||
console.warn("<Turnstile> was created without expected prop 'siteKey'");
|
||
}
|
||
});
|
||
|
||
$$self.$$set = $$new_props => {
|
||
$$invalidate(4, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
|
||
if ('siteKey' in $$new_props) $$invalidate(5, siteKey = $$new_props.siteKey);
|
||
if ('appearance' in $$new_props) $$invalidate(6, appearance = $$new_props.appearance);
|
||
if ('language' in $$new_props) $$invalidate(7, language = $$new_props.language);
|
||
if ('formsField' in $$new_props) $$invalidate(8, formsField = $$new_props.formsField);
|
||
if ('execution' in $$new_props) $$invalidate(9, execution = $$new_props.execution);
|
||
if ('action' in $$new_props) $$invalidate(10, action = $$new_props.action);
|
||
if ('cData' in $$new_props) $$invalidate(11, cData = $$new_props.cData);
|
||
if ('retryInterval' in $$new_props) $$invalidate(12, retryInterval = $$new_props.retryInterval);
|
||
if ('retry' in $$new_props) $$invalidate(13, retry = $$new_props.retry);
|
||
if ('theme' in $$new_props) $$invalidate(14, theme = $$new_props.theme);
|
||
if ('size' in $$new_props) $$invalidate(15, size = $$new_props.size);
|
||
if ('forms' in $$new_props) $$invalidate(16, forms = $$new_props.forms);
|
||
if ('tabIndex' in $$new_props) $$invalidate(17, tabIndex = $$new_props.tabIndex);
|
||
};
|
||
|
||
$$self.$capture_state = () => ({
|
||
createEventDispatcher,
|
||
onMount,
|
||
dispatch,
|
||
loaded,
|
||
mounted,
|
||
widgetId,
|
||
siteKey,
|
||
appearance,
|
||
language,
|
||
formsField,
|
||
execution,
|
||
action,
|
||
cData,
|
||
retryInterval,
|
||
retry,
|
||
theme,
|
||
size,
|
||
forms,
|
||
tabIndex,
|
||
hasTurnstile,
|
||
loadCallback,
|
||
error,
|
||
expired,
|
||
timeout,
|
||
callback,
|
||
reset,
|
||
turnstile
|
||
});
|
||
|
||
$$self.$inject_state = $$new_props => {
|
||
$$invalidate(4, $$props = assign(assign({}, $$props), $$new_props));
|
||
if ('loaded' in $$props) $$invalidate(0, loaded = $$new_props.loaded);
|
||
if ('mounted' in $$props) $$invalidate(1, mounted = $$new_props.mounted);
|
||
if ('widgetId' in $$props) widgetId = $$new_props.widgetId;
|
||
if ('siteKey' in $$props) $$invalidate(5, siteKey = $$new_props.siteKey);
|
||
if ('appearance' in $$props) $$invalidate(6, appearance = $$new_props.appearance);
|
||
if ('language' in $$props) $$invalidate(7, language = $$new_props.language);
|
||
if ('formsField' in $$props) $$invalidate(8, formsField = $$new_props.formsField);
|
||
if ('execution' in $$props) $$invalidate(9, execution = $$new_props.execution);
|
||
if ('action' in $$props) $$invalidate(10, action = $$new_props.action);
|
||
if ('cData' in $$props) $$invalidate(11, cData = $$new_props.cData);
|
||
if ('retryInterval' in $$props) $$invalidate(12, retryInterval = $$new_props.retryInterval);
|
||
if ('retry' in $$props) $$invalidate(13, retry = $$new_props.retry);
|
||
if ('theme' in $$props) $$invalidate(14, theme = $$new_props.theme);
|
||
if ('size' in $$props) $$invalidate(15, size = $$new_props.size);
|
||
if ('forms' in $$props) $$invalidate(16, forms = $$new_props.forms);
|
||
if ('tabIndex' in $$props) $$invalidate(17, tabIndex = $$new_props.tabIndex);
|
||
};
|
||
|
||
if ($$props && "$$inject" in $$props) {
|
||
$$self.$inject_state($$props.$$inject);
|
||
}
|
||
|
||
$$props = exclude_internal_props($$props);
|
||
|
||
return [
|
||
loaded,
|
||
mounted,
|
||
loadCallback,
|
||
turnstile,
|
||
$$props,
|
||
siteKey,
|
||
appearance,
|
||
language,
|
||
formsField,
|
||
execution,
|
||
action,
|
||
cData,
|
||
retryInterval,
|
||
retry,
|
||
theme,
|
||
size,
|
||
forms,
|
||
tabIndex,
|
||
reset
|
||
];
|
||
}
|
||
|
||
class Turnstile extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options);
|
||
|
||
init(this, options, instance$2, create_fragment$2, safe_not_equal, {
|
||
siteKey: 5,
|
||
appearance: 6,
|
||
language: 7,
|
||
formsField: 8,
|
||
execution: 9,
|
||
action: 10,
|
||
cData: 11,
|
||
retryInterval: 12,
|
||
retry: 13,
|
||
theme: 14,
|
||
size: 15,
|
||
forms: 16,
|
||
tabIndex: 17,
|
||
reset: 18
|
||
});
|
||
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "Turnstile",
|
||
options,
|
||
id: create_fragment$2.name
|
||
});
|
||
}
|
||
|
||
get siteKey() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set siteKey(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get appearance() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set appearance(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get language() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set language(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get formsField() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set formsField(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get execution() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set execution(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get action() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set action(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get cData() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set cData(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get retryInterval() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set retryInterval(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get retry() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set retry(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get theme() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set theme(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get size() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set size(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get forms() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set forms(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get tabIndex() {
|
||
throw new Error("<Turnstile>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set tabIndex(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get reset() {
|
||
return this.$$.ctx[18];
|
||
}
|
||
|
||
set reset(value) {
|
||
throw new Error("<Turnstile>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src\Pages\DepositPage.svelte generated by Svelte v3.59.2 */
|
||
const file = "src\\Pages\\DepositPage.svelte";
|
||
|
||
// (130:8) {#if selectedBank === "sber" && captchaVerified}
|
||
function create_if_block(ctx) {
|
||
let button;
|
||
|
||
let t0_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
|
||
? "Отмена"
|
||
: "Запросить реквизиты") + "";
|
||
|
||
let t0;
|
||
let button_class_value;
|
||
let t1;
|
||
let t2;
|
||
let if_block1_anchor;
|
||
let mounted;
|
||
let dispose;
|
||
let if_block0 = /*requestingReqs*/ ctx[3] && create_if_block_2(ctx);
|
||
let if_block1 = /*showReqs*/ ctx[5] && create_if_block_1(ctx);
|
||
|
||
const block = {
|
||
c: function create() {
|
||
button = element("button");
|
||
t0 = text(t0_value);
|
||
t1 = space();
|
||
if (if_block0) if_block0.c();
|
||
t2 = space();
|
||
if (if_block1) if_block1.c();
|
||
if_block1_anchor = empty();
|
||
|
||
attr_dev(button, "class", button_class_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
|
||
? "bg-slate-950 ring-indigo-800 hover:bg-slate-900"
|
||
: "bg-indigo-800 hover:bg-indigo-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4 rounded-3xl transition-all duration-75 ring-2 ring-inset focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white");
|
||
|
||
add_location(button, file, 130, 10, 3913);
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, button, anchor);
|
||
append_dev(button, t0);
|
||
insert_dev(target, t1, anchor);
|
||
if (if_block0) if_block0.m(target, anchor);
|
||
insert_dev(target, t2, anchor);
|
||
if (if_block1) if_block1.m(target, anchor);
|
||
insert_dev(target, if_block1_anchor, anchor);
|
||
|
||
if (!mounted) {
|
||
dispose = listen_dev(button, "click", /*click_handler_1*/ ctx[13], false, false, false, false);
|
||
mounted = true;
|
||
}
|
||
},
|
||
p: function update(ctx, dirty) {
|
||
if (dirty & /*requestingReqs, showReqs*/ 40 && t0_value !== (t0_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
|
||
? "Отмена"
|
||
: "Запросить реквизиты") + "")) set_data_dev(t0, t0_value);
|
||
|
||
if (dirty & /*requestingReqs, showReqs*/ 40 && button_class_value !== (button_class_value = (/*requestingReqs*/ ctx[3] || /*showReqs*/ ctx[5]
|
||
? "bg-slate-950 ring-indigo-800 hover:bg-slate-900"
|
||
: "bg-indigo-800 hover:bg-indigo-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4 rounded-3xl transition-all duration-75 ring-2 ring-inset focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white")) {
|
||
attr_dev(button, "class", button_class_value);
|
||
}
|
||
|
||
if (/*requestingReqs*/ ctx[3]) {
|
||
if (if_block0) {
|
||
if_block0.p(ctx, dirty);
|
||
} else {
|
||
if_block0 = create_if_block_2(ctx);
|
||
if_block0.c();
|
||
if_block0.m(t2.parentNode, t2);
|
||
}
|
||
} else if (if_block0) {
|
||
if_block0.d(1);
|
||
if_block0 = null;
|
||
}
|
||
|
||
if (/*showReqs*/ ctx[5]) {
|
||
if (if_block1) {
|
||
if_block1.p(ctx, dirty);
|
||
} else {
|
||
if_block1 = create_if_block_1(ctx);
|
||
if_block1.c();
|
||
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
||
}
|
||
} else if (if_block1) {
|
||
if_block1.d(1);
|
||
if_block1 = null;
|
||
}
|
||
},
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(button);
|
||
if (detaching) detach_dev(t1);
|
||
if (if_block0) if_block0.d(detaching);
|
||
if (detaching) detach_dev(t2);
|
||
if (if_block1) if_block1.d(detaching);
|
||
if (detaching) detach_dev(if_block1_anchor);
|
||
mounted = false;
|
||
dispose();
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block.name,
|
||
type: "if",
|
||
source: "(130:8) {#if selectedBank === \\\"sber\\\" && captchaVerified}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
// (152:10) {#if requestingReqs}
|
||
function create_if_block_2(ctx) {
|
||
let div;
|
||
let p;
|
||
let t0;
|
||
|
||
let t1_value = Math.floor(/*depositTimeLeft*/ ctx[1] / 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + ":" + Math.floor(/*depositTimeLeft*/ ctx[1] % 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + "";
|
||
|
||
let t1;
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div = element("div");
|
||
p = element("p");
|
||
t0 = text("Реквизиты появятся не позже, чем через ");
|
||
t1 = text(t1_value);
|
||
add_location(p, file, 153, 14, 4986);
|
||
attr_dev(div, "class", "flex justify-center items-center w-full");
|
||
add_location(div, file, 152, 12, 4917);
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div, anchor);
|
||
append_dev(div, p);
|
||
append_dev(p, t0);
|
||
append_dev(p, t1);
|
||
},
|
||
p: function update(ctx, dirty) {
|
||
if (dirty & /*depositTimeLeft*/ 2 && t1_value !== (t1_value = Math.floor(/*depositTimeLeft*/ ctx[1] / 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + ":" + Math.floor(/*depositTimeLeft*/ ctx[1] % 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + "")) set_data_dev(t1, t1_value);
|
||
},
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(div);
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_2.name,
|
||
type: "if",
|
||
source: "(152:10) {#if requestingReqs}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
// (169:10) {#if showReqs}
|
||
function create_if_block_1(ctx) {
|
||
let div4;
|
||
let div3;
|
||
let p0;
|
||
let t1;
|
||
let div2;
|
||
let p1;
|
||
let t2;
|
||
let t3;
|
||
let button0;
|
||
let div0;
|
||
let t4;
|
||
let div1;
|
||
let t5;
|
||
let p2;
|
||
let t8;
|
||
let p3;
|
||
let t9;
|
||
|
||
let t10_value = Math.floor(/*totalDepositTimeLeft*/ ctx[2] / 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + ":" + Math.floor(/*totalDepositTimeLeft*/ ctx[2] % 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + "";
|
||
|
||
let t10;
|
||
let t11;
|
||
let button1;
|
||
let mounted;
|
||
let dispose;
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div4 = element("div");
|
||
div3 = element("div");
|
||
p0 = element("p");
|
||
p0.textContent = "Номер карты для перевода";
|
||
t1 = space();
|
||
div2 = element("div");
|
||
p1 = element("p");
|
||
t2 = text(/*randomCard*/ ctx[6]);
|
||
t3 = space();
|
||
button0 = element("button");
|
||
div0 = element("div");
|
||
t4 = space();
|
||
div1 = element("div");
|
||
t5 = space();
|
||
p2 = element("p");
|
||
p2.textContent = `Получатель: ${/*cardHolder*/ ctx[8]}`;
|
||
t8 = space();
|
||
p3 = element("p");
|
||
t9 = text("Время на оплату ");
|
||
t10 = text(t10_value);
|
||
t11 = space();
|
||
button1 = element("button");
|
||
button1.textContent = `${"Я оплатил"}`;
|
||
attr_dev(p0, "class", "text-lg");
|
||
add_location(p0, file, 171, 16, 5680);
|
||
attr_dev(p1, "class", "text-4xl font-bold");
|
||
add_location(p1, file, 173, 18, 5817);
|
||
attr_dev(div0, "class", "absolute bg-transparent ring-2 ring-white top-2 left-3 w-4 h-5 rounded-[3px]");
|
||
add_location(div0, file, 177, 20, 6038);
|
||
attr_dev(div1, "class", "absolute bg-indigo-900 ring-2 ring-white top-3 group-hover:bg-indigo-800 left-4 w-4 h-5 rounded-[3px]");
|
||
add_location(div1, file, 180, 20, 6201);
|
||
attr_dev(button0, "class", "relative w-11 h-10 p-2 rounded-full bg-indigo-900 group hover:bg-indigo-800");
|
||
add_location(button0, file, 174, 18, 5883);
|
||
attr_dev(div2, "class", "flex gap-4 justify-center items-center");
|
||
add_location(div2, file, 172, 16, 5745);
|
||
attr_dev(p2, "class", "text-lg");
|
||
add_location(p2, file, 185, 16, 6438);
|
||
attr_dev(p3, "class", "text-lg mt-4");
|
||
add_location(p3, file, 186, 16, 6503);
|
||
attr_dev(div3, "class", "flex flex-col gap-2");
|
||
add_location(div3, file, 170, 14, 5629);
|
||
attr_dev(div4, "class", "w-full flex p-8 rounded-3xl bg-indigo-950");
|
||
add_location(div4, file, 169, 12, 5558);
|
||
|
||
attr_dev(button1, "class", ("bg-green-800 hover:bg-green-700 ring-transparent") + " w-full font-semibold text-xl flex gap-1 justify-center items-center text-center p-4 rounded-3xl transition-all duration-75 ring-2 ring-inset focus:outline-none focus:ring-inset focus:ring-1 focus:ring-white");
|
||
|
||
add_location(button1, file, 204, 12, 7161);
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div4, anchor);
|
||
append_dev(div4, div3);
|
||
append_dev(div3, p0);
|
||
append_dev(div3, t1);
|
||
append_dev(div3, div2);
|
||
append_dev(div2, p1);
|
||
append_dev(p1, t2);
|
||
append_dev(div2, t3);
|
||
append_dev(div2, button0);
|
||
append_dev(button0, div0);
|
||
append_dev(button0, t4);
|
||
append_dev(button0, div1);
|
||
append_dev(div3, t5);
|
||
append_dev(div3, p2);
|
||
append_dev(div3, t8);
|
||
append_dev(div3, p3);
|
||
append_dev(p3, t9);
|
||
append_dev(p3, t10);
|
||
insert_dev(target, t11, anchor);
|
||
insert_dev(target, button1, anchor);
|
||
|
||
if (!mounted) {
|
||
dispose = listen_dev(button1, "click", click_handler_2, false, false, false, false);
|
||
mounted = true;
|
||
}
|
||
},
|
||
p: function update(ctx, dirty) {
|
||
if (dirty & /*randomCard*/ 64) set_data_dev(t2, /*randomCard*/ ctx[6]);
|
||
|
||
if (dirty & /*totalDepositTimeLeft*/ 4 && t10_value !== (t10_value = Math.floor(/*totalDepositTimeLeft*/ ctx[2] / 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + ":" + Math.floor(/*totalDepositTimeLeft*/ ctx[2] % 60).toLocaleString("en-US", {
|
||
minimumIntegerDigits: 2,
|
||
useGrouping: false
|
||
}) + "")) set_data_dev(t10, t10_value);
|
||
},
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(div4);
|
||
if (detaching) detach_dev(t11);
|
||
if (detaching) detach_dev(button1);
|
||
mounted = false;
|
||
dispose();
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_if_block_1.name,
|
||
type: "if",
|
||
source: "(169:10) {#if showReqs}",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function create_fragment$1(ctx) {
|
||
let div20;
|
||
let div19;
|
||
let div0;
|
||
let p0;
|
||
let t0;
|
||
let t1;
|
||
let t2;
|
||
let div18;
|
||
let div5;
|
||
let p1;
|
||
let t4;
|
||
let div3;
|
||
let button;
|
||
let div1;
|
||
let img;
|
||
let img_src_value;
|
||
let t5;
|
||
let div2;
|
||
let p2;
|
||
let button_class_value;
|
||
let t7;
|
||
let div4;
|
||
let form;
|
||
let turnstile;
|
||
let t8;
|
||
let t9;
|
||
let div17;
|
||
let div16;
|
||
let div7;
|
||
let div6;
|
||
let t10;
|
||
let p3;
|
||
let t12;
|
||
let div9;
|
||
let div8;
|
||
let t13;
|
||
let p4;
|
||
let t15;
|
||
let div11;
|
||
let div10;
|
||
let t16;
|
||
let p5;
|
||
let t18;
|
||
let div13;
|
||
let div12;
|
||
let t19;
|
||
let p6;
|
||
let t20;
|
||
let span;
|
||
let t22;
|
||
let t23;
|
||
let div15;
|
||
let div14;
|
||
let t24;
|
||
let p7;
|
||
let current;
|
||
let mounted;
|
||
let dispose;
|
||
|
||
turnstile = new Turnstile({
|
||
props: { siteKey: "0x4AAAAAAAdVbiLiWPGwxHjN" },
|
||
$$inline: true
|
||
});
|
||
|
||
let if_block = /*selectedBank*/ ctx[0] === "sber" && /*captchaVerified*/ ctx[7] && create_if_block(ctx);
|
||
|
||
const block = {
|
||
c: function create() {
|
||
div20 = element("div");
|
||
div19 = element("div");
|
||
div0 = element("div");
|
||
p0 = element("p");
|
||
t0 = text("Заявка №");
|
||
t1 = text(/*randomRequestId*/ ctx[4]);
|
||
t2 = space();
|
||
div18 = element("div");
|
||
div5 = element("div");
|
||
p1 = element("p");
|
||
p1.textContent = "Выберите банк";
|
||
t4 = space();
|
||
div3 = element("div");
|
||
button = element("button");
|
||
div1 = element("div");
|
||
img = element("img");
|
||
t5 = space();
|
||
div2 = element("div");
|
||
p2 = element("p");
|
||
p2.textContent = "Сбер";
|
||
t7 = space();
|
||
div4 = element("div");
|
||
form = element("form");
|
||
create_component(turnstile.$$.fragment);
|
||
t8 = space();
|
||
if (if_block) if_block.c();
|
||
t9 = space();
|
||
div17 = element("div");
|
||
div16 = element("div");
|
||
div7 = element("div");
|
||
div6 = element("div");
|
||
t10 = space();
|
||
p3 = element("p");
|
||
p3.textContent = "Дождитесь выдачи реквизитов";
|
||
t12 = space();
|
||
div9 = element("div");
|
||
div8 = element("div");
|
||
t13 = space();
|
||
p4 = element("p");
|
||
p4.textContent = "Скопируйте реквизиты";
|
||
t15 = space();
|
||
div11 = element("div");
|
||
div10 = element("div");
|
||
t16 = space();
|
||
p5 = element("p");
|
||
p5.textContent = "Откройте приложение своего банка";
|
||
t18 = space();
|
||
div13 = element("div");
|
||
div12 = element("div");
|
||
t19 = space();
|
||
p6 = element("p");
|
||
t20 = text("Переведите ");
|
||
span = element("span");
|
||
span.textContent = "точную сумму";
|
||
t22 = text(" на указанный\r\n реквизит");
|
||
t23 = space();
|
||
div15 = element("div");
|
||
div14 = element("div");
|
||
t24 = space();
|
||
p7 = element("p");
|
||
p7.textContent = "После успешного перевода нажмите \"Я оплатил\"";
|
||
attr_dev(p0, "class", "text-xl");
|
||
add_location(p0, file, 101, 6, 2700);
|
||
attr_dev(div0, "class", "w-full flex h-16 justify-center items-center bg-slate-900 rounded-3xl");
|
||
add_location(div0, file, 98, 4, 2596);
|
||
attr_dev(p1, "class", "text-3xl font-bold");
|
||
add_location(p1, file, 105, 8, 2856);
|
||
if (!src_url_equal(img.src, img_src_value = "media/sber-logo.png")) attr_dev(img, "src", img_src_value);
|
||
attr_dev(img, "alt", "sber");
|
||
add_location(img, file, 117, 14, 3379);
|
||
attr_dev(div1, "class", "bg-transparent w-10 h-10 flex-shrink-0");
|
||
add_location(div1, file, 116, 12, 3311);
|
||
attr_dev(p2, "class", "text-xl");
|
||
add_location(p2, file, 120, 14, 3532);
|
||
attr_dev(div2, "class", "w-full flex justify-center items-center pr-16");
|
||
add_location(div2, file, 119, 12, 3457);
|
||
|
||
attr_dev(button, "class", button_class_value = "w-full rounded-3xl flex items-center gap-8 ring-2 py-4 px-4 " + (/*selectedBank*/ ctx[0] === "sber"
|
||
? "ring-indigo-600 bg-slate-900 cursor-default"
|
||
: "ring-slate-600 hover:ring-slate-300"));
|
||
|
||
add_location(button, file, 107, 10, 2943);
|
||
attr_dev(div3, "class", "flex");
|
||
add_location(div3, file, 106, 8, 2913);
|
||
attr_dev(form, "id", "8d895e75b7a0def7699e6c4d7cd54c51d9844775bd5fd5e8e3d34748");
|
||
add_location(form, file, 125, 10, 3678);
|
||
attr_dev(div4, "class", "flex w-full justify-center");
|
||
add_location(div4, file, 124, 8, 3626);
|
||
attr_dev(div5, "class", "flex flex-col w-full gap-8");
|
||
add_location(div5, file, 104, 6, 2806);
|
||
attr_dev(div6, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
|
||
add_location(div6, file, 221, 12, 7958);
|
||
add_location(p3, file, 222, 12, 8035);
|
||
attr_dev(div7, "class", "flex items-center justify-start gap-2 text-lg");
|
||
add_location(div7, file, 220, 10, 7885);
|
||
attr_dev(div8, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
|
||
add_location(div8, file, 225, 12, 8172);
|
||
add_location(p4, file, 226, 12, 8249);
|
||
attr_dev(div9, "class", "flex items-center justify-start gap-2 text-lg");
|
||
add_location(div9, file, 224, 10, 8099);
|
||
attr_dev(div10, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
|
||
add_location(div10, file, 229, 12, 8379);
|
||
add_location(p5, file, 230, 12, 8456);
|
||
attr_dev(div11, "class", "flex items-center justify-start gap-2 text-lg");
|
||
add_location(div11, file, 228, 10, 8306);
|
||
attr_dev(div12, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
|
||
add_location(div12, file, 233, 12, 8598);
|
||
attr_dev(span, "class", "underline");
|
||
add_location(span, file, 235, 25, 8705);
|
||
add_location(p6, file, 234, 12, 8675);
|
||
attr_dev(div13, "class", "flex items-center justify-start gap-2 text-lg");
|
||
add_location(div13, file, 232, 10, 8525);
|
||
attr_dev(div14, "class", "w-2 h-2 bg-white rounded-full flex-shrink-0");
|
||
add_location(div14, file, 240, 12, 8907);
|
||
add_location(p7, file, 241, 12, 8984);
|
||
attr_dev(div15, "class", "flex items-center justify-start gap-2 text-lg");
|
||
add_location(div15, file, 239, 10, 8834);
|
||
attr_dev(div16, "class", "flex flex-col w-full flex-grow-0 bg-slate-900 p-8 gap-2 h-[236px] rounded-3xl");
|
||
add_location(div16, file, 217, 8, 7761);
|
||
attr_dev(div17, "class", "flex w-full");
|
||
add_location(div17, file, 216, 6, 7726);
|
||
attr_dev(div18, "class", "flex w-full gap-16");
|
||
add_location(div18, file, 103, 4, 2766);
|
||
attr_dev(div19, "class", "flex flex-col w-[70%] gap-8 h-[50%]");
|
||
add_location(div19, file, 97, 2, 2541);
|
||
attr_dev(div20, "class", "fixed inset-0 bg-slate-950 w-full h-full flex justify-center items-center gap-4 text-white");
|
||
add_location(div20, file, 94, 0, 2428);
|
||
},
|
||
l: function claim(nodes) {
|
||
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
||
},
|
||
m: function mount(target, anchor) {
|
||
insert_dev(target, div20, anchor);
|
||
append_dev(div20, div19);
|
||
append_dev(div19, div0);
|
||
append_dev(div0, p0);
|
||
append_dev(p0, t0);
|
||
append_dev(p0, t1);
|
||
append_dev(div19, t2);
|
||
append_dev(div19, div18);
|
||
append_dev(div18, div5);
|
||
append_dev(div5, p1);
|
||
append_dev(div5, t4);
|
||
append_dev(div5, div3);
|
||
append_dev(div3, button);
|
||
append_dev(button, div1);
|
||
append_dev(div1, img);
|
||
append_dev(button, t5);
|
||
append_dev(button, div2);
|
||
append_dev(div2, p2);
|
||
append_dev(div5, t7);
|
||
append_dev(div5, div4);
|
||
append_dev(div4, form);
|
||
mount_component(turnstile, form, null);
|
||
append_dev(div5, t8);
|
||
if (if_block) if_block.m(div5, null);
|
||
append_dev(div18, t9);
|
||
append_dev(div18, div17);
|
||
append_dev(div17, div16);
|
||
append_dev(div16, div7);
|
||
append_dev(div7, div6);
|
||
append_dev(div7, t10);
|
||
append_dev(div7, p3);
|
||
append_dev(div16, t12);
|
||
append_dev(div16, div9);
|
||
append_dev(div9, div8);
|
||
append_dev(div9, t13);
|
||
append_dev(div9, p4);
|
||
append_dev(div16, t15);
|
||
append_dev(div16, div11);
|
||
append_dev(div11, div10);
|
||
append_dev(div11, t16);
|
||
append_dev(div11, p5);
|
||
append_dev(div16, t18);
|
||
append_dev(div16, div13);
|
||
append_dev(div13, div12);
|
||
append_dev(div13, t19);
|
||
append_dev(div13, p6);
|
||
append_dev(p6, t20);
|
||
append_dev(p6, span);
|
||
append_dev(p6, t22);
|
||
append_dev(div16, t23);
|
||
append_dev(div16, div15);
|
||
append_dev(div15, div14);
|
||
append_dev(div15, t24);
|
||
append_dev(div15, p7);
|
||
current = true;
|
||
|
||
if (!mounted) {
|
||
dispose = listen_dev(button, "click", /*click_handler*/ ctx[12], false, false, false, false);
|
||
mounted = true;
|
||
}
|
||
},
|
||
p: function update(ctx, [dirty]) {
|
||
if (!current || dirty & /*randomRequestId*/ 16) set_data_dev(t1, /*randomRequestId*/ ctx[4]);
|
||
|
||
if (!current || dirty & /*selectedBank*/ 1 && button_class_value !== (button_class_value = "w-full rounded-3xl flex items-center gap-8 ring-2 py-4 px-4 " + (/*selectedBank*/ ctx[0] === "sber"
|
||
? "ring-indigo-600 bg-slate-900 cursor-default"
|
||
: "ring-slate-600 hover:ring-slate-300"))) {
|
||
attr_dev(button, "class", button_class_value);
|
||
}
|
||
|
||
if (/*selectedBank*/ ctx[0] === "sber" && /*captchaVerified*/ ctx[7]) {
|
||
if (if_block) {
|
||
if_block.p(ctx, dirty);
|
||
} else {
|
||
if_block = create_if_block(ctx);
|
||
if_block.c();
|
||
if_block.m(div5, null);
|
||
}
|
||
} else if (if_block) {
|
||
if_block.d(1);
|
||
if_block = null;
|
||
}
|
||
},
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
transition_in(turnstile.$$.fragment, local);
|
||
current = true;
|
||
},
|
||
o: function outro(local) {
|
||
transition_out(turnstile.$$.fragment, local);
|
||
current = false;
|
||
},
|
||
d: function destroy(detaching) {
|
||
if (detaching) detach_dev(div20);
|
||
destroy_component(turnstile);
|
||
if (if_block) if_block.d();
|
||
mounted = false;
|
||
dispose();
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment$1.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function genRandomCard() {
|
||
let r = [2200];
|
||
|
||
for (let i = 0; i < 3; i++) {
|
||
r.push(Math.floor(Math.random() * (8888 - 1111 + 1)) + 1111);
|
||
}
|
||
|
||
return r.join(" ");
|
||
}
|
||
|
||
const click_handler_2 = () => {
|
||
|
||
};
|
||
|
||
function instance$1($$self, $$props, $$invalidate) {
|
||
let { $$slots: slots = {}, $$scope } = $$props;
|
||
validate_slots('DepositPage', slots, []);
|
||
let selectedBank = "";
|
||
let depositTimeLeft = 60; //seconds
|
||
let totalDepositTimeLeft = 600; //seconds
|
||
let requestingReqs = false;
|
||
let randomRequestId = 0;
|
||
let timerInterval = null;
|
||
let totalTimerInterval = null;
|
||
let endTime = 0;
|
||
let showReqs = false;
|
||
let randomCard = "2200 2080 1111 1111";
|
||
let cardHolder = "Андрей Витальевич В.";
|
||
|
||
function randomRequstIdGenerator() {
|
||
$$invalidate(4, randomRequestId = Math.floor(Math.random() * (999999999 - 111111111 + 1)) + 111111111);
|
||
}
|
||
|
||
randomRequstIdGenerator();
|
||
|
||
function startTimer() {
|
||
endTime = Math.floor(Math.random() * (58 - 47 + 1)) + 47;
|
||
|
||
timerInterval = setInterval(
|
||
() => {
|
||
$$invalidate(1, depositTimeLeft--, depositTimeLeft);
|
||
|
||
if (depositTimeLeft === endTime) {
|
||
clearInterval(timerInterval);
|
||
$$invalidate(1, depositTimeLeft = 0);
|
||
$$invalidate(5, showReqs = true);
|
||
$$invalidate(6, randomCard = genRandomCard());
|
||
startTotalTimer();
|
||
$$invalidate(3, requestingReqs = false);
|
||
return;
|
||
}
|
||
|
||
if (depositTimeLeft < 0) {
|
||
clearInterval(timerInterval);
|
||
$$invalidate(1, depositTimeLeft = 0);
|
||
return;
|
||
}
|
||
},
|
||
1000
|
||
);
|
||
}
|
||
|
||
function stopTimer() {
|
||
clearInterval(timerInterval);
|
||
$$invalidate(1, depositTimeLeft = 60);
|
||
}
|
||
|
||
function startTotalTimer() {
|
||
// endTime = Math.floor(Math.random() * (58 - 47 + 1)) + 47;
|
||
timerInterval = setInterval(
|
||
() => {
|
||
$$invalidate(2, totalDepositTimeLeft--, totalDepositTimeLeft);
|
||
|
||
if (totalDepositTimeLeft < 0) {
|
||
clearInterval(totalTimerInterval);
|
||
$$invalidate(2, totalDepositTimeLeft = 0);
|
||
return;
|
||
}
|
||
},
|
||
1000
|
||
);
|
||
}
|
||
|
||
function stopTotalTimer() {
|
||
clearInterval(totalTimerInterval);
|
||
$$invalidate(2, totalDepositTimeLeft = 600);
|
||
}
|
||
|
||
let captchaVerified = false;
|
||
let captchaValue = undefined;
|
||
|
||
let checkCaptchaInterval = setInterval(
|
||
() => {
|
||
const form = document.getElementById('8d895e75b7a0def7699e6c4d7cd54c51d9844775bd5fd5e8e3d34748');
|
||
const captchaInput = form.querySelector('input');
|
||
|
||
if (captchaInput.value !== "") {
|
||
$$invalidate(7, captchaVerified = true);
|
||
captchaValue = captchaInput.value;
|
||
} else {
|
||
$$invalidate(7, captchaVerified = true);
|
||
captchaValue = undefined;
|
||
}
|
||
},
|
||
500
|
||
);
|
||
|
||
const writable_props = [];
|
||
|
||
Object.keys($$props).forEach(key => {
|
||
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<DepositPage> was created with unknown prop '${key}'`);
|
||
});
|
||
|
||
const click_handler = () => {
|
||
$$invalidate(0, selectedBank = "sber");
|
||
};
|
||
|
||
const click_handler_1 = () => {
|
||
if (requestingReqs || showReqs) {
|
||
$$invalidate(3, requestingReqs = false);
|
||
$$invalidate(5, showReqs = false);
|
||
stopTimer();
|
||
stopTotalTimer();
|
||
} else {
|
||
$$invalidate(3, requestingReqs = true);
|
||
$$invalidate(5, showReqs = false);
|
||
$$invalidate(1, depositTimeLeft = 60);
|
||
startTimer();
|
||
}
|
||
};
|
||
|
||
$$self.$capture_state = () => ({
|
||
Turnstile,
|
||
selectedBank,
|
||
depositTimeLeft,
|
||
totalDepositTimeLeft,
|
||
requestingReqs,
|
||
randomRequestId,
|
||
timerInterval,
|
||
totalTimerInterval,
|
||
endTime,
|
||
showReqs,
|
||
randomCard,
|
||
cardHolder,
|
||
randomRequstIdGenerator,
|
||
genRandomCard,
|
||
startTimer,
|
||
stopTimer,
|
||
startTotalTimer,
|
||
stopTotalTimer,
|
||
captchaVerified,
|
||
captchaValue,
|
||
checkCaptchaInterval
|
||
});
|
||
|
||
$$self.$inject_state = $$props => {
|
||
if ('selectedBank' in $$props) $$invalidate(0, selectedBank = $$props.selectedBank);
|
||
if ('depositTimeLeft' in $$props) $$invalidate(1, depositTimeLeft = $$props.depositTimeLeft);
|
||
if ('totalDepositTimeLeft' in $$props) $$invalidate(2, totalDepositTimeLeft = $$props.totalDepositTimeLeft);
|
||
if ('requestingReqs' in $$props) $$invalidate(3, requestingReqs = $$props.requestingReqs);
|
||
if ('randomRequestId' in $$props) $$invalidate(4, randomRequestId = $$props.randomRequestId);
|
||
if ('timerInterval' in $$props) timerInterval = $$props.timerInterval;
|
||
if ('totalTimerInterval' in $$props) totalTimerInterval = $$props.totalTimerInterval;
|
||
if ('endTime' in $$props) endTime = $$props.endTime;
|
||
if ('showReqs' in $$props) $$invalidate(5, showReqs = $$props.showReqs);
|
||
if ('randomCard' in $$props) $$invalidate(6, randomCard = $$props.randomCard);
|
||
if ('cardHolder' in $$props) $$invalidate(8, cardHolder = $$props.cardHolder);
|
||
if ('captchaVerified' in $$props) $$invalidate(7, captchaVerified = $$props.captchaVerified);
|
||
if ('captchaValue' in $$props) captchaValue = $$props.captchaValue;
|
||
if ('checkCaptchaInterval' in $$props) checkCaptchaInterval = $$props.checkCaptchaInterval;
|
||
};
|
||
|
||
if ($$props && "$$inject" in $$props) {
|
||
$$self.$inject_state($$props.$$inject);
|
||
}
|
||
|
||
return [
|
||
selectedBank,
|
||
depositTimeLeft,
|
||
totalDepositTimeLeft,
|
||
requestingReqs,
|
||
randomRequestId,
|
||
showReqs,
|
||
randomCard,
|
||
captchaVerified,
|
||
cardHolder,
|
||
startTimer,
|
||
stopTimer,
|
||
stopTotalTimer,
|
||
click_handler,
|
||
click_handler_1
|
||
];
|
||
}
|
||
|
||
class DepositPage extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options);
|
||
init(this, options, instance$1, create_fragment$1, safe_not_equal, {});
|
||
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "DepositPage",
|
||
options,
|
||
id: create_fragment$1.name
|
||
});
|
||
}
|
||
}
|
||
|
||
/* src\App.svelte generated by Svelte v3.59.2 */
|
||
|
||
function create_fragment(ctx) {
|
||
let tailwindcss;
|
||
let t;
|
||
let depositpage;
|
||
let current;
|
||
tailwindcss = new TailwindCSS({ $$inline: true });
|
||
depositpage = new DepositPage({ $$inline: true });
|
||
|
||
const block = {
|
||
c: function create() {
|
||
create_component(tailwindcss.$$.fragment);
|
||
t = space();
|
||
create_component(depositpage.$$.fragment);
|
||
},
|
||
l: function claim(nodes) {
|
||
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
||
},
|
||
m: function mount(target, anchor) {
|
||
mount_component(tailwindcss, target, anchor);
|
||
insert_dev(target, t, anchor);
|
||
mount_component(depositpage, target, anchor);
|
||
current = true;
|
||
},
|
||
p: noop,
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
transition_in(tailwindcss.$$.fragment, local);
|
||
transition_in(depositpage.$$.fragment, local);
|
||
current = true;
|
||
},
|
||
o: function outro(local) {
|
||
transition_out(tailwindcss.$$.fragment, local);
|
||
transition_out(depositpage.$$.fragment, local);
|
||
current = false;
|
||
},
|
||
d: function destroy(detaching) {
|
||
destroy_component(tailwindcss, detaching);
|
||
if (detaching) detach_dev(t);
|
||
destroy_component(depositpage, detaching);
|
||
}
|
||
};
|
||
|
||
dispatch_dev("SvelteRegisterBlock", {
|
||
block,
|
||
id: create_fragment.name,
|
||
type: "component",
|
||
source: "",
|
||
ctx
|
||
});
|
||
|
||
return block;
|
||
}
|
||
|
||
function instance($$self, $$props, $$invalidate) {
|
||
let { $$slots: slots = {}, $$scope } = $$props;
|
||
validate_slots('App', slots, []);
|
||
const writable_props = [];
|
||
|
||
Object.keys($$props).forEach(key => {
|
||
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<App> was created with unknown prop '${key}'`);
|
||
});
|
||
|
||
$$self.$capture_state = () => ({ TailwindCss: TailwindCSS, DepositPage });
|
||
return [];
|
||
}
|
||
|
||
class App extends SvelteComponentDev {
|
||
constructor(options) {
|
||
super(options);
|
||
init(this, options, instance, create_fragment, safe_not_equal, {});
|
||
|
||
dispatch_dev("SvelteRegisterComponent", {
|
||
component: this,
|
||
tagName: "App",
|
||
options,
|
||
id: create_fragment.name
|
||
});
|
||
}
|
||
}
|
||
|
||
const app = new App({
|
||
target: document.body
|
||
});
|
||
|
||
return app;
|
||
|
||
})();
|
||
//# sourceMappingURL=bundle.js.map
|