서준혁

create frontend template

1 +div.svelte-hpuxjp{text-align:left;box-sizing:border-box;display:block}body{padding:0;margin:0}html{scroll-behavior:smooth}nav.svelte-pxoyop{background-color:rgb(225, 175, 85);font-family:"Helvetica Neue", "Helvetica", "Arial", sans-serif;height:70px;top:0}.inner.svelte-pxoyop{max-width:500px;padding-left:10px;padding-right:10px;margin:auto;box-sizing:border-box;display:flex;align-items:center;height:100%}.logo.svelte-pxoyop{display:flex;position:absolute;width:50px;left:40px;top:25px
2 + }.navbar-list.svelte-pxoyop{display:flex;padding:0;width:100%;justify-content:space-between;margin:0}#backtotop.svelte-16na1oq{border-radius:100%;width:50px;height:50px;position:fixed;right:4%;bottom:10%}.article.svelte-90y9ti.svelte-90y9ti{font-family:맑은고딕, Malgun Gothic, dotum, gulim, sans-serif;font-size:24pt;padding:10vw;text-align:center;display:flex}.wbg.svelte-90y9ti.svelte-90y9ti{background-color:#ffffff}.gbg.svelte-90y9ti.svelte-90y9ti{background-color:#edeff2}.article.svelte-90y9ti img.svelte-90y9ti{display:inline-block;max-width:500px;width:20vw;margin-left:4vw;margin-right:4vw}.article.svelte-90y9ti .text.svelte-90y9ti{display:inline-block;width:50vw}.contents.svelte-90y9ti.svelte-90y9ti{display:flex;align-items:center}li.svelte-1c821dq{list-style-type:none;position:relative}li.svelte-1c821dq:before{content:"";position:absolute;bottom:0;left:0;width:100%;height:1px}a.svelte-1c821dq{color:#e5e6e5;text-decoration:none;display:inline-flex;height:45px;align-items:center;padding:0 10px;font-size:20px}@media only screen and (max-width: 767px){a.svelte-1c821dq{display:none}}.onmouse.svelte-1c821dq{color:#ffffff}#chat_bg.svelte-1177unw{box-sizing:border-box;display:flex;height:100vh;background-color:#edeff2}
...\ No newline at end of file ...\ No newline at end of file
1 +
2 +(function(l, r) { if (!l || l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (self.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.getElementsByTagName('head')[0].appendChild(r) })(self.document);
3 +var app = (function () {
4 + 'use strict';
5 +
6 + function noop() { }
7 + const identity = x => x;
8 + function add_location(element, file, line, column, char) {
9 + element.__svelte_meta = {
10 + loc: { file, line, column, char }
11 + };
12 + }
13 + function run(fn) {
14 + return fn();
15 + }
16 + function blank_object() {
17 + return Object.create(null);
18 + }
19 + function run_all(fns) {
20 + fns.forEach(run);
21 + }
22 + function is_function(thing) {
23 + return typeof thing === 'function';
24 + }
25 + function safe_not_equal(a, b) {
26 + return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
27 + }
28 + let src_url_equal_anchor;
29 + function src_url_equal(element_src, url) {
30 + if (!src_url_equal_anchor) {
31 + src_url_equal_anchor = document.createElement('a');
32 + }
33 + src_url_equal_anchor.href = url;
34 + return element_src === src_url_equal_anchor.href;
35 + }
36 + function is_empty(obj) {
37 + return Object.keys(obj).length === 0;
38 + }
39 +
40 + const is_client = typeof window !== 'undefined';
41 + let now = is_client
42 + ? () => window.performance.now()
43 + : () => Date.now();
44 + let raf = is_client ? cb => requestAnimationFrame(cb) : noop;
45 +
46 + const tasks = new Set();
47 + function run_tasks(now) {
48 + tasks.forEach(task => {
49 + if (!task.c(now)) {
50 + tasks.delete(task);
51 + task.f();
52 + }
53 + });
54 + if (tasks.size !== 0)
55 + raf(run_tasks);
56 + }
57 + /**
58 + * Creates a new task that runs on each raf frame
59 + * until it returns a falsy value or is aborted
60 + */
61 + function loop(callback) {
62 + let task;
63 + if (tasks.size === 0)
64 + raf(run_tasks);
65 + return {
66 + promise: new Promise(fulfill => {
67 + tasks.add(task = { c: callback, f: fulfill });
68 + }),
69 + abort() {
70 + tasks.delete(task);
71 + }
72 + };
73 + }
74 + function append(target, node) {
75 + target.appendChild(node);
76 + }
77 + function get_root_for_style(node) {
78 + if (!node)
79 + return document;
80 + const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
81 + if (root && root.host) {
82 + return root;
83 + }
84 + return node.ownerDocument;
85 + }
86 + function append_empty_stylesheet(node) {
87 + const style_element = element('style');
88 + append_stylesheet(get_root_for_style(node), style_element);
89 + return style_element;
90 + }
91 + function append_stylesheet(node, style) {
92 + append(node.head || node, style);
93 + }
94 + function insert(target, node, anchor) {
95 + target.insertBefore(node, anchor || null);
96 + }
97 + function detach(node) {
98 + node.parentNode.removeChild(node);
99 + }
100 + function destroy_each(iterations, detaching) {
101 + for (let i = 0; i < iterations.length; i += 1) {
102 + if (iterations[i])
103 + iterations[i].d(detaching);
104 + }
105 + }
106 + function element(name) {
107 + return document.createElement(name);
108 + }
109 + function text(data) {
110 + return document.createTextNode(data);
111 + }
112 + function space() {
113 + return text(' ');
114 + }
115 + function empty() {
116 + return text('');
117 + }
118 + function listen(node, event, handler, options) {
119 + node.addEventListener(event, handler, options);
120 + return () => node.removeEventListener(event, handler, options);
121 + }
122 + function attr(node, attribute, value) {
123 + if (value == null)
124 + node.removeAttribute(attribute);
125 + else if (node.getAttribute(attribute) !== value)
126 + node.setAttribute(attribute, value);
127 + }
128 + function children(element) {
129 + return Array.from(element.childNodes);
130 + }
131 + function toggle_class(element, name, toggle) {
132 + element.classList[toggle ? 'add' : 'remove'](name);
133 + }
134 + function custom_event(type, detail, bubbles = false) {
135 + const e = document.createEvent('CustomEvent');
136 + e.initCustomEvent(type, bubbles, false, detail);
137 + return e;
138 + }
139 +
140 + const active_docs = new Set();
141 + let active = 0;
142 + // https://github.com/darkskyapp/string-hash/blob/master/index.js
143 + function hash(str) {
144 + let hash = 5381;
145 + let i = str.length;
146 + while (i--)
147 + hash = ((hash << 5) - hash) ^ str.charCodeAt(i);
148 + return hash >>> 0;
149 + }
150 + function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
151 + const step = 16.666 / duration;
152 + let keyframes = '{\n';
153 + for (let p = 0; p <= 1; p += step) {
154 + const t = a + (b - a) * ease(p);
155 + keyframes += p * 100 + `%{${fn(t, 1 - t)}}\n`;
156 + }
157 + const rule = keyframes + `100% {${fn(b, 1 - b)}}\n}`;
158 + const name = `__svelte_${hash(rule)}_${uid}`;
159 + const doc = get_root_for_style(node);
160 + active_docs.add(doc);
161 + const stylesheet = doc.__svelte_stylesheet || (doc.__svelte_stylesheet = append_empty_stylesheet(node).sheet);
162 + const current_rules = doc.__svelte_rules || (doc.__svelte_rules = {});
163 + if (!current_rules[name]) {
164 + current_rules[name] = true;
165 + stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
166 + }
167 + const animation = node.style.animation || '';
168 + node.style.animation = `${animation ? `${animation}, ` : ''}${name} ${duration}ms linear ${delay}ms 1 both`;
169 + active += 1;
170 + return name;
171 + }
172 + function delete_rule(node, name) {
173 + const previous = (node.style.animation || '').split(', ');
174 + const next = previous.filter(name
175 + ? anim => anim.indexOf(name) < 0 // remove specific animation
176 + : anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations
177 + );
178 + const deleted = previous.length - next.length;
179 + if (deleted) {
180 + node.style.animation = next.join(', ');
181 + active -= deleted;
182 + if (!active)
183 + clear_rules();
184 + }
185 + }
186 + function clear_rules() {
187 + raf(() => {
188 + if (active)
189 + return;
190 + active_docs.forEach(doc => {
191 + const stylesheet = doc.__svelte_stylesheet;
192 + let i = stylesheet.cssRules.length;
193 + while (i--)
194 + stylesheet.deleteRule(i);
195 + doc.__svelte_rules = {};
196 + });
197 + active_docs.clear();
198 + });
199 + }
200 +
201 + let current_component;
202 + function set_current_component(component) {
203 + current_component = component;
204 + }
205 + function get_current_component() {
206 + if (!current_component)
207 + throw new Error('Function called outside component initialization');
208 + return current_component;
209 + }
210 + function onMount(fn) {
211 + get_current_component().$$.on_mount.push(fn);
212 + }
213 + function onDestroy(fn) {
214 + get_current_component().$$.on_destroy.push(fn);
215 + }
216 +
217 + const dirty_components = [];
218 + const binding_callbacks = [];
219 + const render_callbacks = [];
220 + const flush_callbacks = [];
221 + const resolved_promise = Promise.resolve();
222 + let update_scheduled = false;
223 + function schedule_update() {
224 + if (!update_scheduled) {
225 + update_scheduled = true;
226 + resolved_promise.then(flush);
227 + }
228 + }
229 + function add_render_callback(fn) {
230 + render_callbacks.push(fn);
231 + }
232 + let flushing = false;
233 + const seen_callbacks = new Set();
234 + function flush() {
235 + if (flushing)
236 + return;
237 + flushing = true;
238 + do {
239 + // first, call beforeUpdate functions
240 + // and update components
241 + for (let i = 0; i < dirty_components.length; i += 1) {
242 + const component = dirty_components[i];
243 + set_current_component(component);
244 + update(component.$$);
245 + }
246 + set_current_component(null);
247 + dirty_components.length = 0;
248 + while (binding_callbacks.length)
249 + binding_callbacks.pop()();
250 + // then, once components are updated, call
251 + // afterUpdate functions. This may cause
252 + // subsequent updates...
253 + for (let i = 0; i < render_callbacks.length; i += 1) {
254 + const callback = render_callbacks[i];
255 + if (!seen_callbacks.has(callback)) {
256 + // ...so guard against infinite loops
257 + seen_callbacks.add(callback);
258 + callback();
259 + }
260 + }
261 + render_callbacks.length = 0;
262 + } while (dirty_components.length);
263 + while (flush_callbacks.length) {
264 + flush_callbacks.pop()();
265 + }
266 + update_scheduled = false;
267 + flushing = false;
268 + seen_callbacks.clear();
269 + }
270 + function update($$) {
271 + if ($$.fragment !== null) {
272 + $$.update();
273 + run_all($$.before_update);
274 + const dirty = $$.dirty;
275 + $$.dirty = [-1];
276 + $$.fragment && $$.fragment.p($$.ctx, dirty);
277 + $$.after_update.forEach(add_render_callback);
278 + }
279 + }
280 +
281 + let promise;
282 + function wait() {
283 + if (!promise) {
284 + promise = Promise.resolve();
285 + promise.then(() => {
286 + promise = null;
287 + });
288 + }
289 + return promise;
290 + }
291 + function dispatch(node, direction, kind) {
292 + node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));
293 + }
294 + const outroing = new Set();
295 + let outros;
296 + function group_outros() {
297 + outros = {
298 + r: 0,
299 + c: [],
300 + p: outros // parent group
301 + };
302 + }
303 + function check_outros() {
304 + if (!outros.r) {
305 + run_all(outros.c);
306 + }
307 + outros = outros.p;
308 + }
309 + function transition_in(block, local) {
310 + if (block && block.i) {
311 + outroing.delete(block);
312 + block.i(local);
313 + }
314 + }
315 + function transition_out(block, local, detach, callback) {
316 + if (block && block.o) {
317 + if (outroing.has(block))
318 + return;
319 + outroing.add(block);
320 + outros.c.push(() => {
321 + outroing.delete(block);
322 + if (callback) {
323 + if (detach)
324 + block.d(1);
325 + callback();
326 + }
327 + });
328 + block.o(local);
329 + }
330 + }
331 + const null_transition = { duration: 0 };
332 + function create_bidirectional_transition(node, fn, params, intro) {
333 + let config = fn(node, params);
334 + let t = intro ? 0 : 1;
335 + let running_program = null;
336 + let pending_program = null;
337 + let animation_name = null;
338 + function clear_animation() {
339 + if (animation_name)
340 + delete_rule(node, animation_name);
341 + }
342 + function init(program, duration) {
343 + const d = (program.b - t);
344 + duration *= Math.abs(d);
345 + return {
346 + a: t,
347 + b: program.b,
348 + d,
349 + duration,
350 + start: program.start,
351 + end: program.start + duration,
352 + group: program.group
353 + };
354 + }
355 + function go(b) {
356 + const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
357 + const program = {
358 + start: now() + delay,
359 + b
360 + };
361 + if (!b) {
362 + // @ts-ignore todo: improve typings
363 + program.group = outros;
364 + outros.r += 1;
365 + }
366 + if (running_program || pending_program) {
367 + pending_program = program;
368 + }
369 + else {
370 + // if this is an intro, and there's a delay, we need to do
371 + // an initial tick and/or apply CSS animation immediately
372 + if (css) {
373 + clear_animation();
374 + animation_name = create_rule(node, t, b, duration, delay, easing, css);
375 + }
376 + if (b)
377 + tick(0, 1);
378 + running_program = init(program, duration);
379 + add_render_callback(() => dispatch(node, b, 'start'));
380 + loop(now => {
381 + if (pending_program && now > pending_program.start) {
382 + running_program = init(pending_program, duration);
383 + pending_program = null;
384 + dispatch(node, running_program.b, 'start');
385 + if (css) {
386 + clear_animation();
387 + animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
388 + }
389 + }
390 + if (running_program) {
391 + if (now >= running_program.end) {
392 + tick(t = running_program.b, 1 - t);
393 + dispatch(node, running_program.b, 'end');
394 + if (!pending_program) {
395 + // we're done
396 + if (running_program.b) {
397 + // intro — we can tidy up immediately
398 + clear_animation();
399 + }
400 + else {
401 + // outro — needs to be coordinated
402 + if (!--running_program.group.r)
403 + run_all(running_program.group.c);
404 + }
405 + }
406 + running_program = null;
407 + }
408 + else if (now >= running_program.start) {
409 + const p = now - running_program.start;
410 + t = running_program.a + running_program.d * easing(p / running_program.duration);
411 + tick(t, 1 - t);
412 + }
413 + }
414 + return !!(running_program || pending_program);
415 + });
416 + }
417 + }
418 + return {
419 + run(b) {
420 + if (is_function(config)) {
421 + wait().then(() => {
422 + // @ts-ignore
423 + config = config();
424 + go(b);
425 + });
426 + }
427 + else {
428 + go(b);
429 + }
430 + },
431 + end() {
432 + clear_animation();
433 + running_program = pending_program = null;
434 + }
435 + };
436 + }
437 + function create_component(block) {
438 + block && block.c();
439 + }
440 + function mount_component(component, target, anchor, customElement) {
441 + const { fragment, on_mount, on_destroy, after_update } = component.$$;
442 + fragment && fragment.m(target, anchor);
443 + if (!customElement) {
444 + // onMount happens before the initial afterUpdate
445 + add_render_callback(() => {
446 + const new_on_destroy = on_mount.map(run).filter(is_function);
447 + if (on_destroy) {
448 + on_destroy.push(...new_on_destroy);
449 + }
450 + else {
451 + // Edge case - component was destroyed immediately,
452 + // most likely as a result of a binding initialising
453 + run_all(new_on_destroy);
454 + }
455 + component.$$.on_mount = [];
456 + });
457 + }
458 + after_update.forEach(add_render_callback);
459 + }
460 + function destroy_component(component, detaching) {
461 + const $$ = component.$$;
462 + if ($$.fragment !== null) {
463 + run_all($$.on_destroy);
464 + $$.fragment && $$.fragment.d(detaching);
465 + // TODO null out other refs, including component.$$ (but need to
466 + // preserve final state?)
467 + $$.on_destroy = $$.fragment = null;
468 + $$.ctx = [];
469 + }
470 + }
471 + function make_dirty(component, i) {
472 + if (component.$$.dirty[0] === -1) {
473 + dirty_components.push(component);
474 + schedule_update();
475 + component.$$.dirty.fill(0);
476 + }
477 + component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
478 + }
479 + function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
480 + const parent_component = current_component;
481 + set_current_component(component);
482 + const $$ = component.$$ = {
483 + fragment: null,
484 + ctx: null,
485 + // state
486 + props,
487 + update: noop,
488 + not_equal,
489 + bound: blank_object(),
490 + // lifecycle
491 + on_mount: [],
492 + on_destroy: [],
493 + on_disconnect: [],
494 + before_update: [],
495 + after_update: [],
496 + context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
497 + // everything else
498 + callbacks: blank_object(),
499 + dirty,
500 + skip_bound: false,
501 + root: options.target || parent_component.$$.root
502 + };
503 + append_styles && append_styles($$.root);
504 + let ready = false;
505 + $$.ctx = instance
506 + ? instance(component, options.props || {}, (i, ret, ...rest) => {
507 + const value = rest.length ? rest[0] : ret;
508 + if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
509 + if (!$$.skip_bound && $$.bound[i])
510 + $$.bound[i](value);
511 + if (ready)
512 + make_dirty(component, i);
513 + }
514 + return ret;
515 + })
516 + : [];
517 + $$.update();
518 + ready = true;
519 + run_all($$.before_update);
520 + // `false` as a special case of no DOM component
521 + $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
522 + if (options.target) {
523 + if (options.hydrate) {
524 + const nodes = children(options.target);
525 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
526 + $$.fragment && $$.fragment.l(nodes);
527 + nodes.forEach(detach);
528 + }
529 + else {
530 + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
531 + $$.fragment && $$.fragment.c();
532 + }
533 + if (options.intro)
534 + transition_in(component.$$.fragment);
535 + mount_component(component, options.target, options.anchor, options.customElement);
536 + flush();
537 + }
538 + set_current_component(parent_component);
539 + }
540 + /**
541 + * Base class for Svelte components. Used when dev=false.
542 + */
543 + class SvelteComponent {
544 + $destroy() {
545 + destroy_component(this, 1);
546 + this.$destroy = noop;
547 + }
548 + $on(type, callback) {
549 + const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
550 + callbacks.push(callback);
551 + return () => {
552 + const index = callbacks.indexOf(callback);
553 + if (index !== -1)
554 + callbacks.splice(index, 1);
555 + };
556 + }
557 + $set($$props) {
558 + if (this.$$set && !is_empty($$props)) {
559 + this.$$.skip_bound = true;
560 + this.$$set($$props);
561 + this.$$.skip_bound = false;
562 + }
563 + }
564 + }
565 +
566 + function dispatch_dev(type, detail) {
567 + document.dispatchEvent(custom_event(type, Object.assign({ version: '3.44.1' }, detail), true));
568 + }
569 + function append_dev(target, node) {
570 + dispatch_dev('SvelteDOMInsert', { target, node });
571 + append(target, node);
572 + }
573 + function insert_dev(target, node, anchor) {
574 + dispatch_dev('SvelteDOMInsert', { target, node, anchor });
575 + insert(target, node, anchor);
576 + }
577 + function detach_dev(node) {
578 + dispatch_dev('SvelteDOMRemove', { node });
579 + detach(node);
580 + }
581 + function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
582 + const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
583 + if (has_prevent_default)
584 + modifiers.push('preventDefault');
585 + if (has_stop_propagation)
586 + modifiers.push('stopPropagation');
587 + dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
588 + const dispose = listen(node, event, handler, options);
589 + return () => {
590 + dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
591 + dispose();
592 + };
593 + }
594 + function attr_dev(node, attribute, value) {
595 + attr(node, attribute, value);
596 + if (value == null)
597 + dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
598 + else
599 + dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
600 + }
601 + function set_data_dev(text, data) {
602 + data = '' + data;
603 + if (text.wholeText === data)
604 + return;
605 + dispatch_dev('SvelteDOMSetData', { node: text, data });
606 + text.data = data;
607 + }
608 + function validate_each_argument(arg) {
609 + if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
610 + let msg = '{#each} only iterates over array-like objects.';
611 + if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
612 + msg += ' You can use a spread to convert this iterable into an array.';
613 + }
614 + throw new Error(msg);
615 + }
616 + }
617 + function validate_slots(name, slot, keys) {
618 + for (const slot_key of Object.keys(slot)) {
619 + if (!~keys.indexOf(slot_key)) {
620 + console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
621 + }
622 + }
623 + }
624 + /**
625 + * Base class for Svelte components with some minor dev-enhancements. Used when dev=true.
626 + */
627 + class SvelteComponentDev extends SvelteComponent {
628 + constructor(options) {
629 + if (!options || (!options.target && !options.$$inline)) {
630 + throw new Error("'target' is a required option");
631 + }
632 + super();
633 + }
634 + $destroy() {
635 + super.$destroy();
636 + this.$destroy = () => {
637 + console.warn('Component was already destroyed'); // eslint-disable-line no-console
638 + };
639 + }
640 + $capture_state() { }
641 + $inject_state() { }
642 + }
643 +
644 + /* src\Menuitems.svelte generated by Svelte v3.44.1 */
645 +
646 + const file$5 = "src\\Menuitems.svelte";
647 +
648 + function create_fragment$5(ctx) {
649 + let li;
650 + let a;
651 + let t_value = /*item*/ ctx[0].label + "";
652 + let t;
653 + let a_href_value;
654 + let mounted;
655 + let dispose;
656 +
657 + const block = {
658 + c: function create() {
659 + li = element("li");
660 + a = element("a");
661 + t = text(t_value);
662 + attr_dev(a, "href", a_href_value = /*item*/ ctx[0].href);
663 + attr_dev(a, "class", "svelte-1c821dq");
664 + toggle_class(a, "onmouse", /*onmouse*/ ctx[1]);
665 + add_location(a, file$5, 50, 4, 724);
666 + attr_dev(li, "class", "svelte-1c821dq");
667 + add_location(li, file$5, 49, 0, 669);
668 + },
669 + l: function claim(nodes) {
670 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
671 + },
672 + m: function mount(target, anchor) {
673 + insert_dev(target, li, anchor);
674 + append_dev(li, a);
675 + append_dev(a, t);
676 +
677 + if (!mounted) {
678 + dispose = [
679 + listen_dev(li, "mouseenter", /*enter*/ ctx[2], false, false, false),
680 + listen_dev(li, "mouseleave", /*leave*/ ctx[3], false, false, false)
681 + ];
682 +
683 + mounted = true;
684 + }
685 + },
686 + p: function update(ctx, [dirty]) {
687 + if (dirty & /*item*/ 1 && t_value !== (t_value = /*item*/ ctx[0].label + "")) set_data_dev(t, t_value);
688 +
689 + if (dirty & /*item*/ 1 && a_href_value !== (a_href_value = /*item*/ ctx[0].href)) {
690 + attr_dev(a, "href", a_href_value);
691 + }
692 +
693 + if (dirty & /*onmouse*/ 2) {
694 + toggle_class(a, "onmouse", /*onmouse*/ ctx[1]);
695 + }
696 + },
697 + i: noop,
698 + o: noop,
699 + d: function destroy(detaching) {
700 + if (detaching) detach_dev(li);
701 + mounted = false;
702 + run_all(dispose);
703 + }
704 + };
705 +
706 + dispatch_dev("SvelteRegisterBlock", {
707 + block,
708 + id: create_fragment$5.name,
709 + type: "component",
710 + source: "",
711 + ctx
712 + });
713 +
714 + return block;
715 + }
716 +
717 + function instance$5($$self, $$props, $$invalidate) {
718 + let { $$slots: slots = {}, $$scope } = $$props;
719 + validate_slots('Menuitems', slots, []);
720 + let { item } = $$props;
721 + let onmouse;
722 +
723 + function enter() {
724 + $$invalidate(1, onmouse = true);
725 + }
726 +
727 + function leave() {
728 + $$invalidate(1, onmouse = false);
729 + }
730 +
731 + const writable_props = ['item'];
732 +
733 + Object.keys($$props).forEach(key => {
734 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Menuitems> was created with unknown prop '${key}'`);
735 + });
736 +
737 + $$self.$$set = $$props => {
738 + if ('item' in $$props) $$invalidate(0, item = $$props.item);
739 + };
740 +
741 + $$self.$capture_state = () => ({ item, onmouse, enter, leave });
742 +
743 + $$self.$inject_state = $$props => {
744 + if ('item' in $$props) $$invalidate(0, item = $$props.item);
745 + if ('onmouse' in $$props) $$invalidate(1, onmouse = $$props.onmouse);
746 + };
747 +
748 + if ($$props && "$$inject" in $$props) {
749 + $$self.$inject_state($$props.$$inject);
750 + }
751 +
752 + return [item, onmouse, enter, leave];
753 + }
754 +
755 + class Menuitems extends SvelteComponentDev {
756 + constructor(options) {
757 + super(options);
758 + init(this, options, instance$5, create_fragment$5, safe_not_equal, { item: 0 });
759 +
760 + dispatch_dev("SvelteRegisterComponent", {
761 + component: this,
762 + tagName: "Menuitems",
763 + options,
764 + id: create_fragment$5.name
765 + });
766 +
767 + const { ctx } = this.$$;
768 + const props = options.props || {};
769 +
770 + if (/*item*/ ctx[0] === undefined && !('item' in props)) {
771 + console.warn("<Menuitems> was created without expected prop 'item'");
772 + }
773 + }
774 +
775 + get item() {
776 + throw new Error("<Menuitems>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
777 + }
778 +
779 + set item(value) {
780 + throw new Error("<Menuitems>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
781 + }
782 + }
783 +
784 + /* src\Menu.svelte generated by Svelte v3.44.1 */
785 + const file$4 = "src\\Menu.svelte";
786 +
787 + function get_each_context(ctx, list, i) {
788 + const child_ctx = ctx.slice();
789 + child_ctx[1] = list[i];
790 + return child_ctx;
791 + }
792 +
793 + // (53:8) {#each navItems as item}
794 + function create_each_block(ctx) {
795 + let menuitems;
796 + let current;
797 +
798 + menuitems = new Menuitems({
799 + props: { item: /*item*/ ctx[1] },
800 + $$inline: true
801 + });
802 +
803 + const block = {
804 + c: function create() {
805 + create_component(menuitems.$$.fragment);
806 + },
807 + m: function mount(target, anchor) {
808 + mount_component(menuitems, target, anchor);
809 + current = true;
810 + },
811 + p: noop,
812 + i: function intro(local) {
813 + if (current) return;
814 + transition_in(menuitems.$$.fragment, local);
815 + current = true;
816 + },
817 + o: function outro(local) {
818 + transition_out(menuitems.$$.fragment, local);
819 + current = false;
820 + },
821 + d: function destroy(detaching) {
822 + destroy_component(menuitems, detaching);
823 + }
824 + };
825 +
826 + dispatch_dev("SvelteRegisterBlock", {
827 + block,
828 + id: create_each_block.name,
829 + type: "each",
830 + source: "(53:8) {#each navItems as item}",
831 + ctx
832 + });
833 +
834 + return block;
835 + }
836 +
837 + function create_fragment$4(ctx) {
838 + let nav;
839 + let div0;
840 + let t1;
841 + let div1;
842 + let ul;
843 + let current;
844 + let each_value = /*navItems*/ ctx[0];
845 + validate_each_argument(each_value);
846 + let each_blocks = [];
847 +
848 + for (let i = 0; i < each_value.length; i += 1) {
849 + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
850 + }
851 +
852 + const out = i => transition_out(each_blocks[i], 1, 1, () => {
853 + each_blocks[i] = null;
854 + });
855 +
856 + const block = {
857 + c: function create() {
858 + nav = element("nav");
859 + div0 = element("div");
860 + div0.textContent = "Logo";
861 + t1 = space();
862 + div1 = element("div");
863 + ul = element("ul");
864 +
865 + for (let i = 0; i < each_blocks.length; i += 1) {
866 + each_blocks[i].c();
867 + }
868 +
869 + attr_dev(div0, "class", "logo svelte-pxoyop");
870 + add_location(div0, file$4, 49, 1, 909);
871 + attr_dev(ul, "class", "navbar-list svelte-pxoyop");
872 + add_location(ul, file$4, 51, 8, 969);
873 + attr_dev(div1, "class", "inner svelte-pxoyop");
874 + add_location(div1, file$4, 50, 1, 940);
875 + attr_dev(nav, "class", "svelte-pxoyop");
876 + add_location(nav, file$4, 48, 0, 901);
877 + },
878 + l: function claim(nodes) {
879 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
880 + },
881 + m: function mount(target, anchor) {
882 + insert_dev(target, nav, anchor);
883 + append_dev(nav, div0);
884 + append_dev(nav, t1);
885 + append_dev(nav, div1);
886 + append_dev(div1, ul);
887 +
888 + for (let i = 0; i < each_blocks.length; i += 1) {
889 + each_blocks[i].m(ul, null);
890 + }
891 +
892 + current = true;
893 + },
894 + p: function update(ctx, [dirty]) {
895 + if (dirty & /*navItems*/ 1) {
896 + each_value = /*navItems*/ ctx[0];
897 + validate_each_argument(each_value);
898 + let i;
899 +
900 + for (i = 0; i < each_value.length; i += 1) {
901 + const child_ctx = get_each_context(ctx, each_value, i);
902 +
903 + if (each_blocks[i]) {
904 + each_blocks[i].p(child_ctx, dirty);
905 + transition_in(each_blocks[i], 1);
906 + } else {
907 + each_blocks[i] = create_each_block(child_ctx);
908 + each_blocks[i].c();
909 + transition_in(each_blocks[i], 1);
910 + each_blocks[i].m(ul, null);
911 + }
912 + }
913 +
914 + group_outros();
915 +
916 + for (i = each_value.length; i < each_blocks.length; i += 1) {
917 + out(i);
918 + }
919 +
920 + check_outros();
921 + }
922 + },
923 + i: function intro(local) {
924 + if (current) return;
925 +
926 + for (let i = 0; i < each_value.length; i += 1) {
927 + transition_in(each_blocks[i]);
928 + }
929 +
930 + current = true;
931 + },
932 + o: function outro(local) {
933 + each_blocks = each_blocks.filter(Boolean);
934 +
935 + for (let i = 0; i < each_blocks.length; i += 1) {
936 + transition_out(each_blocks[i]);
937 + }
938 +
939 + current = false;
940 + },
941 + d: function destroy(detaching) {
942 + if (detaching) detach_dev(nav);
943 + destroy_each(each_blocks, detaching);
944 + }
945 + };
946 +
947 + dispatch_dev("SvelteRegisterBlock", {
948 + block,
949 + id: create_fragment$4.name,
950 + type: "component",
951 + source: "",
952 + ctx
953 + });
954 +
955 + return block;
956 + }
957 +
958 + function instance$4($$self, $$props, $$invalidate) {
959 + let { $$slots: slots = {}, $$scope } = $$props;
960 + validate_slots('Menu', slots, []);
961 +
962 + const navItems = [
963 + { label: "Article1", href: "#article1" },
964 + { label: "Article2", href: "#article2" },
965 + { label: "Article3", href: "#article3" },
966 + { label: "Article4", href: "#article4" }
967 + ];
968 +
969 + const writable_props = [];
970 +
971 + Object.keys($$props).forEach(key => {
972 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Menu> was created with unknown prop '${key}'`);
973 + });
974 +
975 + $$self.$capture_state = () => ({ Menuitems, navItems });
976 + return [navItems];
977 + }
978 +
979 + class Menu extends SvelteComponentDev {
980 + constructor(options) {
981 + super(options);
982 + init(this, options, instance$4, create_fragment$4, safe_not_equal, {});
983 +
984 + dispatch_dev("SvelteRegisterComponent", {
985 + component: this,
986 + tagName: "Menu",
987 + options,
988 + id: create_fragment$4.name
989 + });
990 + }
991 + }
992 +
993 + function cubicOut(t) {
994 + const f = t - 1.0;
995 + return f * f * f + 1.0;
996 + }
997 +
998 + function fly(node, { delay = 0, duration = 400, easing = cubicOut, x = 0, y = 0, opacity = 0 } = {}) {
999 + const style = getComputedStyle(node);
1000 + const target_opacity = +style.opacity;
1001 + const transform = style.transform === 'none' ? '' : style.transform;
1002 + const od = target_opacity * (1 - opacity);
1003 + return {
1004 + delay,
1005 + duration,
1006 + easing,
1007 + css: (t, u) => `
1008 + transform: ${transform} translate(${(1 - t) * x}px, ${(1 - t) * y}px);
1009 + opacity: ${target_opacity - (od * u)}`
1010 + };
1011 + }
1012 +
1013 + /* src\Backtotop.svelte generated by Svelte v3.44.1 */
1014 + const file$3 = "src\\Backtotop.svelte";
1015 +
1016 + // (37:0) {#if (show)}
1017 + function create_if_block(ctx) {
1018 + let button;
1019 + let button_transition;
1020 + let current;
1021 + let mounted;
1022 + let dispose;
1023 +
1024 + const block = {
1025 + c: function create() {
1026 + button = element("button");
1027 + button.textContent = "▲";
1028 + attr_dev(button, "id", "backtotop");
1029 + attr_dev(button, "class", "svelte-16na1oq");
1030 + add_location(button, file$3, 37, 4, 730);
1031 + },
1032 + m: function mount(target, anchor) {
1033 + insert_dev(target, button, anchor);
1034 + current = true;
1035 +
1036 + if (!mounted) {
1037 + dispose = listen_dev(button, "click", scrollUp, false, false, false);
1038 + mounted = true;
1039 + }
1040 + },
1041 + p: noop,
1042 + i: function intro(local) {
1043 + if (current) return;
1044 +
1045 + add_render_callback(() => {
1046 + if (!button_transition) button_transition = create_bidirectional_transition(button, fly, { y: 200, duration: 400 }, true);
1047 + button_transition.run(1);
1048 + });
1049 +
1050 + current = true;
1051 + },
1052 + o: function outro(local) {
1053 + if (!button_transition) button_transition = create_bidirectional_transition(button, fly, { y: 200, duration: 400 }, false);
1054 + button_transition.run(0);
1055 + current = false;
1056 + },
1057 + d: function destroy(detaching) {
1058 + if (detaching) detach_dev(button);
1059 + if (detaching && button_transition) button_transition.end();
1060 + mounted = false;
1061 + dispose();
1062 + }
1063 + };
1064 +
1065 + dispatch_dev("SvelteRegisterBlock", {
1066 + block,
1067 + id: create_if_block.name,
1068 + type: "if",
1069 + source: "(37:0) {#if (show)}",
1070 + ctx
1071 + });
1072 +
1073 + return block;
1074 + }
1075 +
1076 + function create_fragment$3(ctx) {
1077 + let if_block_anchor;
1078 + let current;
1079 + let if_block = /*show*/ ctx[0] && create_if_block(ctx);
1080 +
1081 + const block = {
1082 + c: function create() {
1083 + if (if_block) if_block.c();
1084 + if_block_anchor = empty();
1085 + },
1086 + l: function claim(nodes) {
1087 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
1088 + },
1089 + m: function mount(target, anchor) {
1090 + if (if_block) if_block.m(target, anchor);
1091 + insert_dev(target, if_block_anchor, anchor);
1092 + current = true;
1093 + },
1094 + p: function update(ctx, [dirty]) {
1095 + if (/*show*/ ctx[0]) {
1096 + if (if_block) {
1097 + if_block.p(ctx, dirty);
1098 +
1099 + if (dirty & /*show*/ 1) {
1100 + transition_in(if_block, 1);
1101 + }
1102 + } else {
1103 + if_block = create_if_block(ctx);
1104 + if_block.c();
1105 + transition_in(if_block, 1);
1106 + if_block.m(if_block_anchor.parentNode, if_block_anchor);
1107 + }
1108 + } else if (if_block) {
1109 + group_outros();
1110 +
1111 + transition_out(if_block, 1, 1, () => {
1112 + if_block = null;
1113 + });
1114 +
1115 + check_outros();
1116 + }
1117 + },
1118 + i: function intro(local) {
1119 + if (current) return;
1120 + transition_in(if_block);
1121 + current = true;
1122 + },
1123 + o: function outro(local) {
1124 + transition_out(if_block);
1125 + current = false;
1126 + },
1127 + d: function destroy(detaching) {
1128 + if (if_block) if_block.d(detaching);
1129 + if (detaching) detach_dev(if_block_anchor);
1130 + }
1131 + };
1132 +
1133 + dispatch_dev("SvelteRegisterBlock", {
1134 + block,
1135 + id: create_fragment$3.name,
1136 + type: "component",
1137 + source: "",
1138 + ctx
1139 + });
1140 +
1141 + return block;
1142 + }
1143 +
1144 + function scrollUp() {
1145 + document.body.scrollIntoView({ behavior: "smooth" });
1146 + }
1147 +
1148 + function instance$3($$self, $$props, $$invalidate) {
1149 + let { $$slots: slots = {}, $$scope } = $$props;
1150 + validate_slots('Backtotop', slots, []);
1151 + let show = false;
1152 +
1153 + onMount(() => {
1154 + window.onscroll = () => {
1155 + if (window.scrollY > 60) {
1156 + $$invalidate(0, show = true);
1157 + } else {
1158 + $$invalidate(0, show = false);
1159 + }
1160 + };
1161 + });
1162 +
1163 + onDestroy(() => {
1164 + window.onscroll = () => {
1165 +
1166 + };
1167 + });
1168 +
1169 + const writable_props = [];
1170 +
1171 + Object.keys($$props).forEach(key => {
1172 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Backtotop> was created with unknown prop '${key}'`);
1173 + });
1174 +
1175 + $$self.$capture_state = () => ({ fly, onMount, onDestroy, show, scrollUp });
1176 +
1177 + $$self.$inject_state = $$props => {
1178 + if ('show' in $$props) $$invalidate(0, show = $$props.show);
1179 + };
1180 +
1181 + if ($$props && "$$inject" in $$props) {
1182 + $$self.$inject_state($$props.$$inject);
1183 + }
1184 +
1185 + return [show];
1186 + }
1187 +
1188 + class Backtotop extends SvelteComponentDev {
1189 + constructor(options) {
1190 + super(options);
1191 + init(this, options, instance$3, create_fragment$3, safe_not_equal, {});
1192 +
1193 + dispatch_dev("SvelteRegisterComponent", {
1194 + component: this,
1195 + tagName: "Backtotop",
1196 + options,
1197 + id: create_fragment$3.name
1198 + });
1199 + }
1200 + }
1201 +
1202 + /* src\Map.svelte generated by Svelte v3.44.1 */
1203 +
1204 + const file$2 = "src\\Map.svelte";
1205 +
1206 + function create_fragment$2(ctx) {
1207 + let div;
1208 +
1209 + const block = {
1210 + c: function create() {
1211 + div = element("div");
1212 + attr_dev(div, "id", "chat_bg");
1213 + attr_dev(div, "class", "svelte-1177unw");
1214 + add_location(div, file$2, 13, 0, 156);
1215 + },
1216 + l: function claim(nodes) {
1217 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
1218 + },
1219 + m: function mount(target, anchor) {
1220 + insert_dev(target, div, anchor);
1221 + },
1222 + p: noop,
1223 + i: noop,
1224 + o: noop,
1225 + d: function destroy(detaching) {
1226 + if (detaching) detach_dev(div);
1227 + }
1228 + };
1229 +
1230 + dispatch_dev("SvelteRegisterBlock", {
1231 + block,
1232 + id: create_fragment$2.name,
1233 + type: "component",
1234 + source: "",
1235 + ctx
1236 + });
1237 +
1238 + return block;
1239 + }
1240 +
1241 + function instance$2($$self, $$props) {
1242 + let { $$slots: slots = {}, $$scope } = $$props;
1243 + validate_slots('Map', slots, []);
1244 + const writable_props = [];
1245 +
1246 + Object.keys($$props).forEach(key => {
1247 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Map> was created with unknown prop '${key}'`);
1248 + });
1249 +
1250 + return [];
1251 + }
1252 +
1253 + class Map$1 extends SvelteComponentDev {
1254 + constructor(options) {
1255 + super(options);
1256 + init(this, options, instance$2, create_fragment$2, safe_not_equal, {});
1257 +
1258 + dispatch_dev("SvelteRegisterComponent", {
1259 + component: this,
1260 + tagName: "Map",
1261 + options,
1262 + id: create_fragment$2.name
1263 + });
1264 + }
1265 + }
1266 +
1267 + /* src\Articles.svelte generated by Svelte v3.44.1 */
1268 +
1269 + const file$1 = "src\\Articles.svelte";
1270 +
1271 + function create_fragment$1(ctx) {
1272 + let div2;
1273 + let div1;
1274 + let img0;
1275 + let img0_src_value;
1276 + let t0;
1277 + let div0;
1278 + let t2;
1279 + let div5;
1280 + let div4;
1281 + let div3;
1282 + let t4;
1283 + let img1;
1284 + let img1_src_value;
1285 + let t5;
1286 + let div8;
1287 + let div7;
1288 + let img2;
1289 + let img2_src_value;
1290 + let t6;
1291 + let div6;
1292 + let t8;
1293 + let div11;
1294 + let div10;
1295 + let div9;
1296 + let t10;
1297 + let img3;
1298 + let img3_src_value;
1299 +
1300 + const block = {
1301 + c: function create() {
1302 + div2 = element("div");
1303 + div1 = element("div");
1304 + img0 = element("img");
1305 + t0 = space();
1306 + div0 = element("div");
1307 + div0.textContent = "ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ\r\n ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ";
1308 + t2 = space();
1309 + div5 = element("div");
1310 + div4 = element("div");
1311 + div3 = element("div");
1312 + div3.textContent = "ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ\r\n ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ";
1313 + t4 = space();
1314 + img1 = element("img");
1315 + t5 = space();
1316 + div8 = element("div");
1317 + div7 = element("div");
1318 + img2 = element("img");
1319 + t6 = space();
1320 + div6 = element("div");
1321 + div6.textContent = "ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ\r\n ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ";
1322 + t8 = space();
1323 + div11 = element("div");
1324 + div10 = element("div");
1325 + div9 = element("div");
1326 + div9.textContent = "ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ\r\n ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ";
1327 + t10 = space();
1328 + img3 = element("img");
1329 + if (!src_url_equal(img0.src, img0_src_value = "https://d2u3dcdbebyaiu.cloudfront.net/uploads/atch_img/574/a90016a30d614a19fe6987d94edb5e29.jpeg")) attr_dev(img0, "src", img0_src_value);
1330 + attr_dev(img0, "alt", ":)");
1331 + attr_dev(img0, "class", "svelte-90y9ti");
1332 + add_location(img0, file$1, 40, 8, 753);
1333 + attr_dev(div0, "class", "text svelte-90y9ti");
1334 + add_location(div0, file$1, 41, 8, 880);
1335 + attr_dev(div1, "class", "contents svelte-90y9ti");
1336 + add_location(div1, file$1, 39, 4, 721);
1337 + attr_dev(div2, "class", "article wbg svelte-90y9ti");
1338 + attr_dev(div2, "id", "article1");
1339 + add_location(div2, file$1, 38, 0, 676);
1340 + attr_dev(div3, "class", "text svelte-90y9ti");
1341 + add_location(div3, file$1, 49, 8, 1122);
1342 + if (!src_url_equal(img1.src, img1_src_value = "https://www.pinclipart.com/picdir/big/550-5506338_pepe-the-frog-transparent-png-transparent-pepe-png.png")) attr_dev(img1, "src", img1_src_value);
1343 + attr_dev(img1, "alt", ";(");
1344 + attr_dev(img1, "class", "svelte-90y9ti");
1345 + add_location(img1, file$1, 53, 8, 1274);
1346 + attr_dev(div4, "class", "contents svelte-90y9ti");
1347 + add_location(div4, file$1, 48, 4, 1089);
1348 + attr_dev(div5, "class", "article gbg svelte-90y9ti");
1349 + attr_dev(div5, "id", "article2");
1350 + add_location(div5, file$1, 47, 0, 1044);
1351 + if (!src_url_equal(img2.src, img2_src_value = "https://d2u3dcdbebyaiu.cloudfront.net/uploads/atch_img/574/a90016a30d614a19fe6987d94edb5e29.jpeg")) attr_dev(img2, "src", img2_src_value);
1352 + attr_dev(img2, "alt", ":)");
1353 + attr_dev(img2, "class", "svelte-90y9ti");
1354 + add_location(img2, file$1, 58, 8, 1498);
1355 + attr_dev(div6, "class", "text svelte-90y9ti");
1356 + add_location(div6, file$1, 59, 8, 1625);
1357 + attr_dev(div7, "class", "contents svelte-90y9ti");
1358 + add_location(div7, file$1, 57, 4, 1466);
1359 + attr_dev(div8, "class", "article wbg svelte-90y9ti");
1360 + attr_dev(div8, "id", "article3");
1361 + add_location(div8, file$1, 56, 0, 1421);
1362 + attr_dev(div9, "class", "text svelte-90y9ti");
1363 + add_location(div9, file$1, 67, 8, 1866);
1364 + if (!src_url_equal(img3.src, img3_src_value = "https://www.pinclipart.com/picdir/big/550-5506338_pepe-the-frog-transparent-png-transparent-pepe-png.png")) attr_dev(img3, "src", img3_src_value);
1365 + attr_dev(img3, "alt", ";(");
1366 + attr_dev(img3, "class", "svelte-90y9ti");
1367 + add_location(img3, file$1, 71, 8, 2018);
1368 + attr_dev(div10, "class", "contents svelte-90y9ti");
1369 + add_location(div10, file$1, 66, 4, 1834);
1370 + attr_dev(div11, "class", "article gbg svelte-90y9ti");
1371 + attr_dev(div11, "id", "article4");
1372 + add_location(div11, file$1, 65, 0, 1789);
1373 + },
1374 + l: function claim(nodes) {
1375 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
1376 + },
1377 + m: function mount(target, anchor) {
1378 + insert_dev(target, div2, anchor);
1379 + append_dev(div2, div1);
1380 + append_dev(div1, img0);
1381 + append_dev(div1, t0);
1382 + append_dev(div1, div0);
1383 + insert_dev(target, t2, anchor);
1384 + insert_dev(target, div5, anchor);
1385 + append_dev(div5, div4);
1386 + append_dev(div4, div3);
1387 + append_dev(div4, t4);
1388 + append_dev(div4, img1);
1389 + insert_dev(target, t5, anchor);
1390 + insert_dev(target, div8, anchor);
1391 + append_dev(div8, div7);
1392 + append_dev(div7, img2);
1393 + append_dev(div7, t6);
1394 + append_dev(div7, div6);
1395 + insert_dev(target, t8, anchor);
1396 + insert_dev(target, div11, anchor);
1397 + append_dev(div11, div10);
1398 + append_dev(div10, div9);
1399 + append_dev(div10, t10);
1400 + append_dev(div10, img3);
1401 + },
1402 + p: noop,
1403 + i: noop,
1404 + o: noop,
1405 + d: function destroy(detaching) {
1406 + if (detaching) detach_dev(div2);
1407 + if (detaching) detach_dev(t2);
1408 + if (detaching) detach_dev(div5);
1409 + if (detaching) detach_dev(t5);
1410 + if (detaching) detach_dev(div8);
1411 + if (detaching) detach_dev(t8);
1412 + if (detaching) detach_dev(div11);
1413 + }
1414 + };
1415 +
1416 + dispatch_dev("SvelteRegisterBlock", {
1417 + block,
1418 + id: create_fragment$1.name,
1419 + type: "component",
1420 + source: "",
1421 + ctx
1422 + });
1423 +
1424 + return block;
1425 + }
1426 +
1427 + function instance$1($$self, $$props) {
1428 + let { $$slots: slots = {}, $$scope } = $$props;
1429 + validate_slots('Articles', slots, []);
1430 + const writable_props = [];
1431 +
1432 + Object.keys($$props).forEach(key => {
1433 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<Articles> was created with unknown prop '${key}'`);
1434 + });
1435 +
1436 + return [];
1437 + }
1438 +
1439 + class Articles extends SvelteComponentDev {
1440 + constructor(options) {
1441 + super(options);
1442 + init(this, options, instance$1, create_fragment$1, safe_not_equal, {});
1443 +
1444 + dispatch_dev("SvelteRegisterComponent", {
1445 + component: this,
1446 + tagName: "Articles",
1447 + options,
1448 + id: create_fragment$1.name
1449 + });
1450 + }
1451 + }
1452 +
1453 + /* src\App.svelte generated by Svelte v3.44.1 */
1454 + const file = "src\\App.svelte";
1455 +
1456 + function create_fragment(ctx) {
1457 + let div;
1458 + let menu;
1459 + let t0;
1460 + let map;
1461 + let t1;
1462 + let backtotop;
1463 + let t2;
1464 + let article;
1465 + let current;
1466 + menu = new Menu({ $$inline: true });
1467 + map = new Map$1({ $$inline: true });
1468 + backtotop = new Backtotop({ $$inline: true });
1469 + article = new Articles({ $$inline: true });
1470 +
1471 + const block = {
1472 + c: function create() {
1473 + div = element("div");
1474 + create_component(menu.$$.fragment);
1475 + t0 = space();
1476 + create_component(map.$$.fragment);
1477 + t1 = space();
1478 + create_component(backtotop.$$.fragment);
1479 + t2 = space();
1480 + create_component(article.$$.fragment);
1481 + attr_dev(div, "class", "svelte-hpuxjp");
1482 + add_location(div, file, 25, 0, 366);
1483 + },
1484 + l: function claim(nodes) {
1485 + throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
1486 + },
1487 + m: function mount(target, anchor) {
1488 + insert_dev(target, div, anchor);
1489 + mount_component(menu, div, null);
1490 + append_dev(div, t0);
1491 + mount_component(map, div, null);
1492 + append_dev(div, t1);
1493 + mount_component(backtotop, div, null);
1494 + append_dev(div, t2);
1495 + mount_component(article, div, null);
1496 + current = true;
1497 + },
1498 + p: noop,
1499 + i: function intro(local) {
1500 + if (current) return;
1501 + transition_in(menu.$$.fragment, local);
1502 + transition_in(map.$$.fragment, local);
1503 + transition_in(backtotop.$$.fragment, local);
1504 + transition_in(article.$$.fragment, local);
1505 + current = true;
1506 + },
1507 + o: function outro(local) {
1508 + transition_out(menu.$$.fragment, local);
1509 + transition_out(map.$$.fragment, local);
1510 + transition_out(backtotop.$$.fragment, local);
1511 + transition_out(article.$$.fragment, local);
1512 + current = false;
1513 + },
1514 + d: function destroy(detaching) {
1515 + if (detaching) detach_dev(div);
1516 + destroy_component(menu);
1517 + destroy_component(map);
1518 + destroy_component(backtotop);
1519 + destroy_component(article);
1520 + }
1521 + };
1522 +
1523 + dispatch_dev("SvelteRegisterBlock", {
1524 + block,
1525 + id: create_fragment.name,
1526 + type: "component",
1527 + source: "",
1528 + ctx
1529 + });
1530 +
1531 + return block;
1532 + }
1533 +
1534 + function instance($$self, $$props, $$invalidate) {
1535 + let { $$slots: slots = {}, $$scope } = $$props;
1536 + validate_slots('App', slots, []);
1537 + const writable_props = [];
1538 +
1539 + Object.keys($$props).forEach(key => {
1540 + if (!~writable_props.indexOf(key) && key.slice(0, 2) !== '$$' && key !== 'slot') console.warn(`<App> was created with unknown prop '${key}'`);
1541 + });
1542 +
1543 + $$self.$capture_state = () => ({ Menu, Backtotop, Map: Map$1, Article: Articles });
1544 + return [];
1545 + }
1546 +
1547 + class App extends SvelteComponentDev {
1548 + constructor(options) {
1549 + super(options);
1550 + init(this, options, instance, create_fragment, safe_not_equal, {});
1551 +
1552 + dispatch_dev("SvelteRegisterComponent", {
1553 + component: this,
1554 + tagName: "App",
1555 + options,
1556 + id: create_fragment.name
1557 + });
1558 + }
1559 + }
1560 +
1561 + const app = new App({
1562 + target: document.body,
1563 + props: {
1564 + // name: 'world'
1565 + }
1566 + });
1567 +
1568 + return app;
1569 +
1570 +})();
1571 +//# sourceMappingURL=bundle.js.map
This diff could not be displayed because it is too large.
1 +html, body {
2 + position: relative;
3 + width: 100%;
4 + height: 100%;
5 +}
6 +
7 +body {
8 + color: #333;
9 + margin: 0;
10 + padding: 8px;
11 + box-sizing: border-box;
12 + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", sans-serif;
13 +}
14 +
15 +a {
16 + color: rgb(0,100,200);
17 + text-decoration: none;
18 +}
19 +
20 +a:hover {
21 + text-decoration: underline;
22 +}
23 +
24 +a:visited {
25 + color: rgb(0,80,160);
26 +}
27 +
28 +label {
29 + display: block;
30 +}
31 +
32 +input, button, select, textarea {
33 + font-family: inherit;
34 + font-size: inherit;
35 + -webkit-padding: 0.4em 0;
36 + padding: 0.4em;
37 + margin: 0 0 0.5em 0;
38 + box-sizing: border-box;
39 + border: 1px solid #ccc;
40 + border-radius: 2px;
41 +}
42 +
43 +input:disabled {
44 + color: #ccc;
45 +}
46 +
47 +button {
48 + color: #333;
49 + background-color: #f4f4f4;
50 + outline: none;
51 +}
52 +
53 +button:disabled {
54 + color: #999;
55 +}
56 +
57 +button:not(:disabled):active {
58 + background-color: #ddd;
59 +}
60 +
61 +button:focus {
62 + border-color: #666;
63 +}
1 +<!DOCTYPE html>
2 +<html lang="en">
3 +<head>
4 + <meta charset='utf-8'>
5 + <meta name='viewport' content='width=device-width,initial-scale=1'>
6 +
7 + <title>Svelte app</title>
8 +
9 + <link rel='icon' type='image/png' href='./favicon.png'>
10 + <link rel='stylesheet' href='./global.css'>
11 + <link rel='stylesheet' href='./build/bundle.css'>
12 +
13 + <script defer src='./build/bundle.js'></script>
14 +</head>
15 +
16 +<body>
17 +</body>
18 +</html>
1 +<script>
2 + import Menu from './Menu.svelte'
3 + import Backtotop from './Backtotop.svelte'
4 + import Map from './Map.svelte'
5 + import Article from './Articles.svelte'
6 +</script>
7 +
8 +<style>
9 + div {
10 + text-align: left;
11 + box-sizing: border-box;
12 + display: block;
13 + }
14 +
15 + :global(body) {
16 + padding: 0;
17 + margin: 0;
18 + }
19 +
20 + :global(html) {
21 + scroll-behavior: smooth;
22 + }
23 +
24 +</style>
25 +
26 +<div>
27 + <Menu/>
28 + <Map/>
29 + <Backtotop/>
30 + <Article/>
31 +</div>
...\ No newline at end of file ...\ No newline at end of file
1 +<style>
2 + .article{
3 + font-family: 맑은고딕, Malgun Gothic, dotum, gulim, sans-serif;
4 + font-size: 24pt;
5 + padding:10vw;
6 + text-align: center;
7 + display: flex;
8 + }
9 +
10 + .wbg{
11 + background-color: #ffffff;
12 + }
13 +
14 + .gbg{
15 + background-color: #edeff2;
16 + }
17 +
18 + .article img {
19 + display: inline-block;
20 + max-width: 500px;
21 + width: 20vw;
22 + margin-left: 4vw;
23 + margin-right: 4vw;
24 + }
25 +
26 + .article .text {
27 + display: inline-block;
28 + width: 50vw;
29 + }
30 +
31 + .contents{
32 + display: flex;
33 + align-items: center;
34 + }
35 +</style>
36 +<script>
37 +</script>
38 +
39 +<div class="article wbg" id="article1">
40 + <div class="contents">
41 + <img src="https://d2u3dcdbebyaiu.cloudfront.net/uploads/atch_img/574/a90016a30d614a19fe6987d94edb5e29.jpeg" alt=":)">
42 + <div class="text">
43 + ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ
44 + ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ
45 + </div>
46 + </div>
47 +</div>
48 +<div class="article gbg" id="article2">
49 + <div class="contents">
50 + <div class="text">
51 + ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ
52 + ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ
53 + </div>
54 + <img src="https://www.pinclipart.com/picdir/big/550-5506338_pepe-the-frog-transparent-png-transparent-pepe-png.png" alt=";(">
55 + </div>
56 +</div>
57 +<div class="article wbg" id="article3">
58 + <div class="contents">
59 + <img src="https://d2u3dcdbebyaiu.cloudfront.net/uploads/atch_img/574/a90016a30d614a19fe6987d94edb5e29.jpeg" alt=":)">
60 + <div class="text">
61 + ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ
62 + ㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎㅎ
63 + </div>
64 + </div>
65 +</div>
66 +<div class="article gbg" id="article4">
67 + <div class="contents">
68 + <div class="text">
69 + ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ
70 + ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ
71 + </div>
72 + <img src="https://www.pinclipart.com/picdir/big/550-5506338_pepe-the-frog-transparent-png-transparent-pepe-png.png" alt=";(">
73 + </div>
74 +</div>
...\ No newline at end of file ...\ No newline at end of file
1 +<script>
2 + import { fly } from 'svelte/transition'
3 + import { onMount, onDestroy } from 'svelte';
4 + let show = false;
5 +
6 + function scrollUp() {
7 + document.body.scrollIntoView({behavior: "smooth"})
8 + }
9 +
10 + onMount(() => {
11 + window.onscroll = () => {
12 + if (window.scrollY > 60) {
13 + show = true
14 + } else {
15 + show = false
16 + }
17 + }
18 + });
19 +
20 + onDestroy(() => {
21 + window.onscroll = () => {}
22 + });
23 +</script>
24 +
25 +<style>
26 + #backtotop {
27 + border-radius: 100%;
28 + width: 50px;
29 + height: 50px;
30 + position: fixed;
31 + right: 4%;
32 + bottom: 10%;
33 + }
34 +
35 +</style>
36 +
37 +{#if (show)}
38 + <button id="backtotop"
39 + transition:fly="{{ y : 200, duration:400}}"
40 + on:click={scrollUp}>
41 +
42 + </button>
43 +{/if}
...\ No newline at end of file ...\ No newline at end of file
1 +<style>
2 + #chat_bg {
3 + box-sizing: border-box;
4 + display: flex;
5 + height: 100vh;
6 + background-color:#edeff2;
7 + }
8 +</style>
9 +
10 +<script>
11 +
12 +</script>
13 +
14 +<div id="chat_bg">
15 +
16 +</div>
1 +<script>
2 + import Menuitems from './Menuitems.svelte'
3 +
4 + // 메뉴 바 항목들
5 + const navItems = [
6 + { label: "Article1", href: "#article1" },
7 + { label: "Article2", href: "#article2" },
8 + { label: "Article3", href: "#article3" },
9 + { label: "Article4", href: "#article4" }
10 + ];
11 +</script>
12 +
13 +<style>
14 + nav {
15 + background-color: rgb(225, 175, 85);
16 + font-family: "Helvetica Neue", "Helvetica", "Arial", sans-serif;
17 + height: 70px;
18 + top: 0;
19 + }
20 +
21 + .inner {
22 + max-width: 500px;
23 + padding-left: 10px;
24 + padding-right: 10px;
25 + margin: auto;
26 + box-sizing: border-box;
27 + display: flex;
28 + align-items: center;
29 + height: 100%;
30 + }
31 +
32 + .logo {
33 + display: flex;
34 + position: absolute;
35 + width: 50px;
36 + left: 40px;
37 + top: 25px
38 + }
39 +
40 + .navbar-list {
41 + display: flex;
42 + padding: 0;
43 + width: 100%;
44 + justify-content: space-between;
45 + margin: 0;
46 + }
47 +</style>
48 +
49 +<nav>
50 + <div class="logo">Logo</div>
51 + <div class="inner">
52 + <ul class='navbar-list'>
53 + {#each navItems as item}
54 + <Menuitems {item}/>
55 + {/each}
56 + </ul>
57 + </div>
58 +</nav>
...\ No newline at end of file ...\ No newline at end of file
1 +<style>
2 + li {
3 + list-style-type: none;
4 + position: relative;
5 + }
6 +
7 + li:before {
8 + content: "";
9 + position: absolute;
10 + bottom: 0;
11 + left: 0;
12 + width: 100%;
13 + height: 1px;
14 + }
15 +
16 + a {
17 + color: #e5e6e5;
18 + text-decoration: none;
19 + display: inline-flex;
20 + height: 45px;
21 + align-items: center;
22 + padding: 0 10px;
23 + font-size: 20px;
24 + }
25 +
26 + @media only screen and (max-width: 767px) {
27 + a {
28 + display: none;
29 + }
30 + }
31 +
32 + .onmouse {
33 + color: #ffffff;
34 + }
35 +</style>
36 +
37 +<script>
38 + export let item;
39 + let onmouse;
40 +
41 + function enter() {
42 + onmouse = true;
43 + }
44 +
45 + function leave() {
46 + onmouse = false;
47 + }
48 +</script>
49 +
50 +<li on:mouseenter={enter} on:mouseleave={leave} >
51 + <a href={item.href} class:onmouse>{item.label}</a>
52 +</li>
...\ No newline at end of file ...\ No newline at end of file
1 +<script>
2 +
3 +</script>
4 +
5 +<span>
6 + ...
7 +</span>
...\ No newline at end of file ...\ No newline at end of file
1 +import App from './App.svelte';
2 +
3 +const app = new App({
4 + target: document.body,
5 + props: {
6 + // name: 'world'
7 + }
8 +});
9 +
10 +export default app;
...\ No newline at end of file ...\ No newline at end of file