Last active
December 6, 2019 10:14
-
-
Save zevaverbach/83901aed1230fbd3adb01b96a7be0572 to your computer and use it in GitHub Desktop.
bundle.js from sveltejs/template (svelte 3.0.0)
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(function(l, r) { if (l.getElementById('livereloadscript')) return; r = l.createElement('script'); r.async = 1; r.src = '//' + (window.location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; r.id = 'livereloadscript'; l.head.appendChild(r) })(window.document); | |
var app = (function () { | |
'use strict'; | |
function noop() { } | |
function add_location(element, file, line, column, char) { | |
element.__svelte_meta = { | |
loc: { file, line, column, char } | |
}; | |
} | |
function run(fn) { | |
return fn(); | |
} | |
function blank_object() { | |
return Object.create(null); | |
} | |
function run_all(fns) { | |
fns.forEach(run); | |
} | |
function is_function(thing) { | |
return typeof thing === 'function'; | |
} | |
function safe_not_equal(a, b) { | |
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function'); | |
} | |
function append(target, node) { | |
target.appendChild(node); | |
} | |
function insert(target, node, anchor) { | |
target.insertBefore(node, anchor || null); | |
} | |
function detach(node) { | |
node.parentNode.removeChild(node); | |
} | |
function element(name) { | |
return document.createElement(name); | |
} | |
function text(data) { | |
return document.createTextNode(data); | |
} | |
function space() { | |
return text(' '); | |
} | |
function attr(node, attribute, value) { | |
if (value == null) | |
node.removeAttribute(attribute); | |
else if (node.getAttribute(attribute) !== value) | |
node.setAttribute(attribute, value); | |
} | |
function children(element) { | |
return Array.from(element.childNodes); | |
} | |
function custom_event(type, detail) { | |
const e = document.createEvent('CustomEvent'); | |
e.initCustomEvent(type, false, false, detail); | |
return e; | |
} | |
let current_component; | |
function set_current_component(component) { | |
current_component = component; | |
} | |
const dirty_components = []; | |
const binding_callbacks = []; | |
const render_callbacks = []; | |
const flush_callbacks = []; | |
const resolved_promise = Promise.resolve(); | |
let update_scheduled = false; | |
function schedule_update() { | |
if (!update_scheduled) { | |
update_scheduled = true; | |
resolved_promise.then(flush); | |
} | |
} | |
function add_render_callback(fn) { | |
render_callbacks.push(fn); | |
} | |
function flush() { | |
const seen_callbacks = new Set(); | |
do { | |
// first, call beforeUpdate functions | |
// and update components | |
while (dirty_components.length) { | |
const component = dirty_components.shift(); | |
set_current_component(component); | |
update(component.$$); | |
} | |
while (binding_callbacks.length) | |
binding_callbacks.pop()(); | |
// then, once components are updated, call | |
// afterUpdate functions. This may cause | |
// subsequent updates... | |
for (let i = 0; i < render_callbacks.length; i += 1) { | |
const callback = render_callbacks[i]; | |
if (!seen_callbacks.has(callback)) { | |
callback(); | |
// ...so guard against infinite loops | |
seen_callbacks.add(callback); | |
} | |
} | |
render_callbacks.length = 0; | |
} while (dirty_components.length); | |
while (flush_callbacks.length) { | |
flush_callbacks.pop()(); | |
} | |
update_scheduled = false; | |
} | |
function update($$) { | |
if ($$.fragment !== null) { | |
$$.update(); | |
run_all($$.before_update); | |
$$.fragment && $$.fragment.p($$.ctx, $$.dirty); | |
$$.dirty = [-1]; | |
$$.after_update.forEach(add_render_callback); | |
} | |
} | |
const outroing = new Set(); | |
function transition_in(block, local) { | |
if (block && block.i) { | |
outroing.delete(block); | |
block.i(local); | |
} | |
} | |
function mount_component(component, target, anchor) { | |
const { fragment, on_mount, on_destroy, after_update } = component.$$; | |
fragment && fragment.m(target, anchor); | |
// onMount happens before the initial afterUpdate | |
add_render_callback(() => { | |
const new_on_destroy = on_mount.map(run).filter(is_function); | |
if (on_destroy) { | |
on_destroy.push(...new_on_destroy); | |
} | |
else { | |
// Edge case - component was destroyed immediately, | |
// most likely as a result of a binding initialising | |
run_all(new_on_destroy); | |
} | |
component.$$.on_mount = []; | |
}); | |
after_update.forEach(add_render_callback); | |
} | |
function destroy_component(component, detaching) { | |
const $$ = component.$$; | |
if ($$.fragment !== null) { | |
run_all($$.on_destroy); | |
$$.fragment && $$.fragment.d(detaching); | |
// TODO null out other refs, including component.$$ (but need to | |
// preserve final state?) | |
$$.on_destroy = $$.fragment = null; | |
$$.ctx = []; | |
} | |
} | |
function make_dirty(component, i) { | |
if (component.$$.dirty[0] === -1) { | |
dirty_components.push(component); | |
schedule_update(); | |
component.$$.dirty.fill(0); | |
} | |
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31)); | |
} | |
function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) { | |
const parent_component = current_component; | |
set_current_component(component); | |
const prop_values = options.props || {}; | |
const $$ = component.$$ = { | |
fragment: null, | |
ctx: null, | |
// state | |
props, | |
update: noop, | |
not_equal, | |
bound: blank_object(), | |
// lifecycle | |
on_mount: [], | |
on_destroy: [], | |
before_update: [], | |
after_update: [], | |
context: new Map(parent_component ? parent_component.$$.context : []), | |
// everything else | |
callbacks: blank_object(), | |
dirty | |
}; | |
let ready = false; | |
$$.ctx = instance | |
? instance(component, prop_values, (i, ret, value = ret) => { | |
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) { | |
if ($$.bound[i]) | |
$$.bound[i](value); | |
if (ready) | |
make_dirty(component, i); | |
} | |
return ret; | |
}) | |
: []; | |
$$.update(); | |
ready = true; | |
run_all($$.before_update); | |
// `false` as a special case of no DOM component | |
$$.fragment = create_fragment ? create_fragment($$.ctx) : false; | |
if (options.target) { | |
if (options.hydrate) { | |
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion | |
$$.fragment && $$.fragment.l(children(options.target)); | |
} | |
else { | |
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion | |
$$.fragment && $$.fragment.c(); | |
} | |
if (options.intro) | |
transition_in(component.$$.fragment); | |
mount_component(component, options.target, options.anchor); | |
flush(); | |
} | |
set_current_component(parent_component); | |
} | |
class SvelteComponent { | |
$destroy() { | |
destroy_component(this, 1); | |
this.$destroy = noop; | |
} | |
$on(type, callback) { | |
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = [])); | |
callbacks.push(callback); | |
return () => { | |
const index = callbacks.indexOf(callback); | |
if (index !== -1) | |
callbacks.splice(index, 1); | |
}; | |
} | |
$set() { | |
// overridden by instance, if it has props | |
} | |
} | |
function dispatch_dev(type, detail) { | |
document.dispatchEvent(custom_event(type, detail)); | |
} | |
function append_dev(target, node) { | |
dispatch_dev("SvelteDOMInsert", { target, node }); | |
append(target, node); | |
} | |
function insert_dev(target, node, anchor) { | |
dispatch_dev("SvelteDOMInsert", { target, node, anchor }); | |
insert(target, node, anchor); | |
} | |
function detach_dev(node) { | |
dispatch_dev("SvelteDOMRemove", { node }); | |
detach(node); | |
} | |
function attr_dev(node, attribute, value) { | |
attr(node, attribute, value); | |
if (value == null) | |
dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute }); | |
else | |
dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value }); | |
} | |
function set_data_dev(text, data) { | |
data = '' + data; | |
if (text.data === data) | |
return; | |
dispatch_dev("SvelteDOMSetData", { node: text, data }); | |
text.data = data; | |
} | |
class SvelteComponentDev extends SvelteComponent { | |
constructor(options) { | |
if (!options || (!options.target && !options.$$inline)) { | |
throw new Error(`'target' is a required option`); | |
} | |
super(); | |
} | |
$destroy() { | |
super.$destroy(); | |
this.$destroy = () => { | |
console.warn(`Component was already destroyed`); // eslint-disable-line no-console | |
}; | |
} | |
} | |
/* src/App.svelte generated by Svelte v3.16.0 */ | |
const file = "src/App.svelte"; | |
function create_fragment(ctx) { | |
let main; | |
let h1; | |
let t0; | |
let t1; | |
let t2; | |
let t3; | |
let p; | |
let t4; | |
let a; | |
let t6; | |
const block = { | |
c: function create() { | |
main = element("main"); | |
h1 = element("h1"); | |
t0 = text("Hello "); | |
t1 = text(/*name*/ ctx[0]); | |
t2 = text("!"); | |
t3 = space(); | |
p = element("p"); | |
t4 = text("Visit the "); | |
a = element("a"); | |
a.textContent = "Svelte tutorial"; | |
t6 = text(" to learn how to build Svelte apps."); | |
attr_dev(h1, "class", "svelte-1tky8bj"); | |
add_location(h1, file, 5, 1, 46); | |
attr_dev(a, "href", "https://svelte.dev/tutorial"); | |
add_location(a, file, 6, 14, 83); | |
add_location(p, file, 6, 1, 70); | |
attr_dev(main, "class", "svelte-1tky8bj"); | |
add_location(main, file, 4, 0, 38); | |
}, | |
l: function claim(nodes) { | |
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option"); | |
}, | |
m: function mount(target, anchor) { | |
insert_dev(target, main, anchor); | |
append_dev(main, h1); | |
append_dev(h1, t0); | |
append_dev(h1, t1); | |
append_dev(h1, t2); | |
append_dev(main, t3); | |
append_dev(main, p); | |
append_dev(p, t4); | |
append_dev(p, a); | |
append_dev(p, t6); | |
}, | |
p: function update(ctx, [dirty]) { | |
if (dirty & /*name*/ 1) set_data_dev(t1, /*name*/ ctx[0]); | |
}, | |
i: noop, | |
o: noop, | |
d: function destroy(detaching) { | |
if (detaching) detach_dev(main); | |
} | |
}; | |
dispatch_dev("SvelteRegisterBlock", { | |
block, | |
id: create_fragment.name, | |
type: "component", | |
source: "", | |
ctx | |
}); | |
return block; | |
} | |
function instance($$self, $$props, $$invalidate) { | |
let { name } = $$props; | |
const writable_props = ["name"]; | |
Object.keys($$props).forEach(key => { | |
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$") console.warn(`<App> was created with unknown prop '${key}'`); | |
}); | |
$$self.$set = $$props => { | |
if ("name" in $$props) $$invalidate(0, name = $$props.name); | |
}; | |
$$self.$capture_state = () => { | |
return { name }; | |
}; | |
$$self.$inject_state = $$props => { | |
if ("name" in $$props) $$invalidate(0, name = $$props.name); | |
}; | |
return [name]; | |
} | |
class App extends SvelteComponentDev { | |
constructor(options) { | |
super(options); | |
init(this, options, instance, create_fragment, safe_not_equal, { name: 0 }); | |
dispatch_dev("SvelteRegisterComponent", { | |
component: this, | |
tagName: "App", | |
options, | |
id: create_fragment.name | |
}); | |
const { ctx } = this.$$; | |
const props = options.props || ({}); | |
if (/*name*/ ctx[0] === undefined && !("name" in props)) { | |
console.warn("<App> was created without expected prop 'name'"); | |
} | |
} | |
get name() { | |
throw new Error("<App>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"); | |
} | |
set name(value) { | |
throw new Error("<App>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'"); | |
} | |
} | |
const app = new App({ | |
target: document.body, | |
props: { | |
name: 'world', | |
} | |
}); | |
return app; | |
}()); | |
//# sourceMappingURL=bundle.js.map |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment