MediaWiki:Gadget-CurrencyConverter.js
Перейти к навигации
Перейти к поиску
Замечание: Возможно, после публикации вам придётся очистить кэш своего браузера, чтобы увидеть изменения.
- Firefox / Safari: Удерживая клавишу Shift, нажмите на панели инструментов Обновить либо нажмите Ctrl+F5 или Ctrl+R (⌘+R на Mac)
- Google Chrome: Нажмите Ctrl+Shift+R (⌘+Shift+R на Mac)
- Edge: Удерживая Ctrl, нажмите Обновить либо нажмите Ctrl+F5
- Opera: Нажмите Ctrl+F5.
/* CSS: https://wiki.demovio.lovel/MediaWiki:Gadget-CurrencyConverter.css */
var _a, _b, _c;
const DEV = false;
var is_array = Array.isArray;
var index_of = Array.prototype.indexOf;
var array_from = Array.from;
var define_property = Object.defineProperty;
var get_descriptor = Object.getOwnPropertyDescriptor;
var get_descriptors = Object.getOwnPropertyDescriptors;
var object_prototype = Object.prototype;
var array_prototype = Array.prototype;
var get_prototype_of = Object.getPrototypeOf;
const noop = () => {
};
const DERIVED = 1 << 1;
const EFFECT = 1 << 2;
const RENDER_EFFECT = 1 << 3;
const BLOCK_EFFECT = 1 << 4;
const BRANCH_EFFECT = 1 << 5;
const ROOT_EFFECT = 1 << 6;
const BOUNDARY_EFFECT = 1 << 7;
const UNOWNED = 1 << 8;
const DISCONNECTED = 1 << 9;
const CLEAN = 1 << 10;
const DIRTY = 1 << 11;
const MAYBE_DIRTY = 1 << 12;
const INERT = 1 << 13;
const DESTROYED = 1 << 14;
const EFFECT_RAN = 1 << 15;
const EFFECT_TRANSPARENT = 1 << 16;
const HEAD_EFFECT = 1 << 19;
const EFFECT_HAS_DERIVED = 1 << 20;
const STATE_SYMBOL = Symbol("$state");
const LOADING_ATTR_SYMBOL = Symbol("");
function equals(value) {
return value === this.v;
}
function effect_update_depth_exceeded() {
{
throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
}
}
function state_descriptors_fixed() {
{
throw new Error(`https://svelte.dev/e/state_descriptors_fixed`);
}
}
function state_prototype_fixed() {
{
throw new Error(`https://svelte.dev/e/state_prototype_fixed`);
}
}
function state_unsafe_local_read() {
{
throw new Error(`https://svelte.dev/e/state_unsafe_local_read`);
}
}
function state_unsafe_mutation() {
{
throw new Error(`https://svelte.dev/e/state_unsafe_mutation`);
}
}
let legacy_mode_flag = false;
let tracing_mode_flag = false;
function enable_legacy_mode_flag() {
legacy_mode_flag = true;
}
const TEMPLATE_FRAGMENT = 1;
const TEMPLATE_USE_IMPORT_NODE = 1 << 1;
const UNINITIALIZED = Symbol();
const NAMESPACE_HTML = "http://www.w3.org/1999/xhtml";
let component_context = null;
function set_component_context(context) {
component_context = context;
}
function push(props, runes = false, fn) {
var ctx = component_context = {
p: component_context,
c: null,
d: false,
e: null,
m: false,
s: props,
x: null,
l: null
};
if (legacy_mode_flag && !runes) {
component_context.l = {
s: null,
u: null,
r1: [],
r2: source(false)
};
}
teardown(() => {
ctx.d = true;
});
}
function pop(component) {
const context_stack_item = component_context;
if (context_stack_item !== null) {
const component_effects = context_stack_item.e;
if (component_effects !== null) {
var previous_effect = active_effect;
var previous_reaction = active_reaction;
context_stack_item.e = null;
try {
for (var i = 0; i < component_effects.length; i++) {
var component_effect = component_effects[i];
set_active_effect(component_effect.effect);
set_active_reaction(component_effect.reaction);
effect(component_effect.fn);
}
} finally {
set_active_effect(previous_effect);
set_active_reaction(previous_reaction);
}
}
component_context = context_stack_item.p;
context_stack_item.m = true;
}
return (
/** @type {T} */
{}
);
}
function is_runes() {
return !legacy_mode_flag || component_context !== null && component_context.l === null;
}
const old_values = /* @__PURE__ */ new Map();
function source(v, stack) {
var signal = {
f: 0,
// TODO ideally we could skip this altogether, but it causes type errors
v,
reactions: null,
equals,
rv: 0,
wv: 0
};
return signal;
}
function state(v) {
return /* @__PURE__ */ push_derived_source(source(v));
}
// @__NO_SIDE_EFFECTS__
function push_derived_source(source2) {
if (active_reaction !== null && !untracking && (active_reaction.f & DERIVED) !== 0) {
if (derived_sources === null) {
set_derived_sources([source2]);
} else {
derived_sources.push(source2);
}
}
return source2;
}
function set(source2, value) {
if (active_reaction !== null && !untracking && is_runes() && (active_reaction.f & (DERIVED | BLOCK_EFFECT)) !== 0 && // If the source was created locally within the current derived, then
// we allow the mutation.
(derived_sources === null || !derived_sources.includes(source2))) {
state_unsafe_mutation();
}
return internal_set(source2, value);
}
function internal_set(source2, value) {
if (!source2.equals(value)) {
var old_value = source2.v;
if (is_destroying_effect) {
old_values.set(source2, value);
} else {
old_values.set(source2, old_value);
}
source2.v = value;
source2.wv = increment_write_version();
mark_reactions(source2, DIRTY);
if (is_runes() && active_effect !== null && (active_effect.f & CLEAN) !== 0 && (active_effect.f & (BRANCH_EFFECT | ROOT_EFFECT)) === 0) {
if (untracked_writes === null) {
set_untracked_writes([source2]);
} else {
untracked_writes.push(source2);
}
}
}
return value;
}
function mark_reactions(signal, status) {
var reactions = signal.reactions;
if (reactions === null) return;
var runes = is_runes();
var length = reactions.length;
for (var i = 0; i < length; i++) {
var reaction = reactions[i];
var flags = reaction.f;
if ((flags & DIRTY) !== 0) continue;
if (!runes && reaction === active_effect) continue;
set_signal_status(reaction, status);
if ((flags & (CLEAN | UNOWNED)) !== 0) {
if ((flags & DERIVED) !== 0) {
mark_reactions(
/** @type {Derived} */
reaction,
MAYBE_DIRTY
);
} else {
schedule_effect(
/** @type {Effect} */
reaction
);
}
}
}
}
function proxy(value, parent = null, prev) {
if (typeof value !== "object" || value === null || STATE_SYMBOL in value) {
return value;
}
const prototype = get_prototype_of(value);
if (prototype !== object_prototype && prototype !== array_prototype) {
return value;
}
var sources = /* @__PURE__ */ new Map();
var is_proxied_array = is_array(value);
var version = source(0);
if (is_proxied_array) {
sources.set("length", source(
/** @type {any[]} */
value.length
));
}
var metadata;
return new Proxy(
/** @type {any} */
value,
{
defineProperty(_, prop, descriptor) {
if (!("value" in descriptor) || descriptor.configurable === false || descriptor.enumerable === false || descriptor.writable === false) {
state_descriptors_fixed();
}
var s = sources.get(prop);
if (s === void 0) {
s = source(descriptor.value);
sources.set(prop, s);
} else {
set(s, proxy(descriptor.value, metadata));
}
return true;
},
deleteProperty(target, prop) {
var s = sources.get(prop);
if (s === void 0) {
if (prop in target) {
sources.set(prop, source(UNINITIALIZED));
}
} else {
if (is_proxied_array && typeof prop === "string") {
var ls = (
/** @type {Source<number>} */
sources.get("length")
);
var n = Number(prop);
if (Number.isInteger(n) && n < ls.v) {
set(ls, n);
}
}
set(s, UNINITIALIZED);
update_version(version);
}
return true;
},
get(target, prop, receiver) {
var _a2;
if (prop === STATE_SYMBOL) {
return value;
}
var s = sources.get(prop);
var exists = prop in target;
if (s === void 0 && (!exists || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable))) {
s = source(proxy(exists ? target[prop] : UNINITIALIZED, metadata));
sources.set(prop, s);
}
if (s !== void 0) {
var v = get(s);
return v === UNINITIALIZED ? void 0 : v;
}
return Reflect.get(target, prop, receiver);
},
getOwnPropertyDescriptor(target, prop) {
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
if (descriptor && "value" in descriptor) {
var s = sources.get(prop);
if (s) descriptor.value = get(s);
} else if (descriptor === void 0) {
var source2 = sources.get(prop);
var value2 = source2 == null ? void 0 : source2.v;
if (source2 !== void 0 && value2 !== UNINITIALIZED) {
return {
enumerable: true,
configurable: true,
value: value2,
writable: true
};
}
}
return descriptor;
},
has(target, prop) {
var _a2;
if (prop === STATE_SYMBOL) {
return true;
}
var s = sources.get(prop);
var has = s !== void 0 && s.v !== UNINITIALIZED || Reflect.has(target, prop);
if (s !== void 0 || active_effect !== null && (!has || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable))) {
if (s === void 0) {
s = source(has ? proxy(target[prop], metadata) : UNINITIALIZED);
sources.set(prop, s);
}
var value2 = get(s);
if (value2 === UNINITIALIZED) {
return false;
}
}
return has;
},
set(target, prop, value2, receiver) {
var _a2;
var s = sources.get(prop);
var has = prop in target;
if (is_proxied_array && prop === "length") {
for (var i = value2; i < /** @type {Source<number>} */
s.v; i += 1) {
var other_s = sources.get(i + "");
if (other_s !== void 0) {
set(other_s, UNINITIALIZED);
} else if (i in target) {
other_s = source(UNINITIALIZED);
sources.set(i + "", other_s);
}
}
}
if (s === void 0) {
if (!has || ((_a2 = get_descriptor(target, prop)) == null ? void 0 : _a2.writable)) {
s = source(void 0);
set(s, proxy(value2, metadata));
sources.set(prop, s);
}
} else {
has = s.v !== UNINITIALIZED;
set(s, proxy(value2, metadata));
}
var descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
if (descriptor == null ? void 0 : descriptor.set) {
descriptor.set.call(receiver, value2);
}
if (!has) {
if (is_proxied_array && typeof prop === "string") {
var ls = (
/** @type {Source<number>} */
sources.get("length")
);
var n = Number(prop);
if (Number.isInteger(n) && n >= ls.v) {
set(ls, n + 1);
}
}
update_version(version);
}
return true;
},
ownKeys(target) {
get(version);
var own_keys = Reflect.ownKeys(target).filter((key2) => {
var source3 = sources.get(key2);
return source3 === void 0 || source3.v !== UNINITIALIZED;
});
for (var [key, source2] of sources) {
if (source2.v !== UNINITIALIZED && !(key in target)) {
own_keys.push(key);
}
}
return own_keys;
},
setPrototypeOf() {
state_prototype_fixed();
}
}
);
}
function update_version(signal, d = 1) {
set(signal, signal.v + d);
}
var $window;
var is_firefox;
var first_child_getter;
var next_sibling_getter;
function init_operations() {
if ($window !== void 0) {
return;
}
$window = window;
is_firefox = /Firefox/.test(navigator.userAgent);
var element_prototype = Element.prototype;
var node_prototype = Node.prototype;
first_child_getter = get_descriptor(node_prototype, "firstChild").get;
next_sibling_getter = get_descriptor(node_prototype, "nextSibling").get;
element_prototype.__click = void 0;
element_prototype.__className = void 0;
element_prototype.__attributes = null;
element_prototype.__style = void 0;
element_prototype.__e = void 0;
Text.prototype.__t = void 0;
}
function create_text(value = "") {
return document.createTextNode(value);
}
// @__NO_SIDE_EFFECTS__
function get_first_child(node) {
return first_child_getter.call(node);
}
// @__NO_SIDE_EFFECTS__
function get_next_sibling(node) {
return next_sibling_getter.call(node);
}
function child(node, is_text) {
{
return /* @__PURE__ */ get_first_child(node);
}
}
function first_child(fragment, is_text) {
{
var first = (
/** @type {DocumentFragment} */
/* @__PURE__ */ get_first_child(
/** @type {Node} */
fragment
)
);
if (first instanceof Comment && first.data === "") return /* @__PURE__ */ get_next_sibling(first);
return first;
}
}
function sibling(node, count = 1, is_text = false) {
let next_sibling = node;
while (count--) {
next_sibling = /** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(next_sibling);
}
{
return next_sibling;
}
}
// @__NO_SIDE_EFFECTS__
function derived(fn) {
var flags = DERIVED | DIRTY;
var parent_derived = active_reaction !== null && (active_reaction.f & DERIVED) !== 0 ? (
/** @type {Derived} */
active_reaction
) : null;
if (active_effect === null || parent_derived !== null && (parent_derived.f & UNOWNED) !== 0) {
flags |= UNOWNED;
} else {
active_effect.f |= EFFECT_HAS_DERIVED;
}
const signal = {
ctx: component_context,
deps: null,
effects: null,
equals,
f: flags,
fn,
reactions: null,
rv: 0,
v: (
/** @type {V} */
null
),
wv: 0,
parent: parent_derived != null ? parent_derived : active_effect
};
return signal;
}
function destroy_derived_effects(derived2) {
var effects = derived2.effects;
if (effects !== null) {
derived2.effects = null;
for (var i = 0; i < effects.length; i += 1) {
destroy_effect(
/** @type {Effect} */
effects[i]
);
}
}
}
function get_derived_parent_effect(derived2) {
var parent = derived2.parent;
while (parent !== null) {
if ((parent.f & DERIVED) === 0) {
return (
/** @type {Effect} */
parent
);
}
parent = parent.parent;
}
return null;
}
function execute_derived(derived2) {
var value;
var prev_active_effect = active_effect;
set_active_effect(get_derived_parent_effect(derived2));
{
try {
destroy_derived_effects(derived2);
value = update_reaction(derived2);
} finally {
set_active_effect(prev_active_effect);
}
}
return value;
}
function update_derived(derived2) {
var value = execute_derived(derived2);
var status = (skip_reaction || (derived2.f & UNOWNED) !== 0) && derived2.deps !== null ? MAYBE_DIRTY : CLEAN;
set_signal_status(derived2, status);
if (!derived2.equals(value)) {
derived2.v = value;
derived2.wv = increment_write_version();
}
}
function push_effect(effect2, parent_effect) {
var parent_last = parent_effect.last;
if (parent_last === null) {
parent_effect.last = parent_effect.first = effect2;
} else {
parent_last.next = effect2;
effect2.prev = parent_last;
parent_effect.last = effect2;
}
}
function create_effect(type, fn, sync, push2 = true) {
var _a2;
var parent = active_effect;
var effect2 = {
ctx: component_context,
deps: null,
nodes_start: null,
nodes_end: null,
f: type | DIRTY,
first: null,
fn,
last: null,
next: null,
parent,
prev: null,
teardown: null,
transitions: null,
wv: 0
};
if (sync) {
try {
update_effect(effect2);
effect2.f |= EFFECT_RAN;
} catch (e) {
destroy_effect(effect2);
throw e;
}
} else if (fn !== null) {
schedule_effect(effect2);
}
var inert = sync && effect2.deps === null && effect2.first === null && effect2.nodes_start === null && effect2.teardown === null && (effect2.f & (EFFECT_HAS_DERIVED | BOUNDARY_EFFECT)) === 0;
if (!inert && push2) {
if (parent !== null) {
push_effect(effect2, parent);
}
if (active_reaction !== null && (active_reaction.f & DERIVED) !== 0) {
var derived2 = (
/** @type {Derived} */
active_reaction
);
((_a2 = derived2.effects) != null ? _a2 : derived2.effects = []).push(effect2);
}
}
return effect2;
}
function teardown(fn) {
const effect2 = create_effect(RENDER_EFFECT, null, false);
set_signal_status(effect2, CLEAN);
effect2.teardown = fn;
return effect2;
}
function component_root(fn) {
const effect2 = create_effect(ROOT_EFFECT, fn, true);
return (options = {}) => {
return new Promise((fulfil) => {
if (options.outro) {
pause_effect(effect2, () => {
destroy_effect(effect2);
fulfil(void 0);
});
} else {
destroy_effect(effect2);
fulfil(void 0);
}
});
};
}
function effect(fn) {
return create_effect(EFFECT, fn, false);
}
function render_effect(fn) {
return create_effect(RENDER_EFFECT, fn, true);
}
function template_effect(fn, thunks = [], d = derived) {
const deriveds = thunks.map(d);
const effect2 = () => fn(...deriveds.map(get));
return block(effect2);
}
function block(fn, flags = 0) {
return create_effect(RENDER_EFFECT | BLOCK_EFFECT | flags, fn, true);
}
function branch(fn, push2 = true) {
return create_effect(RENDER_EFFECT | BRANCH_EFFECT, fn, true, push2);
}
function execute_effect_teardown(effect2) {
var teardown2 = effect2.teardown;
if (teardown2 !== null) {
const previously_destroying_effect = is_destroying_effect;
const previous_reaction = active_reaction;
set_is_destroying_effect(true);
set_active_reaction(null);
try {
teardown2.call(null);
} finally {
set_is_destroying_effect(previously_destroying_effect);
set_active_reaction(previous_reaction);
}
}
}
function destroy_effect_children(signal, remove_dom = false) {
var effect2 = signal.first;
signal.first = signal.last = null;
while (effect2 !== null) {
var next = effect2.next;
if ((effect2.f & ROOT_EFFECT) !== 0) {
effect2.parent = null;
} else {
destroy_effect(effect2, remove_dom);
}
effect2 = next;
}
}
function destroy_block_effect_children(signal) {
var effect2 = signal.first;
while (effect2 !== null) {
var next = effect2.next;
if ((effect2.f & BRANCH_EFFECT) === 0) {
destroy_effect(effect2);
}
effect2 = next;
}
}
function destroy_effect(effect2, remove_dom = true) {
var removed = false;
if ((remove_dom || (effect2.f & HEAD_EFFECT) !== 0) && effect2.nodes_start !== null) {
var node = effect2.nodes_start;
var end = effect2.nodes_end;
while (node !== null) {
var next = node === end ? null : (
/** @type {TemplateNode} */
/* @__PURE__ */ get_next_sibling(node)
);
node.remove();
node = next;
}
removed = true;
}
destroy_effect_children(effect2, remove_dom && !removed);
remove_reactions(effect2, 0);
set_signal_status(effect2, DESTROYED);
var transitions = effect2.transitions;
if (transitions !== null) {
for (const transition of transitions) {
transition.stop();
}
}
execute_effect_teardown(effect2);
var parent = effect2.parent;
if (parent !== null && parent.first !== null) {
unlink_effect(effect2);
}
effect2.next = effect2.prev = effect2.teardown = effect2.ctx = effect2.deps = effect2.fn = effect2.nodes_start = effect2.nodes_end = null;
}
function unlink_effect(effect2) {
var parent = effect2.parent;
var prev = effect2.prev;
var next = effect2.next;
if (prev !== null) prev.next = next;
if (next !== null) next.prev = prev;
if (parent !== null) {
if (parent.first === effect2) parent.first = next;
if (parent.last === effect2) parent.last = prev;
}
}
function pause_effect(effect2, callback) {
var transitions = [];
pause_children(effect2, transitions, true);
run_out_transitions(transitions, () => {
destroy_effect(effect2);
if (callback) callback();
});
}
function run_out_transitions(transitions, fn) {
var remaining = transitions.length;
if (remaining > 0) {
var check = () => --remaining || fn();
for (var transition of transitions) {
transition.out(check);
}
} else {
fn();
}
}
function pause_children(effect2, transitions, local) {
if ((effect2.f & INERT) !== 0) return;
effect2.f ^= INERT;
if (effect2.transitions !== null) {
for (const transition of effect2.transitions) {
if (transition.is_global || local) {
transitions.push(transition);
}
}
}
var child2 = effect2.first;
while (child2 !== null) {
var sibling2 = child2.next;
var transparent = (child2.f & EFFECT_TRANSPARENT) !== 0 || (child2.f & BRANCH_EFFECT) !== 0;
pause_children(child2, transitions, transparent ? local : false);
child2 = sibling2;
}
}
let is_throwing_error = false;
let is_flushing = false;
let last_scheduled_effect = null;
let is_updating_effect = false;
let is_destroying_effect = false;
function set_is_destroying_effect(value) {
is_destroying_effect = value;
}
let queued_root_effects = [];
let dev_effect_stack = [];
let active_reaction = null;
let untracking = false;
function set_active_reaction(reaction) {
active_reaction = reaction;
}
let active_effect = null;
function set_active_effect(effect2) {
active_effect = effect2;
}
let derived_sources = null;
function set_derived_sources(sources) {
derived_sources = sources;
}
let new_deps = null;
let skipped_deps = 0;
let untracked_writes = null;
function set_untracked_writes(value) {
untracked_writes = value;
}
let write_version = 1;
let read_version = 0;
let skip_reaction = false;
function increment_write_version() {
return ++write_version;
}
function check_dirtiness(reaction) {
var _a2, _b2;
var flags = reaction.f;
if ((flags & DIRTY) !== 0) {
return true;
}
if ((flags & MAYBE_DIRTY) !== 0) {
var dependencies = reaction.deps;
var is_unowned = (flags & UNOWNED) !== 0;
if (dependencies !== null) {
var i;
var dependency;
var is_disconnected = (flags & DISCONNECTED) !== 0;
var is_unowned_connected = is_unowned && active_effect !== null && !skip_reaction;
var length = dependencies.length;
if (is_disconnected || is_unowned_connected) {
var derived2 = (
/** @type {Derived} */
reaction
);
var parent = derived2.parent;
for (i = 0; i < length; i++) {
dependency = dependencies[i];
if (is_disconnected || !((_a2 = dependency == null ? void 0 : dependency.reactions) == null ? void 0 : _a2.includes(derived2))) {
((_b2 = dependency.reactions) != null ? _b2 : dependency.reactions = []).push(derived2);
}
}
if (is_disconnected) {
derived2.f ^= DISCONNECTED;
}
if (is_unowned_connected && parent !== null && (parent.f & UNOWNED) === 0) {
derived2.f ^= UNOWNED;
}
}
for (i = 0; i < length; i++) {
dependency = dependencies[i];
if (check_dirtiness(
/** @type {Derived} */
dependency
)) {
update_derived(
/** @type {Derived} */
dependency
);
}
if (dependency.wv > reaction.wv) {
return true;
}
}
}
if (!is_unowned || active_effect !== null && !skip_reaction) {
set_signal_status(reaction, CLEAN);
}
}
return false;
}
function propagate_error(error, effect2) {
var current = effect2;
while (current !== null) {
if ((current.f & BOUNDARY_EFFECT) !== 0) {
try {
current.fn(error);
return;
} catch (e) {
current.f ^= BOUNDARY_EFFECT;
}
}
current = current.parent;
}
is_throwing_error = false;
throw error;
}
function should_rethrow_error(effect2) {
return (effect2.f & DESTROYED) === 0 && (effect2.parent === null || (effect2.parent.f & BOUNDARY_EFFECT) === 0);
}
function handle_error(error, effect2, previous_effect, component_context2) {
if (is_throwing_error) {
if (previous_effect === null) {
is_throwing_error = false;
}
if (should_rethrow_error(effect2)) {
throw error;
}
return;
}
if (previous_effect !== null) {
is_throwing_error = true;
}
{
propagate_error(error, effect2);
return;
}
}
function schedule_possible_effect_self_invalidation(signal, effect2, root2 = true) {
var reactions = signal.reactions;
if (reactions === null) return;
for (var i = 0; i < reactions.length; i++) {
var reaction = reactions[i];
if ((reaction.f & DERIVED) !== 0) {
schedule_possible_effect_self_invalidation(
/** @type {Derived} */
reaction,
effect2,
false
);
} else if (effect2 === reaction) {
if (root2) {
set_signal_status(reaction, DIRTY);
} else if ((reaction.f & CLEAN) !== 0) {
set_signal_status(reaction, MAYBE_DIRTY);
}
schedule_effect(
/** @type {Effect} */
reaction
);
}
}
}
function update_reaction(reaction) {
var _a2, _b2;
var previous_deps = new_deps;
var previous_skipped_deps = skipped_deps;
var previous_untracked_writes = untracked_writes;
var previous_reaction = active_reaction;
var previous_skip_reaction = skip_reaction;
var prev_derived_sources = derived_sources;
var previous_component_context = component_context;
var previous_untracking = untracking;
var flags = reaction.f;
new_deps = /** @type {null | Value[]} */
null;
skipped_deps = 0;
untracked_writes = null;
skip_reaction = (flags & UNOWNED) !== 0 && (untracking || !is_updating_effect || active_reaction === null);
active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null;
derived_sources = null;
set_component_context(reaction.ctx);
untracking = false;
read_version++;
try {
var result = (
/** @type {Function} */
(0, reaction.fn)()
);
var deps = reaction.deps;
if (new_deps !== null) {
var i;
remove_reactions(reaction, skipped_deps);
if (deps !== null && skipped_deps > 0) {
deps.length = skipped_deps + new_deps.length;
for (i = 0; i < new_deps.length; i++) {
deps[skipped_deps + i] = new_deps[i];
}
} else {
reaction.deps = deps = new_deps;
}
if (!skip_reaction) {
for (i = skipped_deps; i < deps.length; i++) {
((_b2 = (_a2 = deps[i]).reactions) != null ? _b2 : _a2.reactions = []).push(reaction);
}
}
} else if (deps !== null && skipped_deps < deps.length) {
remove_reactions(reaction, skipped_deps);
deps.length = skipped_deps;
}
if (is_runes() && untracked_writes !== null && !untracking && deps !== null && (reaction.f & (DERIVED | MAYBE_DIRTY | DIRTY)) === 0) {
for (i = 0; i < /** @type {Source[]} */
untracked_writes.length; i++) {
schedule_possible_effect_self_invalidation(
untracked_writes[i],
/** @type {Effect} */
reaction
);
}
}
if (previous_reaction !== null) {
read_version++;
}
return result;
} finally {
new_deps = previous_deps;
skipped_deps = previous_skipped_deps;
untracked_writes = previous_untracked_writes;
active_reaction = previous_reaction;
skip_reaction = previous_skip_reaction;
derived_sources = prev_derived_sources;
set_component_context(previous_component_context);
untracking = previous_untracking;
}
}
function remove_reaction(signal, dependency) {
let reactions = dependency.reactions;
if (reactions !== null) {
var index = index_of.call(reactions, signal);
if (index !== -1) {
var new_length = reactions.length - 1;
if (new_length === 0) {
reactions = dependency.reactions = null;
} else {
reactions[index] = reactions[new_length];
reactions.pop();
}
}
}
if (reactions === null && (dependency.f & DERIVED) !== 0 && // Destroying a child effect while updating a parent effect can cause a dependency to appear
// to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
// allows us to skip the expensive work of disconnecting and immediately reconnecting it
(new_deps === null || !new_deps.includes(dependency))) {
set_signal_status(dependency, MAYBE_DIRTY);
if ((dependency.f & (UNOWNED | DISCONNECTED)) === 0) {
dependency.f ^= DISCONNECTED;
}
destroy_derived_effects(
/** @type {Derived} **/
dependency
);
remove_reactions(
/** @type {Derived} **/
dependency,
0
);
}
}
function remove_reactions(signal, start_index) {
var dependencies = signal.deps;
if (dependencies === null) return;
for (var i = start_index; i < dependencies.length; i++) {
remove_reaction(signal, dependencies[i]);
}
}
function update_effect(effect2) {
var flags = effect2.f;
if ((flags & DESTROYED) !== 0) {
return;
}
set_signal_status(effect2, CLEAN);
var previous_effect = active_effect;
var previous_component_context = component_context;
var was_updating_effect = is_updating_effect;
active_effect = effect2;
is_updating_effect = true;
try {
if ((flags & BLOCK_EFFECT) !== 0) {
destroy_block_effect_children(effect2);
} else {
destroy_effect_children(effect2);
}
execute_effect_teardown(effect2);
var teardown2 = update_reaction(effect2);
effect2.teardown = typeof teardown2 === "function" ? teardown2 : null;
effect2.wv = write_version;
var deps = effect2.deps;
var dep;
if (DEV && tracing_mode_flag && (effect2.f & DIRTY) !== 0 && deps !== null) ;
if (DEV) ;
} catch (error) {
handle_error(error, effect2, previous_effect, previous_component_context || effect2.ctx);
} finally {
is_updating_effect = was_updating_effect;
active_effect = previous_effect;
}
}
function infinite_loop_guard() {
try {
effect_update_depth_exceeded();
} catch (error) {
if (last_scheduled_effect !== null) {
{
handle_error(error, last_scheduled_effect, null);
}
} else {
throw error;
}
}
}
function flush_queued_root_effects() {
var was_updating_effect = is_updating_effect;
try {
var flush_count = 0;
is_updating_effect = true;
while (queued_root_effects.length > 0) {
if (flush_count++ > 1e3) {
infinite_loop_guard();
}
var root_effects = queued_root_effects;
var length = root_effects.length;
queued_root_effects = [];
for (var i = 0; i < length; i++) {
var collected_effects = process_effects(root_effects[i]);
flush_queued_effects(collected_effects);
}
}
} finally {
is_flushing = false;
is_updating_effect = was_updating_effect;
last_scheduled_effect = null;
old_values.clear();
}
}
function flush_queued_effects(effects) {
var length = effects.length;
if (length === 0) return;
for (var i = 0; i < length; i++) {
var effect2 = effects[i];
if ((effect2.f & (DESTROYED | INERT)) === 0) {
try {
if (check_dirtiness(effect2)) {
update_effect(effect2);
if (effect2.deps === null && effect2.first === null && effect2.nodes_start === null) {
if (effect2.teardown === null) {
unlink_effect(effect2);
} else {
effect2.fn = null;
}
}
}
} catch (error) {
handle_error(error, effect2, null, effect2.ctx);
}
}
}
}
function schedule_effect(signal) {
if (!is_flushing) {
is_flushing = true;
queueMicrotask(flush_queued_root_effects);
}
var effect2 = last_scheduled_effect = signal;
while (effect2.parent !== null) {
effect2 = effect2.parent;
var flags = effect2.f;
if ((flags & (ROOT_EFFECT | BRANCH_EFFECT)) !== 0) {
if ((flags & CLEAN) === 0) return;
effect2.f ^= CLEAN;
}
}
queued_root_effects.push(effect2);
}
function process_effects(root2) {
var effects = [];
var effect2 = root2;
while (effect2 !== null) {
var flags = effect2.f;
var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0;
var is_skippable_branch = is_branch && (flags & CLEAN) !== 0;
if (!is_skippable_branch && (flags & INERT) === 0) {
if ((flags & EFFECT) !== 0) {
effects.push(effect2);
} else if (is_branch) {
effect2.f ^= CLEAN;
} else {
var previous_active_reaction = active_reaction;
try {
active_reaction = effect2;
if (check_dirtiness(effect2)) {
update_effect(effect2);
}
} catch (error) {
handle_error(error, effect2, null, effect2.ctx);
} finally {
active_reaction = previous_active_reaction;
}
}
var child2 = effect2.first;
if (child2 !== null) {
effect2 = child2;
continue;
}
}
var parent = effect2.parent;
effect2 = effect2.next;
while (effect2 === null && parent !== null) {
effect2 = parent.next;
parent = parent.parent;
}
}
return effects;
}
function get(signal) {
var flags = signal.f;
var is_derived = (flags & DERIVED) !== 0;
if (active_reaction !== null && !untracking) {
if (derived_sources !== null && derived_sources.includes(signal)) {
state_unsafe_local_read();
}
var deps = active_reaction.deps;
if (signal.rv < read_version) {
signal.rv = read_version;
if (new_deps === null && deps !== null && deps[skipped_deps] === signal) {
skipped_deps++;
} else if (new_deps === null) {
new_deps = [signal];
} else if (!skip_reaction || !new_deps.includes(signal)) {
new_deps.push(signal);
}
}
} else if (is_derived && /** @type {Derived} */
signal.deps === null && /** @type {Derived} */
signal.effects === null) {
var derived2 = (
/** @type {Derived} */
signal
);
var parent = derived2.parent;
if (parent !== null && (parent.f & UNOWNED) === 0) {
derived2.f ^= UNOWNED;
}
}
if (is_derived) {
derived2 = /** @type {Derived} */
signal;
if (check_dirtiness(derived2)) {
update_derived(derived2);
}
}
if (is_destroying_effect && old_values.has(signal)) {
return old_values.get(signal);
}
return signal.v;
}
function untrack(fn) {
var previous_untracking = untracking;
try {
untracking = true;
return fn();
} finally {
untracking = previous_untracking;
}
}
const STATUS_MASK = -7169;
function set_signal_status(signal, status) {
signal.f = signal.f & STATUS_MASK | status;
}
const PASSIVE_EVENTS = ["touchstart", "touchmove"];
function is_passive_event(name) {
return PASSIVE_EVENTS.includes(name);
}
let listening_to_form_reset = false;
function add_form_reset_listener() {
if (!listening_to_form_reset) {
listening_to_form_reset = true;
document.addEventListener(
"reset",
(evt) => {
Promise.resolve().then(() => {
var _a2;
if (!evt.defaultPrevented) {
for (
const e of
/**@type {HTMLFormElement} */
evt.target.elements
) {
(_a2 = e.__on_r) == null ? void 0 : _a2.call(e);
}
}
});
},
// In the capture phase to guarantee we get noticed of it (no possiblity of stopPropagation)
{ capture: true }
);
}
}
function without_reactive_context(fn) {
var previous_reaction = active_reaction;
var previous_effect = active_effect;
set_active_reaction(null);
set_active_effect(null);
try {
return fn();
} finally {
set_active_reaction(previous_reaction);
set_active_effect(previous_effect);
}
}
function listen_to_event_and_reset_event(element, event, handler, on_reset = handler) {
element.addEventListener(event, () => without_reactive_context(handler));
const prev = element.__on_r;
if (prev) {
element.__on_r = () => {
prev();
on_reset(true);
};
} else {
element.__on_r = () => on_reset(true);
}
add_form_reset_listener();
}
const all_registered_events = /* @__PURE__ */ new Set();
const root_event_handles = /* @__PURE__ */ new Set();
function handle_event_propagation(event) {
var _a2;
var handler_element = this;
var owner_document = (
/** @type {Node} */
handler_element.ownerDocument
);
var event_name = event.type;
var path = ((_a2 = event.composedPath) == null ? void 0 : _a2.call(event)) || [];
var current_target = (
/** @type {null | Element} */
path[0] || event.target
);
var path_idx = 0;
var handled_at = event.__root;
if (handled_at) {
var at_idx = path.indexOf(handled_at);
if (at_idx !== -1 && (handler_element === document || handler_element === /** @type {any} */
window)) {
event.__root = handler_element;
return;
}
var handler_idx = path.indexOf(handler_element);
if (handler_idx === -1) {
return;
}
if (at_idx <= handler_idx) {
path_idx = at_idx;
}
}
current_target = /** @type {Element} */
path[path_idx] || event.target;
if (current_target === handler_element) return;
define_property(event, "currentTarget", {
configurable: true,
get() {
return current_target || owner_document;
}
});
var previous_reaction = active_reaction;
var previous_effect = active_effect;
set_active_reaction(null);
set_active_effect(null);
try {
var throw_error;
var other_errors = [];
while (current_target !== null) {
var parent_element = current_target.assignedSlot || current_target.parentNode || /** @type {any} */
current_target.host || null;
try {
var delegated = current_target["__" + event_name];
if (delegated != null && (!/** @type {any} */
current_target.disabled || // DOM could've been updated already by the time this is reached, so we check this as well
// -> the target could not have been disabled because it emits the event in the first place
event.target === current_target)) {
if (is_array(delegated)) {
var [fn, ...data] = delegated;
fn.apply(current_target, [event, ...data]);
} else {
delegated.call(current_target, event);
}
}
} catch (error) {
if (throw_error) {
other_errors.push(error);
} else {
throw_error = error;
}
}
if (event.cancelBubble || parent_element === handler_element || parent_element === null) {
break;
}
current_target = parent_element;
}
if (throw_error) {
for (let error of other_errors) {
queueMicrotask(() => {
throw error;
});
}
throw throw_error;
}
} finally {
event.__root = handler_element;
delete event.currentTarget;
set_active_reaction(previous_reaction);
set_active_effect(previous_effect);
}
}
function create_fragment_from_html(html) {
var elem = document.createElement("template");
elem.innerHTML = html;
return elem.content;
}
function assign_nodes(start, end) {
var effect2 = (
/** @type {Effect} */
active_effect
);
if (effect2.nodes_start === null) {
effect2.nodes_start = start;
effect2.nodes_end = end;
}
}
// @__NO_SIDE_EFFECTS__
function template(content, flags) {
var is_fragment = (flags & TEMPLATE_FRAGMENT) !== 0;
var use_import_node = (flags & TEMPLATE_USE_IMPORT_NODE) !== 0;
var node;
var has_start = !content.startsWith("<!>");
return () => {
if (node === void 0) {
node = create_fragment_from_html(has_start ? content : "<!>" + content);
if (!is_fragment) node = /** @type {Node} */
/* @__PURE__ */ get_first_child(node);
}
var clone = (
/** @type {TemplateNode} */
use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true)
);
if (is_fragment) {
var start = (
/** @type {TemplateNode} */
/* @__PURE__ */ get_first_child(clone)
);
var end = (
/** @type {TemplateNode} */
clone.lastChild
);
assign_nodes(start, end);
} else {
assign_nodes(clone, clone);
}
return clone;
};
}
function append(anchor, dom) {
if (anchor === null) {
return;
}
anchor.before(
/** @type {Node} */
dom
);
}
function set_text(text, value) {
var _a2;
var str = value == null ? "" : typeof value === "object" ? value + "" : value;
if (str !== ((_a2 = text.__t) != null ? _a2 : text.__t = text.nodeValue)) {
text.__t = str;
text.nodeValue = str + "";
}
}
function mount(component, options) {
return _mount(component, options);
}
const document_listeners = /* @__PURE__ */ new Map();
function _mount(Component, { target, anchor, props = {}, events, context, intro = true }) {
init_operations();
var registered_events = /* @__PURE__ */ new Set();
var event_handle = (events2) => {
for (var i = 0; i < events2.length; i++) {
var event_name = events2[i];
if (registered_events.has(event_name)) continue;
registered_events.add(event_name);
var passive = is_passive_event(event_name);
target.addEventListener(event_name, handle_event_propagation, { passive });
var n = document_listeners.get(event_name);
if (n === void 0) {
document.addEventListener(event_name, handle_event_propagation, { passive });
document_listeners.set(event_name, 1);
} else {
document_listeners.set(event_name, n + 1);
}
}
};
event_handle(array_from(all_registered_events));
root_event_handles.add(event_handle);
var component = void 0;
var unmount = component_root(() => {
var anchor_node = anchor != null ? anchor : target.appendChild(create_text());
branch(() => {
if (context) {
push({});
var ctx = (
/** @type {ComponentContext} */
component_context
);
ctx.c = context;
}
if (events) {
props.$$events = events;
}
component = Component(anchor_node, props) || {};
if (context) {
pop();
}
});
return () => {
var _a2;
for (var event_name of registered_events) {
target.removeEventListener(event_name, handle_event_propagation);
var n = (
/** @type {number} */
document_listeners.get(event_name)
);
if (--n === 0) {
document.removeEventListener(event_name, handle_event_propagation);
document_listeners.delete(event_name);
} else {
document_listeners.set(event_name, n);
}
}
root_event_handles.delete(event_handle);
if (anchor_node !== anchor) {
(_a2 = anchor_node.parentNode) == null ? void 0 : _a2.removeChild(anchor_node);
}
};
});
mounted_components.set(component, unmount);
return component;
}
let mounted_components = /* @__PURE__ */ new WeakMap();
function r(e) {
var t, f, n = "";
if ("string" == typeof e || "number" == typeof e) n += e;
else if ("object" == typeof e) if (Array.isArray(e)) {
var o = e.length;
for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
} else for (f in e) e[f] && (n && (n += " "), n += f);
return n;
}
function clsx$1() {
for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
return n;
}
function clsx(value) {
if (typeof value === "object") {
return clsx$1(value);
} else {
return value != null ? value : "";
}
}
const whitespace = [..." \n\r\f \v\uFEFF"];
function to_class(value, hash, directives) {
var classname = value == null ? "" : "" + value;
if (hash) {
classname = classname ? classname + " " + hash : hash;
}
if (directives) {
for (var key in directives) {
if (directives[key]) {
classname = classname ? classname + " " + key : key;
} else if (classname.length) {
var len = key.length;
var a = 0;
while ((a = classname.indexOf(key, a)) >= 0) {
var b = a + len;
if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
} else {
a = b;
}
}
}
}
}
return classname === "" ? null : classname;
}
function set_class(dom, is_html, value, hash, prev_classes, next_classes) {
var prev = dom.__className;
if (prev !== value) {
var next_class_name = to_class(value, hash, next_classes);
{
if (next_class_name == null) {
dom.removeAttribute("class");
} else {
dom.className = next_class_name;
}
}
dom.__className = value;
} else if (next_classes && prev_classes !== next_classes) {
for (var key in next_classes) {
var is_present = !!next_classes[key];
if (prev_classes == null || is_present !== !!prev_classes[key]) {
dom.classList.toggle(key, is_present);
}
}
}
return next_classes;
}
const IS_CUSTOM_ELEMENT = Symbol("is custom element");
const IS_HTML = Symbol("is html");
function set_attribute(element, attribute, value, skip_warning) {
var attributes = get_attributes(element);
if (attributes[attribute] === (attributes[attribute] = value)) return;
if (attribute === "loading") {
element[LOADING_ATTR_SYMBOL] = value;
}
if (value == null) {
element.removeAttribute(attribute);
} else if (typeof value !== "string" && get_setters(element).includes(attribute)) {
element[attribute] = value;
} else {
element.setAttribute(attribute, value);
}
}
function get_attributes(element) {
var _a2;
return (
/** @type {Record<string | symbol, unknown>} **/
// @ts-expect-error
(_a2 = element.__attributes) != null ? _a2 : element.__attributes = {
[IS_CUSTOM_ELEMENT]: element.nodeName.includes("-"),
[IS_HTML]: element.namespaceURI === NAMESPACE_HTML
}
);
}
var setters_cache = /* @__PURE__ */ new Map();
function get_setters(element) {
var setters = setters_cache.get(element.nodeName);
if (setters) return setters;
setters_cache.set(element.nodeName, setters = []);
var descriptors;
var proto = element;
var element_proto = Element.prototype;
while (element_proto !== proto) {
descriptors = get_descriptors(proto);
for (var key in descriptors) {
if (descriptors[key].set) {
setters.push(key);
}
}
proto = get_prototype_of(proto);
}
return setters;
}
function bind_value(input, get2, set2 = get2) {
var runes = is_runes();
listen_to_event_and_reset_event(input, "input", (is_reset) => {
var value = is_reset ? input.defaultValue : input.value;
value = is_numberlike_input(input) ? to_number(value) : value;
set2(value);
if (runes && value !== (value = get2())) {
var start = input.selectionStart;
var end = input.selectionEnd;
input.value = value != null ? value : "";
if (end !== null) {
input.selectionStart = start;
input.selectionEnd = Math.min(end, input.value.length);
}
}
});
if (
// If we are hydrating and the value has since changed,
// then use the updated value from the input instead.
// If defaultValue is set, then value == defaultValue
// TODO Svelte 6: remove input.value check and set to empty string?
untrack(get2) == null && input.value
) {
set2(is_numberlike_input(input) ? to_number(input.value) : input.value);
}
render_effect(() => {
var value = get2();
if (is_numberlike_input(input) && value === to_number(input.value)) {
return;
}
if (input.type === "date" && !value && !input.value) {
return;
}
if (value !== input.value) {
input.value = value != null ? value : "";
}
});
}
function is_numberlike_input(input) {
var type = input.type;
return type === "number" || type === "range";
}
function to_number(value) {
return value === "" ? null : +value;
}
const PUBLIC_VERSION = "5";
if (typeof window !== "undefined") {
((_c = (_b = (_a = window.__svelte) != null ? _a : window.__svelte = {}).v) != null ? _c : _b.v = /* @__PURE__ */ new Set()).add(PUBLIC_VERSION);
}
enable_legacy_mode_flag();
const oneDiamondCost = 16;
const spurNominal = 1;
const bevelNominal = 8;
const sprocketNominal = 16;
const cogNominal = 64;
const crownNominal = 512;
const sunNominal = 4096;
const coins = {
spur: {
name: "Шпора",
icon: "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAB5QTFRFAAAArlNJlz9B/NSE8pBi1XJZwmJRTxMliDM1YhwwkybagwAAAAp0Uk5TAP///////////36JFFYAAAAzSURBVHicY2SAAkYiGUIM78AMRmMlqQkgBpODM3cBWCRc7xVEJPmPPliEoZKhnXiTwQAAKocIEWy1aOkAAAAASUVORK5CYII="
},
bevel: {
name: "Фаска",
icon: "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAACFQTFRFAAAAVXRpaYl+T2xi/Pz80/zZMFNNITo+t+a/mdepESQnGcI8qAAAAAt0Uk5TAP////////////99dn3VAAAASElEQVR4nGNkgAJGvAwhJSXBmSCGiuF/plUghqmyLlMliOHq+Pn+ChAj1OiTQDmIkfLV5msZiJGqwMyfCWKUMSk9aCNgBQQAABG0DxGAYM3OAAAAAElFTkSuQmCC"
},
sprocket: {
name: "Звездочка",
icon: "iVBORw0KGgoAAAANSUhEUgAAABIAAAASBAMAAACk4JNkAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAABtQTFRFAAAAXV1dW1hYRURE/Pz81dXVNDQ0pqamgICAAZLarAAAAAl0Uk5TAP//////////NwKb1AAAAHJJREFUeJxjZIABRhwsRqW/D8AsIUWhdx/uglgqek/+2/WCWKbvbBc11gJZTAbnzC4YaC1gZGB0Ouwoz/gTyGIKeeC0w+IHiGWoe+2UGUiWwfT3tVjhLpBe9ZgHLPJVIJYxg+s7hllg25iNf13A7RYIAADKMCETREzRzAAAAABJRU5ErkJggg=="
},
cog: {
name: "Шестеренка",
icon: "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAACFQTFRFAAAApWRGl1k8dUUs/Pvy/PbF/OiS+Mpn0J9UXy4ks3dItOn4hwAAAAt0Uk5TAP////////////99dn3VAAAAV0lEQVR4nGNkgAJGrAwhwbtghusDO5aZIEYYgyJjB5DBqOKk+FG8gJGBKURW/R0HiJGqJPiBDchgNgmWY3wOZDCkCwotuAbSVaEg+DMObOBMhnRcdoEBAKSeERHDCr9IAAAAAElFTkSuQmCC"
},
crown: {
name: "Коронка",
icon: "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAB5QTFRFAAAAuW0bsGMR/Prd+vJeoEsL99NJ5q8VdCgC2ZQTcNIm5wAAAAp0Uk5TAP///////////36JFFYAAABrSURBVHicY2SAAkZkhpDAPRCDUZFRXvj3BkYGJhdGg/evQIykfQwht4AMIYN9DJ3/KxgZlP37GJrEMhgZVPyAjGU3GBmUAoAMNqAUa5Iiw8LwBiAjUWdC6UsQI8BkfsKPBpAVHQwVaJaCAQC1vhwRzgHJGAAAAABJRU5ErkJggg=="
},
sun: {
name: "Солнышко",
icon: "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAB5QTFRFAAAAPTExLygoc3BzWVZaJxwdTUdMTEBCEREROzg7i8dWIQAAAAp0Uk5TAP///////////36JFFYAAACISURBVHicY2SAAkYgEhD4/wDIEBQQEhBiWM3IIKz/yeC90GxGBpXAR/tsjrxmZBS02+q9tfkHI6OR7AYG1hRxRkZjx26GRoH3jEwu51+DGYzGMhsYOLjyGJmCf++o6Gj4wcgQfMjmeKZ4BiND2KFAjR/zbzAyhDJbNpYxVAAt5Whg+NEAsh0CADzeJhHT2v5cAAAAAElFTkSuQmCC"
}
};
const diamondIcon = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAIVBMVEUAAAD////V//ah++hK7dks4NggxbUaqqcckZoRcnoUXlN/hNeyAAAAAXRSTlMAQObYZgAAAF1JREFUeNpjwApmzoTQnIJCE8CMiS5GWWABEWNltwVghpCQC4gx0dHFuKwKxHByNm4DM8SMTdpBjEku5eVpXUAGl3taWtkCECM8La0YxGBY4WKcBTaZa9WqBUg2AwByXRcdUQ3W3QAAAABJRU5ErkJggg==";
var root_1$1 = /* @__PURE__ */ template(`<div class="coin svelte-1rrj40a"><input> <img class="icon icon32px svelte-1rrj40a"></div>`);
var root$3 = /* @__PURE__ */ template(`<div class="convert svelte-1rrj40a"><div class="coins svelte-1rrj40a"><!> <!> <!> <!> <!> <!></div> <div class="result svelte-1rrj40a"><span>=</span> <strong> </strong> <div class="diamonds svelte-1rrj40a"> <img alt="Алмазы" class="icon icon24px svelte-1rrj40a"> )</div></div></div>`);
function CurrencyToDiamonds($$anchor, $$props) {
push($$props, true);
let values = proxy({
spur: "",
bevel: "",
sprocket: "",
cog: "",
crown: "",
sun: ""
});
const isValidValue = (value) => Number.isSafeInteger(Number(value));
const numericValues = /* @__PURE__ */ derived(() => Object.fromEntries(Object.entries(values).map(([key, value]) => {
if (isValidValue(value) && Number(value) > 0) return [key, Number(value)];
else return [key, 0];
})));
const sum = /* @__PURE__ */ derived(() => get(numericValues).spur * spurNominal + get(numericValues).bevel * bevelNominal + get(numericValues).sprocket * sprocketNominal + get(numericValues).cog * cogNominal + get(numericValues).crown * crownNominal + get(numericValues).sun * sunNominal);
const diamonds = /* @__PURE__ */ derived(() => Math.round(get(sum) / oneDiamondCost));
var div = root$3();
var div_1 = child(div);
{
const Coin = ($$anchor2, name = noop) => {
var div_2 = root_1$1();
var input = child(div_2);
set_attribute(input, "maxlength", 3);
var img = sibling(input, 2);
template_effect(
($0) => {
set_attribute(div_2, "title", coins[name()].name);
set_class(input, 1, $0, "svelte-1rrj40a");
set_attribute(img, "src", "data:image/png;base64," + coins[name()].icon);
set_attribute(img, "alt", coins[name()].name);
},
[
() => clsx({ invalid: !isValidValue(values[name()]) })
]
);
bind_value(input, () => values[name()], ($$value) => values[name()] = $$value);
append($$anchor2, div_2);
};
var node = child(div_1);
Coin(node, () => "spur");
var node_1 = sibling(node, 2);
Coin(node_1, () => "bevel");
var node_2 = sibling(node_1, 2);
Coin(node_2, () => "sprocket");
var node_3 = sibling(node_2, 2);
Coin(node_3, () => "cog");
var node_4 = sibling(node_3, 2);
Coin(node_4, () => "crown");
var node_5 = sibling(node_4, 2);
Coin(node_5, () => "sun");
}
var div_3 = sibling(div_1, 2);
var strong = sibling(child(div_3), 2);
var text = child(strong);
var div_4 = sibling(strong, 2);
var text_1 = child(div_4);
var img_1 = sibling(text_1);
set_attribute(img_1, "src", diamondIcon);
template_effect(() => {
var _a2;
set_text(text, get(sum));
set_text(text_1, `(~ ${(_a2 = get(diamonds)) != null ? _a2 : ""} `);
});
append($$anchor, div);
pop();
}
var root_1 = /* @__PURE__ */ template(`<div class="coin svelte-1u7m319"><span> </span> <img class="icon icon32px svelte-1u7m319"></div>`);
var root$2 = /* @__PURE__ */ template(`<div class="convert svelte-1u7m319"><div class="input svelte-1u7m319"><div class="diamonds svelte-1u7m319"><input type="text"> <img alt="Алмазы" class="icon icon24px svelte-1u7m319"></div> <span> </span></div> <div class="result"><span>=</span></div> <div class="coins svelte-1u7m319"><!> <!> <!> <!> <!> <!></div></div>`);
function DiamondsToCurrency($$anchor, $$props) {
push($$props, true);
let diamonds = state("");
const sum = /* @__PURE__ */ derived(() => {
if (isValidValue(get(diamonds)) && Number(get(diamonds)) > 0) return Number(get(diamonds)) * oneDiamondCost;
else return 0;
});
const isValidValue = (value) => Number.isSafeInteger(Number(value));
const coinsValues = /* @__PURE__ */ derived(() => {
let coinsSum = get(sum);
const coins2 = {};
coins2.sun = Math.floor(coinsSum / sunNominal);
coinsSum -= coins2.sun * sunNominal;
coins2.crown = Math.floor(coinsSum / crownNominal);
coinsSum -= coins2.crown * crownNominal;
coins2.cog = Math.floor(coinsSum / cogNominal);
coinsSum -= coins2.cog * cogNominal;
coins2.sprocket = Math.floor(coinsSum / sprocketNominal);
coinsSum -= coins2.sprocket * sprocketNominal;
coins2.bevel = Math.floor(coinsSum / bevelNominal);
coinsSum -= coins2.bevel * bevelNominal;
coins2.spur = Math.floor(coinsSum / spurNominal);
return coins2;
});
var div = root$2();
var div_1 = child(div);
var div_2 = child(div_1);
var input = child(div_2);
set_attribute(input, "maxlength", 6);
let classes;
var img = sibling(input, 2);
set_attribute(img, "src", diamondIcon);
var span = sibling(div_2, 2);
var text = child(span);
var div_3 = sibling(div_1, 4);
{
const Coin = ($$anchor2, name = noop) => {
var div_4 = root_1();
var span_1 = child(div_4);
var text_1 = child(span_1);
var img_1 = sibling(span_1, 2);
template_effect(() => {
set_attribute(div_4, "title", coins[name()].name);
set_class(
span_1,
1,
clsx([
"result",
{ bold: get(coinsValues)[name()] > 0 }
]),
"svelte-1u7m319"
);
set_text(text_1, get(coinsValues)[name()]);
set_attribute(img_1, "src", "data:image/png;base64," + coins[name()].icon);
set_attribute(img_1, "alt", coins[name()].name);
});
append($$anchor2, div_4);
};
var node = child(div_3);
Coin(node, () => "spur");
var node_1 = sibling(node, 2);
Coin(node_1, () => "bevel");
var node_2 = sibling(node_1, 2);
Coin(node_2, () => "sprocket");
var node_3 = sibling(node_2, 2);
Coin(node_3, () => "cog");
var node_4 = sibling(node_3, 2);
Coin(node_4, () => "crown");
var node_5 = sibling(node_4, 2);
Coin(node_5, () => "sun");
}
template_effect(
($0) => {
var _a2;
classes = set_class(input, 1, "svelte-1u7m319", null, classes, $0);
set_text(text, `(${(_a2 = get(sum)) != null ? _a2 : ""})`);
},
[
() => ({
invalid: !isValidValue(get(diamonds))
})
]
);
bind_value(input, () => get(diamonds), ($$value) => set(diamonds, $$value));
append($$anchor, div);
pop();
}
var root$1 = /* @__PURE__ */ template(`<!> <!>`, 1);
function App($$anchor) {
var fragment = root$1();
var node = first_child(fragment);
CurrencyToDiamonds(node, {});
var node_1 = sibling(node, 2);
DiamondsToCurrency(node_1, {});
append($$anchor, fragment);
}
const root = document.getElementById("currency-converter-root");
if (root) {
root.innerHTML = "";
}
mount(App, {
target: root
});