astro/src/frontend/SvelteWrapper.svelte.client.ts

/* eslint-disable */
// @ts-nocheck
// TODO: don't precompile this, but it works for now
import {
	HtmlTag,
	SvelteComponentDev,
	assign,
	claim_component,
	create_component,
	destroy_component,
	detach_dev,
	dispatch_dev,
	empty,
	exclude_internal_props,
	get_spread_object,
	get_spread_update,
	init,
	insert_dev,
	mount_component,
	noop,
	not_equal,
	transition_in,
	transition_out,
	validate_slots
} from "svelte/internal";

const file = "App.svelte";

// (5:0) <Component {...props}>
function create_default_slot(ctx) {
	let html_tag;
	let html_anchor;

	const block = {
		c: function create() {
			html_anchor = empty();
			this.h();
		},
		l: function claim(nodes) {
			html_anchor = empty();
			this.h();
		},
		h: function hydrate() {
			html_tag = new HtmlTag(html_anchor);
		},
		m: function mount(target, anchor) {
			html_tag.m(/*__astro_children*/ ctx[1], target, anchor);
			insert_dev(target, html_anchor, anchor);
		},
		p: noop,
		d: function destroy(detaching) {
			if (detaching) detach_dev(html_anchor);
			if (detaching) html_tag.d();
		}
	};

	dispatch_dev("SvelteRegisterBlock", {
		block,
		id: create_default_slot.name,
		type: "slot",
		source: "(5:0) <Component {...props}>",
		ctx
	});

	return block;
}

function create_fragment(ctx) {
	let component;
	let current;
	const component_spread_levels = [/*props*/ ctx[2]];

	let component_props = {
		$$slots: { default: [create_default_slot] },
		$$scope: { ctx }
	};

	for (let i = 0; i < component_spread_levels.length; i += 1) {
		component_props = assign(component_props, component_spread_levels[i]);
	}

	component = new /*Component*/ ctx[0]({ props: component_props, $$inline: true });

	const block = {
		c: function create() {
			create_component(component.$$.fragment);
		},
		l: function claim(nodes) {
			claim_component(component.$$.fragment, nodes);
		},
		m: function mount(target, anchor) {
			mount_component(component, target, anchor);
			current = true;
		},
		p: function update(ctx, [dirty]) {
			const component_changes = (dirty & /*props*/ 4)
			? get_spread_update(component_spread_levels, [get_spread_object(/*props*/ ctx[2])])
			: {};

			if (dirty & /*$$scope*/ 16) {
				component_changes.$$scope = { dirty, ctx };
			}

			component.$set(component_changes);
		},
		i: function intro(local) {
			if (current) return;
			transition_in(component.$$.fragment, local);
			current = true;
		},
		o: function outro(local) {
			transition_out(component.$$.fragment, local);
			current = false;
		},
		d: function destroy(detaching) {
			destroy_component(component, detaching);
		}
	};

	dispatch_dev("SvelteRegisterBlock", {
		block,
		id: create_fragment.name,
		type: "component",
		source: "",
		ctx
	});

	return block;
}

function instance($$self, $$props, $$invalidate) {
	let { $$slots: slots = {}, $$scope } = $$props;
	validate_slots("App", slots, []);
	const { __astro_component: Component, __astro_children, ...props } = $$props;

	$$self.$$set = $$new_props => {
		$$invalidate(3, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
	};

	$$self.$capture_state = () => ({ Component, __astro_children, props });

	$$self.$inject_state = $$new_props => {
		$$invalidate(3, $$props = assign(assign({}, $$props), $$new_props));
	};

	if ($$props && "$$inject" in $$props) {
		$$self.$inject_state($$props.$$inject);
	}

	$$props = exclude_internal_props($$props);
	return [Component, __astro_children, props];
}

class App extends SvelteComponentDev {
	constructor(options) {
		super(options);
		init(this, options, instance, create_fragment, not_equal, {});

		dispatch_dev("SvelteRegisterComponent", {
			component: this,
			tagName: "App",
			options,
			id: create_fragment.name
		});
	}
}

export default App;