forked from OpenServer/OpenAuth_views
6198 lines
190 KiB
JavaScript
6198 lines
190 KiB
JavaScript
var app = (function () {
|
||
'use strict';
|
||
|
||
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
||
|
||
function unwrapExports (x) {
|
||
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
||
}
|
||
|
||
function createCommonjsModule(fn, module) {
|
||
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
||
}
|
||
|
||
var internal = createCommonjsModule(function (module, exports) {
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
function noop() {}
|
||
|
||
const identity = x => x;
|
||
|
||
function assign(tar, src) {
|
||
for (const k in src) tar[k] = src[k];
|
||
return tar;
|
||
}
|
||
|
||
function is_promise(value) {
|
||
return value && 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 || typeof store.subscribe !== 'function') {
|
||
throw new Error(`'${name}' is not a store with a 'subscribe' method`);
|
||
}
|
||
}
|
||
|
||
function subscribe(component, store, callback) {
|
||
const unsub = store.subscribe(callback);
|
||
|
||
component.$$.on_destroy.push(unsub.unsubscribe
|
||
? () => unsub.unsubscribe()
|
||
: unsub);
|
||
}
|
||
|
||
function create_slot(definition, ctx, fn) {
|
||
if (definition) {
|
||
const slot_ctx = get_slot_context(definition, ctx, fn);
|
||
return definition[0](slot_ctx);
|
||
}
|
||
}
|
||
|
||
function get_slot_context(definition, ctx, fn) {
|
||
return definition[1]
|
||
? assign({}, assign(ctx.$$scope.ctx, definition[1](fn ? fn(ctx) : {})))
|
||
: ctx.$$scope.ctx;
|
||
}
|
||
|
||
function get_slot_changes(definition, ctx, changed, fn) {
|
||
return definition[1]
|
||
? assign({}, assign(ctx.$$scope.changed || {}, definition[1](fn ? fn(changed) : {})))
|
||
: ctx.$$scope.changed || {};
|
||
}
|
||
|
||
function exclude_internal_props(props) {
|
||
const result = {};
|
||
for (const k in props) if (k[0] !== '$') result[k] = props[k];
|
||
return result;
|
||
}
|
||
|
||
const tasks = new Set();
|
||
let running = false;
|
||
|
||
function run_tasks() {
|
||
tasks.forEach(task => {
|
||
if (!task[0](window.performance.now())) {
|
||
tasks.delete(task);
|
||
task[1]();
|
||
}
|
||
});
|
||
|
||
running = tasks.size > 0;
|
||
if (running) requestAnimationFrame(run_tasks);
|
||
}
|
||
|
||
function clear_loops() {
|
||
// for testing...
|
||
tasks.forEach(task => tasks.delete(task));
|
||
running = false;
|
||
}
|
||
|
||
function loop(fn) {
|
||
let task;
|
||
|
||
if (!running) {
|
||
running = true;
|
||
requestAnimationFrame(run_tasks);
|
||
}
|
||
|
||
return {
|
||
promise: new Promise(fulfil => {
|
||
tasks.add(task = [fn, fulfil]);
|
||
}),
|
||
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 detach_between(before, after) {
|
||
while (before.nextSibling && before.nextSibling !== after) {
|
||
before.parentNode.removeChild(before.nextSibling);
|
||
}
|
||
}
|
||
|
||
function detach_before(after) {
|
||
while (after.previousSibling) {
|
||
after.parentNode.removeChild(after.previousSibling);
|
||
}
|
||
}
|
||
|
||
function detach_after(before) {
|
||
while (before.nextSibling) {
|
||
before.parentNode.removeChild(before.nextSibling);
|
||
}
|
||
}
|
||
|
||
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 object_without_properties(obj, exclude) {
|
||
const target = {};
|
||
for (const k in obj) {
|
||
if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) {
|
||
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();
|
||
return fn.call(this, event);
|
||
};
|
||
}
|
||
|
||
function stop_propagation(fn) {
|
||
return function(event) {
|
||
event.stopPropagation();
|
||
return fn.call(this, event);
|
||
};
|
||
}
|
||
|
||
function attr(node, attribute, value) {
|
||
if (value == null) node.removeAttribute(attribute);
|
||
else node.setAttribute(attribute, value);
|
||
}
|
||
|
||
function set_attributes(node, attributes) {
|
||
for (const key in attributes) {
|
||
if (key === 'style') {
|
||
node.style.cssText = attributes[key];
|
||
} else if (key in node) {
|
||
node[key] = attributes[key];
|
||
} else {
|
||
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) {
|
||
for (let j = 0; j < node.attributes.length; j += 1) {
|
||
const attribute = node.attributes[j];
|
||
if (!attributes[attribute.name]) node.removeAttribute(attribute.name);
|
||
}
|
||
return nodes.splice(i, 1)[0]; // TODO strip unwanted attributes
|
||
}
|
||
}
|
||
|
||
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 set_data(text, data) {
|
||
data = '' + data;
|
||
if (text.data !== data) text.data = data;
|
||
}
|
||
|
||
function set_input_type(input, type) {
|
||
try {
|
||
input.type = type;
|
||
} catch (e) {
|
||
// do nothing
|
||
}
|
||
}
|
||
|
||
function set_style(node, key, value) {
|
||
node.style.setProperty(key, value);
|
||
}
|
||
|
||
function select_option(select, value) {
|
||
for (let i = 0; i < select.options.length; i += 1) {
|
||
const option = select.options[i];
|
||
|
||
if (option.__value === value) {
|
||
option.selected = true;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
function select_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.type = 'text/html';
|
||
|
||
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;
|
||
}
|
||
|
||
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() {
|
||
requestAnimationFrame(() => {
|
||
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,
|
||
start: start_time = window.performance.now() + delay,
|
||
end = start_time + duration,
|
||
tick = noop,
|
||
css
|
||
} = fn(node, { from, to }, params);
|
||
|
||
let running = true;
|
||
let started = false;
|
||
let name;
|
||
|
||
const css_text = node.style.cssText;
|
||
|
||
function start() {
|
||
if (css) {
|
||
if (delay) node.style.cssText = css_text; // TODO create delayed animation instead?
|
||
name = create_rule(node, 0, 1, duration, 0, easing, css);
|
||
}
|
||
|
||
started = true;
|
||
}
|
||
|
||
function stop() {
|
||
if (css) delete_rule(node, name);
|
||
running = false;
|
||
}
|
||
|
||
loop(now => {
|
||
if (!started && now >= start_time) {
|
||
start();
|
||
}
|
||
|
||
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;
|
||
});
|
||
|
||
if (delay) {
|
||
if (css) node.style.cssText += css(0, 1);
|
||
} else {
|
||
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;
|
||
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)`;
|
||
}
|
||
}
|
||
}
|
||
|
||
function set_current_component(component) {
|
||
exports.current_component = component;
|
||
}
|
||
|
||
function get_current_component() {
|
||
if (!exports.current_component) throw new Error(`Function called outside component initialization`);
|
||
return exports.current_component;
|
||
}
|
||
|
||
function beforeUpdate(fn) {
|
||
get_current_component().$$.before_render.push(fn);
|
||
}
|
||
|
||
function onMount(fn) {
|
||
get_current_component().$$.on_mount.push(fn);
|
||
}
|
||
|
||
function afterUpdate(fn) {
|
||
get_current_component().$$.after_render.push(fn);
|
||
}
|
||
|
||
function onDestroy(fn) {
|
||
get_current_component().$$.on_destroy.push(fn);
|
||
}
|
||
|
||
function createEventDispatcher() {
|
||
const component = exports.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 resolved_promise = Promise.resolve();
|
||
let update_scheduled = false;
|
||
const binding_callbacks = [];
|
||
const render_callbacks = [];
|
||
const flush_callbacks = [];
|
||
|
||
function schedule_update() {
|
||
if (!update_scheduled) {
|
||
update_scheduled = true;
|
||
resolved_promise.then(flush);
|
||
}
|
||
}
|
||
|
||
function tick() {
|
||
schedule_update();
|
||
return resolved_promise;
|
||
}
|
||
|
||
function add_binding_callback(fn) {
|
||
binding_callbacks.push(fn);
|
||
}
|
||
|
||
function add_render_callback(fn) {
|
||
render_callbacks.push(fn);
|
||
}
|
||
|
||
function add_flush_callback(fn) {
|
||
flush_callbacks.push(fn);
|
||
}
|
||
|
||
function flush() {
|
||
const seen_callbacks = new Set();
|
||
|
||
do {
|
||
// first, call beforeUpdate functions
|
||
// and update components
|
||
while (dirty_components.length) {
|
||
const component = dirty_components.shift();
|
||
set_current_component(component);
|
||
update(component.$$);
|
||
}
|
||
|
||
while (binding_callbacks.length) binding_callbacks.shift()();
|
||
|
||
// then, once components are updated, call
|
||
// afterUpdate functions. This may cause
|
||
// subsequent updates...
|
||
while (render_callbacks.length) {
|
||
const callback = render_callbacks.pop();
|
||
if (!seen_callbacks.has(callback)) {
|
||
callback();
|
||
|
||
// ...so guard against infinite loops
|
||
seen_callbacks.add(callback);
|
||
}
|
||
}
|
||
} while (dirty_components.length);
|
||
|
||
while (flush_callbacks.length) {
|
||
flush_callbacks.pop()();
|
||
}
|
||
|
||
update_scheduled = false;
|
||
}
|
||
|
||
function update($$) {
|
||
if ($$.fragment) {
|
||
$$.update($$.dirty);
|
||
run_all($$.before_render);
|
||
$$.fragment.p($$.dirty, $$.ctx);
|
||
$$.dirty = null;
|
||
|
||
$$.after_render.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}`));
|
||
}
|
||
|
||
let outros;
|
||
|
||
function group_outros() {
|
||
outros = {
|
||
remaining: 0,
|
||
callbacks: []
|
||
};
|
||
}
|
||
|
||
function check_outros() {
|
||
if (!outros.remaining) {
|
||
run_all(outros.callbacks);
|
||
}
|
||
}
|
||
|
||
function on_outro(callback) {
|
||
outros.callbacks.push(callback);
|
||
}
|
||
|
||
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: tick$$1 = noop,
|
||
css
|
||
} = config;
|
||
|
||
if (css) animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);
|
||
tick$$1(0, 1);
|
||
|
||
const start_time = window.performance.now() + delay;
|
||
const end_time = start_time + duration;
|
||
|
||
if (task) task.abort();
|
||
running = true;
|
||
|
||
task = loop(now => {
|
||
if (running) {
|
||
if (now >= end_time) {
|
||
tick$$1(1, 0);
|
||
cleanup();
|
||
return running = false;
|
||
}
|
||
|
||
if (now >= start_time) {
|
||
const t = easing((now - start_time) / duration);
|
||
tick$$1(t, 1 - t);
|
||
}
|
||
}
|
||
|
||
return running;
|
||
});
|
||
}
|
||
|
||
let started = false;
|
||
|
||
return {
|
||
start() {
|
||
if (started) return;
|
||
|
||
delete_rule(node);
|
||
|
||
if (typeof config === 'function') {
|
||
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.remaining += 1;
|
||
|
||
function go() {
|
||
const {
|
||
delay = 0,
|
||
duration = 300,
|
||
easing = identity,
|
||
tick: tick$$1 = noop,
|
||
css
|
||
} = config;
|
||
|
||
if (css) animation_name = create_rule(node, 1, 0, duration, delay, easing, css);
|
||
|
||
const start_time = window.performance.now() + delay;
|
||
const end_time = start_time + duration;
|
||
|
||
loop(now => {
|
||
if (running) {
|
||
if (now >= end_time) {
|
||
tick$$1(0, 1);
|
||
|
||
if (!--group.remaining) {
|
||
// this will result in `end()` being called,
|
||
// so we don't need to clean up here
|
||
run_all(group.callbacks);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
if (now >= start_time) {
|
||
const t = easing((now - start_time) / duration);
|
||
tick$$1(1 - t, t);
|
||
}
|
||
}
|
||
|
||
return running;
|
||
});
|
||
}
|
||
|
||
if (typeof config === 'function') {
|
||
wait().then(() => {
|
||
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: tick$$1 = noop,
|
||
css
|
||
} = config;
|
||
|
||
const program = {
|
||
start: window.performance.now() + delay,
|
||
b
|
||
};
|
||
|
||
if (!b) {
|
||
program.group = outros;
|
||
outros.remaining += 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$$1(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$$1(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.remaining) run_all(running_program.group.callbacks);
|
||
}
|
||
}
|
||
|
||
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$$1(t, 1 - t);
|
||
}
|
||
}
|
||
|
||
return !!(running_program || pending_program);
|
||
});
|
||
}
|
||
}
|
||
|
||
return {
|
||
run(b) {
|
||
if (typeof config === 'function') {
|
||
wait().then(() => {
|
||
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 = key && { [key]: value };
|
||
|
||
const child_ctx = assign(assign({}, info.ctx), info.resolved);
|
||
const block = type && (info.current = type)(child_ctx);
|
||
|
||
if (info.block) {
|
||
if (info.blocks) {
|
||
info.blocks.forEach((block, i) => {
|
||
if (i !== index && block) {
|
||
group_outros();
|
||
on_outro(() => {
|
||
block.d(1);
|
||
info.blocks[i] = null;
|
||
});
|
||
block.o(1);
|
||
check_outros();
|
||
}
|
||
});
|
||
} else {
|
||
info.block.d(1);
|
||
}
|
||
|
||
block.c();
|
||
if (block.i) block.i(1);
|
||
block.m(info.mount(), info.anchor);
|
||
|
||
flush();
|
||
}
|
||
|
||
info.block = block;
|
||
if (info.blocks) info.blocks[index] = block;
|
||
}
|
||
|
||
if (is_promise(promise)) {
|
||
promise.then(value => {
|
||
update(info.then, 1, info.value, value);
|
||
}, error => {
|
||
update(info.catch, 2, info.error, error);
|
||
});
|
||
|
||
// 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 = { [info.value]: promise };
|
||
}
|
||
}
|
||
|
||
function destroy_block(block, lookup) {
|
||
block.d(1);
|
||
lookup.delete(block.key);
|
||
}
|
||
|
||
function outro_and_destroy_block(block, lookup) {
|
||
on_outro(() => {
|
||
destroy_block(block, lookup);
|
||
});
|
||
|
||
block.o(1);
|
||
}
|
||
|
||
function fix_and_outro_and_destroy_block(block, lookup) {
|
||
block.f();
|
||
outro_and_destroy_block(block, lookup);
|
||
}
|
||
|
||
function update_keyed_each(old_blocks, changed, 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(changed, child_ctx);
|
||
}
|
||
|
||
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) {
|
||
if (block.i) block.i(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 measure(blocks) {
|
||
const rects = {};
|
||
let i = blocks.length;
|
||
while (i--) rects[blocks[i].key] = blocks[i].node.getBoundingClientRect();
|
||
return rects;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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) {
|
||
const attributes = Object.assign({}, ...args);
|
||
let str = '';
|
||
|
||
Object.keys(attributes).forEach(name => {
|
||
if (invalid_attribute_name_character.test(name)) return;
|
||
|
||
const value = attributes[name];
|
||
if (value === undefined) return;
|
||
if (value === true) str += " " + name;
|
||
|
||
const escaped = String(value)
|
||
.replace(/"/g, '"')
|
||
.replace(/'/g, ''');
|
||
|
||
str += " " + name + "=" + JSON.stringify(escaped);
|
||
});
|
||
|
||
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 = exports.current_component;
|
||
|
||
const $$ = {
|
||
on_destroy,
|
||
context: new Map(parent_component ? parent_component.$$.context : []),
|
||
|
||
// these will be immediately discarded
|
||
on_mount: [],
|
||
before_render: [],
|
||
after_render: [],
|
||
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 = { 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.head
|
||
};
|
||
},
|
||
|
||
$$render
|
||
};
|
||
}
|
||
|
||
function get_store_value(store) {
|
||
let value;
|
||
store.subscribe(_ => value = _)();
|
||
return value;
|
||
}
|
||
|
||
function bind(component, name, callback) {
|
||
if (component.$$.props.indexOf(name) === -1) return;
|
||
component.$$.bound[name] = callback;
|
||
callback(component.$$.ctx[name]);
|
||
}
|
||
|
||
function mount_component(component, target, anchor) {
|
||
const { fragment, on_mount, on_destroy, after_render } = component.$$;
|
||
|
||
fragment.m(target, anchor);
|
||
|
||
// onMount happens after the initial afterUpdate. Because
|
||
// afterUpdate callbacks happen in reverse order (inner first)
|
||
// we schedule onMount callbacks before afterUpdate callbacks
|
||
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_render.forEach(add_render_callback);
|
||
}
|
||
|
||
function destroy(component, detaching) {
|
||
if (component.$$) {
|
||
run_all(component.$$.on_destroy);
|
||
component.$$.fragment.d(detaching);
|
||
|
||
// TODO null out other refs, including component.$$ (but need to
|
||
// preserve final state?)
|
||
component.$$.on_destroy = component.$$.fragment = null;
|
||
component.$$.ctx = {};
|
||
}
|
||
}
|
||
|
||
function make_dirty(component, key) {
|
||
if (!component.$$.dirty) {
|
||
dirty_components.push(component);
|
||
schedule_update();
|
||
component.$$.dirty = {};
|
||
}
|
||
component.$$.dirty[key] = true;
|
||
}
|
||
|
||
function init(component, options, instance, create_fragment, not_equal$$1, prop_names) {
|
||
const parent_component = exports.current_component;
|
||
set_current_component(component);
|
||
|
||
const props = options.props || {};
|
||
|
||
const $$ = component.$$ = {
|
||
fragment: null,
|
||
ctx: null,
|
||
|
||
// state
|
||
props: prop_names,
|
||
update: noop,
|
||
not_equal: not_equal$$1,
|
||
bound: blank_object(),
|
||
|
||
// lifecycle
|
||
on_mount: [],
|
||
on_destroy: [],
|
||
before_render: [],
|
||
after_render: [],
|
||
context: new Map(parent_component ? parent_component.$$.context : []),
|
||
|
||
// everything else
|
||
callbacks: blank_object(),
|
||
dirty: null
|
||
};
|
||
|
||
let ready = false;
|
||
|
||
$$.ctx = instance
|
||
? instance(component, props, (key, value) => {
|
||
if ($$.ctx && not_equal$$1($$.ctx[key], $$.ctx[key] = value)) {
|
||
if ($$.bound[key]) $$.bound[key](value);
|
||
if (ready) make_dirty(component, key);
|
||
}
|
||
})
|
||
: props;
|
||
|
||
$$.update();
|
||
ready = true;
|
||
run_all($$.before_render);
|
||
$$.fragment = create_fragment($$.ctx);
|
||
|
||
if (options.target) {
|
||
if (options.hydrate) {
|
||
$$.fragment.l(children(options.target));
|
||
} else {
|
||
$$.fragment.c();
|
||
}
|
||
|
||
if (options.intro && component.$$.fragment.i) component.$$.fragment.i();
|
||
mount_component(component, options.target, options.anchor);
|
||
flush();
|
||
}
|
||
|
||
set_current_component(parent_component);
|
||
}
|
||
if (typeof HTMLElement !== 'undefined') {
|
||
exports.SvelteElement = class extends HTMLElement {
|
||
constructor() {
|
||
super();
|
||
this.attachShadow({ mode: 'open' });
|
||
}
|
||
|
||
connectedCallback() {
|
||
for (const key in this.$$.slotted) {
|
||
this.appendChild(this.$$.slotted[key]);
|
||
}
|
||
}
|
||
|
||
attributeChangedCallback(attr$$1, oldValue, newValue) {
|
||
this[attr$$1] = newValue;
|
||
}
|
||
|
||
$destroy() {
|
||
destroy(this, true);
|
||
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(this, true);
|
||
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
|
||
}
|
||
}
|
||
|
||
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
|
||
};
|
||
}
|
||
}
|
||
|
||
exports.create_animation = create_animation;
|
||
exports.fix_position = fix_position;
|
||
exports.handle_promise = handle_promise;
|
||
exports.append = append;
|
||
exports.insert = insert;
|
||
exports.detach = detach;
|
||
exports.detach_between = detach_between;
|
||
exports.detach_before = detach_before;
|
||
exports.detach_after = detach_after;
|
||
exports.destroy_each = destroy_each;
|
||
exports.element = element;
|
||
exports.object_without_properties = object_without_properties;
|
||
exports.svg_element = svg_element;
|
||
exports.text = text;
|
||
exports.space = space;
|
||
exports.empty = empty;
|
||
exports.listen = listen;
|
||
exports.prevent_default = prevent_default;
|
||
exports.stop_propagation = stop_propagation;
|
||
exports.attr = attr;
|
||
exports.set_attributes = set_attributes;
|
||
exports.set_custom_element_data = set_custom_element_data;
|
||
exports.xlink_attr = xlink_attr;
|
||
exports.get_binding_group_value = get_binding_group_value;
|
||
exports.to_number = to_number;
|
||
exports.time_ranges_to_array = time_ranges_to_array;
|
||
exports.children = children;
|
||
exports.claim_element = claim_element;
|
||
exports.claim_text = claim_text;
|
||
exports.set_data = set_data;
|
||
exports.set_input_type = set_input_type;
|
||
exports.set_style = set_style;
|
||
exports.select_option = select_option;
|
||
exports.select_options = select_options;
|
||
exports.select_value = select_value;
|
||
exports.select_multiple_value = select_multiple_value;
|
||
exports.add_resize_listener = add_resize_listener;
|
||
exports.toggle_class = toggle_class;
|
||
exports.custom_event = custom_event;
|
||
exports.destroy_block = destroy_block;
|
||
exports.outro_and_destroy_block = outro_and_destroy_block;
|
||
exports.fix_and_outro_and_destroy_block = fix_and_outro_and_destroy_block;
|
||
exports.update_keyed_each = update_keyed_each;
|
||
exports.measure = measure;
|
||
exports.set_current_component = set_current_component;
|
||
exports.beforeUpdate = beforeUpdate;
|
||
exports.onMount = onMount;
|
||
exports.afterUpdate = afterUpdate;
|
||
exports.onDestroy = onDestroy;
|
||
exports.createEventDispatcher = createEventDispatcher;
|
||
exports.setContext = setContext;
|
||
exports.getContext = getContext;
|
||
exports.bubble = bubble;
|
||
exports.clear_loops = clear_loops;
|
||
exports.loop = loop;
|
||
exports.dirty_components = dirty_components;
|
||
exports.intros = intros;
|
||
exports.schedule_update = schedule_update;
|
||
exports.tick = tick;
|
||
exports.add_binding_callback = add_binding_callback;
|
||
exports.add_render_callback = add_render_callback;
|
||
exports.add_flush_callback = add_flush_callback;
|
||
exports.flush = flush;
|
||
exports.get_spread_update = get_spread_update;
|
||
exports.invalid_attribute_name_character = invalid_attribute_name_character;
|
||
exports.spread = spread;
|
||
exports.escaped = escaped;
|
||
exports.escape = escape;
|
||
exports.each = each;
|
||
exports.missing_component = missing_component;
|
||
exports.validate_component = validate_component;
|
||
exports.debug = debug;
|
||
exports.create_ssr_component = create_ssr_component;
|
||
exports.get_store_value = get_store_value;
|
||
exports.group_outros = group_outros;
|
||
exports.check_outros = check_outros;
|
||
exports.on_outro = on_outro;
|
||
exports.create_in_transition = create_in_transition;
|
||
exports.create_out_transition = create_out_transition;
|
||
exports.create_bidirectional_transition = create_bidirectional_transition;
|
||
exports.noop = noop;
|
||
exports.identity = identity;
|
||
exports.assign = assign;
|
||
exports.is_promise = is_promise;
|
||
exports.add_location = add_location;
|
||
exports.run = run;
|
||
exports.blank_object = blank_object;
|
||
exports.run_all = run_all;
|
||
exports.is_function = is_function;
|
||
exports.safe_not_equal = safe_not_equal;
|
||
exports.not_equal = not_equal;
|
||
exports.validate_store = validate_store;
|
||
exports.subscribe = subscribe;
|
||
exports.create_slot = create_slot;
|
||
exports.get_slot_context = get_slot_context;
|
||
exports.get_slot_changes = get_slot_changes;
|
||
exports.exclude_internal_props = exclude_internal_props;
|
||
exports.bind = bind;
|
||
exports.mount_component = mount_component;
|
||
exports.init = init;
|
||
exports.SvelteComponent = SvelteComponent;
|
||
exports.SvelteComponentDev = SvelteComponentDev;
|
||
});
|
||
|
||
unwrapExports(internal);
|
||
var internal_1 = internal.current_component;
|
||
var internal_2 = internal.SvelteElement;
|
||
var internal_3 = internal.create_animation;
|
||
var internal_4 = internal.fix_position;
|
||
var internal_5 = internal.handle_promise;
|
||
var internal_6 = internal.append;
|
||
var internal_7 = internal.insert;
|
||
var internal_8 = internal.detach;
|
||
var internal_9 = internal.detach_between;
|
||
var internal_10 = internal.detach_before;
|
||
var internal_11 = internal.detach_after;
|
||
var internal_12 = internal.destroy_each;
|
||
var internal_13 = internal.element;
|
||
var internal_14 = internal.object_without_properties;
|
||
var internal_15 = internal.svg_element;
|
||
var internal_16 = internal.text;
|
||
var internal_17 = internal.space;
|
||
var internal_18 = internal.empty;
|
||
var internal_19 = internal.listen;
|
||
var internal_20 = internal.prevent_default;
|
||
var internal_21 = internal.stop_propagation;
|
||
var internal_22 = internal.attr;
|
||
var internal_23 = internal.set_attributes;
|
||
var internal_24 = internal.set_custom_element_data;
|
||
var internal_25 = internal.xlink_attr;
|
||
var internal_26 = internal.get_binding_group_value;
|
||
var internal_27 = internal.to_number;
|
||
var internal_28 = internal.time_ranges_to_array;
|
||
var internal_29 = internal.children;
|
||
var internal_30 = internal.claim_element;
|
||
var internal_31 = internal.claim_text;
|
||
var internal_32 = internal.set_data;
|
||
var internal_33 = internal.set_input_type;
|
||
var internal_34 = internal.set_style;
|
||
var internal_35 = internal.select_option;
|
||
var internal_36 = internal.select_options;
|
||
var internal_37 = internal.select_value;
|
||
var internal_38 = internal.select_multiple_value;
|
||
var internal_39 = internal.add_resize_listener;
|
||
var internal_40 = internal.toggle_class;
|
||
var internal_41 = internal.custom_event;
|
||
var internal_42 = internal.destroy_block;
|
||
var internal_43 = internal.outro_and_destroy_block;
|
||
var internal_44 = internal.fix_and_outro_and_destroy_block;
|
||
var internal_45 = internal.update_keyed_each;
|
||
var internal_46 = internal.measure;
|
||
var internal_47 = internal.set_current_component;
|
||
var internal_48 = internal.beforeUpdate;
|
||
var internal_49 = internal.onMount;
|
||
var internal_50 = internal.afterUpdate;
|
||
var internal_51 = internal.onDestroy;
|
||
var internal_52 = internal.createEventDispatcher;
|
||
var internal_53 = internal.setContext;
|
||
var internal_54 = internal.getContext;
|
||
var internal_55 = internal.bubble;
|
||
var internal_56 = internal.clear_loops;
|
||
var internal_57 = internal.loop;
|
||
var internal_58 = internal.dirty_components;
|
||
var internal_59 = internal.intros;
|
||
var internal_60 = internal.schedule_update;
|
||
var internal_61 = internal.tick;
|
||
var internal_62 = internal.add_binding_callback;
|
||
var internal_63 = internal.add_render_callback;
|
||
var internal_64 = internal.add_flush_callback;
|
||
var internal_65 = internal.flush;
|
||
var internal_66 = internal.get_spread_update;
|
||
var internal_67 = internal.invalid_attribute_name_character;
|
||
var internal_68 = internal.spread;
|
||
var internal_69 = internal.escaped;
|
||
var internal_70 = internal.escape;
|
||
var internal_71 = internal.each;
|
||
var internal_72 = internal.missing_component;
|
||
var internal_73 = internal.validate_component;
|
||
var internal_74 = internal.debug;
|
||
var internal_75 = internal.create_ssr_component;
|
||
var internal_76 = internal.get_store_value;
|
||
var internal_77 = internal.group_outros;
|
||
var internal_78 = internal.check_outros;
|
||
var internal_79 = internal.on_outro;
|
||
var internal_80 = internal.create_in_transition;
|
||
var internal_81 = internal.create_out_transition;
|
||
var internal_82 = internal.create_bidirectional_transition;
|
||
var internal_83 = internal.noop;
|
||
var internal_84 = internal.identity;
|
||
var internal_85 = internal.assign;
|
||
var internal_86 = internal.is_promise;
|
||
var internal_87 = internal.add_location;
|
||
var internal_88 = internal.run;
|
||
var internal_89 = internal.blank_object;
|
||
var internal_90 = internal.run_all;
|
||
var internal_91 = internal.is_function;
|
||
var internal_92 = internal.safe_not_equal;
|
||
var internal_93 = internal.not_equal;
|
||
var internal_94 = internal.validate_store;
|
||
var internal_95 = internal.subscribe;
|
||
var internal_96 = internal.create_slot;
|
||
var internal_97 = internal.get_slot_context;
|
||
var internal_98 = internal.get_slot_changes;
|
||
var internal_99 = internal.exclude_internal_props;
|
||
var internal_100 = internal.bind;
|
||
var internal_101 = internal.mount_component;
|
||
var internal_102 = internal.init;
|
||
var internal_103 = internal.SvelteComponent;
|
||
var internal_104 = internal.SvelteComponentDev;
|
||
|
||
/*! *****************************************************************************
|
||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
||
this file except in compliance with the License. You may obtain a copy of the
|
||
License at http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||
MERCHANTABLITY OR NON-INFRINGEMENT.
|
||
|
||
See the Apache Version 2.0 License for specific language governing permissions
|
||
and limitations under the License.
|
||
***************************************************************************** */
|
||
|
||
function __awaiter(thisArg, _arguments, P, generator) {
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
}
|
||
|
||
function __generator(thisArg, body) {
|
||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||
function step(op) {
|
||
if (f) throw new TypeError("Generator is already executing.");
|
||
while (_) try {
|
||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||
switch (op[0]) {
|
||
case 0: case 1: t = op; break;
|
||
case 4: _.label++; return { value: op[1], done: false };
|
||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||
default:
|
||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||
if (t[2]) _.ops.pop();
|
||
_.trys.pop(); continue;
|
||
}
|
||
op = body.call(thisArg, _);
|
||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||
}
|
||
}
|
||
|
||
function setCookie(cname, cvalue, exdate) {
|
||
var expires = exdate ? ";expires=" + exdate : "";
|
||
document.cookie = cname + "=" + cvalue + expires;
|
||
}
|
||
function getCookie(cname) {
|
||
var name = cname + "=";
|
||
var dc = decodeURIComponent(document.cookie);
|
||
var ca = dc.split(';');
|
||
for (var i = 0; i < ca.length; i++) {
|
||
var c = ca[i];
|
||
while (c.charAt(0) == ' ') {
|
||
c = c.substring(1);
|
||
}
|
||
if (c.indexOf(name) == 0) {
|
||
return c.substring(name.length, c.length);
|
||
}
|
||
}
|
||
return "";
|
||
}
|
||
|
||
// const baseURL = "https://auth.stamm.me";
|
||
var baseURL = "http://localhost:3000";
|
||
function request(endpoint, parameters, method, body, authInParam) {
|
||
if (parameters === void 0) { parameters = {}; }
|
||
if (method === void 0) { method = "GET"; }
|
||
if (authInParam === void 0) { authInParam = false; }
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var pairs, key, url;
|
||
return __generator(this, function (_a) {
|
||
pairs = [];
|
||
if (authInParam) {
|
||
parameters.login = getCookie("login");
|
||
parameters.special = getCookie("special");
|
||
}
|
||
for (key in parameters) {
|
||
pairs.push(key + "=" + parameters[key]);
|
||
}
|
||
url = endpoint;
|
||
if (pairs.length > 0) {
|
||
url += "?" + pairs.join("&");
|
||
}
|
||
return [2 /*return*/, fetch(baseURL + url, {
|
||
method: method,
|
||
body: JSON.stringify(body),
|
||
credentials: "same-origin",
|
||
headers: {
|
||
'content-type': 'application/json'
|
||
},
|
||
}).then(function (e) {
|
||
if (e.status !== 200)
|
||
throw new Error(e.statusText);
|
||
return e.json();
|
||
}).then(function (data) {
|
||
if (data.error) {
|
||
if (data.additional && data.additional.auth) {
|
||
var state = btoa(window.location.pathname + window.location.hash);
|
||
// window.location.href = `/login?state=${state}&base64=true`;
|
||
}
|
||
return Promise.reject(new Error(data.error));
|
||
}
|
||
return data;
|
||
})];
|
||
});
|
||
});
|
||
}
|
||
|
||
var b;if(!(b=t)){var w=Math,y={},B=y.p={},aa=function(){},C=B.A={extend:function(o){aa.prototype=this;var _=new aa;return o&&_.u(o),_.z=this,_},create:function(){var o=this.extend();return o.h.apply(o,arguments),o},h:function(){},u:function(o){for(var _ in o)o.hasOwnProperty(_)&&(this[_]=o[_]);o.hasOwnProperty("toString")&&(this.toString=o.toString);},e:function(){return this.z.extend(this)}},D=B.i=C.extend({h:function(o,_){o=this.d=o||[],this.c=void 0==_?4*o.length:_;},toString:function(o){return (o||ba).stringify(this)},concat:function(o){var _=this.d,Da=o.d,Ea=this.c,o=o.c;if(this.t(),Ea%4)for(var Fa=0;Fa<o;Fa++)_[Ea+Fa>>>2]|=(255&Da[Fa>>>2]>>>24-8*(Fa%4))<<24-8*((Ea+Fa)%4);else if(65535<Da.length)for(Fa=0;Fa<o;Fa+=4)_[Ea+Fa>>>2]=Da[Fa>>>2];else _.push.apply(_,Da);return this.c+=o,this},t:function(){var o=this.d,_=this.c;o[_>>>2]&=4294967295<<32-8*(_%4),o.length=w.ceil(_/4);},e:function(){var o=C.e.call(this);return o.d=this.d.slice(0),o},random:function(o){for(var _=[],Da=0;Da<o;Da+=4)_.push(0|4294967296*w.random());return D.create(_,o)}}),ca=y.O={},ba=ca.K={stringify:function(o){for(var Fa,_=o.d,o=o.c,Da=[],Ea=0;Ea<o;Ea++)Fa=255&_[Ea>>>2]>>>24-8*(Ea%4),Da.push((Fa>>>4).toString(16)),Da.push((15&Fa).toString(16));return Da.join("")},parse:function(o){for(var _=o.length,Da=[],Ea=0;Ea<_;Ea+=2)Da[Ea>>>3]|=parseInt(o.substr(Ea,2),16)<<24-4*(Ea%8);return D.create(Da,_/2)}},da=ca.M={stringify:function(o){for(var _=o.d,o=o.c,Da=[],Ea=0;Ea<o;Ea++)Da.push(String.fromCharCode(255&_[Ea>>>2]>>>24-8*(Ea%4)));return Da.join("")},parse:function(o){for(var _=o.length,Da=[],Ea=0;Ea<_;Ea++)Da[Ea>>>2]|=(255&o.charCodeAt(Ea))<<24-8*(Ea%4);return D.create(Da,_)}},ea=ca.N={stringify:function(o){try{return decodeURIComponent(escape(da.stringify(o)))}catch(_){throw Error("Malformed UTF-8 data")}},parse:function(o){return da.parse(unescape(encodeURIComponent(o)))}},ia=B.I=C.extend({reset:function(){this.g=D.create(),this.j=0;},l:function(o){"string"==typeof o&&(o=ea.parse(o)),this.g.concat(o),this.j+=o.c;},m:function(o){var _=this.g,Da=_.d,Ea=_.c,Fa=this.n,Ga=Ea/(4*Fa),Ga=o?w.ceil(Ga):w.max((0|Ga)-this.r,0),o=Ga*Fa,Ea=w.min(4*o,Ea);if(o){for(var Ha=0;Ha<o;Ha+=Fa)this.H(Da,Ha);Ha=Da.splice(0,o),_.c-=Ea;}return D.create(Ha,Ea)},e:function(){var o=C.e.call(this);return o.g=this.g.e(),o},r:0});B.B=ia.extend({h:function(){this.reset();},reset:function(){ia.reset.call(this),this.q();},update:function(o){return this.l(o),this.m(),this},o:function(o){return o&&this.l(o),this.G(),this.f},e:function(){var o=ia.e.call(this);return o.f=this.f.e(),o},n:16,D:function(o){return function(_,Da){return o.create(Da).o(_)}},F:function(o){return function(_,Da){return ja.J.create(o,Da).o(_)}}});var ja=y.s={};b=y;}var t=b,K=t,ka=K.p,la=ka.A,va=ka.i,K=K.w={};K.C=la.extend({h:function(o,_){this.a=o,this.b=_;}}),K.i=la.extend({h:function(o,_){o=this.d=o||[],this.c=void 0==_?8*o.length:_;},v:function(){for(var Fa,o=this.d,_=o.length,Da=[],Ea=0;Ea<_;Ea++)Fa=o[Ea],Da.push(Fa.a),Da.push(Fa.b);return va.create(Da,this.c)},e:function(){for(var o=la.e.call(this),_=o.d=this.d.slice(0),Da=_.length,Ea=0;Ea<Da;Ea++)_[Ea]=_[Ea].e();return o}});function L(){return wa.create.apply(wa,arguments)}for(var xa=t.p.B,M=t.w,wa=M.C,ya=M.i,M=t.s,za=[L(1116352408,3609767458),L(1899447441,602891725),L(3049323471,3964484399),L(3921009573,2173295548),L(961987163,4081628472),L(1508970993,3053834265),L(2453635748,2937671579),L(2870763221,3664609560),L(3624381080,2734883394),L(310598401,1164996542),L(607225278,1323610764),L(1426881987,3590304994),L(1925078388,4068182383),L(2162078206,991336113),L(2614888103,633803317),L(3248222580,3479774868),L(3835390401,2666613458),L(4022224774,944711139),L(264347078,2341262773),L(604807628,2007800933),L(770255983,1495990901),L(1249150122,1856431235),L(1555081692,3175218132),L(1996064986,2198950837),L(2554220882,3999719339),L(2821834349,766784016),L(2952996808,2566594879),L(3210313671,3203337956),L(3336571891,1034457026),L(3584528711,2466948901),L(113926993,3758326383),L(338241895,168717936),L(666307205,1188179964),L(773529912,1546045734),L(1294757372,1522805485),L(1396182291,2643833823),L(1695183700,2343527390),L(1986661051,1014477480),L(2177026350,1206759142),L(2456956037,344077627),L(2730485921,1290863460),L(2820302411,3158454273),L(3259730800,3505952657),L(3345764771,106217008),L(3516065817,3606008344),L(3600352804,1432725776),L(4094571909,1467031594),L(275423344,851169720),L(430227734,3100823752),L(506948616,1363258195),L(659060556,3750685593),L(883997877,3785050280),L(958139571,3318307427),L(1322822218,3812723403),L(1537002063,2003034995),L(1747873779,3602036899),L(1955562222,1575990012),L(2024104815,1125592928),L(2227730452,2716904306),L(2361852424,442776044),L(2428436474,593698344),L(2756734187,3733110249),L(3204031479,2999351573),L(3329325298,3815920427),L(3391569614,3928383900),L(3515267271,566280711),L(3940187606,3454069534),L(4118630271,4000239992),L(116418474,1914138554),L(174292421,2731055270),L(289380356,3203993006),L(460393269,320620315),L(685471733,587496836),L(852142971,1086792851),L(1017036298,365543100),L(1126000580,2618297676),L(1288033470,3409855158),L(1501505948,4234509866),L(1607167915,987167468),L(1816402316,1246189591)],$=[],Aa=0;80>Aa;Aa++)$[Aa]=L();M=M.k=xa.extend({q:function(){this.f=ya.create([L(1779033703,4089235720),L(3144134277,2227873595),L(1013904242,4271175723),L(2773480762,1595750129),L(1359893119,2917565137),L(2600822924,725511199),L(528734635,4215389547),L(1541459225,327033209)]);},H:function(o,_){for(var qb,Da=this.f.d,Ea=Da[0],Fa=Da[1],Ga=Da[2],Ha=Da[3],Ia=Da[4],Ja=Da[5],Ka=Da[6],Da=Da[7],La=Ea.a,Ma=Ea.b,Na=Fa.a,Oa=Fa.b,Pa=Ga.a,Qa=Ga.b,Ra=Ha.a,Sa=Ha.b,Ta=Ia.a,Ua=Ia.b,Va=Ja.a,Wa=Ja.b,Xa=Ka.a,Ya=Ka.b,Za=Da.a,$a=Da.b,_a=La,ab=Ma,bb=Na,cb=Oa,db=Pa,eb=Qa,fb=Ra,gb=Sa,hb=Ta,ib=Ua,jb=Va,kb=Wa,lb=Xa,mb=Ya,nb=Za,ob=$a,pb=0;80>pb;pb++){if(qb=$[pb],16>pb)var rb=qb.a=0|o[_+2*pb],sb=qb.b=0|o[_+2*pb+1];else{var rb=$[pb-15],sb=rb.a,tb=rb.b,rb=(tb<<31|sb>>>1)^(tb<<24|sb>>>8)^sb>>>7,tb=(sb<<31|tb>>>1)^(sb<<24|tb>>>8)^(sb<<25|tb>>>7),ub=$[pb-2],sb=ub.a,vb=ub.b,ub=(vb<<13|sb>>>19)^(sb<<3|vb>>>29)^sb>>>6,vb=(sb<<13|vb>>>19)^(vb<<3|sb>>>29)^(sb<<26|vb>>>6),sb=$[pb-7],wb=sb.a,xb=$[pb-16],yb=xb.a,xb=xb.b,sb=tb+sb.b,rb=rb+wb+(sb>>>0<tb>>>0?1:0),sb=sb+vb,rb=rb+ub+(sb>>>0<vb>>>0?1:0),sb=sb+xb,rb=rb+yb+(sb>>>0<xb>>>0?1:0);qb.a=rb,qb.b=sb;}var wb=hb&jb^~hb&lb,xb=ib&kb^~ib&mb,qb=_a&bb^_a&db^bb&db,tb=(ab<<4|_a>>>28)^(_a<<30|ab>>>2)^(_a<<25|ab>>>7),ub=(_a<<4|ab>>>28)^(ab<<30|_a>>>2)^(ab<<25|_a>>>7),vb=za[pb],Ab=vb.a,Bb=vb.b,vb=ob+((hb<<18|ib>>>14)^(hb<<14|ib>>>18)^(ib<<23|hb>>>9)),yb=nb+((ib<<18|hb>>>14)^(ib<<14|hb>>>18)^(hb<<23|ib>>>9))+(vb>>>0<ob>>>0?1:0),vb=vb+xb,yb=yb+wb+(vb>>>0<xb>>>0?1:0),vb=vb+Bb,yb=yb+Ab+(vb>>>0<Bb>>>0?1:0),vb=vb+sb,yb=yb+rb+(vb>>>0<sb>>>0?1:0),sb=ub+(ab&cb^ab&eb^cb&eb),qb=tb+qb+(sb>>>0<ub>>>0?1:0),nb=lb,ob=mb,lb=jb,mb=kb,jb=hb,kb=ib,ib=0|gb+vb,hb=0|fb+yb+(ib>>>0<gb>>>0?1:0),fb=db,gb=eb,db=bb,eb=cb,bb=_a,cb=ab,ab=0|vb+sb,_a=0|yb+qb+(ab>>>0<vb>>>0?1:0);}Ma=Ea.b=0|Ma+ab,Ea.a=0|La+_a+(Ma>>>0<ab>>>0?1:0),Oa=Fa.b=0|Oa+cb,Fa.a=0|Na+bb+(Oa>>>0<cb>>>0?1:0),Qa=Ga.b=0|Qa+eb,Ga.a=0|Pa+db+(Qa>>>0<eb>>>0?1:0),Sa=Ha.b=0|Sa+gb,Ha.a=0|Ra+fb+(Sa>>>0<gb>>>0?1:0),Ua=Ia.b=0|Ua+ib,Ia.a=0|Ta+hb+(Ua>>>0<ib>>>0?1:0),Wa=Ja.b=0|Wa+kb,Ja.a=0|Va+jb+(Wa>>>0<kb>>>0?1:0),Ya=Ka.b=0|Ya+mb,Ka.a=0|Xa+lb+(Ya>>>0<mb>>>0?1:0),$a=Da.b=0|$a+ob,Da.a=0|Za+nb+($a>>>0<ob>>>0?1:0);},G:function(){var o=this.g,_=o.d,Da=8*this.j,Ea=8*o.c;_[Ea>>>5]|=128<<24-Ea%32,_[(Ea+128>>>10<<5)+31]=Da,o.c=4*_.length,this.m(),this.f=this.f.v();},n:32}),t.k=xa.D(M),t.L=xa.F(M);function sha512 (o){return t.k(o)+""}
|
||
|
||
var TFATypes;
|
||
(function (TFATypes) {
|
||
TFATypes[TFATypes["OTC"] = 0] = "OTC";
|
||
TFATypes[TFATypes["BACKUP_CODE"] = 1] = "BACKUP_CODE";
|
||
TFATypes[TFATypes["U2F"] = 2] = "U2F";
|
||
TFATypes[TFATypes["APP_ALLOW"] = 3] = "APP_ALLOW";
|
||
})(TFATypes || (TFATypes = {}));
|
||
var Api = {
|
||
// twofactor: [{
|
||
// id: "1",
|
||
// name: "Backup Codes",
|
||
// type: TFATypes.BACKUP_CODE
|
||
// }, {
|
||
// id: "2",
|
||
// name: "YubiKey",
|
||
// type: TFATypes.U2F
|
||
// }, {
|
||
// id: "3",
|
||
// name: "Authenticator",
|
||
// type: TFATypes.OTC
|
||
// }] as TwoFactor[],
|
||
getUsername: function () {
|
||
return this.username || getCookie("username");
|
||
},
|
||
setUsername: function (username) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
return [2 /*return*/, request("/api/user/login", {
|
||
type: "username",
|
||
username: username
|
||
}, "POST").then(function (res) {
|
||
_this.salt = res.salt;
|
||
_this.username = username;
|
||
return {
|
||
error: undefined
|
||
};
|
||
})["catch"](function (err) {
|
||
var error = err.message;
|
||
return { error: error };
|
||
})];
|
||
});
|
||
});
|
||
},
|
||
setPassword: function (password) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var pw;
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
pw = sha512(this.salt + password);
|
||
return [2 /*return*/, request("/api/user/login", {
|
||
type: "password"
|
||
}, "POST", {
|
||
username: this.username,
|
||
password: pw
|
||
}).then(function (_a) {
|
||
var login = _a.login, special = _a.special, tfa = _a.tfa;
|
||
_this.login = login;
|
||
_this.special = special;
|
||
if (tfa && Array.isArray(tfa) && tfa.length > 0)
|
||
_this.twofactor = tfa;
|
||
else
|
||
_this.twofactor = undefined;
|
||
return {
|
||
error: undefined
|
||
};
|
||
})["catch"](function (err) {
|
||
var error = err.message;
|
||
return { error: error };
|
||
})];
|
||
});
|
||
});
|
||
},
|
||
gettok: function () {
|
||
return {
|
||
login: this.login.token,
|
||
special: this.special.token
|
||
};
|
||
},
|
||
sendBackup: function (id, code) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
return [2 /*return*/, request("/api/user/twofactor/backup", this.gettok(), "PUT", { code: code, id: id }).then(function (_a) {
|
||
var login_exp = _a.login_exp, special_exp = _a.special_exp;
|
||
_this.login.expires = login_exp;
|
||
_this.special.expires = special_exp;
|
||
return {};
|
||
})["catch"](function (err) { return ({ error: err.message }); })];
|
||
});
|
||
});
|
||
},
|
||
sendOTC: function (id, code) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _this = this;
|
||
return __generator(this, function (_a) {
|
||
return [2 /*return*/, request("/api/user/twofactor/otc", this.gettok(), "PUT", { code: code, id: id }).then(function (_a) {
|
||
var login_exp = _a.login_exp, special_exp = _a.special_exp;
|
||
_this.login.expires = login_exp;
|
||
_this.special.expires = special_exp;
|
||
return {};
|
||
})["catch"](function (error) { return ({ error: error.message }); })];
|
||
});
|
||
});
|
||
},
|
||
finish: function () {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var d, url, state, red, base64;
|
||
return __generator(this, function (_a) {
|
||
d = new Date();
|
||
d.setTime(d.getTime() + (30 * 24 * 60 * 60 * 1000)); //Keep the username 30 days
|
||
setCookie("username", this.username, d.toUTCString());
|
||
setCookie("login", this.login.token, new Date(this.login.expires).toUTCString());
|
||
setCookie("special", this.special.token, new Date(this.special.expires).toUTCString());
|
||
url = new URL(window.location.href);
|
||
state = url.searchParams.get("state");
|
||
red = "/";
|
||
if (state) {
|
||
base64 = url.searchParams.get("base64");
|
||
if (base64)
|
||
red = atob(state);
|
||
else
|
||
red = state;
|
||
}
|
||
window.location.href = red;
|
||
return [2 /*return*/];
|
||
});
|
||
});
|
||
}
|
||
};
|
||
|
||
/* src/Login/Credentials.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file = "src/Login/Credentials.svelte";
|
||
|
||
// (66:0) {:else}
|
||
function create_else_block(ctx) {
|
||
var h3, t0, t1, t2, div1, input, t3, span0, t4, span1, t5, label, t7, div0, t8, div0_style_value, dispose;
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
t0 = internal_16("Enter password for ");
|
||
t1 = internal_16(ctx.username);
|
||
t2 = internal_17();
|
||
div1 = internal_13("div");
|
||
input = internal_13("input");
|
||
t3 = internal_17();
|
||
span0 = internal_13("span");
|
||
t4 = internal_17();
|
||
span1 = internal_13("span");
|
||
t5 = internal_17();
|
||
label = internal_13("label");
|
||
label.textContent = "Password";
|
||
t7 = internal_17();
|
||
div0 = internal_13("div");
|
||
t8 = internal_16(ctx.error);
|
||
internal_87(h3, file, 66, 0, 1416);
|
||
internal_22(input, "type", "password");
|
||
input.autocomplete = "password";
|
||
input.autofocus = true;
|
||
internal_87(input, file, 68, 3, 1487);
|
||
span0.className = "highlight";
|
||
internal_87(span0, file, 69, 3, 1570);
|
||
span1.className = "bar";
|
||
internal_87(span1, file, 70, 3, 1605);
|
||
internal_87(label, file, 71, 3, 1634);
|
||
div0.className = "error svelte-m6rjik";
|
||
div0.style.cssText = div0_style_value = !ctx.error ? "display: none;" : "";
|
||
internal_87(div0, file, 72, 3, 1661);
|
||
div1.className = "floating group";
|
||
internal_87(div1, file, 67, 0, 1455);
|
||
dispose = internal_19(input, "input", ctx.input_input_handler_1);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, h3, anchor);
|
||
internal_6(h3, t0);
|
||
internal_6(h3, t1);
|
||
internal_7(target, t2, anchor);
|
||
internal_7(target, div1, anchor);
|
||
internal_6(div1, input);
|
||
|
||
input.value = ctx.password;
|
||
|
||
internal_6(div1, t3);
|
||
internal_6(div1, span0);
|
||
internal_6(div1, t4);
|
||
internal_6(div1, span1);
|
||
internal_6(div1, t5);
|
||
internal_6(div1, label);
|
||
internal_6(div1, t7);
|
||
internal_6(div1, div0);
|
||
internal_6(div0, t8);
|
||
input.focus();
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.username) {
|
||
internal_32(t1, ctx.username);
|
||
}
|
||
|
||
if (changed.password) input.value = ctx.password;
|
||
|
||
if (changed.error) {
|
||
internal_32(t8, ctx.error);
|
||
}
|
||
|
||
if ((changed.error) && div0_style_value !== (div0_style_value = !ctx.error ? "display: none;" : "")) {
|
||
div0.style.cssText = div0_style_value;
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t2);
|
||
internal_8(div1);
|
||
}
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
// (57:0) {#if state === states.username}
|
||
function create_if_block(ctx) {
|
||
var h3, t1, div1, input, t2, span0, t3, span1, t4, label, t6, div0, t7, div0_style_value, dispose;
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
h3.textContent = "Enter your Username or your E-Mail Address";
|
||
t1 = internal_17();
|
||
div1 = internal_13("div");
|
||
input = internal_13("input");
|
||
t2 = internal_17();
|
||
span0 = internal_13("span");
|
||
t3 = internal_17();
|
||
span1 = internal_13("span");
|
||
t4 = internal_17();
|
||
label = internal_13("label");
|
||
label.textContent = "Username or E-Mail";
|
||
t6 = internal_17();
|
||
div0 = internal_13("div");
|
||
t7 = internal_16(ctx.error);
|
||
internal_87(h3, file, 57, 0, 1064);
|
||
internal_22(input, "type", "text");
|
||
input.autocomplete = "username";
|
||
input.autofocus = true;
|
||
internal_87(input, file, 59, 3, 1148);
|
||
span0.className = "highlight";
|
||
internal_87(span0, file, 60, 3, 1227);
|
||
span1.className = "bar";
|
||
internal_87(span1, file, 61, 3, 1262);
|
||
internal_87(label, file, 62, 3, 1291);
|
||
div0.className = "error svelte-m6rjik";
|
||
div0.style.cssText = div0_style_value = !ctx.error ? "display: none;" : "";
|
||
internal_87(div0, file, 63, 3, 1328);
|
||
div1.className = "floating group";
|
||
internal_87(div1, file, 58, 0, 1116);
|
||
dispose = internal_19(input, "input", ctx.input_input_handler);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, h3, anchor);
|
||
internal_7(target, t1, anchor);
|
||
internal_7(target, div1, anchor);
|
||
internal_6(div1, input);
|
||
|
||
input.value = ctx.username;
|
||
|
||
internal_6(div1, t2);
|
||
internal_6(div1, span0);
|
||
internal_6(div1, t3);
|
||
internal_6(div1, span1);
|
||
internal_6(div1, t4);
|
||
internal_6(div1, label);
|
||
internal_6(div1, t6);
|
||
internal_6(div1, div0);
|
||
internal_6(div0, t7);
|
||
input.focus();
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.username && (input.value !== ctx.username)) input.value = ctx.username;
|
||
|
||
if (changed.error) {
|
||
internal_32(t7, ctx.error);
|
||
}
|
||
|
||
if ((changed.error) && div0_style_value !== (div0_style_value = !ctx.error ? "display: none;" : "")) {
|
||
div0.style.cssText = div0_style_value;
|
||
}
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t1);
|
||
internal_8(div1);
|
||
}
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function create_fragment(ctx) {
|
||
var t, button, dispose;
|
||
|
||
function select_block_type(ctx) {
|
||
if (ctx.state === ctx.states.username) return create_if_block;
|
||
return create_else_block;
|
||
}
|
||
|
||
var current_block_type = select_block_type(ctx);
|
||
var if_block = current_block_type(ctx);
|
||
|
||
return {
|
||
c: function create() {
|
||
if_block.c();
|
||
t = internal_17();
|
||
button = internal_13("button");
|
||
button.textContent = "Next";
|
||
button.className = "btn svelte-m6rjik";
|
||
internal_87(button, file, 76, 0, 1748);
|
||
dispose = internal_19(button, "click", ctx.buttonClick);
|
||
},
|
||
|
||
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_block.m(target, anchor);
|
||
internal_7(target, t, anchor);
|
||
internal_7(target, button, anchor);
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
|
||
if_block.p(changed, ctx);
|
||
} else {
|
||
if_block.d(1);
|
||
if_block = current_block_type(ctx);
|
||
if (if_block) {
|
||
if_block.c();
|
||
if_block.m(t.parentNode, t);
|
||
}
|
||
}
|
||
},
|
||
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if_block.d(detaching);
|
||
|
||
if (detaching) {
|
||
internal_8(t);
|
||
internal_8(button);
|
||
}
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance($$self, $$props, $$invalidate) {
|
||
let error;
|
||
let password = "";
|
||
let username = Api.getUsername();
|
||
|
||
const states = {
|
||
username: 1,
|
||
password: 2
|
||
};
|
||
|
||
let state = states.username;
|
||
|
||
let { setLoading, next } = $$props;
|
||
|
||
async function buttonClick() {
|
||
setLoading(true);
|
||
if (state === states.username) {
|
||
let res = await Api.setUsername(username);
|
||
if (res.error) {
|
||
$$invalidate('error', error = res.error);
|
||
} else {
|
||
$$invalidate('state', state = states.password);
|
||
$$invalidate('error', error = undefined);
|
||
}
|
||
} else if (state === states.password) {
|
||
let res = await Api.setPassword(password);
|
||
if (res.error) {
|
||
$$invalidate('error', error = res.error);
|
||
} else {
|
||
$$invalidate('error', error = undefined);
|
||
next();
|
||
}
|
||
}
|
||
|
||
setLoading(false);
|
||
}
|
||
|
||
function input_input_handler() {
|
||
username = this.value;
|
||
$$invalidate('username', username);
|
||
}
|
||
|
||
function input_input_handler_1() {
|
||
password = this.value;
|
||
$$invalidate('password', password);
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ('setLoading' in $$props) $$invalidate('setLoading', setLoading = $$props.setLoading);
|
||
if ('next' in $$props) $$invalidate('next', next = $$props.next);
|
||
};
|
||
|
||
return {
|
||
error,
|
||
password,
|
||
username,
|
||
states,
|
||
state,
|
||
setLoading,
|
||
next,
|
||
buttonClick,
|
||
input_input_handler,
|
||
input_input_handler_1
|
||
};
|
||
}
|
||
|
||
class Credentials extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance, create_fragment, internal_92, ["setLoading", "next"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.setLoading === undefined && !('setLoading' in props)) {
|
||
console.warn("<Credentials> was created without expected prop 'setLoading'");
|
||
}
|
||
if (ctx.next === undefined && !('next' in props)) {
|
||
console.warn("<Credentials> was created without expected prop 'next'");
|
||
}
|
||
}
|
||
|
||
get setLoading() {
|
||
throw new Error("<Credentials>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set setLoading(value) {
|
||
throw new Error("<Credentials>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get next() {
|
||
throw new Error("<Credentials>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set next(value) {
|
||
throw new Error("<Credentials>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
var svelte = createCommonjsModule(function (module, exports) {
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
|
||
|
||
|
||
|
||
exports.onMount = internal.onMount;
|
||
exports.onDestroy = internal.onDestroy;
|
||
exports.beforeUpdate = internal.beforeUpdate;
|
||
exports.afterUpdate = internal.afterUpdate;
|
||
exports.setContext = internal.setContext;
|
||
exports.getContext = internal.getContext;
|
||
exports.tick = internal.tick;
|
||
exports.createEventDispatcher = internal.createEventDispatcher;
|
||
});
|
||
|
||
unwrapExports(svelte);
|
||
var svelte_1 = svelte.onMount;
|
||
var svelte_2 = svelte.onDestroy;
|
||
var svelte_3 = svelte.beforeUpdate;
|
||
var svelte_4 = svelte.afterUpdate;
|
||
var svelte_5 = svelte.setContext;
|
||
var svelte_6 = svelte.getContext;
|
||
var svelte_7 = svelte.tick;
|
||
var svelte_8 = svelte.createEventDispatcher;
|
||
|
||
/* src/Login/Redirect.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$1 = "src/Login/Redirect.svelte";
|
||
|
||
function create_fragment$1(ctx) {
|
||
var div, svg, circle, path, t0, h3, t1;
|
||
|
||
return {
|
||
c: function create() {
|
||
div = internal_13("div");
|
||
svg = internal_15("svg");
|
||
circle = internal_15("circle");
|
||
path = internal_15("path");
|
||
t0 = internal_17();
|
||
h3 = internal_13("h3");
|
||
t1 = internal_16(ctx.text);
|
||
internal_22(circle, "class", "checkmark__circle svelte-zjta2c");
|
||
internal_22(circle, "cx", "26");
|
||
internal_22(circle, "cy", "26");
|
||
internal_22(circle, "r", "25");
|
||
internal_22(circle, "fill", "none");
|
||
internal_87(circle, file$1, 33, 6, 634);
|
||
internal_22(path, "class", "checkmark__check svelte-zjta2c");
|
||
internal_22(path, "fill", "none");
|
||
internal_22(path, "d", "M14.1 27.2l7.1 7.2 16.7-16.8");
|
||
internal_87(path, file$1, 34, 6, 712);
|
||
internal_22(svg, "class", "checkmark svelte-zjta2c");
|
||
internal_22(svg, "xmlns", "http://www.w3.org/2000/svg");
|
||
internal_22(svg, "viewBox", "0 0 52 52");
|
||
internal_87(svg, file$1, 32, 3, 549);
|
||
div.className = "scale svelte-zjta2c";
|
||
internal_87(div, file$1, 31, 0, 526);
|
||
internal_87(h3, file$1, 38, 0, 851);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, div, anchor);
|
||
internal_6(div, svg);
|
||
internal_6(svg, circle);
|
||
internal_6(svg, path);
|
||
internal_7(target, t0, anchor);
|
||
internal_7(target, h3, anchor);
|
||
internal_6(h3, t1);
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.text) {
|
||
internal_32(t1, ctx.text);
|
||
}
|
||
},
|
||
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div);
|
||
internal_8(t0);
|
||
internal_8(h3);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
const basetext = "Logged in. Redirecting";
|
||
|
||
function instance$1($$self, $$props, $$invalidate) {
|
||
|
||
let dots = 0;
|
||
|
||
let iv;
|
||
svelte_1(() => {
|
||
console.log("Mounted");
|
||
$$invalidate('iv', iv = setInterval(() => {
|
||
dots++; $$invalidate('dots', dots);
|
||
if (dots > 3)
|
||
$$invalidate('dots', dots = 0);
|
||
}, 500));
|
||
});
|
||
|
||
svelte_2(() => {
|
||
console.log("on Destroy");
|
||
clearInterval(iv);
|
||
});
|
||
|
||
let text;
|
||
|
||
$$self.$$.update = ($$dirty = { dots: 1 }) => {
|
||
if ($$dirty.dots) { $$invalidate('text', text = basetext + ".".repeat(dots)); }
|
||
};
|
||
|
||
return { text };
|
||
}
|
||
|
||
class Redirect extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$1, create_fragment$1, internal_92, []);
|
||
}
|
||
}
|
||
|
||
/* src/Login/icons/Icon.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$2 = "src/Login/icons/Icon.svelte";
|
||
|
||
// (13:0) {:else}
|
||
function create_else_block$1(ctx) {
|
||
var t;
|
||
|
||
return {
|
||
c: function create() {
|
||
t = internal_16("ERR");
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, t, anchor);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(t);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (11:34)
|
||
function create_if_block_3(ctx) {
|
||
var svg, path0, rect, path1, ellipse;
|
||
|
||
return {
|
||
c: function create() {
|
||
svg = internal_15("svg");
|
||
path0 = internal_15("path");
|
||
rect = internal_15("rect");
|
||
path1 = internal_15("path");
|
||
ellipse = internal_15("ellipse");
|
||
internal_22(path0, "d", "M18.617,1.72c0,-0.949 -0.771,-1.72 -1.721,-1.72l-9.792,0c-0.95,0 -1.721,0.771 -1.721,1.72l0,20.56c0,0.949 0.771,1.72 1.721,1.72l9.792,0c0.95,0 1.721,-0.771 1.721,-1.72l0,-20.56Z");
|
||
internal_34(path0, "fill", "#4d4d4d");
|
||
internal_87(path0, file$2, 11, 294, 5677);
|
||
internal_22(rect, "x", "6");
|
||
internal_22(rect, "y", "3");
|
||
internal_22(rect, "width", "12");
|
||
internal_22(rect, "height", "18");
|
||
internal_34(rect, "fill", "#b3b3b3");
|
||
internal_87(rect, file$2, 11, 505, 5888);
|
||
internal_22(path1, "d", "M14,1.5c0,-0.129 -0.105,-0.233 -0.233,-0.233l-3.534,0c-0.128,0 -0.233,0.104 -0.233,0.233c0,0.129 0.105,0.233 0.233,0.233l3.534,0c0.128,0 0.233,-0.104 0.233,-0.233Z");
|
||
internal_34(path1, "fill", "#b3b3b3");
|
||
internal_87(path1, file$2, 11, 569, 5952);
|
||
internal_22(ellipse, "cx", "12");
|
||
internal_22(ellipse, "cy", "22.5");
|
||
internal_22(ellipse, "rx", "0.983");
|
||
internal_22(ellipse, "ry", "1");
|
||
internal_34(ellipse, "fill", "#b3b3b3");
|
||
internal_87(ellipse, file$2, 11, 766, 6149);
|
||
internal_22(svg, "width", "100%");
|
||
internal_22(svg, "height", "100%");
|
||
internal_22(svg, "viewBox", "0 0 24 24");
|
||
internal_22(svg, "version", "1.1");
|
||
internal_22(svg, "xmlns", "http://www.w3.org/2000/svg");
|
||
internal_22(svg, "xmlns:xlink", "http://www.w3.org/1999/xlink");
|
||
internal_22(svg, "xml:space", "preserve");
|
||
internal_22(svg, "xmlns:serif", "http://www.serif.com/");
|
||
internal_34(svg, "fill-rule", "evenodd");
|
||
internal_34(svg, "clip-rule", "evenodd");
|
||
internal_34(svg, "stroke-linejoin", "round");
|
||
internal_34(svg, "stroke-miterlimit", "1.41421");
|
||
internal_87(svg, file$2, 11, 0, 5383);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, svg, anchor);
|
||
internal_6(svg, path0);
|
||
internal_6(svg, rect);
|
||
internal_6(svg, path1);
|
||
internal_6(svg, ellipse);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(svg);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (9:37)
|
||
function create_if_block_2(ctx) {
|
||
var svg, path0, circle, path1;
|
||
|
||
return {
|
||
c: function create() {
|
||
svg = internal_15("svg");
|
||
path0 = internal_15("path");
|
||
circle = internal_15("circle");
|
||
path1 = internal_15("path");
|
||
internal_22(path0, "d", "M20.562,9.105c0,-0.853 -0.692,-1.544 -1.544,-1.544l-14.036,0c-0.852,0 -1.544,0.691 -1.544,1.544l0,12.351c0,0.852 0.692,1.544 1.544,1.544l14.036,0c0.852,0 1.544,-0.692 1.544,-1.544l0,-12.351Z");
|
||
internal_34(path0, "fill", "none");
|
||
internal_34(path0, "stroke", "#000");
|
||
internal_34(path0, "stroke-width", "1.5px");
|
||
internal_87(path0, file$2, 9, 311, 4883);
|
||
internal_22(circle, "cx", "12");
|
||
internal_22(circle, "cy", "15.3");
|
||
internal_22(circle, "r", "1.5");
|
||
internal_87(circle, file$2, 9, 563, 5135);
|
||
internal_22(path1, "d", "M16.646,4.28c0,-1.81 -1.47,-3.28 -3.28,-3.28l-2.732,0c-1.81,0 -3.28,1.47 -3.28,3.28l0,3.281l9.292,0l0,-3.281Z");
|
||
internal_34(path1, "fill", "none");
|
||
internal_34(path1, "stroke", "#000");
|
||
internal_34(path1, "stroke-width", "1.5px");
|
||
internal_87(path1, file$2, 9, 598, 5170);
|
||
internal_22(svg, "width", "100%");
|
||
internal_22(svg, "height", "100%");
|
||
internal_22(svg, "viewBox", "0 0 24 24");
|
||
internal_22(svg, "version", "1.1");
|
||
internal_22(svg, "xmlns", "http://www.w3.org/2000/svg");
|
||
internal_22(svg, "xmlns:xlink", "http://www.w3.org/1999/xlink");
|
||
internal_22(svg, "xml:space", "preserve");
|
||
internal_22(svg, "xmlns:serif", "http://www.serif.com/");
|
||
internal_34(svg, "fill-rule", "evenodd");
|
||
internal_34(svg, "clip-rule", "evenodd");
|
||
internal_34(svg, "stroke-linecap", "round");
|
||
internal_34(svg, "stroke-linejoin", "round");
|
||
internal_34(svg, "stroke-miterlimit", "1.5");
|
||
internal_87(svg, file$2, 9, 0, 4572);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, svg, anchor);
|
||
internal_6(svg, path0);
|
||
internal_6(svg, circle);
|
||
internal_6(svg, path1);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(svg);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (7:40)
|
||
function create_if_block_1(ctx) {
|
||
var svg, g, path0, circle0, path1, circle1, circle2, circle3, path2, path3, path4, circle4, circle5, path5, path6, path7, path8, path9, path10, circle6, defs, linearGradient, stop0, stop1;
|
||
|
||
return {
|
||
c: function create() {
|
||
svg = internal_15("svg");
|
||
g = internal_15("g");
|
||
path0 = internal_15("path");
|
||
circle0 = internal_15("circle");
|
||
path1 = internal_15("path");
|
||
circle1 = internal_15("circle");
|
||
circle2 = internal_15("circle");
|
||
circle3 = internal_15("circle");
|
||
path2 = internal_15("path");
|
||
path3 = internal_15("path");
|
||
path4 = internal_15("path");
|
||
circle4 = internal_15("circle");
|
||
circle5 = internal_15("circle");
|
||
path5 = internal_15("path");
|
||
path6 = internal_15("path");
|
||
path7 = internal_15("path");
|
||
path8 = internal_15("path");
|
||
path9 = internal_15("path");
|
||
path10 = internal_15("path");
|
||
circle6 = internal_15("circle");
|
||
defs = internal_15("defs");
|
||
linearGradient = internal_15("linearGradient");
|
||
stop0 = internal_15("stop");
|
||
stop1 = internal_15("stop");
|
||
internal_22(path0, "d", "M18.5,12c0,3.59 -2.91,6.5 -6.5,6.5c-3.59,0 -6.5,-2.91 -6.5,-6.5c0,-3.59 2.91,-6.5 6.5,-6.5c1.729,0 3.295,0.679 4.46,1.78l4.169,-3.599c-2.184,-2.265 -5.242,-3.681 -8.629,-3.681c-6.617,0 -12,5.383 -12,12c0,6.617 5.383,12 12,12c6.617,0 12,-5.383 12,-12l-5.5,0Z");
|
||
internal_34(path0, "fill", "#999");
|
||
internal_34(path0, "fill-rule", "nonzero");
|
||
internal_87(path0, file$2, 7, 297, 1300);
|
||
internal_22(circle0, "id", "XMLID_1331_");
|
||
internal_22(circle0, "cx", "12");
|
||
internal_22(circle0, "cy", "12");
|
||
internal_22(circle0, "r", "12");
|
||
internal_34(circle0, "fill", "#808080");
|
||
internal_87(circle0, file$2, 7, 603, 1606);
|
||
internal_22(path1, "d", "M19,12c0,3.866 -3.134,7 -7,7c-3.866,0 -7,-3.134 -7,-7c0,-3.866 3.134,-7 7,-7c1.88,0 3.583,0.745 4.841,1.951l3.788,-3.27c-2.184,-2.265 -5.242,-3.681 -8.629,-3.681c-6.617,0 -12,5.383 -12,12c0,6.617 5.383,12 12,12c6.617,0 12,-5.383 12,-12l-5,0Z");
|
||
internal_34(path1, "fill", "#999");
|
||
internal_34(path1, "fill-rule", "nonzero");
|
||
internal_87(path1, file$2, 7, 674, 1677);
|
||
internal_22(circle1, "cx", "12");
|
||
internal_22(circle1, "cy", "2.5");
|
||
internal_22(circle1, "r", "1");
|
||
internal_34(circle1, "fill", "#b3b3b3");
|
||
internal_87(circle1, file$2, 7, 964, 1967);
|
||
internal_22(circle2, "cx", "12");
|
||
internal_22(circle2, "cy", "21.5");
|
||
internal_22(circle2, "r", "1");
|
||
internal_34(circle2, "fill", "#b3b3b3");
|
||
internal_87(circle2, file$2, 7, 1018, 2021);
|
||
internal_22(circle3, "cx", "2.5");
|
||
internal_22(circle3, "cy", "12");
|
||
internal_22(circle3, "r", "1");
|
||
internal_34(circle3, "fill", "#b3b3b3");
|
||
internal_87(circle3, file$2, 7, 1073, 2076);
|
||
internal_22(path2, "d", "M4.575,18.01c0.391,-0.39 1.024,-0.39 1.415,0c0.39,0.391 0.39,1.024 0,1.415c-0.391,0.39 -1.024,0.39 -1.415,0c-0.39,-0.391 -0.39,-1.024 0,-1.415Z");
|
||
internal_34(path2, "fill", "#b3b3b3");
|
||
internal_87(path2, file$2, 7, 1127, 2130);
|
||
internal_22(path3, "d", "M18.01,18.01c0.391,-0.39 1.024,-0.39 1.415,0c0.39,0.391 0.39,1.024 0,1.415c-0.391,0.39 -1.024,0.39 -1.415,0c-0.39,-0.391 -0.39,-1.024 0,-1.415Z");
|
||
internal_34(path3, "fill", "#b3b3b3");
|
||
internal_87(path3, file$2, 7, 1304, 2307);
|
||
internal_22(path4, "d", "M4.575,4.575c0.391,-0.39 1.024,-0.39 1.415,0c0.39,0.391 0.39,1.024 0,1.415c-0.391,0.39 -1.024,0.39 -1.415,0c-0.39,-0.391 -0.39,-1.024 0,-1.415Z");
|
||
internal_34(path4, "fill", "#b3b3b3");
|
||
internal_87(path4, file$2, 7, 1481, 2484);
|
||
internal_22(circle4, "id", "XMLID_1329_");
|
||
internal_22(circle4, "cx", "12");
|
||
internal_22(circle4, "cy", "12");
|
||
internal_22(circle4, "r", "6");
|
||
internal_34(circle4, "fill", "#808080");
|
||
internal_87(circle4, file$2, 7, 1658, 2661);
|
||
internal_22(circle5, "id", "XMLID_1330_");
|
||
internal_22(circle5, "cx", "12");
|
||
internal_22(circle5, "cy", "12");
|
||
internal_22(circle5, "r", "7");
|
||
internal_34(circle5, "fill", "#808080");
|
||
internal_87(circle5, file$2, 7, 1728, 2731);
|
||
internal_22(path5, "d", "M19,12.25c0,-0.042 -0.006,-0.083 -0.006,-0.125c-0.068,3.808 -3.17,6.875 -6.994,6.875c-3.824,0 -6.933,-3.067 -7,-6.875c-0.001,0.042 0,0.083 0,0.125c0,3.866 3.134,7 7,7c3.866,0 7,-3.134 7,-7Z");
|
||
internal_34(path5, "fill", "#fff");
|
||
internal_34(path5, "fill-opacity", "0.2");
|
||
internal_34(path5, "fill-rule", "nonzero");
|
||
internal_87(path5, file$2, 7, 1798, 2801);
|
||
internal_22(path6, "d", "M18.92,13l-3.061,0c0.083,-0.321 0.141,-0.653 0.141,-1c0,-2.209 -1.791,-4 -4,-4c-2.209,0 -4,1.791 -4,4c0,1.105 0.448,2.105 1.172,2.828c1.014,1.015 4.057,4.058 4.057,4.058c2.955,-0.525 5.263,-2.899 5.691,-5.886Z");
|
||
internal_34(path6, "fill", "#4d4d4d");
|
||
internal_34(path6, "fill-rule", "nonzero");
|
||
internal_87(path6, file$2, 7, 2053, 3056);
|
||
internal_22(path7, "d", "M22,13l-10,0c-0.553,0 -1,-0.448 -1,-1c0,-0.552 0.447,-1 1,-1l10,0c0.553,0 1,0.448 1,1c0,0.552 -0.447,1 -1,1Z");
|
||
internal_34(path7, "fill", "#b3b3b3");
|
||
internal_34(path7, "fill-rule", "nonzero");
|
||
internal_87(path7, file$2, 7, 2314, 3317);
|
||
internal_22(path8, "d", "M11.948,11.25l10.104,0c0.409,0 0.776,0.247 0.935,0.592c-0.08,-0.471 -0.492,-0.842 -0.987,-0.842l-10,0c-0.495,0 -0.9,0.33 -0.98,0.801c0.159,-0.345 0.519,-0.551 0.928,-0.551Z");
|
||
internal_34(path8, "fill", "#fff");
|
||
internal_34(path8, "fill-opacity", "0.2");
|
||
internal_34(path8, "fill-rule", "nonzero");
|
||
internal_87(path8, file$2, 7, 2474, 3477);
|
||
internal_22(path9, "d", "M23,12c0,0.552 -0.447,1 -1,1l-3.08,0c-0.428,2.988 -2.737,5.362 -5.693,5.886l3.935,3.946c4.04,-1.931 6.838,-6.056 6.838,-10.832l-1,0Z");
|
||
internal_34(path9, "fill", "#666");
|
||
internal_34(path9, "fill-opacity", "0.5");
|
||
internal_34(path9, "fill-rule", "nonzero");
|
||
internal_87(path9, file$2, 7, 2712, 3715);
|
||
internal_22(path10, "d", "M12,5c-3.866,0 -7,3.134 -7,7c0,0.042 -0.001,0.069 0,0.111c0.067,-3.808 3.176,-6.861 7,-6.861c2.828,0 4.841,1.701 4.841,1.701c-1.257,-1.198 -2.968,-1.951 -4.841,-1.951Z");
|
||
internal_34(path10, "fill-opacity", "0.1");
|
||
internal_34(path10, "fill-rule", "nonzero");
|
||
internal_87(path10, file$2, 7, 2910, 3913);
|
||
internal_22(circle6, "id", "XMLID_4_");
|
||
internal_22(circle6, "cx", "12");
|
||
internal_22(circle6, "cy", "12");
|
||
internal_22(circle6, "r", "12");
|
||
internal_34(circle6, "fill", "url(#_Linear1)");
|
||
internal_87(circle6, file$2, 7, 3133, 4136);
|
||
internal_87(g, file$2, 7, 294, 1297);
|
||
internal_22(stop0, "offset", "0");
|
||
internal_34(stop0, "stop-color", "#fff");
|
||
internal_34(stop0, "stop-opacity", "0.2");
|
||
internal_87(stop0, file$2, 7, 3384, 4387);
|
||
internal_22(stop1, "offset", "1");
|
||
internal_34(stop1, "stop-color", "#fff");
|
||
internal_34(stop1, "stop-opacity", "0");
|
||
internal_87(stop1, file$2, 7, 3443, 4446);
|
||
internal_22(linearGradient, "id", "_Linear1");
|
||
internal_22(linearGradient, "x1", "0");
|
||
internal_22(linearGradient, "y1", "0");
|
||
internal_22(linearGradient, "x2", "1");
|
||
internal_22(linearGradient, "y2", "0");
|
||
internal_22(linearGradient, "gradientUnits", "userSpaceOnUse");
|
||
internal_22(linearGradient, "gradientTransform", "matrix(21.7566,10.1453,-10.1453,21.7566,1.12171,6.92737)");
|
||
internal_87(linearGradient, file$2, 7, 3218, 4221);
|
||
internal_87(defs, file$2, 7, 3212, 4215);
|
||
internal_22(svg, "width", "100%");
|
||
internal_22(svg, "height", "100%");
|
||
internal_22(svg, "viewBox", "0 0 24 24");
|
||
internal_22(svg, "version", "1.1");
|
||
internal_22(svg, "xmlns", "http://www.w3.org/2000/svg");
|
||
internal_22(svg, "xmlns:xlink", "http://www.w3.org/1999/xlink");
|
||
internal_22(svg, "xml:space", "preserve");
|
||
internal_22(svg, "xmlns:serif", "http://www.serif.com/");
|
||
internal_34(svg, "fill-rule", "evenodd");
|
||
internal_34(svg, "clip-rule", "evenodd");
|
||
internal_34(svg, "stroke-linejoin", "round");
|
||
internal_34(svg, "stroke-miterlimit", "1.41421");
|
||
internal_87(svg, file$2, 7, 0, 1003);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, svg, anchor);
|
||
internal_6(svg, g);
|
||
internal_6(g, path0);
|
||
internal_6(g, circle0);
|
||
internal_6(g, path1);
|
||
internal_6(g, circle1);
|
||
internal_6(g, circle2);
|
||
internal_6(g, circle3);
|
||
internal_6(g, path2);
|
||
internal_6(g, path3);
|
||
internal_6(g, path4);
|
||
internal_6(g, circle4);
|
||
internal_6(g, circle5);
|
||
internal_6(g, path5);
|
||
internal_6(g, path6);
|
||
internal_6(g, path7);
|
||
internal_6(g, path8);
|
||
internal_6(g, path9);
|
||
internal_6(g, path10);
|
||
internal_6(g, circle6);
|
||
internal_6(svg, defs);
|
||
internal_6(defs, linearGradient);
|
||
internal_6(linearGradient, stop0);
|
||
internal_6(linearGradient, stop1);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(svg);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (5:0) {#if icon_name === "SecurityKey"}
|
||
function create_if_block$1(ctx) {
|
||
var svg, path, rect0, rect1, rect2, rect3, rect4;
|
||
|
||
return {
|
||
c: function create() {
|
||
svg = internal_15("svg");
|
||
path = internal_15("path");
|
||
rect0 = internal_15("rect");
|
||
rect1 = internal_15("rect");
|
||
rect2 = internal_15("rect");
|
||
rect3 = internal_15("rect");
|
||
rect4 = internal_15("rect");
|
||
internal_22(path, "d", "M18,7.692c0,-0.925 -0.751,-1.675 -1.675,-1.675l-14.65,0c-0.924,0 -1.675,0.75 -1.675,1.675l0,8.616c0,0.925 0.751,1.675 1.675,1.675l14.65,0c0.924,0 1.675,-0.75 1.675,-1.675l0,-8.616Z");
|
||
internal_34(path, "fill", "#4d4d4d");
|
||
internal_87(path, file$2, 5, 294, 373);
|
||
internal_22(rect0, "x", "18");
|
||
internal_22(rect0, "y", "8.011");
|
||
internal_22(rect0, "width", "6");
|
||
internal_22(rect0, "height", "7.978");
|
||
internal_34(rect0, "fill", "#4d4d4d");
|
||
internal_87(rect0, file$2, 5, 508, 587);
|
||
internal_22(rect1, "x", "18");
|
||
internal_22(rect1, "y", "10.644");
|
||
internal_22(rect1, "width", "4.8");
|
||
internal_22(rect1, "height", "1.231");
|
||
internal_34(rect1, "fill", "#b3b3b3");
|
||
internal_87(rect1, file$2, 5, 579, 658);
|
||
internal_22(rect2, "x", "18");
|
||
internal_22(rect2, "y", "12.229");
|
||
internal_22(rect2, "width", "4.8");
|
||
internal_22(rect2, "height", "1.164");
|
||
internal_34(rect2, "fill", "#b3b3b3");
|
||
internal_87(rect2, file$2, 5, 653, 732);
|
||
internal_22(rect3, "x", "18");
|
||
internal_22(rect3, "y", "9.008");
|
||
internal_22(rect3, "width", "5.25");
|
||
internal_22(rect3, "height", "1.231");
|
||
internal_34(rect3, "fill", "#b3b3b3");
|
||
internal_87(rect3, file$2, 5, 727, 806);
|
||
internal_22(rect4, "x", "18");
|
||
internal_22(rect4, "y", "13.794");
|
||
internal_22(rect4, "width", "5.25");
|
||
internal_22(rect4, "height", "1.197");
|
||
internal_34(rect4, "fill", "#b3b3b3");
|
||
internal_87(rect4, file$2, 5, 801, 880);
|
||
internal_22(svg, "width", "100%");
|
||
internal_22(svg, "height", "100%");
|
||
internal_22(svg, "viewBox", "0 0 24 24");
|
||
internal_22(svg, "version", "1.1");
|
||
internal_22(svg, "xmlns", "http://www.w3.org/2000/svg");
|
||
internal_22(svg, "xmlns:xlink", "http://www.w3.org/1999/xlink");
|
||
internal_22(svg, "xml:space", "preserve");
|
||
internal_22(svg, "xmlns:serif", "http://www.serif.com/");
|
||
internal_34(svg, "fill-rule", "evenodd");
|
||
internal_34(svg, "clip-rule", "evenodd");
|
||
internal_34(svg, "stroke-linejoin", "round");
|
||
internal_34(svg, "stroke-miterlimit", "1.41421");
|
||
internal_87(svg, file$2, 5, 0, 79);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, svg, anchor);
|
||
internal_6(svg, path);
|
||
internal_6(svg, rect0);
|
||
internal_6(svg, rect1);
|
||
internal_6(svg, rect2);
|
||
internal_6(svg, rect3);
|
||
internal_6(svg, rect4);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(svg);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
function create_fragment$2(ctx) {
|
||
var if_block_anchor;
|
||
|
||
function select_block_type(ctx) {
|
||
if (ctx.icon_name === "SecurityKey") return create_if_block$1;
|
||
if (ctx.icon_name === "Authenticator") return create_if_block_1;
|
||
if (ctx.icon_name === "BackupCode") return create_if_block_2;
|
||
if (ctx.icon_name === "AppPush") return create_if_block_3;
|
||
return create_else_block$1;
|
||
}
|
||
|
||
var current_block_type = select_block_type(ctx);
|
||
var if_block = current_block_type(ctx);
|
||
|
||
return {
|
||
c: function create() {
|
||
if_block.c();
|
||
if_block_anchor = internal_18();
|
||
},
|
||
|
||
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_block.m(target, anchor);
|
||
internal_7(target, if_block_anchor, anchor);
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (current_block_type !== (current_block_type = select_block_type(ctx))) {
|
||
if_block.d(1);
|
||
if_block = current_block_type(ctx);
|
||
if (if_block) {
|
||
if_block.c();
|
||
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
||
}
|
||
}
|
||
},
|
||
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if_block.d(detaching);
|
||
|
||
if (detaching) {
|
||
internal_8(if_block_anchor);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance$2($$self, $$props, $$invalidate) {
|
||
let { icon_name } = $$props;
|
||
|
||
$$self.$set = $$props => {
|
||
if ('icon_name' in $$props) $$invalidate('icon_name', icon_name = $$props.icon_name);
|
||
};
|
||
|
||
return { icon_name };
|
||
}
|
||
|
||
class Icon extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$2, create_fragment$2, internal_92, ["icon_name"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.icon_name === undefined && !('icon_name' in props)) {
|
||
console.warn("<Icon> was created without expected prop 'icon_name'");
|
||
}
|
||
}
|
||
|
||
get icon_name() {
|
||
throw new Error("<Icon>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set icon_name(value) {
|
||
throw new Error("<Icon>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/twofactors/toList.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$3 = "src/Login/twofactors/toList.svelte";
|
||
|
||
function create_fragment$3(ctx) {
|
||
var p, a, dispose;
|
||
|
||
return {
|
||
c: function create() {
|
||
p = internal_13("p");
|
||
a = internal_13("a");
|
||
a.textContent = "Choose another Method";
|
||
a.href = "# ";
|
||
a.className = "svelte-ieslp9";
|
||
internal_87(a, file$3, 11, 3, 147);
|
||
internal_87(p, file$3, 10, 0, 140);
|
||
dispose = internal_19(a, "click", ctx.click_handler);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, p, anchor);
|
||
internal_6(p, a);
|
||
},
|
||
|
||
p: internal_83,
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(p);
|
||
}
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance$3($$self, $$props, $$invalidate) {
|
||
let { finish = () => {} } = $$props;
|
||
|
||
function click_handler(evt) {
|
||
return evt.preventDefault() || finish(false);
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ('finish' in $$props) $$invalidate('finish', finish = $$props.finish);
|
||
};
|
||
|
||
return { finish, click_handler };
|
||
}
|
||
|
||
class ToList extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$3, create_fragment$3, internal_92, ["finish"]);
|
||
}
|
||
|
||
get finish() {
|
||
throw new Error("<ToList>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set finish(value) {
|
||
throw new Error("<ToList>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
var cleave = createCommonjsModule(function (module, exports) {
|
||
(function webpackUniversalModuleDefinition(root, factory) {
|
||
module.exports = factory();
|
||
})(commonjsGlobal, function () {
|
||
return /******/ (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] = {
|
||
/******/ exports: {},
|
||
/******/ id: moduleId,
|
||
/******/ loaded: false
|
||
/******/
|
||
};
|
||
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.loaded = 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;
|
||
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(0);
|
||
/******/
|
||
})
|
||
/************************************************************************/
|
||
/******/([
|
||
/* 0 */
|
||
/***/ (function (module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function (global) {
|
||
|
||
/**
|
||
* Construct a new Cleave instance by passing the configuration object
|
||
*
|
||
* @param {String | HTMLElement} element
|
||
* @param {Object} opts
|
||
*/
|
||
var Cleave = function (element, opts) {
|
||
var owner = this;
|
||
var hasMultipleElements = false;
|
||
|
||
if (typeof element === 'string') {
|
||
owner.element = document.querySelector(element);
|
||
hasMultipleElements = document.querySelectorAll(element).length > 1;
|
||
} else {
|
||
if (typeof element.length !== 'undefined' && element.length > 0) {
|
||
owner.element = element[0];
|
||
hasMultipleElements = element.length > 1;
|
||
} else {
|
||
owner.element = element;
|
||
}
|
||
}
|
||
|
||
if (!owner.element) {
|
||
throw new Error('[cleave.js] Please check the element');
|
||
}
|
||
|
||
if (hasMultipleElements) {
|
||
try {
|
||
// eslint-disable-next-line
|
||
console.warn('[cleave.js] Multiple input fields matched, cleave.js will only take the first one.');
|
||
} catch (e) {
|
||
// Old IE
|
||
}
|
||
}
|
||
|
||
opts.initValue = owner.element.value;
|
||
|
||
owner.properties = Cleave.DefaultProperties.assign({}, opts);
|
||
|
||
owner.init();
|
||
};
|
||
|
||
Cleave.prototype = {
|
||
init: function () {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
// no need to use this lib
|
||
if (!pps.numeral && !pps.phone && !pps.creditCard && !pps.time && !pps.date && (pps.blocksLength === 0 && !pps.prefix)) {
|
||
owner.onInput(pps.initValue);
|
||
|
||
return;
|
||
}
|
||
|
||
pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
|
||
|
||
owner.isAndroid = Cleave.Util.isAndroid();
|
||
owner.lastInputValue = '';
|
||
|
||
owner.onChangeListener = owner.onChange.bind(owner);
|
||
owner.onKeyDownListener = owner.onKeyDown.bind(owner);
|
||
owner.onFocusListener = owner.onFocus.bind(owner);
|
||
owner.onCutListener = owner.onCut.bind(owner);
|
||
owner.onCopyListener = owner.onCopy.bind(owner);
|
||
|
||
owner.element.addEventListener('input', owner.onChangeListener);
|
||
owner.element.addEventListener('keydown', owner.onKeyDownListener);
|
||
owner.element.addEventListener('focus', owner.onFocusListener);
|
||
owner.element.addEventListener('cut', owner.onCutListener);
|
||
owner.element.addEventListener('copy', owner.onCopyListener);
|
||
|
||
|
||
owner.initPhoneFormatter();
|
||
owner.initDateFormatter();
|
||
owner.initTimeFormatter();
|
||
owner.initNumeralFormatter();
|
||
|
||
// avoid touch input field if value is null
|
||
// otherwise Firefox will add red box-shadow for <input required />
|
||
if (pps.initValue || (pps.prefix && !pps.noImmediatePrefix)) {
|
||
owner.onInput(pps.initValue);
|
||
}
|
||
},
|
||
|
||
initNumeralFormatter: function () {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
if (!pps.numeral) {
|
||
return;
|
||
}
|
||
|
||
pps.numeralFormatter = new Cleave.NumeralFormatter(
|
||
pps.numeralDecimalMark,
|
||
pps.numeralIntegerScale,
|
||
pps.numeralDecimalScale,
|
||
pps.numeralThousandsGroupStyle,
|
||
pps.numeralPositiveOnly,
|
||
pps.stripLeadingZeroes,
|
||
pps.delimiter
|
||
);
|
||
},
|
||
|
||
initTimeFormatter: function () {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
if (!pps.time) {
|
||
return;
|
||
}
|
||
|
||
pps.timeFormatter = new Cleave.TimeFormatter(pps.timePattern, pps.timeFormat);
|
||
pps.blocks = pps.timeFormatter.getBlocks();
|
||
pps.blocksLength = pps.blocks.length;
|
||
pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
|
||
},
|
||
|
||
initDateFormatter: function () {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
if (!pps.date) {
|
||
return;
|
||
}
|
||
|
||
pps.dateFormatter = new Cleave.DateFormatter(pps.datePattern);
|
||
pps.blocks = pps.dateFormatter.getBlocks();
|
||
pps.blocksLength = pps.blocks.length;
|
||
pps.maxLength = Cleave.Util.getMaxLength(pps.blocks);
|
||
},
|
||
|
||
initPhoneFormatter: function () {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
if (!pps.phone) {
|
||
return;
|
||
}
|
||
|
||
// Cleave.AsYouTypeFormatter should be provided by
|
||
// external google closure lib
|
||
try {
|
||
pps.phoneFormatter = new Cleave.PhoneFormatter(
|
||
new pps.root.Cleave.AsYouTypeFormatter(pps.phoneRegionCode),
|
||
pps.delimiter
|
||
);
|
||
} catch (ex) {
|
||
throw new Error('[cleave.js] Please include phone-type-formatter.{country}.js lib');
|
||
}
|
||
},
|
||
|
||
onKeyDown: function (event) {
|
||
var owner = this, pps = owner.properties,
|
||
charCode = event.which || event.keyCode,
|
||
Util = Cleave.Util,
|
||
currentValue = owner.element.value;
|
||
|
||
// if we got any charCode === 8, this means, that this device correctly
|
||
// sends backspace keys in event, so we do not need to apply any hacks
|
||
owner.hasBackspaceSupport = owner.hasBackspaceSupport || charCode === 8;
|
||
if (!owner.hasBackspaceSupport
|
||
&& Util.isAndroidBackspaceKeydown(owner.lastInputValue, currentValue)
|
||
) {
|
||
charCode = 8;
|
||
}
|
||
|
||
owner.lastInputValue = currentValue;
|
||
|
||
// hit backspace when last character is delimiter
|
||
var postDelimiter = Util.getPostDelimiter(currentValue, pps.delimiter, pps.delimiters);
|
||
if (charCode === 8 && postDelimiter) {
|
||
pps.postDelimiterBackspace = postDelimiter;
|
||
} else {
|
||
pps.postDelimiterBackspace = false;
|
||
}
|
||
},
|
||
|
||
onChange: function () {
|
||
this.onInput(this.element.value);
|
||
},
|
||
|
||
onFocus: function () {
|
||
var owner = this,
|
||
pps = owner.properties;
|
||
|
||
Cleave.Util.fixPrefixCursor(owner.element, pps.prefix, pps.delimiter, pps.delimiters);
|
||
},
|
||
|
||
onCut: function (e) {
|
||
this.copyClipboardData(e);
|
||
this.onInput('');
|
||
},
|
||
|
||
onCopy: function (e) {
|
||
this.copyClipboardData(e);
|
||
},
|
||
|
||
copyClipboardData: function (e) {
|
||
var owner = this,
|
||
pps = owner.properties,
|
||
Util = Cleave.Util,
|
||
inputValue = owner.element.value,
|
||
textToCopy = '';
|
||
|
||
if (!pps.copyDelimiter) {
|
||
textToCopy = Util.stripDelimiters(inputValue, pps.delimiter, pps.delimiters);
|
||
} else {
|
||
textToCopy = inputValue;
|
||
}
|
||
|
||
try {
|
||
if (e.clipboardData) {
|
||
e.clipboardData.setData('Text', textToCopy);
|
||
} else {
|
||
window.clipboardData.setData('Text', textToCopy);
|
||
}
|
||
|
||
e.preventDefault();
|
||
} catch (ex) {
|
||
// empty
|
||
}
|
||
},
|
||
|
||
onInput: function (value) {
|
||
var owner = this, pps = owner.properties,
|
||
Util = Cleave.Util;
|
||
|
||
// case 1: delete one more character "4"
|
||
// 1234*| -> hit backspace -> 123|
|
||
// case 2: last character is not delimiter which is:
|
||
// 12|34* -> hit backspace -> 1|34*
|
||
// note: no need to apply this for numeral mode
|
||
var postDelimiterAfter = Util.getPostDelimiter(value, pps.delimiter, pps.delimiters);
|
||
if (!pps.numeral && pps.postDelimiterBackspace && !postDelimiterAfter) {
|
||
value = Util.headStr(value, value.length - pps.postDelimiterBackspace.length);
|
||
}
|
||
|
||
// phone formatter
|
||
if (pps.phone) {
|
||
if (pps.prefix && (!pps.noImmediatePrefix || value.length)) {
|
||
pps.result = pps.prefix + pps.phoneFormatter.format(value).slice(pps.prefix.length);
|
||
} else {
|
||
pps.result = pps.phoneFormatter.format(value);
|
||
}
|
||
owner.updateValueState();
|
||
|
||
return;
|
||
}
|
||
|
||
// numeral formatter
|
||
if (pps.numeral) {
|
||
if (pps.prefix && (!pps.noImmediatePrefix || value.length)) {
|
||
pps.result = pps.prefix + pps.numeralFormatter.format(value);
|
||
} else {
|
||
pps.result = pps.numeralFormatter.format(value);
|
||
}
|
||
owner.updateValueState();
|
||
|
||
return;
|
||
}
|
||
|
||
// date
|
||
if (pps.date) {
|
||
value = pps.dateFormatter.getValidatedDate(value);
|
||
}
|
||
|
||
// time
|
||
if (pps.time) {
|
||
value = pps.timeFormatter.getValidatedTime(value);
|
||
}
|
||
|
||
// strip delimiters
|
||
value = Util.stripDelimiters(value, pps.delimiter, pps.delimiters);
|
||
|
||
// strip prefix
|
||
// var strippedPreviousResult = Util.stripDelimiters(pps.result, pps.delimiter, pps.delimiters);
|
||
value = Util.getPrefixStrippedValue(value, pps.prefix, pps.prefixLength, pps.result, pps.delimiter, pps.delimiters);
|
||
|
||
// strip non-numeric characters
|
||
value = pps.numericOnly ? Util.strip(value, /[^\d]/g) : value;
|
||
|
||
// convert case
|
||
value = pps.uppercase ? value.toUpperCase() : value;
|
||
value = pps.lowercase ? value.toLowerCase() : value;
|
||
|
||
// prefix
|
||
if (pps.prefix && (!pps.noImmediatePrefix || value.length)) {
|
||
value = pps.prefix + value;
|
||
|
||
// no blocks specified, no need to do formatting
|
||
if (pps.blocksLength === 0) {
|
||
pps.result = value;
|
||
owner.updateValueState();
|
||
|
||
return;
|
||
}
|
||
}
|
||
|
||
// update credit card props
|
||
if (pps.creditCard) {
|
||
owner.updateCreditCardPropsByValue(value);
|
||
}
|
||
|
||
// strip over length characters
|
||
value = Util.headStr(value, pps.maxLength);
|
||
|
||
// apply blocks
|
||
pps.result = Util.getFormattedValue(
|
||
value,
|
||
pps.blocks, pps.blocksLength,
|
||
pps.delimiter, pps.delimiters, pps.delimiterLazyShow
|
||
);
|
||
|
||
owner.updateValueState();
|
||
},
|
||
|
||
updateCreditCardPropsByValue: function (value) {
|
||
var owner = this, pps = owner.properties,
|
||
Util = Cleave.Util,
|
||
creditCardInfo;
|
||
|
||
// At least one of the first 4 characters has changed
|
||
if (Util.headStr(pps.result, 4) === Util.headStr(value, 4)) {
|
||
return;
|
||
}
|
||
|
||
creditCardInfo = Cleave.CreditCardDetector.getInfo(value, pps.creditCardStrictMode);
|
||
|
||
pps.blocks = creditCardInfo.blocks;
|
||
pps.blocksLength = pps.blocks.length;
|
||
pps.maxLength = Util.getMaxLength(pps.blocks);
|
||
|
||
// credit card type changed
|
||
if (pps.creditCardType !== creditCardInfo.type) {
|
||
pps.creditCardType = creditCardInfo.type;
|
||
|
||
pps.onCreditCardTypeChanged.call(owner, pps.creditCardType);
|
||
}
|
||
},
|
||
|
||
updateValueState: function () {
|
||
var owner = this,
|
||
Util = Cleave.Util,
|
||
pps = owner.properties;
|
||
|
||
if (!owner.element) {
|
||
return;
|
||
}
|
||
|
||
var endPos = owner.element.selectionEnd;
|
||
var oldValue = owner.element.value;
|
||
var newValue = pps.result;
|
||
|
||
endPos = Util.getNextCursorPosition(endPos, oldValue, newValue, pps.delimiter, pps.delimiters);
|
||
|
||
// fix Android browser type="text" input field
|
||
// cursor not jumping issue
|
||
if (owner.isAndroid) {
|
||
window.setTimeout(function () {
|
||
owner.element.value = newValue;
|
||
Util.setSelection(owner.element, endPos, pps.document, false);
|
||
owner.callOnValueChanged();
|
||
}, 1);
|
||
|
||
return;
|
||
}
|
||
|
||
owner.element.value = newValue;
|
||
Util.setSelection(owner.element, endPos, pps.document, false);
|
||
owner.callOnValueChanged();
|
||
},
|
||
|
||
callOnValueChanged: function () {
|
||
var owner = this,
|
||
pps = owner.properties;
|
||
|
||
pps.onValueChanged.call(owner, {
|
||
target: {
|
||
value: pps.result,
|
||
rawValue: owner.getRawValue()
|
||
}
|
||
});
|
||
},
|
||
|
||
setPhoneRegionCode: function (phoneRegionCode) {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
pps.phoneRegionCode = phoneRegionCode;
|
||
owner.initPhoneFormatter();
|
||
owner.onChange();
|
||
},
|
||
|
||
setRawValue: function (value) {
|
||
var owner = this, pps = owner.properties;
|
||
|
||
value = value !== undefined && value !== null ? value.toString() : '';
|
||
|
||
if (pps.numeral) {
|
||
value = value.replace('.', pps.numeralDecimalMark);
|
||
}
|
||
|
||
pps.postDelimiterBackspace = false;
|
||
|
||
owner.element.value = value;
|
||
owner.onInput(value);
|
||
},
|
||
|
||
getRawValue: function () {
|
||
var owner = this,
|
||
pps = owner.properties,
|
||
Util = Cleave.Util,
|
||
rawValue = owner.element.value;
|
||
|
||
if (pps.rawValueTrimPrefix) {
|
||
rawValue = Util.getPrefixStrippedValue(rawValue, pps.prefix, pps.prefixLength, pps.result, pps.delimiter, pps.delimiters);
|
||
}
|
||
|
||
if (pps.numeral) {
|
||
rawValue = pps.numeralFormatter.getRawValue(rawValue);
|
||
} else {
|
||
rawValue = Util.stripDelimiters(rawValue, pps.delimiter, pps.delimiters);
|
||
}
|
||
|
||
return rawValue;
|
||
},
|
||
|
||
getISOFormatDate: function () {
|
||
var owner = this,
|
||
pps = owner.properties;
|
||
|
||
return pps.date ? pps.dateFormatter.getISOFormatDate() : '';
|
||
},
|
||
|
||
getISOFormatTime: function () {
|
||
var owner = this,
|
||
pps = owner.properties;
|
||
|
||
return pps.time ? pps.timeFormatter.getISOFormatTime() : '';
|
||
},
|
||
|
||
getFormattedValue: function () {
|
||
return this.element.value;
|
||
},
|
||
|
||
destroy: function () {
|
||
var owner = this;
|
||
|
||
owner.element.removeEventListener('input', owner.onChangeListener);
|
||
owner.element.removeEventListener('keydown', owner.onKeyDownListener);
|
||
owner.element.removeEventListener('focus', owner.onFocusListener);
|
||
owner.element.removeEventListener('cut', owner.onCutListener);
|
||
owner.element.removeEventListener('copy', owner.onCopyListener);
|
||
},
|
||
|
||
toString: function () {
|
||
return '[Cleave Object]';
|
||
}
|
||
};
|
||
|
||
Cleave.NumeralFormatter = __webpack_require__(1);
|
||
Cleave.DateFormatter = __webpack_require__(2);
|
||
Cleave.TimeFormatter = __webpack_require__(3);
|
||
Cleave.PhoneFormatter = __webpack_require__(4);
|
||
Cleave.CreditCardDetector = __webpack_require__(5);
|
||
Cleave.Util = __webpack_require__(6);
|
||
Cleave.DefaultProperties = __webpack_require__(7);
|
||
|
||
// for angular directive
|
||
((typeof global === 'object' && global) ? global : window)['Cleave'] = Cleave;
|
||
|
||
// CommonJS
|
||
module.exports = Cleave;
|
||
|
||
/* WEBPACK VAR INJECTION */
|
||
}.call(exports, (function () { return this; }())));
|
||
|
||
/***/
|
||
}),
|
||
/* 1 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var NumeralFormatter = function (numeralDecimalMark,
|
||
numeralIntegerScale,
|
||
numeralDecimalScale,
|
||
numeralThousandsGroupStyle,
|
||
numeralPositiveOnly,
|
||
stripLeadingZeroes,
|
||
delimiter) {
|
||
var owner = this;
|
||
|
||
owner.numeralDecimalMark = numeralDecimalMark || '.';
|
||
owner.numeralIntegerScale = numeralIntegerScale > 0 ? numeralIntegerScale : 0;
|
||
owner.numeralDecimalScale = numeralDecimalScale >= 0 ? numeralDecimalScale : 2;
|
||
owner.numeralThousandsGroupStyle = numeralThousandsGroupStyle || NumeralFormatter.groupStyle.thousand;
|
||
owner.numeralPositiveOnly = !!numeralPositiveOnly;
|
||
owner.stripLeadingZeroes = stripLeadingZeroes !== false;
|
||
owner.delimiter = (delimiter || delimiter === '') ? delimiter : ',';
|
||
owner.delimiterRE = delimiter ? new RegExp('\\' + delimiter, 'g') : '';
|
||
};
|
||
|
||
NumeralFormatter.groupStyle = {
|
||
thousand: 'thousand',
|
||
lakh: 'lakh',
|
||
wan: 'wan',
|
||
none: 'none'
|
||
};
|
||
|
||
NumeralFormatter.prototype = {
|
||
getRawValue: function (value) {
|
||
return value.replace(this.delimiterRE, '').replace(this.numeralDecimalMark, '.');
|
||
},
|
||
|
||
format: function (value) {
|
||
var owner = this, parts, partInteger, partDecimal = '';
|
||
|
||
// strip alphabet letters
|
||
value = value.replace(/[A-Za-z]/g, '')
|
||
// replace the first decimal mark with reserved placeholder
|
||
.replace(owner.numeralDecimalMark, 'M')
|
||
|
||
// strip non numeric letters except minus and "M"
|
||
// this is to ensure prefix has been stripped
|
||
.replace(/[^\dM-]/g, '')
|
||
|
||
// replace the leading minus with reserved placeholder
|
||
.replace(/^\-/, 'N')
|
||
|
||
// strip the other minus sign (if present)
|
||
.replace(/\-/g, '')
|
||
|
||
// replace the minus sign (if present)
|
||
.replace('N', owner.numeralPositiveOnly ? '' : '-')
|
||
|
||
// replace decimal mark
|
||
.replace('M', owner.numeralDecimalMark);
|
||
|
||
// strip any leading zeros
|
||
if (owner.stripLeadingZeroes) {
|
||
value = value.replace(/^(-)?0+(?=\d)/, '$1');
|
||
}
|
||
|
||
partInteger = value;
|
||
|
||
if (value.indexOf(owner.numeralDecimalMark) >= 0) {
|
||
parts = value.split(owner.numeralDecimalMark);
|
||
partInteger = parts[0];
|
||
partDecimal = owner.numeralDecimalMark + parts[1].slice(0, owner.numeralDecimalScale);
|
||
}
|
||
|
||
if (owner.numeralIntegerScale > 0) {
|
||
partInteger = partInteger.slice(0, owner.numeralIntegerScale + (value.slice(0, 1) === '-' ? 1 : 0));
|
||
}
|
||
|
||
switch (owner.numeralThousandsGroupStyle) {
|
||
case NumeralFormatter.groupStyle.lakh:
|
||
partInteger = partInteger.replace(/(\d)(?=(\d\d)+\d$)/g, '$1' + owner.delimiter);
|
||
|
||
break;
|
||
|
||
case NumeralFormatter.groupStyle.wan:
|
||
partInteger = partInteger.replace(/(\d)(?=(\d{4})+$)/g, '$1' + owner.delimiter);
|
||
|
||
break;
|
||
|
||
case NumeralFormatter.groupStyle.thousand:
|
||
partInteger = partInteger.replace(/(\d)(?=(\d{3})+$)/g, '$1' + owner.delimiter);
|
||
|
||
break;
|
||
}
|
||
|
||
return partInteger.toString() + (owner.numeralDecimalScale > 0 ? partDecimal.toString() : '');
|
||
}
|
||
};
|
||
|
||
module.exports = NumeralFormatter;
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 2 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var DateFormatter = function (datePattern) {
|
||
var owner = this;
|
||
|
||
owner.date = [];
|
||
owner.blocks = [];
|
||
owner.datePattern = datePattern;
|
||
owner.initBlocks();
|
||
};
|
||
|
||
DateFormatter.prototype = {
|
||
initBlocks: function () {
|
||
var owner = this;
|
||
owner.datePattern.forEach(function (value) {
|
||
if (value === 'Y') {
|
||
owner.blocks.push(4);
|
||
} else {
|
||
owner.blocks.push(2);
|
||
}
|
||
});
|
||
},
|
||
|
||
getISOFormatDate: function () {
|
||
var owner = this,
|
||
date = owner.date;
|
||
|
||
return date[2] ? (
|
||
date[2] + '-' + owner.addLeadingZero(date[1]) + '-' + owner.addLeadingZero(date[0])
|
||
) : '';
|
||
},
|
||
|
||
getBlocks: function () {
|
||
return this.blocks;
|
||
},
|
||
|
||
getValidatedDate: function (value) {
|
||
var owner = this, result = '';
|
||
|
||
value = value.replace(/[^\d]/g, '');
|
||
|
||
owner.blocks.forEach(function (length, index) {
|
||
if (value.length > 0) {
|
||
var sub = value.slice(0, length),
|
||
sub0 = sub.slice(0, 1),
|
||
rest = value.slice(length);
|
||
|
||
switch (owner.datePattern[index]) {
|
||
case 'd':
|
||
if (sub === '00') {
|
||
sub = '01';
|
||
} else if (parseInt(sub0, 10) > 3) {
|
||
sub = '0' + sub0;
|
||
} else if (parseInt(sub, 10) > 31) {
|
||
sub = '31';
|
||
}
|
||
|
||
break;
|
||
|
||
case 'm':
|
||
if (sub === '00') {
|
||
sub = '01';
|
||
} else if (parseInt(sub0, 10) > 1) {
|
||
sub = '0' + sub0;
|
||
} else if (parseInt(sub, 10) > 12) {
|
||
sub = '12';
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
result += sub;
|
||
|
||
// update remaining string
|
||
value = rest;
|
||
}
|
||
});
|
||
|
||
return this.getFixedDateString(result);
|
||
},
|
||
|
||
getFixedDateString: function (value) {
|
||
var owner = this, datePattern = owner.datePattern, date = [],
|
||
dayIndex = 0, monthIndex = 0, yearIndex = 0,
|
||
dayStartIndex = 0, monthStartIndex = 0, yearStartIndex = 0,
|
||
day, month, year, fullYearDone = false;
|
||
|
||
// mm-dd || dd-mm
|
||
if (value.length === 4 && datePattern[0].toLowerCase() !== 'y' && datePattern[1].toLowerCase() !== 'y') {
|
||
dayStartIndex = datePattern[0] === 'd' ? 0 : 2;
|
||
monthStartIndex = 2 - dayStartIndex;
|
||
day = parseInt(value.slice(dayStartIndex, dayStartIndex + 2), 10);
|
||
month = parseInt(value.slice(monthStartIndex, monthStartIndex + 2), 10);
|
||
|
||
date = this.getFixedDate(day, month, 0);
|
||
}
|
||
|
||
// yyyy-mm-dd || yyyy-dd-mm || mm-dd-yyyy || dd-mm-yyyy || dd-yyyy-mm || mm-yyyy-dd
|
||
if (value.length === 8) {
|
||
datePattern.forEach(function (type, index) {
|
||
switch (type) {
|
||
case 'd':
|
||
dayIndex = index;
|
||
break;
|
||
case 'm':
|
||
monthIndex = index;
|
||
break;
|
||
default:
|
||
yearIndex = index;
|
||
break;
|
||
}
|
||
});
|
||
|
||
yearStartIndex = yearIndex * 2;
|
||
dayStartIndex = (dayIndex <= yearIndex) ? dayIndex * 2 : (dayIndex * 2 + 2);
|
||
monthStartIndex = (monthIndex <= yearIndex) ? monthIndex * 2 : (monthIndex * 2 + 2);
|
||
|
||
day = parseInt(value.slice(dayStartIndex, dayStartIndex + 2), 10);
|
||
month = parseInt(value.slice(monthStartIndex, monthStartIndex + 2), 10);
|
||
year = parseInt(value.slice(yearStartIndex, yearStartIndex + 4), 10);
|
||
|
||
fullYearDone = value.slice(yearStartIndex, yearStartIndex + 4).length === 4;
|
||
|
||
date = this.getFixedDate(day, month, year);
|
||
}
|
||
|
||
owner.date = date;
|
||
|
||
return date.length === 0 ? value : datePattern.reduce(function (previous, current) {
|
||
switch (current) {
|
||
case 'd':
|
||
return previous + owner.addLeadingZero(date[0]);
|
||
case 'm':
|
||
return previous + owner.addLeadingZero(date[1]);
|
||
default:
|
||
return previous + (fullYearDone ? owner.addLeadingZeroForYear(date[2]) : '');
|
||
}
|
||
}, '');
|
||
},
|
||
|
||
getFixedDate: function (day, month, year) {
|
||
day = Math.min(day, 31);
|
||
month = Math.min(month, 12);
|
||
year = parseInt((year || 0), 10);
|
||
|
||
if ((month < 7 && month % 2 === 0) || (month > 8 && month % 2 === 1)) {
|
||
day = Math.min(day, month === 2 ? (this.isLeapYear(year) ? 29 : 28) : 30);
|
||
}
|
||
|
||
return [day, month, year];
|
||
},
|
||
|
||
isLeapYear: function (year) {
|
||
return ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0);
|
||
},
|
||
|
||
addLeadingZero: function (number) {
|
||
return (number < 10 ? '0' : '') + number;
|
||
},
|
||
|
||
addLeadingZeroForYear: function (number) {
|
||
return (number < 10 ? '000' : (number < 100 ? '00' : (number < 1000 ? '0' : ''))) + number;
|
||
}
|
||
};
|
||
|
||
module.exports = DateFormatter;
|
||
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 3 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var TimeFormatter = function (timePattern, timeFormat) {
|
||
var owner = this;
|
||
|
||
owner.time = [];
|
||
owner.blocks = [];
|
||
owner.timePattern = timePattern;
|
||
owner.timeFormat = timeFormat;
|
||
owner.initBlocks();
|
||
};
|
||
|
||
TimeFormatter.prototype = {
|
||
initBlocks: function () {
|
||
var owner = this;
|
||
owner.timePattern.forEach(function () {
|
||
owner.blocks.push(2);
|
||
});
|
||
},
|
||
|
||
getISOFormatTime: function () {
|
||
var owner = this,
|
||
time = owner.time;
|
||
|
||
return time[2] ? (
|
||
owner.addLeadingZero(time[0]) + ':' + owner.addLeadingZero(time[1]) + ':' + owner.addLeadingZero(time[2])
|
||
) : '';
|
||
},
|
||
|
||
getBlocks: function () {
|
||
return this.blocks;
|
||
},
|
||
|
||
getTimeFormatOptions: function () {
|
||
var owner = this;
|
||
if (String(owner.timeFormat) === '12') {
|
||
return {
|
||
maxHourFirstDigit: 1,
|
||
maxHours: 12,
|
||
maxMinutesFirstDigit: 5,
|
||
maxMinutes: 60
|
||
};
|
||
}
|
||
|
||
return {
|
||
maxHourFirstDigit: 2,
|
||
maxHours: 23,
|
||
maxMinutesFirstDigit: 5,
|
||
maxMinutes: 60
|
||
};
|
||
},
|
||
|
||
getValidatedTime: function (value) {
|
||
var owner = this, result = '';
|
||
|
||
value = value.replace(/[^\d]/g, '');
|
||
|
||
var timeFormatOptions = owner.getTimeFormatOptions();
|
||
|
||
owner.blocks.forEach(function (length, index) {
|
||
if (value.length > 0) {
|
||
var sub = value.slice(0, length),
|
||
sub0 = sub.slice(0, 1),
|
||
rest = value.slice(length);
|
||
|
||
switch (owner.timePattern[index]) {
|
||
|
||
case 'h':
|
||
if (parseInt(sub0, 10) > timeFormatOptions.maxHourFirstDigit) {
|
||
sub = '0' + sub0;
|
||
} else if (parseInt(sub, 10) > timeFormatOptions.maxHours) {
|
||
sub = timeFormatOptions.maxHours + '';
|
||
}
|
||
|
||
break;
|
||
|
||
case 'm':
|
||
case 's':
|
||
if (parseInt(sub0, 10) > timeFormatOptions.maxMinutesFirstDigit) {
|
||
sub = '0' + sub0;
|
||
} else if (parseInt(sub, 10) > timeFormatOptions.maxMinutes) {
|
||
sub = timeFormatOptions.maxMinutes + '';
|
||
}
|
||
break;
|
||
}
|
||
|
||
result += sub;
|
||
|
||
// update remaining string
|
||
value = rest;
|
||
}
|
||
});
|
||
|
||
return this.getFixedTimeString(result);
|
||
},
|
||
|
||
getFixedTimeString: function (value) {
|
||
var owner = this, timePattern = owner.timePattern, time = [],
|
||
secondIndex = 0, minuteIndex = 0, hourIndex = 0,
|
||
secondStartIndex = 0, minuteStartIndex = 0, hourStartIndex = 0,
|
||
second, minute, hour;
|
||
|
||
if (value.length === 6) {
|
||
timePattern.forEach(function (type, index) {
|
||
switch (type) {
|
||
case 's':
|
||
secondIndex = index * 2;
|
||
break;
|
||
case 'm':
|
||
minuteIndex = index * 2;
|
||
break;
|
||
case 'h':
|
||
hourIndex = index * 2;
|
||
break;
|
||
}
|
||
});
|
||
|
||
hourStartIndex = hourIndex;
|
||
minuteStartIndex = minuteIndex;
|
||
secondStartIndex = secondIndex;
|
||
|
||
second = parseInt(value.slice(secondStartIndex, secondStartIndex + 2), 10);
|
||
minute = parseInt(value.slice(minuteStartIndex, minuteStartIndex + 2), 10);
|
||
hour = parseInt(value.slice(hourStartIndex, hourStartIndex + 2), 10);
|
||
|
||
time = this.getFixedTime(hour, minute, second);
|
||
}
|
||
|
||
if (value.length === 4 && owner.timePattern.indexOf('s') < 0) {
|
||
timePattern.forEach(function (type, index) {
|
||
switch (type) {
|
||
case 'm':
|
||
minuteIndex = index * 2;
|
||
break;
|
||
case 'h':
|
||
hourIndex = index * 2;
|
||
break;
|
||
}
|
||
});
|
||
|
||
hourStartIndex = hourIndex;
|
||
minuteStartIndex = minuteIndex;
|
||
|
||
second = 0;
|
||
minute = parseInt(value.slice(minuteStartIndex, minuteStartIndex + 2), 10);
|
||
hour = parseInt(value.slice(hourStartIndex, hourStartIndex + 2), 10);
|
||
|
||
time = this.getFixedTime(hour, minute, second);
|
||
}
|
||
|
||
owner.time = time;
|
||
|
||
return time.length === 0 ? value : timePattern.reduce(function (previous, current) {
|
||
switch (current) {
|
||
case 's':
|
||
return previous + owner.addLeadingZero(time[2]);
|
||
case 'm':
|
||
return previous + owner.addLeadingZero(time[1]);
|
||
case 'h':
|
||
return previous + owner.addLeadingZero(time[0]);
|
||
}
|
||
}, '');
|
||
},
|
||
|
||
getFixedTime: function (hour, minute, second) {
|
||
second = Math.min(parseInt(second || 0, 10), 60);
|
||
minute = Math.min(minute, 60);
|
||
hour = Math.min(hour, 60);
|
||
|
||
return [hour, minute, second];
|
||
},
|
||
|
||
addLeadingZero: function (number) {
|
||
return (number < 10 ? '0' : '') + number;
|
||
}
|
||
};
|
||
|
||
module.exports = TimeFormatter;
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 4 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var PhoneFormatter = function (formatter, delimiter) {
|
||
var owner = this;
|
||
|
||
owner.delimiter = (delimiter || delimiter === '') ? delimiter : ' ';
|
||
owner.delimiterRE = delimiter ? new RegExp('\\' + delimiter, 'g') : '';
|
||
|
||
owner.formatter = formatter;
|
||
};
|
||
|
||
PhoneFormatter.prototype = {
|
||
setFormatter: function (formatter) {
|
||
this.formatter = formatter;
|
||
},
|
||
|
||
format: function (phoneNumber) {
|
||
var owner = this;
|
||
|
||
owner.formatter.clear();
|
||
|
||
// only keep number and +
|
||
phoneNumber = phoneNumber.replace(/[^\d+]/g, '');
|
||
|
||
// strip non-leading +
|
||
phoneNumber = phoneNumber.replace(/^\+/, 'B').replace(/\+/g, '').replace('B', '+');
|
||
|
||
// strip delimiter
|
||
phoneNumber = phoneNumber.replace(owner.delimiterRE, '');
|
||
|
||
var result = '', current, validated = false;
|
||
|
||
for (var i = 0, iMax = phoneNumber.length; i < iMax; i++) {
|
||
current = owner.formatter.inputDigit(phoneNumber.charAt(i));
|
||
|
||
// has ()- or space inside
|
||
if (/[\s()-]/g.test(current)) {
|
||
result = current;
|
||
|
||
validated = true;
|
||
} else {
|
||
if (!validated) {
|
||
result = current;
|
||
}
|
||
// else: over length input
|
||
// it turns to invalid number again
|
||
}
|
||
}
|
||
|
||
// strip ()
|
||
// e.g. US: 7161234567 returns (716) 123-4567
|
||
result = result.replace(/[()]/g, '');
|
||
// replace library delimiter with user customized delimiter
|
||
result = result.replace(/[\s-]/g, owner.delimiter);
|
||
|
||
return result;
|
||
}
|
||
};
|
||
|
||
module.exports = PhoneFormatter;
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 5 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var CreditCardDetector = {
|
||
blocks: {
|
||
uatp: [4, 5, 6],
|
||
amex: [4, 6, 5],
|
||
diners: [4, 6, 4],
|
||
discover: [4, 4, 4, 4],
|
||
mastercard: [4, 4, 4, 4],
|
||
dankort: [4, 4, 4, 4],
|
||
instapayment: [4, 4, 4, 4],
|
||
jcb15: [4, 6, 5],
|
||
jcb: [4, 4, 4, 4],
|
||
maestro: [4, 4, 4, 4],
|
||
visa: [4, 4, 4, 4],
|
||
mir: [4, 4, 4, 4],
|
||
unionPay: [4, 4, 4, 4],
|
||
general: [4, 4, 4, 4],
|
||
generalStrict: [4, 4, 4, 7]
|
||
},
|
||
|
||
re: {
|
||
// starts with 1; 15 digits, not starts with 1800 (jcb card)
|
||
uatp: /^(?!1800)1\d{0,14}/,
|
||
|
||
// starts with 34/37; 15 digits
|
||
amex: /^3[47]\d{0,13}/,
|
||
|
||
// starts with 6011/65/644-649; 16 digits
|
||
discover: /^(?:6011|65\d{0,2}|64[4-9]\d?)\d{0,12}/,
|
||
|
||
// starts with 300-305/309 or 36/38/39; 14 digits
|
||
diners: /^3(?:0([0-5]|9)|[689]\d?)\d{0,11}/,
|
||
|
||
// starts with 51-55/2221–2720; 16 digits
|
||
mastercard: /^(5[1-5]\d{0,2}|22[2-9]\d{0,1}|2[3-7]\d{0,2})\d{0,12}/,
|
||
|
||
// starts with 5019/4175/4571; 16 digits
|
||
dankort: /^(5019|4175|4571)\d{0,12}/,
|
||
|
||
// starts with 637-639; 16 digits
|
||
instapayment: /^63[7-9]\d{0,13}/,
|
||
|
||
// starts with 2131/1800; 15 digits
|
||
jcb15: /^(?:2131|1800)\d{0,11}/,
|
||
|
||
// starts with 2131/1800/35; 16 digits
|
||
jcb: /^(?:35\d{0,2})\d{0,12}/,
|
||
|
||
// starts with 50/56-58/6304/67; 16 digits
|
||
maestro: /^(?:5[0678]\d{0,2}|6304|67\d{0,2})\d{0,12}/,
|
||
|
||
// starts with 22; 16 digits
|
||
mir: /^220[0-4]\d{0,12}/,
|
||
|
||
// starts with 4; 16 digits
|
||
visa: /^4\d{0,15}/,
|
||
|
||
// starts with 62; 16 digits
|
||
unionPay: /^62\d{0,14}/
|
||
},
|
||
|
||
getInfo: function (value, strictMode) {
|
||
var blocks = CreditCardDetector.blocks,
|
||
re = CreditCardDetector.re;
|
||
|
||
// Some credit card can have up to 19 digits number.
|
||
// Set strictMode to true will remove the 16 max-length restrain,
|
||
// however, I never found any website validate card number like
|
||
// this, hence probably you don't want to enable this option.
|
||
strictMode = !!strictMode;
|
||
|
||
for (var key in re) {
|
||
if (re[key].test(value)) {
|
||
var block;
|
||
|
||
if (strictMode) {
|
||
block = blocks.generalStrict;
|
||
} else {
|
||
block = blocks[key];
|
||
}
|
||
|
||
return {
|
||
type: key,
|
||
blocks: block
|
||
};
|
||
}
|
||
}
|
||
|
||
return {
|
||
type: 'unknown',
|
||
blocks: strictMode ? blocks.generalStrict : blocks.general
|
||
};
|
||
}
|
||
};
|
||
|
||
module.exports = CreditCardDetector;
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 6 */
|
||
/***/ (function (module, exports) {
|
||
|
||
var Util = {
|
||
noop: function () {
|
||
},
|
||
|
||
strip: function (value, re) {
|
||
return value.replace(re, '');
|
||
},
|
||
|
||
getPostDelimiter: function (value, delimiter, delimiters) {
|
||
// single delimiter
|
||
if (delimiters.length === 0) {
|
||
return value.slice(-delimiter.length) === delimiter ? delimiter : '';
|
||
}
|
||
|
||
// multiple delimiters
|
||
var matchedDelimiter = '';
|
||
delimiters.forEach(function (current) {
|
||
if (value.slice(-current.length) === current) {
|
||
matchedDelimiter = current;
|
||
}
|
||
});
|
||
|
||
return matchedDelimiter;
|
||
},
|
||
|
||
getDelimiterREByDelimiter: function (delimiter) {
|
||
return new RegExp(delimiter.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1'), 'g');
|
||
},
|
||
|
||
getNextCursorPosition: function (prevPos, oldValue, newValue, delimiter, delimiters) {
|
||
// If cursor was at the end of value, just place it back.
|
||
// Because new value could contain additional chars.
|
||
if (oldValue.length === prevPos) {
|
||
return newValue.length;
|
||
}
|
||
|
||
return prevPos + this.getPositionOffset(prevPos, oldValue, newValue, delimiter, delimiters);
|
||
},
|
||
|
||
getPositionOffset: function (prevPos, oldValue, newValue, delimiter, delimiters) {
|
||
var oldRawValue, newRawValue, lengthOffset;
|
||
|
||
oldRawValue = this.stripDelimiters(oldValue.slice(0, prevPos), delimiter, delimiters);
|
||
newRawValue = this.stripDelimiters(newValue.slice(0, prevPos), delimiter, delimiters);
|
||
lengthOffset = oldRawValue.length - newRawValue.length;
|
||
|
||
return (lengthOffset !== 0) ? (lengthOffset / Math.abs(lengthOffset)) : 0;
|
||
},
|
||
|
||
stripDelimiters: function (value, delimiter, delimiters) {
|
||
var owner = this;
|
||
|
||
// single delimiter
|
||
if (delimiters.length === 0) {
|
||
var delimiterRE = delimiter ? owner.getDelimiterREByDelimiter(delimiter) : '';
|
||
|
||
return value.replace(delimiterRE, '');
|
||
}
|
||
|
||
// multiple delimiters
|
||
delimiters.forEach(function (current) {
|
||
current.split('').forEach(function (letter) {
|
||
value = value.replace(owner.getDelimiterREByDelimiter(letter), '');
|
||
});
|
||
});
|
||
|
||
return value;
|
||
},
|
||
|
||
headStr: function (str, length) {
|
||
return str.slice(0, length);
|
||
},
|
||
|
||
getMaxLength: function (blocks) {
|
||
return blocks.reduce(function (previous, current) {
|
||
return previous + current;
|
||
}, 0);
|
||
},
|
||
|
||
// strip prefix
|
||
// Before type | After type | Return value
|
||
// PEFIX-... | PEFIX-... | ''
|
||
// PREFIX-123 | PEFIX-123 | 123
|
||
// PREFIX-123 | PREFIX-23 | 23
|
||
// PREFIX-123 | PREFIX-1234 | 1234
|
||
getPrefixStrippedValue: function (value, prefix, prefixLength, prevResult, delimiter, delimiters) {
|
||
// No prefix
|
||
if (prefixLength === 0) {
|
||
return value;
|
||
}
|
||
|
||
// Pre result has issue
|
||
// Revert to raw prefix
|
||
if (prevResult.slice(0, prefixLength) !== prefix) {
|
||
return '';
|
||
}
|
||
|
||
var prevValue = this.stripDelimiters(prevResult, delimiter, delimiters);
|
||
|
||
// New value has issue, someone typed in between prefix letters
|
||
// Revert to pre value
|
||
if (value.slice(0, prefixLength) !== prefix) {
|
||
return prevValue.slice(prefixLength);
|
||
}
|
||
|
||
// No issue, strip prefix for new value
|
||
return value.slice(prefixLength);
|
||
},
|
||
|
||
getFirstDiffIndex: function (prev, current) {
|
||
var index = 0;
|
||
|
||
while (prev.charAt(index) === current.charAt(index)) {
|
||
if (prev.charAt(index++) === '') {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
return index;
|
||
},
|
||
|
||
getFormattedValue: function (value, blocks, blocksLength, delimiter, delimiters, delimiterLazyShow) {
|
||
var result = '',
|
||
multipleDelimiters = delimiters.length > 0,
|
||
currentDelimiter;
|
||
|
||
// no options, normal input
|
||
if (blocksLength === 0) {
|
||
return value;
|
||
}
|
||
|
||
blocks.forEach(function (length, index) {
|
||
if (value.length > 0) {
|
||
var sub = value.slice(0, length),
|
||
rest = value.slice(length);
|
||
|
||
if (multipleDelimiters) {
|
||
currentDelimiter = delimiters[delimiterLazyShow ? (index - 1) : index] || currentDelimiter;
|
||
} else {
|
||
currentDelimiter = delimiter;
|
||
}
|
||
|
||
if (delimiterLazyShow) {
|
||
if (index > 0) {
|
||
result += currentDelimiter;
|
||
}
|
||
|
||
result += sub;
|
||
} else {
|
||
result += sub;
|
||
|
||
if (sub.length === length && index < blocksLength - 1) {
|
||
result += currentDelimiter;
|
||
}
|
||
}
|
||
|
||
// update remaining string
|
||
value = rest;
|
||
}
|
||
});
|
||
|
||
return result;
|
||
},
|
||
|
||
// move cursor to the end
|
||
// the first time user focuses on an input with prefix
|
||
fixPrefixCursor: function (el, prefix, delimiter, delimiters) {
|
||
if (!el) {
|
||
return;
|
||
}
|
||
|
||
var val = el.value,
|
||
appendix = delimiter || (delimiters[0] || ' ');
|
||
|
||
if (!el.setSelectionRange || !prefix || (prefix.length + appendix.length) < val.length) {
|
||
return;
|
||
}
|
||
|
||
var len = val.length * 2;
|
||
|
||
// set timeout to avoid blink
|
||
setTimeout(function () {
|
||
el.setSelectionRange(len, len);
|
||
}, 1);
|
||
},
|
||
|
||
setSelection: function (element, position, doc) {
|
||
if (element !== this.getActiveElement(doc)) {
|
||
return;
|
||
}
|
||
|
||
// cursor is already in the end
|
||
if (element && element.value.length <= position) {
|
||
return;
|
||
}
|
||
|
||
if (element.createTextRange) {
|
||
var range = element.createTextRange();
|
||
|
||
range.move('character', position);
|
||
range.select();
|
||
} else {
|
||
try {
|
||
element.setSelectionRange(position, position);
|
||
} catch (e) {
|
||
// eslint-disable-next-line
|
||
console.warn('The input element type does not support selection');
|
||
}
|
||
}
|
||
},
|
||
|
||
getActiveElement: function (parent) {
|
||
var activeElement = parent.activeElement;
|
||
if (activeElement && activeElement.shadowRoot) {
|
||
return this.getActiveElement(activeElement.shadowRoot);
|
||
}
|
||
return activeElement;
|
||
},
|
||
|
||
isAndroid: function () {
|
||
return navigator && /android/i.test(navigator.userAgent);
|
||
},
|
||
|
||
// On Android chrome, the keyup and keydown events
|
||
// always return key code 229 as a composition that
|
||
// buffers the user’s keystrokes
|
||
// see https://github.com/nosir/cleave.js/issues/147
|
||
isAndroidBackspaceKeydown: function (lastInputValue, currentInputValue) {
|
||
if (!this.isAndroid() || !lastInputValue || !currentInputValue) {
|
||
return false;
|
||
}
|
||
|
||
return currentInputValue === lastInputValue.slice(0, -1);
|
||
}
|
||
};
|
||
|
||
module.exports = Util;
|
||
|
||
|
||
/***/
|
||
}),
|
||
/* 7 */
|
||
/***/ (function (module, exports) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function (global) {
|
||
|
||
/**
|
||
* Props Assignment
|
||
*
|
||
* Separate this, so react module can share the usage
|
||
*/
|
||
var DefaultProperties = {
|
||
// Maybe change to object-assign
|
||
// for now just keep it as simple
|
||
assign: function (target, opts) {
|
||
target = target || {};
|
||
opts = opts || {};
|
||
|
||
// credit card
|
||
target.creditCard = !!opts.creditCard;
|
||
target.creditCardStrictMode = !!opts.creditCardStrictMode;
|
||
target.creditCardType = '';
|
||
target.onCreditCardTypeChanged = opts.onCreditCardTypeChanged || (function () { });
|
||
|
||
// phone
|
||
target.phone = !!opts.phone;
|
||
target.phoneRegionCode = opts.phoneRegionCode || 'AU';
|
||
target.phoneFormatter = {};
|
||
|
||
// time
|
||
target.time = !!opts.time;
|
||
target.timePattern = opts.timePattern || ['h', 'm', 's'];
|
||
target.timeFormat = opts.timeFormat || '24';
|
||
target.timeFormatter = {};
|
||
|
||
// date
|
||
target.date = !!opts.date;
|
||
target.datePattern = opts.datePattern || ['d', 'm', 'Y'];
|
||
target.dateFormatter = {};
|
||
|
||
// numeral
|
||
target.numeral = !!opts.numeral;
|
||
target.numeralIntegerScale = opts.numeralIntegerScale > 0 ? opts.numeralIntegerScale : 0;
|
||
target.numeralDecimalScale = opts.numeralDecimalScale >= 0 ? opts.numeralDecimalScale : 2;
|
||
target.numeralDecimalMark = opts.numeralDecimalMark || '.';
|
||
target.numeralThousandsGroupStyle = opts.numeralThousandsGroupStyle || 'thousand';
|
||
target.numeralPositiveOnly = !!opts.numeralPositiveOnly;
|
||
target.stripLeadingZeroes = opts.stripLeadingZeroes !== false;
|
||
|
||
// others
|
||
target.numericOnly = target.creditCard || target.date || !!opts.numericOnly;
|
||
|
||
target.uppercase = !!opts.uppercase;
|
||
target.lowercase = !!opts.lowercase;
|
||
|
||
target.prefix = (target.creditCard || target.date) ? '' : (opts.prefix || '');
|
||
target.noImmediatePrefix = !!opts.noImmediatePrefix;
|
||
target.prefixLength = target.prefix.length;
|
||
target.rawValueTrimPrefix = !!opts.rawValueTrimPrefix;
|
||
target.copyDelimiter = !!opts.copyDelimiter;
|
||
|
||
target.initValue = (opts.initValue !== undefined && opts.initValue !== null) ? opts.initValue.toString() : '';
|
||
|
||
target.delimiter =
|
||
(opts.delimiter || opts.delimiter === '') ? opts.delimiter :
|
||
(opts.date ? '/' :
|
||
(opts.time ? ':' :
|
||
(opts.numeral ? ',' :
|
||
(opts.phone ? ' ' :
|
||
' '))));
|
||
target.delimiterLength = target.delimiter.length;
|
||
target.delimiterLazyShow = !!opts.delimiterLazyShow;
|
||
target.delimiters = opts.delimiters || [];
|
||
|
||
target.blocks = opts.blocks || [];
|
||
target.blocksLength = target.blocks.length;
|
||
|
||
target.root = (typeof global === 'object' && global) ? global : window;
|
||
target.document = opts.document || target.root.document;
|
||
|
||
target.maxLength = 0;
|
||
|
||
target.backspace = false;
|
||
target.result = '';
|
||
|
||
target.onValueChanged = opts.onValueChanged || (function () { });
|
||
|
||
return target;
|
||
}
|
||
};
|
||
|
||
module.exports = DefaultProperties;
|
||
|
||
/* WEBPACK VAR INJECTION */
|
||
}.call(exports, (function () { return this; }())));
|
||
|
||
/***/
|
||
})
|
||
/******/])
|
||
});
|
||
});
|
||
|
||
/* src/Login/twofactors/codeInput.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$4 = "src/Login/twofactors/codeInput.svelte";
|
||
|
||
function create_fragment$4(ctx) {
|
||
var div1, input_1, t0, span0, t1, span1, t2, label_1, t4, div0, t5, div0_style_value, dispose;
|
||
|
||
return {
|
||
c: function create() {
|
||
div1 = internal_13("div");
|
||
input_1 = internal_13("input");
|
||
t0 = internal_17();
|
||
span0 = internal_13("span");
|
||
t1 = internal_17();
|
||
span1 = internal_13("span");
|
||
t2 = internal_17();
|
||
label_1 = internal_13("label");
|
||
label_1.textContent = "Code";
|
||
t4 = internal_17();
|
||
div0 = internal_13("div");
|
||
t5 = internal_16(ctx.error);
|
||
input_1.autofocus = true;
|
||
internal_87(input_1, file$4, 29, 3, 502);
|
||
span0.className = "highlight";
|
||
internal_87(span0, file$4, 30, 3, 560);
|
||
span1.className = "bar";
|
||
internal_87(span1, file$4, 31, 3, 595);
|
||
internal_87(label_1, file$4, 32, 3, 624);
|
||
div0.className = "error svelte-1dvmdfa";
|
||
div0.style.cssText = div0_style_value = !ctx.error ? "display: none;" : "";
|
||
internal_87(div0, file$4, 33, 3, 647);
|
||
div1.className = "floating group";
|
||
internal_87(div1, file$4, 28, 0, 470);
|
||
dispose = internal_19(input_1, "input", ctx.input_1_input_handler);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, div1, anchor);
|
||
internal_6(div1, input_1);
|
||
|
||
input_1.value = ctx.value;
|
||
|
||
internal_62(() => ctx.input_1_binding(input_1, null));
|
||
internal_6(div1, t0);
|
||
internal_6(div1, span0);
|
||
internal_6(div1, t1);
|
||
internal_6(div1, span1);
|
||
internal_6(div1, t2);
|
||
internal_6(div1, label_1);
|
||
internal_6(div1, t4);
|
||
internal_6(div1, div0);
|
||
internal_6(div0, t5);
|
||
input_1.focus();
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.value && (input_1.value !== ctx.value)) input_1.value = ctx.value;
|
||
if (changed.items) {
|
||
ctx.input_1_binding(null, input_1);
|
||
ctx.input_1_binding(input_1, null);
|
||
}
|
||
|
||
if (changed.error) {
|
||
internal_32(t5, ctx.error);
|
||
}
|
||
|
||
if ((changed.error) && div0_style_value !== (div0_style_value = !ctx.error ? "display: none;" : "")) {
|
||
div0.style.cssText = div0_style_value;
|
||
}
|
||
},
|
||
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div1);
|
||
}
|
||
|
||
ctx.input_1_binding(null, input_1);
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance$4($$self, $$props, $$invalidate) {
|
||
|
||
|
||
let { error, label, value, length = 6 } = $$props;
|
||
|
||
let input;
|
||
svelte_1(() => {
|
||
const cleaveCustom = new cleave(input, {
|
||
blocks: [length / 2, length / 2],
|
||
delimiter: ' ',
|
||
numericOnly: true
|
||
});
|
||
});
|
||
|
||
function input_1_input_handler() {
|
||
value = this.value;
|
||
$$invalidate('value', value);
|
||
}
|
||
|
||
function input_1_binding($$node, check) {
|
||
input = $$node;
|
||
$$invalidate('input', input);
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ('error' in $$props) $$invalidate('error', error = $$props.error);
|
||
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
||
if ('value' in $$props) $$invalidate('value', value = $$props.value);
|
||
if ('length' in $$props) $$invalidate('length', length = $$props.length);
|
||
};
|
||
|
||
return {
|
||
error,
|
||
label,
|
||
value,
|
||
length,
|
||
input,
|
||
input_1_input_handler,
|
||
input_1_binding
|
||
};
|
||
}
|
||
|
||
class CodeInput extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$4, create_fragment$4, internal_92, ["error", "label", "value", "length"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.error === undefined && !('error' in props)) {
|
||
console.warn("<CodeInput> was created without expected prop 'error'");
|
||
}
|
||
if (ctx.label === undefined && !('label' in props)) {
|
||
console.warn("<CodeInput> was created without expected prop 'label'");
|
||
}
|
||
if (ctx.value === undefined && !('value' in props)) {
|
||
console.warn("<CodeInput> was created without expected prop 'value'");
|
||
}
|
||
}
|
||
|
||
get error() {
|
||
throw new Error("<CodeInput>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set error(value) {
|
||
throw new Error("<CodeInput>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get label() {
|
||
throw new Error("<CodeInput>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set label(value) {
|
||
throw new Error("<CodeInput>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get value() {
|
||
throw new Error("<CodeInput>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set value(value) {
|
||
throw new Error("<CodeInput>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get length() {
|
||
throw new Error("<CodeInput>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set length(value) {
|
||
throw new Error("<CodeInput>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/twofactors/otc.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$5 = "src/Login/twofactors/otc.svelte";
|
||
|
||
function create_fragment$5(ctx) {
|
||
var h3, t0, t1, updating_value, t2, div, t3, button, current, dispose;
|
||
|
||
function codeinput_value_binding(value) {
|
||
ctx.codeinput_value_binding.call(null, value);
|
||
updating_value = true;
|
||
internal_64(() => updating_value = false);
|
||
}
|
||
|
||
let codeinput_props = {
|
||
label: "Code",
|
||
error: ctx.error,
|
||
length: ctx.length
|
||
};
|
||
if (ctx.code !== void 0) {
|
||
codeinput_props.value = ctx.code;
|
||
}
|
||
var codeinput = new CodeInput({ props: codeinput_props, $$inline: true });
|
||
|
||
internal_62(() => internal_100(codeinput, 'value', codeinput_value_binding));
|
||
|
||
var tolist = new ToList({
|
||
props: { finish: ctx.finish },
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
t0 = internal_16(ctx.title);
|
||
t1 = internal_17();
|
||
codeinput.$$.fragment.c();
|
||
t2 = internal_17();
|
||
div = internal_13("div");
|
||
tolist.$$.fragment.c();
|
||
t3 = internal_17();
|
||
button = internal_13("button");
|
||
button.textContent = "Send";
|
||
internal_87(h3, file$5, 48, 0, 980);
|
||
button.className = "btn svelte-1l4mr9e";
|
||
internal_34(button, "margin-left", "auto");
|
||
internal_87(button, file$5, 54, 3, 1122);
|
||
div.className = "actions svelte-1l4mr9e";
|
||
internal_87(div, file$5, 52, 0, 1074);
|
||
dispose = internal_19(button, "click", ctx.sendCode);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, h3, anchor);
|
||
internal_6(h3, t0);
|
||
internal_7(target, t1, anchor);
|
||
internal_101(codeinput, target, anchor);
|
||
internal_7(target, t2, anchor);
|
||
internal_7(target, div, anchor);
|
||
internal_101(tolist, div, null);
|
||
internal_6(div, t3);
|
||
internal_6(div, button);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var codeinput_changes = {};
|
||
if (changed.error) codeinput_changes.error = ctx.error;
|
||
if (changed.length) codeinput_changes.length = ctx.length;
|
||
if (!updating_value && changed.code) {
|
||
codeinput_changes.value = ctx.code;
|
||
}
|
||
codeinput.$set(codeinput_changes);
|
||
|
||
var tolist_changes = {};
|
||
if (changed.finish) tolist_changes.finish = ctx.finish;
|
||
tolist.$set(tolist_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
codeinput.$$.fragment.i(local);
|
||
|
||
tolist.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
codeinput.$$.fragment.o(local);
|
||
tolist.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t1);
|
||
}
|
||
|
||
codeinput.$destroy(detaching);
|
||
|
||
if (detaching) {
|
||
internal_8(t2);
|
||
internal_8(div);
|
||
}
|
||
|
||
tolist.$destroy();
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance$5($$self, $$props, $$invalidate) {
|
||
|
||
|
||
let error = "";
|
||
let code = "";
|
||
let { finish, id, otc = false } = $$props;
|
||
let title = otc ? "One Time Code (OTC)" : "Backup Code";
|
||
let length = otc ? 6 : 8;
|
||
|
||
async function sendCode() {
|
||
let c = code.replace(/\s+/g, "");
|
||
if (c.length < length) {
|
||
$$invalidate('error', error = `Code must be ${length} digits long!`);
|
||
} else {
|
||
$$invalidate('error', error = "");
|
||
let res;
|
||
if (otc)
|
||
res = await Api.sendOTC(id, c);
|
||
else
|
||
res = await Api.sendBackup(id, c);
|
||
if (res.error)
|
||
$$invalidate('error', error = res.error);
|
||
else
|
||
finish(true);
|
||
}
|
||
}
|
||
|
||
function codeinput_value_binding(value) {
|
||
code = value;
|
||
$$invalidate('code', code);
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ('finish' in $$props) $$invalidate('finish', finish = $$props.finish);
|
||
if ('id' in $$props) $$invalidate('id', id = $$props.id);
|
||
if ('otc' in $$props) $$invalidate('otc', otc = $$props.otc);
|
||
};
|
||
|
||
return {
|
||
error,
|
||
code,
|
||
finish,
|
||
id,
|
||
otc,
|
||
title,
|
||
length,
|
||
sendCode,
|
||
codeinput_value_binding
|
||
};
|
||
}
|
||
|
||
class Otc extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$5, create_fragment$5, internal_92, ["finish", "id", "otc"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.finish === undefined && !('finish' in props)) {
|
||
console.warn("<Otc> was created without expected prop 'finish'");
|
||
}
|
||
if (ctx.id === undefined && !('id' in props)) {
|
||
console.warn("<Otc> was created without expected prop 'id'");
|
||
}
|
||
}
|
||
|
||
get finish() {
|
||
throw new Error("<Otc>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set finish(value) {
|
||
throw new Error("<Otc>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get id() {
|
||
throw new Error("<Otc>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set id(value) {
|
||
throw new Error("<Otc>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get otc() {
|
||
throw new Error("<Otc>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set otc(value) {
|
||
throw new Error("<Otc>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/twofactors/push.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$6 = "src/Login/twofactors/push.svelte";
|
||
|
||
function create_fragment$6(ctx) {
|
||
var h3, t1, p, t2, b, t3, t4, div10, div1, div0, t5, div3, div2, t6, div5, div4, t7, div7, div6, t8, div9, div8, t9, div11, t10, t11, current;
|
||
|
||
var tolist = new ToList({
|
||
props: { finish: ctx.finish },
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
h3.textContent = "SMS";
|
||
t1 = internal_17();
|
||
p = internal_13("p");
|
||
t2 = internal_16("A code was sent to your Device ");
|
||
b = internal_13("b");
|
||
t3 = internal_16(ctx.device);
|
||
t4 = internal_17();
|
||
div10 = internal_13("div");
|
||
div1 = internal_13("div");
|
||
div0 = internal_13("div");
|
||
t5 = internal_17();
|
||
div3 = internal_13("div");
|
||
div2 = internal_13("div");
|
||
t6 = internal_17();
|
||
div5 = internal_13("div");
|
||
div4 = internal_13("div");
|
||
t7 = internal_17();
|
||
div7 = internal_13("div");
|
||
div6 = internal_13("div");
|
||
t8 = internal_17();
|
||
div9 = internal_13("div");
|
||
div8 = internal_13("div");
|
||
t9 = internal_17();
|
||
div11 = internal_13("div");
|
||
t10 = internal_16(error);
|
||
t11 = internal_17();
|
||
tolist.$$.fragment.c();
|
||
internal_87(h3, file$6, 369, 0, 7853);
|
||
internal_87(b, file$6, 371, 34, 7901);
|
||
internal_87(p, file$6, 371, 0, 7867);
|
||
div0.className = "wInnerBall svelte-1xgtl8s";
|
||
internal_87(div0, file$6, 375, 6, 7987);
|
||
div1.className = "wBall svelte-1xgtl8s";
|
||
div1.id = "wBall_1";
|
||
internal_87(div1, file$6, 374, 3, 7948);
|
||
div2.className = "wInnerBall svelte-1xgtl8s";
|
||
internal_87(div2, file$6, 378, 6, 8070);
|
||
div3.className = "wBall svelte-1xgtl8s";
|
||
div3.id = "wBall_2";
|
||
internal_87(div3, file$6, 377, 3, 8031);
|
||
div4.className = "wInnerBall svelte-1xgtl8s";
|
||
internal_87(div4, file$6, 381, 6, 8153);
|
||
div5.className = "wBall svelte-1xgtl8s";
|
||
div5.id = "wBall_3";
|
||
internal_87(div5, file$6, 380, 3, 8114);
|
||
div6.className = "wInnerBall svelte-1xgtl8s";
|
||
internal_87(div6, file$6, 384, 6, 8236);
|
||
div7.className = "wBall svelte-1xgtl8s";
|
||
div7.id = "wBall_4";
|
||
internal_87(div7, file$6, 383, 3, 8197);
|
||
div8.className = "wInnerBall svelte-1xgtl8s";
|
||
internal_87(div8, file$6, 387, 6, 8319);
|
||
div9.className = "wBall svelte-1xgtl8s";
|
||
div9.id = "wBall_5";
|
||
internal_87(div9, file$6, 386, 3, 8280);
|
||
div10.className = "windows8 svelte-1xgtl8s";
|
||
internal_87(div10, file$6, 373, 0, 7922);
|
||
div11.className = "error svelte-1xgtl8s";
|
||
internal_87(div11, file$6, 391, 0, 8368);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, h3, anchor);
|
||
internal_7(target, t1, anchor);
|
||
internal_7(target, p, anchor);
|
||
internal_6(p, t2);
|
||
internal_6(p, b);
|
||
internal_6(b, t3);
|
||
internal_7(target, t4, anchor);
|
||
internal_7(target, div10, anchor);
|
||
internal_6(div10, div1);
|
||
internal_6(div1, div0);
|
||
internal_6(div10, t5);
|
||
internal_6(div10, div3);
|
||
internal_6(div3, div2);
|
||
internal_6(div10, t6);
|
||
internal_6(div10, div5);
|
||
internal_6(div5, div4);
|
||
internal_6(div10, t7);
|
||
internal_6(div10, div7);
|
||
internal_6(div7, div6);
|
||
internal_6(div10, t8);
|
||
internal_6(div10, div9);
|
||
internal_6(div9, div8);
|
||
internal_7(target, t9, anchor);
|
||
internal_7(target, div11, anchor);
|
||
internal_6(div11, t10);
|
||
internal_7(target, t11, anchor);
|
||
internal_101(tolist, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (!current || changed.device) {
|
||
internal_32(t3, ctx.device);
|
||
}
|
||
|
||
var tolist_changes = {};
|
||
if (changed.finish) tolist_changes.finish = ctx.finish;
|
||
tolist.$set(tolist_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
tolist.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
tolist.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t1);
|
||
internal_8(p);
|
||
internal_8(t4);
|
||
internal_8(div10);
|
||
internal_8(t9);
|
||
internal_8(div11);
|
||
internal_8(t11);
|
||
}
|
||
|
||
tolist.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
let error = "";
|
||
|
||
function instance$6($$self, $$props, $$invalidate) {
|
||
|
||
let { device = "Handy01", deviceId = "", finish } = $$props;
|
||
|
||
$$self.$set = $$props => {
|
||
if ('device' in $$props) $$invalidate('device', device = $$props.device);
|
||
if ('deviceId' in $$props) $$invalidate('deviceId', deviceId = $$props.deviceId);
|
||
if ('finish' in $$props) $$invalidate('finish', finish = $$props.finish);
|
||
};
|
||
|
||
return { device, deviceId, finish };
|
||
}
|
||
|
||
class Push extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$6, create_fragment$6, internal_92, ["device", "deviceId", "finish"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.finish === undefined && !('finish' in props)) {
|
||
console.warn("<Push> was created without expected prop 'finish'");
|
||
}
|
||
}
|
||
|
||
get device() {
|
||
throw new Error("<Push>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set device(value) {
|
||
throw new Error("<Push>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get deviceId() {
|
||
throw new Error("<Push>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set deviceId(value) {
|
||
throw new Error("<Push>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
get finish() {
|
||
throw new Error("<Push>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set finish(value) {
|
||
throw new Error("<Push>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/twofactors/u2f.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$7 = "src/Login/twofactors/u2f.svelte";
|
||
|
||
function create_fragment$7(ctx) {
|
||
var h3, t1, h4, t3, current;
|
||
|
||
var tolist = new ToList({
|
||
props: { finish: ctx.finish },
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
h3.textContent = "U2F Security Key";
|
||
t1 = internal_17();
|
||
h4 = internal_13("h4");
|
||
h4.textContent = "This Method is currently not supported. Please choose another one!";
|
||
t3 = internal_17();
|
||
tolist.$$.fragment.c();
|
||
h3.className = "svelte-1b22rk9";
|
||
internal_87(h3, file$7, 69, 0, 1410);
|
||
h4.className = "svelte-1b22rk9";
|
||
internal_87(h4, file$7, 70, 0, 1436);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, h3, anchor);
|
||
internal_7(target, t1, anchor);
|
||
internal_7(target, h4, anchor);
|
||
internal_7(target, t3, anchor);
|
||
internal_101(tolist, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var tolist_changes = {};
|
||
if (changed.finish) tolist_changes.finish = ctx.finish;
|
||
tolist.$set(tolist_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
tolist.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
tolist.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t1);
|
||
internal_8(h4);
|
||
internal_8(t3);
|
||
}
|
||
|
||
tolist.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
function instance$7($$self, $$props, $$invalidate) {
|
||
let { finish } = $$props;
|
||
|
||
const states = {
|
||
getChallenge: 0,
|
||
requestUser: 1,
|
||
sendChallenge: 2,
|
||
error: 3
|
||
};
|
||
|
||
let state = states.getChallenge;
|
||
|
||
let error = "";
|
||
|
||
const onError = err => {
|
||
$$invalidate('state', state = states.error);
|
||
$$invalidate('error', error = err.message);
|
||
};
|
||
|
||
let challenge;
|
||
|
||
async function requestUser() {
|
||
$$invalidate('state', state = states.requestUser);
|
||
let res = await window.navigator.credentials.get({
|
||
publicKey: challenge
|
||
});
|
||
$$invalidate('state', state = states.sendChallenge());
|
||
let r = res.response;
|
||
let data = encode({
|
||
authenticatorData: r.authenticatorData,
|
||
clientDataJSON: r.clientDataJSON,
|
||
signature: r.signature,
|
||
userHandle: r.userHandle
|
||
});
|
||
let {
|
||
success
|
||
} = fetch("https://localhost:8444/auth", {
|
||
body: data,
|
||
method: "POST"
|
||
}).then(res => res.json());
|
||
if (success) {
|
||
finish(true);
|
||
}
|
||
}
|
||
|
||
async function getChallenge() {
|
||
$$invalidate('state', state = states.getChallenge);
|
||
$$invalidate('challenge', challenge = await fetch("https://localhost:8444/auth")
|
||
.then(res => res.arrayBuffer())
|
||
.then(data => decode(MessagePack.Buffer.from(data))));
|
||
|
||
requestUser().catch(onError);
|
||
}
|
||
getChallenge().catch(onError);
|
||
|
||
$$self.$set = $$props => {
|
||
if ('finish' in $$props) $$invalidate('finish', finish = $$props.finish);
|
||
};
|
||
|
||
return { finish };
|
||
}
|
||
|
||
class U2f extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$7, create_fragment$7, internal_92, ["finish"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.finish === undefined && !('finish' in props)) {
|
||
console.warn("<U2f> was created without expected prop 'finish'");
|
||
}
|
||
}
|
||
|
||
get finish() {
|
||
throw new Error("<U2f>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set finish(value) {
|
||
throw new Error("<U2f>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/Twofactor.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$8 = "src/Login/Twofactor.svelte";
|
||
|
||
function get_each_context(ctx, list, i) {
|
||
const child_ctx = Object.create(ctx);
|
||
child_ctx.tf = list[i];
|
||
return child_ctx;
|
||
}
|
||
|
||
// (107:6) {:else}
|
||
function create_else_block$2(ctx) {
|
||
var div;
|
||
|
||
return {
|
||
c: function create() {
|
||
div = internal_13("div");
|
||
div.textContent = "Invalid TwoFactor Method!";
|
||
internal_87(div, file$8, 107, 9, 2311);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, div, anchor);
|
||
},
|
||
|
||
p: internal_83,
|
||
i: internal_83,
|
||
o: internal_83,
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (105:54)
|
||
function create_if_block_4(ctx) {
|
||
var current;
|
||
|
||
var pushtwofactor = new Push({
|
||
props: { id: ctx.twofactor.id, finish: ctx.onFinish },
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
pushtwofactor.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(pushtwofactor, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var pushtwofactor_changes = {};
|
||
if (changed.twofactor) pushtwofactor_changes.id = ctx.twofactor.id;
|
||
if (changed.onFinish) pushtwofactor_changes.finish = ctx.onFinish;
|
||
pushtwofactor.$set(pushtwofactor_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
pushtwofactor.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
pushtwofactor.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
pushtwofactor.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (103:48)
|
||
function create_if_block_3$1(ctx) {
|
||
var current;
|
||
|
||
var u2ftwofactor = new U2f({
|
||
props: { id: ctx.twofactor.id, finish: ctx.onFinish },
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
u2ftwofactor.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(u2ftwofactor, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var u2ftwofactor_changes = {};
|
||
if (changed.twofactor) u2ftwofactor_changes.id = ctx.twofactor.id;
|
||
if (changed.onFinish) u2ftwofactor_changes.finish = ctx.onFinish;
|
||
u2ftwofactor.$set(u2ftwofactor_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
u2ftwofactor.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
u2ftwofactor.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
u2ftwofactor.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (101:56)
|
||
function create_if_block_2$1(ctx) {
|
||
var current;
|
||
|
||
var otctwofactor = new Otc({
|
||
props: {
|
||
id: ctx.twofactor.id,
|
||
finish: ctx.onFinish,
|
||
otc: false
|
||
},
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
otctwofactor.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(otctwofactor, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var otctwofactor_changes = {};
|
||
if (changed.twofactor) otctwofactor_changes.id = ctx.twofactor.id;
|
||
if (changed.onFinish) otctwofactor_changes.finish = ctx.onFinish;
|
||
otctwofactor.$set(otctwofactor_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
otctwofactor.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
otctwofactor.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
otctwofactor.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (99:6) {#if twofactor.type === TFATypes.OTC}
|
||
function create_if_block_1$1(ctx) {
|
||
var current;
|
||
|
||
var otctwofactor = new Otc({
|
||
props: {
|
||
id: ctx.twofactor.id,
|
||
finish: ctx.onFinish,
|
||
otc: true
|
||
},
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
otctwofactor.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(otctwofactor, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var otctwofactor_changes = {};
|
||
if (changed.twofactor) otctwofactor_changes.id = ctx.twofactor.id;
|
||
if (changed.onFinish) otctwofactor_changes.finish = ctx.onFinish;
|
||
otctwofactor.$set(otctwofactor_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
otctwofactor.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
otctwofactor.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
otctwofactor.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (83:3) {#if !twofactor}
|
||
function create_if_block$2(ctx) {
|
||
var h3, t_1, ul, current;
|
||
|
||
var each_value = ctx.twofactors;
|
||
|
||
var each_blocks = [];
|
||
|
||
for (var i = 0; i < each_value.length; i += 1) {
|
||
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
|
||
}
|
||
|
||
function outro_block(i, detaching, local) {
|
||
if (each_blocks[i]) {
|
||
if (detaching) {
|
||
internal_79(() => {
|
||
each_blocks[i].d(detaching);
|
||
each_blocks[i] = null;
|
||
});
|
||
}
|
||
|
||
each_blocks[i].o(local);
|
||
}
|
||
}
|
||
|
||
return {
|
||
c: function create() {
|
||
h3 = internal_13("h3");
|
||
h3.textContent = "Select your Authentication method:";
|
||
t_1 = internal_17();
|
||
ul = internal_13("ul");
|
||
|
||
for (var i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].c();
|
||
}
|
||
internal_87(h3, file$8, 83, 3, 1491);
|
||
ul.className = "svelte-w0gm0o";
|
||
internal_87(ul, file$8, 84, 3, 1538);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, h3, anchor);
|
||
internal_7(target, t_1, anchor);
|
||
internal_7(target, ul, anchor);
|
||
|
||
for (var i = 0; i < each_blocks.length; i += 1) {
|
||
each_blocks[i].m(ul, null);
|
||
}
|
||
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (changed.twofactors) {
|
||
each_value = ctx.twofactors;
|
||
|
||
for (var i = 0; i < each_value.length; i += 1) {
|
||
const child_ctx = get_each_context(ctx, each_value, i);
|
||
|
||
if (each_blocks[i]) {
|
||
each_blocks[i].p(changed, child_ctx);
|
||
each_blocks[i].i(1);
|
||
} else {
|
||
each_blocks[i] = create_each_block(child_ctx);
|
||
each_blocks[i].c();
|
||
each_blocks[i].i(1);
|
||
each_blocks[i].m(ul, null);
|
||
}
|
||
}
|
||
|
||
internal_77();
|
||
for (; i < each_blocks.length; i += 1) outro_block(i, 1, 1);
|
||
internal_78();
|
||
}
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
for (var i = 0; i < each_value.length; i += 1) each_blocks[i].i();
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
each_blocks = each_blocks.filter(Boolean);
|
||
for (let i = 0; i < each_blocks.length; i += 1) outro_block(i, 0);
|
||
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(h3);
|
||
internal_8(t_1);
|
||
internal_8(ul);
|
||
}
|
||
|
||
internal_12(each_blocks, detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (86:6) {#each twofactors as tf}
|
||
function create_each_block(ctx) {
|
||
var li, div0, t0, div1, t1_value = ctx.tf.name, t1, t2, current, dispose;
|
||
|
||
var icon = new Icon({
|
||
props: { icon_name: ctx.tf.icon },
|
||
$$inline: true
|
||
});
|
||
|
||
function click_handler() {
|
||
return ctx.click_handler(ctx);
|
||
}
|
||
|
||
return {
|
||
c: function create() {
|
||
li = internal_13("li");
|
||
div0 = internal_13("div");
|
||
icon.$$.fragment.c();
|
||
t0 = internal_17();
|
||
div1 = internal_13("div");
|
||
t1 = internal_16(t1_value);
|
||
t2 = internal_17();
|
||
div0.className = "icon svelte-w0gm0o";
|
||
internal_87(div0, file$8, 87, 9, 1624);
|
||
div1.className = "name svelte-w0gm0o";
|
||
internal_87(div1, file$8, 91, 9, 1709);
|
||
li.className = "svelte-w0gm0o";
|
||
internal_87(li, file$8, 86, 6, 1580);
|
||
dispose = internal_19(li, "click", click_handler);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, li, anchor);
|
||
internal_6(li, div0);
|
||
internal_101(icon, div0, null);
|
||
internal_6(li, t0);
|
||
internal_6(li, div1);
|
||
internal_6(div1, t1);
|
||
internal_6(li, t2);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, new_ctx) {
|
||
ctx = new_ctx;
|
||
var icon_changes = {};
|
||
if (changed.twofactors) icon_changes.icon_name = ctx.tf.icon;
|
||
icon.$set(icon_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
icon.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
icon.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(li);
|
||
}
|
||
|
||
icon.$destroy();
|
||
|
||
dispose();
|
||
}
|
||
};
|
||
}
|
||
|
||
function create_fragment$8(ctx) {
|
||
var div, current_block_type_index, if_block, current;
|
||
|
||
var if_block_creators = [
|
||
create_if_block$2,
|
||
create_if_block_1$1,
|
||
create_if_block_2$1,
|
||
create_if_block_3$1,
|
||
create_if_block_4,
|
||
create_else_block$2
|
||
];
|
||
|
||
var if_blocks = [];
|
||
|
||
function select_block_type(ctx) {
|
||
if (!ctx.twofactor) return 0;
|
||
if (ctx.twofactor.type === TFATypes.OTC) return 1;
|
||
if (ctx.twofactor.type === TFATypes.BACKUP_CODE) return 2;
|
||
if (ctx.twofactor.type === TFATypes.U2F) return 3;
|
||
if (ctx.twofactor.type === TFATypes.APP_ALLOW) return 4;
|
||
return 5;
|
||
}
|
||
|
||
current_block_type_index = select_block_type(ctx);
|
||
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
||
|
||
return {
|
||
c: function create() {
|
||
div = internal_13("div");
|
||
if_block.c();
|
||
internal_87(div, file$8, 81, 0, 1461);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, div, anchor);
|
||
if_blocks[current_block_type_index].m(div, null);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var previous_block_index = current_block_type_index;
|
||
current_block_type_index = select_block_type(ctx);
|
||
if (current_block_type_index === previous_block_index) {
|
||
if_blocks[current_block_type_index].p(changed, ctx);
|
||
} else {
|
||
internal_77();
|
||
internal_79(() => {
|
||
if_blocks[previous_block_index].d(1);
|
||
if_blocks[previous_block_index] = null;
|
||
});
|
||
if_block.o(1);
|
||
internal_78();
|
||
|
||
if_block = if_blocks[current_block_type_index];
|
||
if (!if_block) {
|
||
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
||
if_block.c();
|
||
}
|
||
if_block.i(1);
|
||
if_block.m(div, null);
|
||
}
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
if (if_block) if_block.i();
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
if (if_block) if_block.o();
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div);
|
||
}
|
||
|
||
if_blocks[current_block_type_index].d();
|
||
}
|
||
};
|
||
}
|
||
|
||
function getIcon(tf) {
|
||
switch (tf.type) {
|
||
case TFATypes.OTC:
|
||
return "Authenticator"
|
||
case TFATypes.BACKUP_CODE:
|
||
return "BackupCode"
|
||
case TFATypes.U2F:
|
||
return "SecurityKey"
|
||
case TFATypes.APP_ALLOW:
|
||
return "AppPush"
|
||
}
|
||
}
|
||
|
||
function instance$8($$self, $$props, $$invalidate) {
|
||
|
||
let twofactors = Api.twofactor.map(tf => {
|
||
return {
|
||
...tf,
|
||
icon: getIcon(tf)
|
||
}
|
||
});
|
||
|
||
let twofactor = undefined;
|
||
$$invalidate('twofactor', twofactor = twofactors[0]);
|
||
|
||
function onFinish(res) {
|
||
if (res)
|
||
finish();
|
||
else
|
||
$$invalidate('twofactor', twofactor = undefined);
|
||
}
|
||
|
||
let { finish } = $$props;
|
||
|
||
function click_handler({ tf }) {
|
||
const $$result = twofactor = tf;
|
||
$$invalidate('twofactor', twofactor);
|
||
return $$result;
|
||
}
|
||
|
||
$$self.$set = $$props => {
|
||
if ('finish' in $$props) $$invalidate('finish', finish = $$props.finish);
|
||
};
|
||
|
||
$$self.$$.update = ($$dirty = { twofactor: 1 }) => {
|
||
if ($$dirty.twofactor) { console.log(twofactor); }
|
||
};
|
||
|
||
return {
|
||
twofactors,
|
||
twofactor,
|
||
onFinish,
|
||
finish,
|
||
click_handler
|
||
};
|
||
}
|
||
|
||
class Twofactor extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$8, create_fragment$8, internal_92, ["finish"]);
|
||
|
||
const { ctx } = this.$$;
|
||
const props = options.props || {};
|
||
if (ctx.finish === undefined && !('finish' in props)) {
|
||
console.warn("<Twofactor> was created without expected prop 'finish'");
|
||
}
|
||
}
|
||
|
||
get finish() {
|
||
throw new Error("<Twofactor>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
|
||
set finish(value) {
|
||
throw new Error("<Twofactor>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
}
|
||
}
|
||
|
||
/* src/Login/App.svelte generated by Svelte v3.2.1 */
|
||
|
||
const file$9 = "src/Login/App.svelte";
|
||
|
||
// (105:6) {#if loading}
|
||
function create_if_block_3$2(ctx) {
|
||
var div2, div1, div0;
|
||
|
||
return {
|
||
c: function create() {
|
||
div2 = internal_13("div");
|
||
div1 = internal_13("div");
|
||
div0 = internal_13("div");
|
||
div0.className = "loader";
|
||
internal_87(div0, file$9, 107, 12, 2332);
|
||
div1.className = "loader_box";
|
||
internal_87(div1, file$9, 106, 9, 2295);
|
||
div2.className = "loader_container svelte-1ckcw4k";
|
||
internal_87(div2, file$9, 105, 6, 2255);
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_7(target, div2, anchor);
|
||
internal_6(div2, div1);
|
||
internal_6(div1, div0);
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div2);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
// (117:46)
|
||
function create_if_block_2$2(ctx) {
|
||
var current;
|
||
|
||
var twofactor = new Twofactor({
|
||
props: {
|
||
finish: ctx.afterTwoFactor,
|
||
setLoading: ctx.func_1
|
||
},
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
twofactor.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(twofactor, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var twofactor_changes = {};
|
||
if (changed.afterTwoFactor) twofactor_changes.finish = ctx.afterTwoFactor;
|
||
twofactor.$set(twofactor_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
twofactor.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
twofactor.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
twofactor.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (115:48)
|
||
function create_if_block_1$2(ctx) {
|
||
var current;
|
||
|
||
var credentials = new Credentials({
|
||
props: {
|
||
next: ctx.afterCredentials,
|
||
setLoading: ctx.func
|
||
},
|
||
$$inline: true
|
||
});
|
||
|
||
return {
|
||
c: function create() {
|
||
credentials.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(credentials, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
var credentials_changes = {};
|
||
if (changed.afterCredentials) credentials_changes.next = ctx.afterCredentials;
|
||
credentials.$set(credentials_changes);
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
credentials.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
credentials.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
credentials.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
// (113:9) {#if state === states.redirect}
|
||
function create_if_block$3(ctx) {
|
||
var current;
|
||
|
||
var redirect = new Redirect({ $$inline: true });
|
||
|
||
return {
|
||
c: function create() {
|
||
redirect.$$.fragment.c();
|
||
},
|
||
|
||
m: function mount(target, anchor) {
|
||
internal_101(redirect, target, anchor);
|
||
current = true;
|
||
},
|
||
|
||
p: internal_83,
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
redirect.$$.fragment.i(local);
|
||
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
redirect.$$.fragment.o(local);
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
redirect.$destroy(detaching);
|
||
}
|
||
};
|
||
}
|
||
|
||
function create_fragment$9(ctx) {
|
||
var div2, form, div0, h1, t1, t2, div1, current_block_type_index, if_block1, t3, footer, p, t4, t5, current;
|
||
|
||
var if_block0 = (ctx.loading) && create_if_block_3$2(ctx);
|
||
|
||
var if_block_creators = [
|
||
create_if_block$3,
|
||
create_if_block_1$2,
|
||
create_if_block_2$2
|
||
];
|
||
|
||
var if_blocks = [];
|
||
|
||
function select_block_type(ctx) {
|
||
if (ctx.state === ctx.states.redirect) return 0;
|
||
if (ctx.state === ctx.states.credentials) return 1;
|
||
if (ctx.state === ctx.states.twofactor) return 2;
|
||
return -1;
|
||
}
|
||
|
||
if (~(current_block_type_index = select_block_type(ctx))) {
|
||
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
||
}
|
||
|
||
return {
|
||
c: function create() {
|
||
div2 = internal_13("div");
|
||
form = internal_13("form");
|
||
div0 = internal_13("div");
|
||
h1 = internal_13("h1");
|
||
h1.textContent = "Login";
|
||
t1 = internal_17();
|
||
if (if_block0) if_block0.c();
|
||
t2 = internal_17();
|
||
div1 = internal_13("div");
|
||
if (if_block1) if_block1.c();
|
||
t3 = internal_17();
|
||
footer = internal_13("footer");
|
||
p = internal_13("p");
|
||
t4 = internal_16("Powered by ");
|
||
t5 = internal_16(appname);
|
||
internal_87(h1, file$9, 102, 9, 2201);
|
||
div0.className = "card title-container svelte-1ckcw4k";
|
||
internal_87(div0, file$9, 101, 6, 2157);
|
||
div1.className = "container svelte-1ckcw4k";
|
||
internal_40(div1, "loading_container", ctx.loading);
|
||
internal_87(div1, file$9, 111, 6, 2406);
|
||
form.action = "JavaScript:void(0)";
|
||
form.className = "card svelte-1ckcw4k";
|
||
internal_87(form, file$9, 100, 3, 2103);
|
||
div2.className = "form-container svelte-1ckcw4k";
|
||
internal_87(div2, file$9, 99, 0, 2071);
|
||
internal_87(p, file$9, 123, 1, 2843);
|
||
footer.className = "svelte-1ckcw4k";
|
||
internal_87(footer, file$9, 122, 0, 2833);
|
||
},
|
||
|
||
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) {
|
||
internal_7(target, div2, anchor);
|
||
internal_6(div2, form);
|
||
internal_6(form, div0);
|
||
internal_6(div0, h1);
|
||
internal_6(form, t1);
|
||
if (if_block0) if_block0.m(form, null);
|
||
internal_6(form, t2);
|
||
internal_6(form, div1);
|
||
if (~current_block_type_index) if_blocks[current_block_type_index].m(div1, null);
|
||
internal_7(target, t3, anchor);
|
||
internal_7(target, footer, anchor);
|
||
internal_6(footer, p);
|
||
internal_6(p, t4);
|
||
internal_6(p, t5);
|
||
current = true;
|
||
},
|
||
|
||
p: function update(changed, ctx) {
|
||
if (ctx.loading) {
|
||
if (!if_block0) {
|
||
if_block0 = create_if_block_3$2(ctx);
|
||
if_block0.c();
|
||
if_block0.m(form, t2);
|
||
}
|
||
} else if (if_block0) {
|
||
if_block0.d(1);
|
||
if_block0 = null;
|
||
}
|
||
|
||
var previous_block_index = current_block_type_index;
|
||
current_block_type_index = select_block_type(ctx);
|
||
if (current_block_type_index === previous_block_index) {
|
||
if (~current_block_type_index) if_blocks[current_block_type_index].p(changed, ctx);
|
||
} else {
|
||
if (if_block1) {
|
||
internal_77();
|
||
internal_79(() => {
|
||
if_blocks[previous_block_index].d(1);
|
||
if_blocks[previous_block_index] = null;
|
||
});
|
||
if_block1.o(1);
|
||
internal_78();
|
||
}
|
||
|
||
if (~current_block_type_index) {
|
||
if_block1 = if_blocks[current_block_type_index];
|
||
if (!if_block1) {
|
||
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
||
if_block1.c();
|
||
}
|
||
if_block1.i(1);
|
||
if_block1.m(div1, null);
|
||
} else {
|
||
if_block1 = null;
|
||
}
|
||
}
|
||
|
||
if (changed.loading) {
|
||
internal_40(div1, "loading_container", ctx.loading);
|
||
}
|
||
},
|
||
|
||
i: function intro(local) {
|
||
if (current) return;
|
||
if (if_block1) if_block1.i();
|
||
current = true;
|
||
},
|
||
|
||
o: function outro(local) {
|
||
if (if_block1) if_block1.o();
|
||
current = false;
|
||
},
|
||
|
||
d: function destroy(detaching) {
|
||
if (detaching) {
|
||
internal_8(div2);
|
||
}
|
||
|
||
if (if_block0) if_block0.d();
|
||
if (~current_block_type_index) if_blocks[current_block_type_index].d();
|
||
|
||
if (detaching) {
|
||
internal_8(t3);
|
||
internal_8(footer);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
const appname = "OpenAuth";
|
||
|
||
function instance$9($$self, $$props, $$invalidate) {
|
||
|
||
|
||
const states = {
|
||
credentials: 1,
|
||
twofactor: 3,
|
||
redirect: 4
|
||
};
|
||
|
||
let username = Api.getUsername();
|
||
|
||
let loading = false;
|
||
let state = states.credentials;
|
||
|
||
function getButtonText(state) {
|
||
switch (state) {
|
||
case states.username:
|
||
return "Next";
|
||
case states.password:
|
||
return "Login";
|
||
default:
|
||
return "";
|
||
}
|
||
}
|
||
|
||
function startRedirect() {
|
||
$$invalidate('state', state = states.redirect);
|
||
// Show message to User and then redirect
|
||
setTimeout(() => Api.finish(), 2000);
|
||
}
|
||
|
||
function afterCredentials() {
|
||
|
||
if (Api.twofactor) {
|
||
$$invalidate('state', state = states.twofactor);
|
||
} else {
|
||
startRedirect();
|
||
}
|
||
}
|
||
|
||
function afterTwoFactor() {
|
||
startRedirect();
|
||
}
|
||
|
||
function func(s) {
|
||
const $$result = loading = s;
|
||
$$invalidate('loading', loading);
|
||
return $$result;
|
||
}
|
||
|
||
function func_1(s) {
|
||
const $$result = loading = s;
|
||
$$invalidate('loading', loading);
|
||
return $$result;
|
||
}
|
||
|
||
let btnText;
|
||
|
||
$$self.$$.update = ($$dirty = { state: 1 }) => {
|
||
if ($$dirty.state) { $$invalidate('btnText', btnText = getButtonText(state)); }
|
||
};
|
||
|
||
return {
|
||
states,
|
||
loading,
|
||
state,
|
||
afterCredentials,
|
||
afterTwoFactor,
|
||
func,
|
||
func_1
|
||
};
|
||
}
|
||
|
||
class App extends internal_104 {
|
||
constructor(options) {
|
||
super(options);
|
||
internal_102(this, options, instance$9, create_fragment$9, internal_92, []);
|
||
}
|
||
}
|
||
|
||
var app = new App({
|
||
target: document.getElementById("content")
|
||
});
|
||
|
||
return app;
|
||
|
||
}());
|
||
//# sourceMappingURL=bundle.js.map
|