@pixui-dev/pxw 0.1.16

package/lib/pika-svelte/internal/index.js

@@ -0,0 +1,1926 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _a;
+function noop() {}
+const identity = (x) => x;
+function assign(tar, src) {
+	// @ts-ignore
+	for (const k in src) tar[k] = src[k];
+	return tar;
+}
+function is_promise(value) {
+	return value && typeof value === 'object' && typeof value.then === 'function';
+}
+function add_location(element, file, line, column, char) {
+	element.__svelte_meta = {
+		loc: { file, line, column, char },
+	};
+}
+function run(fn) {
+	return fn();
+}
+function blank_object() {
+	return Object.create(null);
+}
+function run_all(fns) {
+	fns.forEach(run);
+}
+function is_function(thing) {
+	return typeof thing === 'function';
+}
+function safe_not_equal(a, b) {
+	return a != a ? b == b : a !== b || (a && typeof a === 'object') || typeof a === 'function';
+}
+function not_equal(a, b) {
+	return a != a ? b == b : a !== b;
+}
+function is_empty(obj) {
+	return Object.keys(obj).length === 0;
+}
+function validate_store(store, name) {
+	if (store != null && typeof store.subscribe !== 'function') {
+		throw new Error(`'${name}' is not a store with a 'subscribe' method`);
+	}
+}
+function subscribe(store, ...callbacks) {
+	if (store == null) {
+		return noop;
+	}
+	const unsub = store.subscribe(...callbacks);
+	return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
+}
+function get_store_value(store) {
+	let value;
+	subscribe(store, (_) => (value = _))();
+	return value;
+}
+function component_subscribe(component, store, callback) {
+	component.$$.on_destroy.push(subscribe(store, callback));
+}
+function create_slot(definition, ctx, $$scope, fn) {
+	if (definition) {
+		const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
+		return definition[0](slot_ctx);
+	}
+}
+function get_slot_context(definition, ctx, $$scope, fn) {
+	return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
+}
+function get_slot_changes(definition, $$scope, dirty, fn) {
+	if (definition[2] && fn) {
+		const lets = definition[2](fn(dirty));
+		if ($$scope.dirty === undefined) {
+			return lets;
+		}
+		if (typeof lets === 'object') {
+			const merged = [];
+			const len = Math.max($$scope.dirty.length, lets.length);
+			for (let i = 0; i < len; i += 1) {
+				merged[i] = $$scope.dirty[i] | lets[i];
+			}
+			return merged;
+		}
+		return $$scope.dirty | lets;
+	}
+	return $$scope.dirty;
+}
+function update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {
+	const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);
+	if (slot_changes) {
+		const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
+		slot.p(slot_context, slot_changes);
+	}
+}
+function update_slot_spread(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_spread_changes_fn, get_slot_context_fn) {
+	const slot_changes = get_slot_spread_changes_fn(dirty) | get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);
+	if (slot_changes) {
+		const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
+		slot.p(slot_context, slot_changes);
+	}
+}
+function exclude_internal_props(props) {
+	const result = {};
+	for (const k in props) if (k[0] !== '$') result[k] = props[k];
+	return result;
+}
+function compute_rest_props(props, keys) {
+	const rest = {};
+	keys = new Set(keys);
+	for (const k in props) if (!keys.has(k) && k[0] !== '$') rest[k] = props[k];
+	return rest;
+}
+function compute_slots(slots) {
+	const result = {};
+	for (const key in slots) {
+		result[key] = true;
+	}
+	return result;
+}
+function once(fn) {
+	let ran = false;
+	return function (...args) {
+		if (ran) return;
+		ran = true;
+		fn.call(this, ...args);
+	};
+}
+function null_to_empty(value) {
+	return value == null ? '' : value;
+}
+function set_store_value(store, ret, value = ret) {
+	store.set(value);
+	return ret;
+}
+const has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+function action_destroyer(action_result) {
+	return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
+}
+// PIKA: 支持空节点
+const pixuiVersion = (_a = navigator.userAgent.match(/PixUI\/(\d\.\d)/)) === null || _a === void 0 ? void 0 : _a[1];
+const isSupportEmptyText = !pixuiVersion || parseInt(pixuiVersion, 10) >= 0.4;
+
+const is_client = typeof window !== 'undefined';
+exports.now = is_client ? () => window.performance.now() : () => Date.now();
+exports.raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
+// used internally for testing
+function set_now(fn) {
+	exports.now = fn;
+}
+function set_raf(fn) {
+	exports.raf = fn;
+}
+
+const tasks = new Set();
+function run_tasks(now) {
+	tasks.forEach((task) => {
+		if (!task.c(now)) {
+			tasks.delete(task);
+			task.f();
+		}
+	});
+	// requestAnimationFrame
+	if (tasks.size !== 0) exports.raf(run_tasks);
+}
+/**
+ * For testing purposes only!
+ */
+function clear_loops() {
+	tasks.clear();
+}
+/**
+ * Creates a new task that runs on each raf frame
+ * until it returns a falsy value or is aborted
+ */
+function loop(callback) {
+	let task;
+	if (tasks.size === 0) exports.raf(run_tasks);
+	return {
+		promise: new Promise((fulfill) => {
+			tasks.add((task = { c: callback, f: fulfill }));
+		}),
+		abort() {
+			tasks.delete(task);
+		},
+	};
+}
+
+function append(target, node) {
+	// PIKA: svelte 懒操作 DOM
+	//@ts-ignore
+	if (Array.from(target.childNodes).indexOf(node) === -1) {
+		// console.log('append', target, node);
+		target.appendChild(node);
+	}
+}
+function insert(target, node, anchor) {
+	// PIKA: 兼容 PixUI insertBefore 与标准不对齐的问题
+	if (anchor) {
+		// console.log('insert', target, node, anchor);
+		target.insertBefore(node, anchor || null);
+	}
+	else {
+		append(target, node);
+	}
+}
+function detach(node) {
+	// console.log('detach', node);
+	node.parentNode.removeChild(node);
+}
+function destroy_each(iterations, detaching) {
+	for (let i = 0; i < iterations.length; i += 1) {
+		if (iterations[i]) iterations[i].d(detaching);
+	}
+}
+function element(name) {
+	return document.createElement(name);
+}
+function element_is(name, is) {
+	return document.createElement(name, { is });
+}
+function object_without_properties(obj, exclude) {
+	const target = {};
+	for (const k in obj) {
+		if (
+			has_prop(obj, k) &&
+			// @ts-ignore
+			exclude.indexOf(k) === -1
+		) {
+			// @ts-ignore
+			target[k] = obj[k];
+		}
+	}
+	return target;
+}
+function svg_element(name) {
+	return document.createElementNS('http://www.w3.org/2000/svg', name);
+}
+function text(data) {
+	return document.createTextNode(data);
+}
+// PIKA: 支持空节点
+function space() {
+	// @ts-ignore
+	// return element('pika-empty');
+	// return text(' ');
+	return isSupportEmptyText ? text(' ') : element('pika-empty');
+}
+// PIKA: 支持空节点
+function empty() {
+	// PIKA: 兼容 PixUI 空文本会占用行高的问题
+	// @ts-ignore
+	return isSupportEmptyText ? text('') : element('pika-empty');
+	// return text('');
+}
+function listen(node, event, handler, options) {
+	node.addEventListener(event, handler, options);
+	return () => node.removeEventListener(event, handler, options);
+}
+function prevent_default(fn) {
+	return function (event) {
+		event.preventDefault();
+		// @ts-ignore
+		return fn.call(this, event);
+	};
+}
+function stop_propagation(fn) {
+	return function (event) {
+		event.stopPropagation();
+		// @ts-ignore
+		return fn.call(this, event);
+	};
+}
+function self(fn) {
+	return function (event) {
+		// @ts-ignore
+		if (event.target === this) fn.call(this, event);
+	};
+}
+const compatAttrMap = {
+	draggable: true,
+	src: true,
+	width: true,
+	height: true,
+	value: true,
+	placeholder: true,
+	noclip: true,
+};
+function attr(node, attribute, value) {
+	// PIKA: 兼容 draggable 等属性设置方式问题
+	if (has_prop(compatAttrMap, attribute)) {
+		node[attribute] = value;
+		// return;
+	}
+	if (value == null) node.removeAttribute(attribute);
+	else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value);
+}
+function show(node) {
+	toggle_class(node, 'pika_lazy_block', false);
+}
+function hide(node) {
+	toggle_class(node, 'pika_lazy_block', true);
+}
+let hasInitLazyClass = false;
+function initLazyClass(_node) {
+	if (!hasInitLazyClass) {
+		hasInitLazyClass = true;
+		const style = document.createElement('style');
+		document.head.appendChild(style);
+		style.type = 'text/css';
+		style.appendChild(
+			document.createTextNode(`
+			.pika_lazy_block {
+				position: absolute!important;
+				left: -10000px!important;
+			}
+		`),
+		);
+	}
+}
+function set_attributes(node, attributes) {
+	// @ts-ignore
+	const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
+	for (const key in attributes) {
+		if (attributes[key] == null) {
+			node.removeAttribute(key);
+		}
+		else if (key === 'style') {
+			node.style.cssText = attributes[key];
+		}
+		else if (key === '__value') {
+			node.value = node[key] = attributes[key];
+		}
+		else if (descriptors[key] && descriptors[key].set) {
+			node[key] = attributes[key];
+		}
+		else {
+			attr(node, key, attributes[key]);
+		}
+	}
+}
+function set_svg_attributes(node, attributes) {
+	for (const key in attributes) {
+		attr(node, key, attributes[key]);
+	}
+}
+function set_custom_element_data(node, prop, value) {
+	if (prop in node) {
+		node[prop] = value;
+	}
+	else {
+		attr(node, prop, value);
+	}
+}
+function xlink_attr(node, attribute, value) {
+	node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);
+}
+function get_binding_group_value(group, __value, checked) {
+	const value = new Set();
+	for (let i = 0; i < group.length; i += 1) {
+		if (group[i].checked) value.add(group[i].__value);
+	}
+	if (!checked) {
+		value.delete(__value);
+	}
+	return Array.from(value);
+}
+function to_number(value) {
+	return value === '' ? null : +value;
+}
+function time_ranges_to_array(ranges) {
+	const array = [];
+	for (let i = 0; i < ranges.length; i += 1) {
+		array.push({ start: ranges.start(i), end: ranges.end(i) });
+	}
+	return array;
+}
+function children(element) {
+	return Array.from(element.childNodes);
+}
+function claim_element(nodes, name, attributes, svg) {
+	for (let i = 0; i < nodes.length; i += 1) {
+		const node = nodes[i];
+		if (node.nodeName === name) {
+			let j = 0;
+			const remove = [];
+			while (j < node.attributes.length) {
+				const attribute = node.attributes[j++];
+				if (!attributes[attribute.name]) {
+					remove.push(attribute.name);
+				}
+			}
+			for (let k = 0; k < remove.length; k++) {
+				node.removeAttribute(remove[k]);
+			}
+			return nodes.splice(i, 1)[0];
+		}
+	}
+	return svg ? svg_element(name) : element(name);
+}
+function claim_text(nodes, data) {
+	for (let i = 0; i < nodes.length; i += 1) {
+		const node = nodes[i];
+		if (node.nodeType === 3) {
+			node.data = '' + data;
+			return nodes.splice(i, 1)[0];
+		}
+	}
+	return text(data);
+}
+function claim_space(nodes) {
+	return claim_text(nodes, ' ');
+}
+function set_data(text, data) {
+	data = '' + data;
+	// PIKA: 兼容 wholeText
+	if (text.data !== data) text.data = data;
+}
+function set_input_value(input, value) {
+	input.value = value == null ? '' : value;
+}
+function set_input_type(input, type) {
+	try {
+		input.type = type;
+	}
+	catch (e) {
+		// do nothing
+	}
+}
+function set_style(node, key, value, _important) {
+	// PIKA: style key 全部转为驼峰
+	const camelKey = key.replace(/-(\w)/g, (_match, $1) => $1.toUpperCase());
+	// PIKA: 懒更新，PixUI v0.4- 会触发 style parse
+	if (node.style[camelKey] !== value) {
+		node.style[camelKey] = value;
+	}
+	// node.style.setProperty(key, value, important ? 'important' : '');
+}
+function select_option(select, value) {
+	for (let i = 0; i < select.options.length; i += 1) {
+		const option = select.options[i];
+		if (option.__value === value) {
+			option.selected = true;
+			return;
+		}
+	}
+}
+function select_options(select, value) {
+	for (let i = 0; i < select.options.length; i += 1) {
+		const option = select.options[i];
+		option.selected = ~value.indexOf(option.__value);
+	}
+}
+function select_value(select) {
+	const selected_option = select.querySelector(':checked') || select.options[0];
+	return selected_option && selected_option.__value;
+}
+function select_multiple_value(select) {
+	return [].map.call(select.querySelectorAll(':checked'), (option) => option.__value);
+}
+// unfortunately this can't be a constant as that wouldn't be tree-shakeable
+// so we cache the result instead
+let crossorigin;
+function is_crossorigin() {
+	if (crossorigin === undefined) {
+		crossorigin = false;
+		try {
+			if (typeof window !== 'undefined' && window.parent) {
+				void window.parent.document;
+			}
+		}
+		catch (error) {
+			crossorigin = true;
+		}
+	}
+	return crossorigin;
+}
+function add_resize_listener(node, fn) {
+	const computed_style = getComputedStyle(node);
+	if (computed_style.position === 'static') {
+		node.style.position = 'relative';
+	}
+	const iframe = element('iframe');
+	iframe.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; ' + 'overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;');
+	iframe.setAttribute('aria-hidden', 'true');
+	iframe.tabIndex = -1;
+	const crossorigin = is_crossorigin();
+	let unsubscribe;
+	if (crossorigin) {
+		iframe.src = 'data:text/html,<script>onresize=function(){parent.postMessage(0,\'*\')}</script>';
+		unsubscribe = listen(window, 'message', (event) => {
+			if (event.source === iframe.contentWindow) fn();
+		});
+	}
+	else {
+		iframe.src = 'about:blank';
+		iframe.onload = () => {
+			unsubscribe = listen(iframe.contentWindow, 'resize', fn);
+		};
+	}
+	append(node, iframe);
+	return () => {
+		if (crossorigin) {
+			unsubscribe();
+		}
+		else if (unsubscribe && iframe.contentWindow) {
+			unsubscribe();
+		}
+		detach(iframe);
+	};
+}
+function toggle_class(element, name, toggle) {
+	// PIKA: 兼容 classList
+	const clasNameStr = element.className;
+	const classNameArr = clasNameStr.split(' ');
+	const idx = classNameArr.indexOf(name);
+	if (toggle) {
+		if (idx === -1) {
+			element.className = `${clasNameStr} ${name}`;
+		}
+	}
+	else {
+		if (idx !== -1) {
+			classNameArr.splice(idx, 1);
+			element.className = classNameArr.join(' ');
+		}
+	}
+	// element.classList[toggle ? 'add' : 'remove'](name);
+}
+function custom_event(type, detail) {
+	// PIKA: 支持自定义事件
+	const e = { type, detail };
+	// const e: CustomEvent<T> = document.createEvent('CustomEvent');
+	// e.initCustomEvent(type, false, false, detail);
+	return e;
+}
+function query_selector_all(selector, parent = document.body) {
+	return Array.from(parent.querySelectorAll(selector));
+}
+class HtmlTag {
+	constructor(anchor = null) {
+		this.a = anchor;
+		this.e = this.n = null;
+	}
+	// insert childNodes into parent
+	m(html, target, anchor = null) {
+		if (!this.e) {
+			this.e = element(target.nodeName);
+			this.t = target;
+			this.h(html);
+		}
+		this.i(anchor);
+	}
+	// innerHtml render
+	h(html) {
+		this.e.innerHTML = html;
+		this.n = Array.from(this.e.childNodes);
+	}
+	// insert childNodes into parent
+	i(anchor) {
+		for (let i = 0; i < this.n.length; i += 1) {
+			insert(this.t, this.n[i], anchor);
+		}
+	}
+	// update childNodes
+	p(html) {
+		this.d();
+		this.h(html);
+		this.i(this.a);
+	}
+	// delete
+	d() {
+		this.n.forEach(detach);
+	}
+}
+function attribute_to_object(attributes) {
+	const result = {};
+	for (const attribute of attributes) {
+		result[attribute.name] = attribute.value;
+	}
+	return result;
+}
+function get_custom_elements_slots(element) {
+	const result = {};
+	element.childNodes.forEach((node) => {
+		result[node.slot || 'default'] = true;
+	});
+	return result;
+}
+
+const active_docs = new Set();
+let active = 0;
+// https://github.com/darkskyapp/string-hash/blob/master/index.js
+function hash(str) {
+	let hash = 5381;
+	let i = str.length;
+	while (i--) hash = ((hash << 5) - hash) ^ str.charCodeAt(i);
+	return hash >>> 0;
+}
+function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
+	const step = 16.666 / duration;
+	let keyframes = '{\n';
+	for (let p = 0; p <= 1; p += step) {
+		const t = a + (b - a) * ease(p);
+		keyframes += p * 100 + `%{${fn(t, 1 - t)}}\n`;
+	}
+	const rule = keyframes + `100% {${fn(b, 1 - b)}}\n}`;
+	const name = `__svelte_${hash(rule)}_${uid}`;
+	const doc = node.ownerDocument;
+	active_docs.add(doc);
+	const stylesheet = doc.__svelte_stylesheet || (doc.__svelte_stylesheet = doc.head.appendChild(element('style')).sheet);
+	const current_rules = doc.__svelte_rules || (doc.__svelte_rules = {});
+	if (!current_rules[name]) {
+		current_rules[name] = true;
+		stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
+	}
+	const animation = node.style.animation || '';
+	node.style.animation = `${animation ? `${animation}, ` : ''}${name} ${duration}ms linear ${delay}ms 1 both`;
+	active += 1;
+	return name;
+}
+function delete_rule(node, name) {
+	const previous = (node.style.animation || '').split(', ');
+	const next = previous.filter(
+		name
+			? (anim) => anim.indexOf(name) < 0 // remove specific animation
+			: (anim) => anim.indexOf('__svelte') === -1, // remove all Svelte animations
+	);
+	const deleted = previous.length - next.length;
+	if (deleted) {
+		node.style.animation = next.join(', ');
+		active -= deleted;
+		if (!active) clear_rules();
+	}
+}
+function clear_rules() {
+	exports.raf(() => {
+		if (active) return;
+		active_docs.forEach((doc) => {
+			const stylesheet = doc.__svelte_stylesheet;
+			let i = stylesheet.cssRules.length;
+			while (i--) stylesheet.deleteRule(i);
+			doc.__svelte_rules = {};
+		});
+		active_docs.clear();
+	});
+}
+
+function create_animation(node, from, fn, params) {
+	if (!from) return noop;
+	const to = node.getBoundingClientRect();
+	if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom) return noop;
+	const {
+		delay = 0,
+		duration = 300,
+		easing = identity,
+		// @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?
+		start: start_time = exports.now() + delay,
+		// @ts-ignore todo:
+		end = start_time + duration,
+		tick = noop,
+		css,
+	} = fn(node, { from, to }, params);
+	let running = true;
+	let started = false;
+	let name;
+	function start() {
+		if (css) {
+			name = create_rule(node, 0, 1, duration, delay, easing, css);
+		}
+		if (!delay) {
+			started = true;
+		}
+	}
+	function stop() {
+		if (css) delete_rule(node, name);
+		running = false;
+	}
+	loop((now) => {
+		if (!started && now >= start_time) {
+			started = true;
+		}
+		if (started && now >= end) {
+			tick(1, 0);
+			stop();
+		}
+		if (!running) {
+			return false;
+		}
+		if (started) {
+			const p = now - start_time;
+			const t = 0 + 1 * easing(p / duration);
+			tick(t, 1 - t);
+		}
+		return true;
+	});
+	start();
+	tick(0, 1);
+	return stop;
+}
+function fix_position(node) {
+	const style = getComputedStyle(node);
+	if (style.position !== 'absolute' && style.position !== 'fixed') {
+		const { width, height } = style;
+		const a = node.getBoundingClientRect();
+		node.style.position = 'absolute';
+		node.style.width = width;
+		node.style.height = height;
+		add_transform(node, a);
+	}
+}
+function add_transform(node, a) {
+	const b = node.getBoundingClientRect();
+	if (a.left !== b.left || a.top !== b.top) {
+		const style = getComputedStyle(node);
+		const transform = style.transform === 'none' ? '' : style.transform;
+		node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;
+	}
+}
+
+function set_current_component(component) {
+	exports.current_component = component;
+}
+function get_current_component() {
+	if (!exports.current_component) throw new Error('Function called outside component initialization');
+	return exports.current_component;
+}
+function beforeUpdate(fn) {
+	get_current_component().$$.before_update.push(fn);
+}
+function onMount(fn) {
+	get_current_component().$$.on_mount.push(fn);
+}
+function afterUpdate(fn) {
+	get_current_component().$$.after_update.push(fn);
+}
+function onDestroy(fn) {
+	get_current_component().$$.on_destroy.push(fn);
+}
+function createEventDispatcher() {
+	const component = get_current_component();
+	return (type, detail) => {
+		const callbacks = component.$$.callbacks[type];
+		if (callbacks) {
+			// TODO are there situations where events could be dispatched
+			// in a server (non-DOM) environment?
+			const event = custom_event(type, detail);
+			callbacks.slice().forEach((fn) => {
+				fn.call(component, event);
+			});
+		}
+	};
+}
+function setContext(key, context) {
+	get_current_component().$$.context.set(key, context);
+}
+function getContext(key) {
+	return get_current_component().$$.context.get(key);
+}
+function hasContext(key) {
+	return get_current_component().$$.context.has(key);
+}
+// TODO figure out if we still want to support
+// shorthand events, or if we want to implement
+// a real bubbling mechanism
+function bubble(component, event) {
+	const callbacks = component.$$.callbacks[event.type];
+	if (callbacks) {
+		callbacks.slice().forEach((fn) => fn(event));
+	}
+}
+
+const dirty_components = [];
+const intros = { enabled: false };
+const 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 tick() {
+	schedule_update();
+	return resolved_promise;
+}
+function add_render_callback(fn) {
+	render_callbacks.push(fn);
+}
+function add_flush_callback(fn) {
+	flush_callbacks.push(fn);
+}
+let flushing = false;
+const seen_callbacks = new Set();
+function flush() {
+	if (flushing) return;
+	flushing = true;
+	do {
+		// first, call beforeUpdate functions
+		// and update components
+		for (let i = 0; i < dirty_components.length; i += 1) {
+			const component = dirty_components[i];
+			set_current_component(component);
+			update(component.$$);
+		}
+		set_current_component(null);
+		dirty_components.length = 0;
+		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)) {
+				// ...so guard against infinite loops
+				seen_callbacks.add(callback);
+				callback();
+			}
+		}
+		render_callbacks.length = 0;
+	} while (dirty_components.length);
+	while (flush_callbacks.length) {
+		flush_callbacks.pop()();
+	}
+	update_scheduled = false;
+	flushing = false;
+	seen_callbacks.clear();
+}
+function update($$) {
+	if ($$.fragment !== null) {
+		$$.update();
+		run_all($$.before_update);
+		const dirty = $$.dirty;
+		$$.dirty = [-1];
+		$$.fragment && $$.fragment.p($$.ctx, dirty);
+		$$.after_update.forEach(add_render_callback);
+	}
+}
+
+let promise;
+function wait() {
+	if (!promise) {
+		promise = Promise.resolve();
+		promise.then(() => {
+			promise = null;
+		});
+	}
+	return promise;
+}
+function dispatch(node, direction, kind) {
+	// @ts-ignore
+	node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));
+}
+const outroing = new Set();
+let outros;
+function group_outros() {
+	outros = {
+		r: 0,
+		c: [],
+		p: outros, // parent group
+	};
+}
+function check_outros() {
+	if (!outros.r) {
+		run_all(outros.c);
+	}
+	outros = outros.p;
+}
+function transition_in(block, local) {
+	if (block && block.i) {
+		outroing.delete(block);
+		block.i(local);
+	}
+}
+function transition_out(block, local, detach, callback) {
+	if (block && block.o) {
+		if (outroing.has(block)) return;
+		outroing.add(block);
+		outros.c.push(() => {
+			outroing.delete(block);
+			if (callback) {
+				if (detach) block.d(1);
+				callback();
+			}
+		});
+		block.o(local);
+	}
+}
+const null_transition = { duration: 0 };
+function create_in_transition(node, fn, params) {
+	let config = fn(node, params);
+	let running = false;
+	let animation_name;
+	let task;
+	let uid = 0;
+	function cleanup() {
+		if (animation_name) delete_rule(node, animation_name);
+	}
+	function go() {
+		const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
+		if (css) animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);
+		tick(0, 1);
+		const start_time = exports.now() + delay;
+		const end_time = start_time + duration;
+		if (task) task.abort();
+		running = true;
+		add_render_callback(() => dispatch(node, true, 'start'));
+		task = loop((now) => {
+			if (running) {
+				if (now >= end_time) {
+					tick(1, 0);
+					dispatch(node, true, 'end');
+					cleanup();
+					return (running = false);
+				}
+				if (now >= start_time) {
+					const t = easing((now - start_time) / duration);
+					tick(t, 1 - t);
+				}
+			}
+			return running;
+		});
+	}
+	let started = false;
+	return {
+		start() {
+			if (started) return;
+			delete_rule(node);
+			if (is_function(config)) {
+				config = config();
+				wait().then(go);
+			}
+			else {
+				go();
+			}
+		},
+		invalidate() {
+			started = false;
+		},
+		end() {
+			if (running) {
+				cleanup();
+				running = false;
+			}
+		},
+	};
+}
+function create_out_transition(node, fn, params) {
+	let config = fn(node, params);
+	let running = true;
+	let animation_name;
+	const group = outros;
+	group.r += 1;
+	function go() {
+		const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
+		if (css) animation_name = create_rule(node, 1, 0, duration, delay, easing, css);
+		const start_time = exports.now() + delay;
+		const end_time = start_time + duration;
+		add_render_callback(() => dispatch(node, false, 'start'));
+		loop((now) => {
+			if (running) {
+				if (now >= end_time) {
+					tick(0, 1);
+					dispatch(node, false, 'end');
+					if (!--group.r) {
+						// this will result in `end()` being called,
+						// so we don't need to clean up here
+						run_all(group.c);
+					}
+					return false;
+				}
+				if (now >= start_time) {
+					const t = easing((now - start_time) / duration);
+					tick(1 - t, t);
+				}
+			}
+			return running;
+		});
+	}
+	if (is_function(config)) {
+		wait().then(() => {
+			// @ts-ignore
+			config = config();
+			go();
+		});
+	}
+	else {
+		go();
+	}
+	return {
+		end(reset) {
+			if (reset && config.tick) {
+				config.tick(1, 0);
+			}
+			if (running) {
+				if (animation_name) delete_rule(node, animation_name);
+				running = false;
+			}
+		},
+	};
+}
+function create_bidirectional_transition(node, fn, params, intro) {
+	let config = fn(node, params);
+	let t = intro ? 0 : 1;
+	let running_program = null;
+	let pending_program = null;
+	let animation_name = null;
+	function clear_animation() {
+		if (animation_name) delete_rule(node, animation_name);
+	}
+	function init(program, duration) {
+		const d = program.b - t;
+		duration *= Math.abs(d);
+		return {
+			a: t,
+			b: program.b,
+			d,
+			duration,
+			start: program.start,
+			end: program.start + duration,
+			group: program.group,
+		};
+	}
+	function go(b) {
+		const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
+		const program = {
+			start: exports.now() + delay,
+			b,
+		};
+		if (!b) {
+			// @ts-ignore todo: improve typings
+			program.group = outros;
+			outros.r += 1;
+		}
+		if (running_program || pending_program) {
+			pending_program = program;
+		}
+		else {
+			// if this is an intro, and there's a delay, we need to do
+			// an initial tick and/or apply CSS animation immediately
+			if (css) {
+				clear_animation();
+				animation_name = create_rule(node, t, b, duration, delay, easing, css);
+			}
+			if (b) tick(0, 1);
+			running_program = init(program, duration);
+			add_render_callback(() => dispatch(node, b, 'start'));
+			loop((now) => {
+				if (pending_program && now > pending_program.start) {
+					running_program = init(pending_program, duration);
+					pending_program = null;
+					dispatch(node, running_program.b, 'start');
+					if (css) {
+						clear_animation();
+						animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
+					}
+				}
+				if (running_program) {
+					if (now >= running_program.end) {
+						tick((t = running_program.b), 1 - t);
+						dispatch(node, running_program.b, 'end');
+						if (!pending_program) {
+							// we're done
+							if (running_program.b) {
+								// intro — we can tidy up immediately
+								clear_animation();
+							}
+							else {
+								// outro — needs to be coordinated
+								if (!--running_program.group.r) run_all(running_program.group.c);
+							}
+						}
+						running_program = null;
+					}
+					else if (now >= running_program.start) {
+						const p = now - running_program.start;
+						t = running_program.a + running_program.d * easing(p / running_program.duration);
+						tick(t, 1 - t);
+					}
+				}
+				return !!(running_program || pending_program);
+			});
+		}
+	}
+	return {
+		run(b) {
+			if (is_function(config)) {
+				wait().then(() => {
+					// @ts-ignore
+					config = config();
+					go(b);
+				});
+			}
+			else {
+				go(b);
+			}
+		},
+		end() {
+			clear_animation();
+			running_program = pending_program = null;
+		},
+	};
+}
+
+function handle_promise(promise, info) {
+	const token = (info.token = {});
+	function update(type, index, key, value) {
+		if (info.token !== token) return;
+		info.resolved = value;
+		let child_ctx = info.ctx;
+		if (key !== undefined) {
+			child_ctx = child_ctx.slice();
+			child_ctx[key] = value;
+		}
+		const block = type && (info.current = type)(child_ctx);
+		let needs_flush = false;
+		if (info.block) {
+			if (info.blocks) {
+				info.blocks.forEach((block, i) => {
+					if (i !== index && block) {
+						group_outros();
+						transition_out(block, 1, 1, () => {
+							if (info.blocks[i] === block) {
+								info.blocks[i] = null;
+							}
+						});
+						check_outros();
+					}
+				});
+			}
+			else {
+				info.block.d(1);
+			}
+			block.c();
+			transition_in(block, 1);
+			block.m(info.mount(), info.anchor);
+			needs_flush = true;
+		}
+		info.block = block;
+		if (info.blocks) info.blocks[index] = block;
+		if (needs_flush) {
+			flush();
+		}
+	}
+	if (is_promise(promise)) {
+		const current_component = get_current_component();
+		promise.then(
+			(value) => {
+				set_current_component(current_component);
+				update(info.then, 1, info.value, value);
+				set_current_component(null);
+			},
+			(error) => {
+				set_current_component(current_component);
+				update(info.catch, 2, info.error, error);
+				set_current_component(null);
+				if (!info.hasCatch) {
+					throw error;
+				}
+			},
+		);
+		// if we previously had a then/catch block, destroy it
+		if (info.current !== info.pending) {
+			update(info.pending, 0);
+			return true;
+		}
+	}
+	else {
+		if (info.current !== info.then) {
+			update(info.then, 1, info.value, promise);
+			return true;
+		}
+		info.resolved = promise;
+	}
+}
+
+const globals = typeof window !== 'undefined' ? window : typeof globalThis !== 'undefined' ? globalThis : global;
+
+function destroy_block(block, lookup) {
+	block.d(1);
+	lookup.delete(block.key);
+}
+function outro_and_destroy_block(block, lookup) {
+	transition_out(block, 1, 1, () => {
+		lookup.delete(block.key);
+	});
+}
+function fix_and_destroy_block(block, lookup) {
+	block.f();
+	destroy_block(block, lookup);
+}
+function fix_and_outro_and_destroy_block(block, lookup) {
+	block.f();
+	outro_and_destroy_block(block, lookup);
+}
+function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {
+	let o = old_blocks.length;
+	let n = list.length;
+	let i = o;
+	const old_indexes = {};
+	while (i--) old_indexes[old_blocks[i].key] = i;
+	const new_blocks = [];
+	const new_lookup = new Map();
+	const deltas = new Map();
+	i = n;
+	while (i--) {
+		const child_ctx = get_context(ctx, list, i);
+		const key = get_key(child_ctx);
+		let block = lookup.get(key);
+		if (!block) {
+			block = create_each_block(key, child_ctx);
+			block.c();
+		}
+		else if (dynamic) {
+			block.p(child_ctx, dirty);
+		}
+		new_lookup.set(key, (new_blocks[i] = block));
+		if (key in old_indexes) deltas.set(key, Math.abs(i - old_indexes[key]));
+	}
+	const will_move = new Set();
+	const did_move = new Set();
+	function insert(block) {
+		transition_in(block, 1);
+		block.m(node, next);
+		lookup.set(block.key, block);
+		next = block.first;
+		n--;
+	}
+	while (o && n) {
+		const new_block = new_blocks[n - 1];
+		const old_block = old_blocks[o - 1];
+		const new_key = new_block.key;
+		const old_key = old_block.key;
+		if (new_block === old_block) {
+			// do nothing
+			next = new_block.first;
+			o--;
+			n--;
+		}
+		else if (!new_lookup.has(old_key)) {
+			// remove old block
+			destroy(old_block, lookup);
+			o--;
+		}
+		else if (!lookup.has(new_key) || will_move.has(new_key)) {
+			insert(new_block);
+		}
+		else if (did_move.has(old_key)) {
+			o--;
+		}
+		else if (deltas.get(new_key) > deltas.get(old_key)) {
+			did_move.add(new_key);
+			insert(new_block);
+		}
+		else {
+			will_move.add(old_key);
+			o--;
+		}
+	}
+	while (o--) {
+		const old_block = old_blocks[o];
+		if (!new_lookup.has(old_block.key)) destroy(old_block, lookup);
+	}
+	while (n) insert(new_blocks[n - 1]);
+	return new_blocks;
+}
+function validate_each_keys(ctx, list, get_context, get_key) {
+	const keys = new Set();
+	for (let i = 0; i < list.length; i++) {
+		const key = get_key(get_context(ctx, list, i));
+		if (keys.has(key)) {
+			throw new Error('Cannot have duplicate keys in a keyed each');
+		}
+		keys.add(key);
+	}
+}
+
+function get_spread_update(levels, updates) {
+	const update = {};
+	const to_null_out = {};
+	const accounted_for = { $$scope: 1 };
+	let i = levels.length;
+	while (i--) {
+		const o = levels[i];
+		const n = updates[i];
+		if (n) {
+			for (const key in o) {
+				// 收集已存在，但本次未触发更新的属性
+				if (!(key in n)) to_null_out[key] = 1;
+			}
+			for (const key in n) {
+				// 收集触发更新且尚未记录更新的属性
+				if (!accounted_for[key]) {
+					update[key] = n[key];
+					accounted_for[key] = 1;
+				}
+			}
+			// 将更新记录
+			levels[i] = n;
+		}
+		else {
+			for (const key in o) {
+				accounted_for[key] = 1;
+			}
+		}
+	}
+	for (const key in to_null_out) {
+		// 未触发更新的属性，update 置空
+		if (!(key in update)) update[key] = undefined;
+	}
+	return update;
+}
+function get_spread_object(spread_props) {
+	return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};
+}
+
+// source: https://html.spec.whatwg.org/multipage/indices.html
+const boolean_attributes = new Set([
+	'allowfullscreen',
+	'allowpaymentrequest',
+	'async',
+	'autofocus',
+	'autoplay',
+	'checked',
+	'controls',
+	'default',
+	'defer',
+	'disabled',
+	'formnovalidate',
+	'hidden',
+	'ismap',
+	'loop',
+	'multiple',
+	'muted',
+	'nomodule',
+	'novalidate',
+	'open',
+	'playsinline',
+	'readonly',
+	'required',
+	'reversed',
+	'selected',
+]);
+
+const invalid_attribute_name_character =
+	/[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
+// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+// https://infra.spec.whatwg.org/#noncharacter
+// 将 attributes obj 序列化为 string
+function spread(args, classes_to_add) {
+	const attributes = Object.assign({}, ...args);
+	if (classes_to_add) {
+		if (attributes.class == null) {
+			attributes.class = classes_to_add;
+		}
+		else {
+			attributes.class += ' ' + classes_to_add;
+		}
+	}
+	let str = '';
+	Object.keys(attributes).forEach((name) => {
+		if (invalid_attribute_name_character.test(name)) return;
+		const value = attributes[name];
+		if (value === true) str += ' ' + name;
+		else if (boolean_attributes.has(name.toLowerCase())) {
+			if (value) str += ' ' + name;
+		}
+		else if (value != null) {
+			str += ` ${name}="${String(value).replace(/"/g, '&#34;').replace(/'/g, '&#39;')}"`;
+		}
+	});
+	return str;
+}
+// escaped map
+const escaped = {
+	'"': '&quot;',
+	'\'': '&#39;',
+	'&': '&amp;',
+	'<': '&lt;',
+	'>': '&gt;',
+};
+// escaped helper function
+function escape(html) {
+	return String(html).replace(/["'&<>]/g, (match) => escaped[match]);
+}
+// run each item by helper fn
+function each(items, fn) {
+	let str = '';
+	for (let i = 0; i < items.length; i += 1) {
+		str += fn(items[i], i);
+	}
+	return str;
+}
+// empty component render function
+const missing_component = {
+	$$render: () => '',
+};
+function validate_component(component, name) {
+	if (!component || !component.$$render) {
+		if (name === 'svelte:component') name += ' this={...}';
+		throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);
+	}
+	return component;
+}
+// debug console
+function debug(file, line, column, values) {
+	console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console
+	console.log(values); // eslint-disable-line no-console
+	return '';
+}
+let on_destroy;
+// 生成 ssr component 生成器
+function create_ssr_component(fn) {
+	function $$render(result, props, bindings, slots) {
+		const parent_component = exports.current_component;
+		const $$ = {
+			on_destroy,
+			context: new Map(parent_component ? parent_component.$$.context : []),
+			// these will be immediately discarded
+			on_mount: [],
+			before_update: [],
+			after_update: [],
+			callbacks: blank_object(),
+		};
+		set_current_component({ $$ });
+		const html = fn(result, props, bindings, slots);
+		set_current_component(parent_component);
+		return html;
+	}
+	return {
+		render: (props = {}, options = {}) => {
+			on_destroy = [];
+			const result = { title: '', head: '', css: new Set() };
+			const html = $$render(result, props, {}, options);
+			run_all(on_destroy);
+			return {
+				html,
+				css: {
+					code: Array.from(result.css)
+						.map((css) => css.code)
+						.join('\n'),
+					map: null, // TODO
+				},
+				head: result.title + result.head,
+			};
+		},
+		$$render,
+	};
+}
+function add_attribute(name, value, boolean) {
+	if (value == null || (boolean && !value)) return '';
+	return ` ${name}${value === true ? '' : `=${typeof value === 'string' ? JSON.stringify(escape(value)) : `"${value}"`}`}`;
+}
+function add_classes(classes) {
+	return classes ? ` class="${classes}"` : '';
+}
+
+function bind(component, name, callback) {
+	const index = component.$$.props[name];
+	if (index !== undefined) {
+		component.$$.bound[index] = callback;
+		callback(component.$$.ctx[index]);
+	}
+}
+function create_component(block) {
+	block && block.c();
+}
+function claim_component(block, parent_nodes) {
+	block && block.l(parent_nodes);
+}
+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 = exports.current_component;
+	set_current_component(component);
+	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,
+		skip_bound: false,
+	});
+	let ready = false;
+	$$.ctx = instance
+		? instance(component, options.props || {}, (i, ret, ...rest) => {
+			const value = rest.length ? rest[0] : ret;
+			if ($$.ctx && not_equal($$.ctx[i], ($$.ctx[i] = value))) {
+				if (!$$.skip_bound && $$.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) {
+			const nodes = children(options.target);
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			$$.fragment && $$.fragment.l(nodes);
+			nodes.forEach(detach);
+		}
+		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);
+}
+if (typeof HTMLElement === 'function') {
+	exports.SvelteElement = class extends HTMLElement {
+		constructor() {
+			super();
+			this.attachShadow({ mode: 'open' });
+		}
+		connectedCallback() {
+			// @ts-ignore todo: improve typings
+			for (const key in this.$$.slotted) {
+				// @ts-ignore todo: improve typings
+				this.appendChild(this.$$.slotted[key]);
+			}
+		}
+		attributeChangedCallback(attr, _oldValue, newValue) {
+			this[attr] = newValue;
+		}
+		$destroy() {
+			destroy_component(this, 1);
+			this.$destroy = noop;
+		}
+		$on(type, callback) {
+			// TODO should this delegate to addEventListener?
+			const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
+			callbacks.push(callback);
+			return () => {
+				const index = callbacks.indexOf(callback);
+				if (index !== -1) callbacks.splice(index, 1);
+			};
+		}
+		$set($$props) {
+			if (this.$$set && !is_empty($$props)) {
+				this.$$.skip_bound = true;
+				this.$$set($$props);
+				this.$$.skip_bound = false;
+			}
+		}
+	};
+}
+/**
+ * Base class for Svelte components. Used when dev=false.
+ */
+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($$props) {
+		if (this.$$set && !is_empty($$props)) {
+			this.$$.skip_bound = true;
+			this.$$set($$props);
+			this.$$.skip_bound = false;
+		}
+	}
+}
+
+function dispatch_dev(_type, _detail) {
+	// PIKA: PixUI document 不支持 dispatch 自定义事件
+	// document.dispatchEvent(custom_event(type, { version: '1.0.7', ...detail }));
+}
+function append_dev(target, node) {
+	append(target, node);
+}
+function insert_dev(target, node, anchor) {
+	insert(target, node, anchor);
+}
+function detach_dev(node) {
+	detach(node);
+}
+function detach_between_dev(before, after) {
+	while (before.nextSibling && before.nextSibling !== after) {
+		detach_dev(before.nextSibling);
+	}
+}
+function detach_before_dev(after) {
+	while (after.previousSibling) {
+		detach_dev(after.previousSibling);
+	}
+}
+function detach_after_dev(before) {
+	while (before.nextSibling) {
+		detach_dev(before.nextSibling);
+	}
+}
+function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
+	const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
+	if (has_prevent_default) modifiers.push('preventDefault');
+	if (has_stop_propagation) modifiers.push('stopPropagation');
+	const dispose = listen(node, event, handler, options);
+	return () => {
+		dispose();
+	};
+}
+function attr_dev(node, attribute, value) {
+	attr(node, attribute, value);
+}
+function show_dev(node) {
+	show(node);
+}
+function hide_dev(node) {
+	hide(node);
+}
+function initLazyClass_dev(node) {
+	initLazyClass();
+}
+function prop_dev(node, property, value) {
+	node[property] = value;
+}
+function dataset_dev(node, property, value) {
+	node.dataset[property] = value;
+}
+function set_data_dev(text, data) {
+	data = '' + data;
+	if (text.data === data) return;
+	text.data = data;
+}
+function validate_each_argument(arg) {
+	if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
+		let msg = '{#each} only iterates over array-like objects.';
+		if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
+			msg += ' You can use a spread to convert this iterable into an array.';
+		}
+		throw new Error(msg);
+	}
+}
+function validate_slots(name, slot, keys) {
+	for (const slot_key of Object.keys(slot)) {
+		if (!~keys.indexOf(slot_key)) {
+			console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
+		}
+	}
+}
+/**
+ * Base class for Svelte components with some minor dev-enhancements. Used when dev=true.
+ */
+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
+		};
+	}
+	$capture_state() {}
+	$inject_state() {}
+}
+/**
+ * Base class to create strongly typed Svelte components.
+ * This only exists for typing purposes and should be used in `.d.ts` files.
+ *
+ * ### Example:
+ *
+ * You have component library on npm called `component-library`, from which
+ * you export a component called `MyComponent`. For Svelte+TypeScript users,
+ * you want to provide typings. Therefore you create a `index.d.ts`:
+ * ```ts
+ * import { SvelteComponentTyped } from "svelte";
+ * export class MyComponent extends SvelteComponentTyped<{foo: string}> {}
+ * ```
+ * Typing this makes it possible for IDEs like VS Code with the Svelte extension
+ * to provide intellisense and to use the component like this in a Svelte file
+ * with TypeScript:
+ * ```svelte
+ * <script lang="ts">
+ * 	import { MyComponent } from "component-library";
+ * </script>
+ * <MyComponent foo={'bar'} />
+ * ```
+ *
+ * #### Why not make this part of `SvelteComponent(Dev)`?
+ * Because
+ * ```ts
+ * class ASubclassOfSvelteComponent extends SvelteComponent<{foo: string}> {}
+ * const component: typeof SvelteComponent = ASubclassOfSvelteComponent;
+ * ```
+ * will throw a type error, so we need to seperate the more strictly typed class.
+ */
+class SvelteComponentTyped extends SvelteComponentDev {
+	constructor(options) {
+		super(options);
+	}
+}
+function loop_guard(timeout) {
+	const start = Date.now();
+	return () => {
+		if (Date.now() - start > timeout) {
+			throw new Error('Infinite loop detected');
+		}
+	};
+}
+
+exports.HtmlTag = HtmlTag;
+exports.SvelteComponent = SvelteComponent;
+exports.SvelteComponentDev = SvelteComponentDev;
+exports.SvelteComponentTyped = SvelteComponentTyped;
+exports.action_destroyer = action_destroyer;
+exports.add_attribute = add_attribute;
+exports.add_classes = add_classes;
+exports.add_flush_callback = add_flush_callback;
+exports.add_location = add_location;
+exports.add_render_callback = add_render_callback;
+exports.add_resize_listener = add_resize_listener;
+exports.add_transform = add_transform;
+exports.afterUpdate = afterUpdate;
+exports.append = append;
+exports.append_dev = append_dev;
+exports.assign = assign;
+exports.attr = attr;
+exports.attr_dev = attr_dev;
+exports.attribute_to_object = attribute_to_object;
+exports.beforeUpdate = beforeUpdate;
+exports.bind = bind;
+exports.binding_callbacks = binding_callbacks;
+exports.blank_object = blank_object;
+exports.bubble = bubble;
+exports.check_outros = check_outros;
+exports.children = children;
+exports.claim_component = claim_component;
+exports.claim_element = claim_element;
+exports.claim_space = claim_space;
+exports.claim_text = claim_text;
+exports.clear_loops = clear_loops;
+exports.component_subscribe = component_subscribe;
+exports.compute_rest_props = compute_rest_props;
+exports.compute_slots = compute_slots;
+exports.createEventDispatcher = createEventDispatcher;
+exports.create_animation = create_animation;
+exports.create_bidirectional_transition = create_bidirectional_transition;
+exports.create_component = create_component;
+exports.create_in_transition = create_in_transition;
+exports.create_out_transition = create_out_transition;
+exports.create_slot = create_slot;
+exports.create_ssr_component = create_ssr_component;
+exports.custom_event = custom_event;
+exports.dataset_dev = dataset_dev;
+exports.debug = debug;
+exports.destroy_block = destroy_block;
+exports.destroy_component = destroy_component;
+exports.destroy_each = destroy_each;
+exports.detach = detach;
+exports.detach_after_dev = detach_after_dev;
+exports.detach_before_dev = detach_before_dev;
+exports.detach_between_dev = detach_between_dev;
+exports.detach_dev = detach_dev;
+exports.dirty_components = dirty_components;
+exports.dispatch_dev = dispatch_dev;
+exports.each = each;
+exports.element = element;
+exports.element_is = element_is;
+exports.empty = empty;
+exports.escape = escape;
+exports.escaped = escaped;
+exports.exclude_internal_props = exclude_internal_props;
+exports.fix_and_destroy_block = fix_and_destroy_block;
+exports.fix_and_outro_and_destroy_block = fix_and_outro_and_destroy_block;
+exports.fix_position = fix_position;
+exports.flush = flush;
+exports.getContext = getContext;
+exports.get_binding_group_value = get_binding_group_value;
+exports.get_current_component = get_current_component;
+exports.get_custom_elements_slots = get_custom_elements_slots;
+exports.get_slot_changes = get_slot_changes;
+exports.get_slot_context = get_slot_context;
+exports.get_spread_object = get_spread_object;
+exports.get_spread_update = get_spread_update;
+exports.get_store_value = get_store_value;
+exports.globals = globals;
+exports.group_outros = group_outros;
+exports.handle_promise = handle_promise;
+exports.hasContext = hasContext;
+exports.has_prop = has_prop;
+exports.hide = hide;
+exports.hide_dev = hide_dev;
+exports.identity = identity;
+exports.init = init;
+exports.initLazyClass = initLazyClass;
+exports.initLazyClass_dev = initLazyClass_dev;
+exports.insert = insert;
+exports.insert_dev = insert_dev;
+exports.intros = intros;
+exports.invalid_attribute_name_character = invalid_attribute_name_character;
+exports.isSupportEmptyText = isSupportEmptyText;
+exports.is_client = is_client;
+exports.is_crossorigin = is_crossorigin;
+exports.is_empty = is_empty;
+exports.is_function = is_function;
+exports.is_promise = is_promise;
+exports.listen = listen;
+exports.listen_dev = listen_dev;
+exports.loop = loop;
+exports.loop_guard = loop_guard;
+exports.missing_component = missing_component;
+exports.mount_component = mount_component;
+exports.noop = noop;
+exports.not_equal = not_equal;
+exports.null_to_empty = null_to_empty;
+exports.object_without_properties = object_without_properties;
+exports.onDestroy = onDestroy;
+exports.onMount = onMount;
+exports.once = once;
+exports.outro_and_destroy_block = outro_and_destroy_block;
+exports.prevent_default = prevent_default;
+exports.prop_dev = prop_dev;
+exports.query_selector_all = query_selector_all;
+exports.run = run;
+exports.run_all = run_all;
+exports.safe_not_equal = safe_not_equal;
+exports.schedule_update = schedule_update;
+exports.select_multiple_value = select_multiple_value;
+exports.select_option = select_option;
+exports.select_options = select_options;
+exports.select_value = select_value;
+exports.self = self;
+exports.setContext = setContext;
+exports.set_attributes = set_attributes;
+exports.set_current_component = set_current_component;
+exports.set_custom_element_data = set_custom_element_data;
+exports.set_data = set_data;
+exports.set_data_dev = set_data_dev;
+exports.set_input_type = set_input_type;
+exports.set_input_value = set_input_value;
+exports.set_now = set_now;
+exports.set_raf = set_raf;
+exports.set_store_value = set_store_value;
+exports.set_style = set_style;
+exports.set_svg_attributes = set_svg_attributes;
+exports.show = show;
+exports.show_dev = show_dev;
+exports.space = space;
+exports.spread = spread;
+exports.stop_propagation = stop_propagation;
+exports.subscribe = subscribe;
+exports.svg_element = svg_element;
+exports.text = text;
+exports.tick = tick;
+exports.time_ranges_to_array = time_ranges_to_array;
+exports.to_number = to_number;
+exports.toggle_class = toggle_class;
+exports.transition_in = transition_in;
+exports.transition_out = transition_out;
+exports.update_keyed_each = update_keyed_each;
+exports.update_slot = update_slot;
+exports.update_slot_spread = update_slot_spread;
+exports.validate_component = validate_component;
+exports.validate_each_argument = validate_each_argument;
+exports.validate_each_keys = validate_each_keys;
+exports.validate_slots = validate_slots;
+exports.validate_store = validate_store;
+exports.xlink_attr = xlink_attr;