(function () {
	'use strict';

	/** @returns {void} */
	function noop() {}

	// Adapted from https://github.com/then/is-promise/blob/master/index.js
	// Distributed under MIT License https://github.com/then/is-promise/blob/master/LICENSE
	/**
	 * @param {any} value
	 * @returns {value is PromiseLike<any>}
	 */
	function is_promise(value) {
		return (
			!!value &&
			(typeof value === 'object' || typeof value === 'function') &&
			typeof (/** @type {any} */ (value).then) === 'function'
		);
	}

	function run(fn) {
		return fn();
	}

	function blank_object() {
		return Object.create(null);
	}

	/**
	 * @param {Function[]} fns
	 * @returns {void}
	 */
	function run_all(fns) {
		fns.forEach(run);
	}

	/**
	 * @param {any} thing
	 * @returns {thing is Function}
	 */
	function is_function(thing) {
		return typeof thing === 'function';
	}

	/** @returns {boolean} */
	function safe_not_equal(a, b) {
		return a != a ? b == b : a !== b || (a && typeof a === 'object') || typeof a === 'function';
	}

	/** @returns {boolean} */
	function is_empty(obj) {
		return Object.keys(obj).length === 0;
	}

	/**
	 * @param {Node} target
	 * @param {Node} node
	 * @returns {void}
	 */
	function append(target, node) {
		target.appendChild(node);
	}

	/**
	 * @param {Node} target
	 * @param {Node} node
	 * @param {Node} [anchor]
	 * @returns {void}
	 */
	function insert(target, node, anchor) {
		target.insertBefore(node, anchor || null);
	}

	/**
	 * @param {Node} node
	 * @returns {void}
	 */
	function detach(node) {
		if (node.parentNode) {
			node.parentNode.removeChild(node);
		}
	}

	/**
	 * @returns {void} */
	function destroy_each(iterations, detaching) {
		for (let i = 0; i < iterations.length; i += 1) {
			if (iterations[i]) iterations[i].d(detaching);
		}
	}

	/**
	 * @template {keyof HTMLElementTagNameMap} K
	 * @param {K} name
	 * @returns {HTMLElementTagNameMap[K]}
	 */
	function element(name) {
		return document.createElement(name);
	}

	/**
	 * @param {string} data
	 * @returns {Text}
	 */
	function text(data) {
		return document.createTextNode(data);
	}

	/**
	 * @returns {Text} */
	function space() {
		return text(' ');
	}

	/**
	 * @returns {Text} */
	function empty() {
		return text('');
	}

	/**
	 * @param {Element} element
	 * @returns {ChildNode[]}
	 */
	function children(element) {
		return Array.from(element.childNodes);
	}

	/**
	 * @param {Text} text
	 * @param {unknown} data
	 * @returns {void}
	 */
	function set_data(text, data) {
		data = '' + data;
		if (text.data === data) return;
		text.data = /** @type {string} */ (data);
	}

	/**
	 * @typedef {Node & {
	 * 	claim_order?: number;
	 * 	hydrate_init?: true;
	 * 	actual_end_child?: NodeEx;
	 * 	childNodes: NodeListOf<NodeEx>;
	 * }} NodeEx
	 */

	/** @typedef {ChildNode & NodeEx} ChildNodeEx */

	/** @typedef {NodeEx & { claim_order: number }} NodeEx2 */

	/**
	 * @typedef {ChildNodeEx[] & {
	 * 	claim_info?: {
	 * 		last_index: number;
	 * 		total_claimed: number;
	 * 	};
	 * }} ChildNodeArray
	 */

	let current_component;

	/** @returns {void} */
	function set_current_component(component) {
		current_component = component;
	}

	function get_current_component() {
		if (!current_component) throw new Error('Function called outside component initialization');
		return current_component;
	}

	const dirty_components = [];
	const binding_callbacks = [];

	let render_callbacks = [];

	const flush_callbacks = [];

	const resolved_promise = /* @__PURE__ */ Promise.resolve();

	let update_scheduled = false;

	/** @returns {void} */
	function schedule_update() {
		if (!update_scheduled) {
			update_scheduled = true;
			resolved_promise.then(flush);
		}
	}

	/** @returns {void} */
	function add_render_callback(fn) {
		render_callbacks.push(fn);
	}

	// flush() calls callbacks in this order:
	// 1. All beforeUpdate callbacks, in order: parents before children
	// 2. All bind:this callbacks, in reverse order: children before parents.
	// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
	//    for afterUpdates called during the initial onMount, which are called in
	//    reverse order: children before parents.
	// Since callbacks might update component values, which could trigger another
	// call to flush(), the following steps guard against this:
	// 1. During beforeUpdate, any updated components will be added to the
	//    dirty_components array and will cause a reentrant call to flush(). Because
	//    the flush index is kept outside the function, the reentrant call will pick
	//    up where the earlier call left off and go through all dirty components. The
	//    current_component value is saved and restored so that the reentrant call will
	//    not interfere with the "parent" flush() call.
	// 2. bind:this callbacks cannot trigger new flush() calls.
	// 3. During afterUpdate, any updated components will NOT have their afterUpdate
	//    callback called a second time; the seen_callbacks set, outside the flush()
	//    function, guarantees this behavior.
	const seen_callbacks = new Set();

	let flushidx = 0; // Do *not* move this inside the flush() function

	/** @returns {void} */
	function flush() {
		// Do not reenter flush while dirty components are updated, as this can
		// result in an infinite loop. Instead, let the inner flush handle it.
		// Reentrancy is ok afterwards for bindings etc.
		if (flushidx !== 0) {
			return;
		}
		const saved_component = current_component;
		do {
			// first, call beforeUpdate functions
			// and update components
			try {
				while (flushidx < dirty_components.length) {
					const component = dirty_components[flushidx];
					flushidx++;
					set_current_component(component);
					update(component.$$);
				}
			} catch (e) {
				// reset dirty state to not end up in a deadlocked state and then rethrow
				dirty_components.length = 0;
				flushidx = 0;
				throw e;
			}
			set_current_component(null);
			dirty_components.length = 0;
			flushidx = 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;
		seen_callbacks.clear();
		set_current_component(saved_component);
	}

	/** @returns {void} */
	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);
		}
	}

	/**
	 * Useful for example to execute remaining `afterUpdate` callbacks before executing `destroy`.
	 * @param {Function[]} fns
	 * @returns {void}
	 */
	function flush_render_callbacks(fns) {
		const filtered = [];
		const targets = [];
		render_callbacks.forEach((c) => (fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c)));
		targets.forEach((c) => c());
		render_callbacks = filtered;
	}

	const outroing = new Set();

	/**
	 * @type {Outro}
	 */
	let outros;

	/**
	 * @returns {void} */
	function group_outros() {
		outros = {
			r: 0,
			c: [],
			p: outros // parent group
		};
	}

	/**
	 * @returns {void} */
	function check_outros() {
		if (!outros.r) {
			run_all(outros.c);
		}
		outros = outros.p;
	}

	/**
	 * @param {import('./private.js').Fragment} block
	 * @param {0 | 1} [local]
	 * @returns {void}
	 */
	function transition_in(block, local) {
		if (block && block.i) {
			outroing.delete(block);
			block.i(local);
		}
	}

	/**
	 * @param {import('./private.js').Fragment} block
	 * @param {0 | 1} local
	 * @param {0 | 1} [detach]
	 * @param {() => void} [callback]
	 * @returns {void}
	 */
	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);
		} else if (callback) {
			callback();
		}
	}

	/** @typedef {1} INTRO */
	/** @typedef {0} OUTRO */
	/** @typedef {{ direction: 'in' | 'out' | 'both' }} TransitionOptions */
	/** @typedef {(node: Element, params: any, options: TransitionOptions) => import('../transition/public.js').TransitionConfig} TransitionFn */

	/**
	 * @typedef {Object} Outro
	 * @property {number} r
	 * @property {Function[]} c
	 * @property {Object} p
	 */

	/**
	 * @typedef {Object} PendingProgram
	 * @property {number} start
	 * @property {INTRO|OUTRO} b
	 * @property {Outro} [group]
	 */

	/**
	 * @typedef {Object} Program
	 * @property {number} a
	 * @property {INTRO|OUTRO} b
	 * @property {1|-1} d
	 * @property {number} duration
	 * @property {number} start
	 * @property {number} end
	 * @property {Outro} [group]
	 */

	/**
	 * @template T
	 * @param {Promise<T>} promise
	 * @param {import('./private.js').PromiseInfo<T>} info
	 * @returns {boolean}
	 */
	function handle_promise(promise, info) {
		const token = (info.token = {});
		/**
		 * @param {import('./private.js').FragmentFactory} type
		 * @param {0 | 1 | 2} index
		 * @param {number} [key]
		 * @param {any} [value]
		 * @returns {void}
		 */
		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 = /** @type {T} */ (promise);
		}
	}

	/** @returns {void} */
	function update_await_block_branch(info, ctx, dirty) {
		const child_ctx = ctx.slice();
		const { resolved } = info;
		if (info.current === info.then) {
			child_ctx[info.value] = resolved;
		}
		if (info.current === info.catch) {
			child_ctx[info.error] = resolved;
		}
		info.block.p(child_ctx, dirty);
	}

	// general each functions:

	function ensure_array_like(array_like_or_iterator) {
		return array_like_or_iterator?.length !== undefined
			? array_like_or_iterator
			: Array.from(array_like_or_iterator);
	}

	/** @returns {void} */
	function create_component(block) {
		block && block.c();
	}

	/** @returns {void} */
	function mount_component(component, target, anchor) {
		const { fragment, after_update } = component.$$;
		fragment && fragment.m(target, anchor);
		// onMount happens before the initial afterUpdate
		add_render_callback(() => {
			const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
			// if the component was destroyed immediately
			// it will update the `$$.on_destroy` reference to `null`.
			// the destructured on_destroy may still reference to the old array
			if (component.$$.on_destroy) {
				component.$$.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);
	}

	/** @returns {void} */
	function destroy_component(component, detaching) {
		const $$ = component.$$;
		if ($$.fragment !== null) {
			flush_render_callbacks($$.after_update);
			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 = [];
		}
	}

	/** @returns {void} */
	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;
	}

	// TODO: Document the other params
	/**
	 * @param {SvelteComponent} component
	 * @param {import('./public.js').ComponentConstructorOptions} options
	 *
	 * @param {import('./utils.js')['not_equal']} not_equal Used to compare props and state values.
	 * @param {(target: Element | ShadowRoot) => void} [append_styles] Function that appends styles to the DOM when the component is first initialised.
	 * This will be the `add_css` function from the compiled component.
	 *
	 * @returns {void}
	 */
	function init(
		component,
		options,
		instance,
		create_fragment,
		not_equal,
		props,
		append_styles = null,
		dirty = [-1]
	) {
		const parent_component = current_component;
		set_current_component(component);
		/** @type {import('./private.js').T$$} */
		const $$ = (component.$$ = {
			fragment: null,
			ctx: [],
			// state
			props,
			update: noop,
			not_equal,
			bound: blank_object(),
			// lifecycle
			on_mount: [],
			on_destroy: [],
			on_disconnect: [],
			before_update: [],
			after_update: [],
			context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
			// everything else
			callbacks: blank_object(),
			dirty,
			skip_bound: false,
			root: options.target || parent_component.$$.root
		});
		append_styles && append_styles($$.root);
		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) {
				// TODO: what is the correct type here?
				// @ts-expect-error
				const nodes = children(options.target);
				$$.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);
	}

	/**
	 * Base class for Svelte components. Used when dev=false.
	 *
	 * @template {Record<string, any>} [Props=any]
	 * @template {Record<string, any>} [Events=any]
	 */
	class SvelteComponent {
		/**
		 * ### PRIVATE API
		 *
		 * Do not use, may change at any time
		 *
		 * @type {any}
		 */
		$$ = undefined;
		/**
		 * ### PRIVATE API
		 *
		 * Do not use, may change at any time
		 *
		 * @type {any}
		 */
		$$set = undefined;

		/** @returns {void} */
		$destroy() {
			destroy_component(this, 1);
			this.$destroy = noop;
		}

		/**
		 * @template {Extract<keyof Events, string>} K
		 * @param {K} type
		 * @param {((e: Events[K]) => void) | null | undefined} callback
		 * @returns {() => void}
		 */
		$on(type, callback) {
			if (!is_function(callback)) {
				return noop;
			}
			const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
			callbacks.push(callback);
			return () => {
				const index = callbacks.indexOf(callback);
				if (index !== -1) callbacks.splice(index, 1);
			};
		}

		/**
		 * @param {Partial<Props>} props
		 * @returns {void}
		 */
		$set(props) {
			if (this.$$set && !is_empty(props)) {
				this.$$.skip_bound = true;
				this.$$set(props);
				this.$$.skip_bound = false;
			}
		}
	}

	/**
	 * @typedef {Object} CustomElementPropDefinition
	 * @property {string} [attribute]
	 * @property {boolean} [reflect]
	 * @property {'String'|'Boolean'|'Number'|'Array'|'Object'} [type]
	 */

	// generated during release, do not modify

	const PUBLIC_VERSION = '4';

	if (typeof window !== 'undefined')
		// @ts-ignore
		(window.__svelte || (window.__svelte = { v: new Set() })).v.add(PUBLIC_VERSION);

	/* src\lib\Left.svelte generated by Svelte v4.2.20 */

	function create_else_block$9(ctx) {
		let li;
		let t0;
		let t1_value = /*data*/ ctx[0].RelativePath + "";
		let t1;
		let t2;
		let t3_value = /*data*/ ctx[0].Size + "";
		let t3;
		let t4;
		let t5_value = /*data*/ ctx[0].Ticks + "";
		let t5;

		return {
			c() {
				li = element("li");
				t0 = text("Left: ");
				t1 = text(t1_value);
				t2 = text(" - ");
				t3 = text(t3_value);
				t4 = text(" - ");
				t5 = text(t5_value);
			},
			m(target, anchor) {
				insert(target, li, anchor);
				append(li, t0);
				append(li, t1);
				append(li, t2);
				append(li, t3);
				append(li, t4);
				append(li, t5);
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1 && t1_value !== (t1_value = /*data*/ ctx[0].RelativePath + "")) set_data(t1, t1_value);
				if (dirty & /*data*/ 1 && t3_value !== (t3_value = /*data*/ ctx[0].Size + "")) set_data(t3, t3_value);
				if (dirty & /*data*/ 1 && t5_value !== (t5_value = /*data*/ ctx[0].Ticks + "")) set_data(t5, t5_value);
			},
			d(detaching) {
				if (detaching) {
					detach(li);
				}
			}
		};
	}

	// (5:0) {#if !data}
	function create_if_block$9(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "Left data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	function create_fragment$9(ctx) {
		let if_block_anchor;

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return create_if_block$9;
			return create_else_block$9;
		}

		let current_block_type = select_block_type(ctx);
		let if_block = current_block_type(ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_block.m(target, anchor);
				insert(target, if_block_anchor, anchor);
			},
			p(ctx, [dirty]) {
				if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
					if_block.p(ctx, dirty);
				} else {
					if_block.d(1);
					if_block = current_block_type(ctx);

					if (if_block) {
						if_block.c();
						if_block.m(if_block_anchor.parentNode, if_block_anchor);
					}
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_block.d(detaching);
			}
		};
	}

	function instance$9($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class Left extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$9, create_fragment$9, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\Right.svelte generated by Svelte v4.2.20 */

	function create_else_block$8(ctx) {
		let li;
		let t0;
		let t1_value = /*data*/ ctx[0].RelativePath + "";
		let t1;
		let t2;
		let t3_value = /*data*/ ctx[0].Size + "";
		let t3;
		let t4;
		let t5_value = /*data*/ ctx[0].Ticks + "";
		let t5;

		return {
			c() {
				li = element("li");
				t0 = text("Right: ");
				t1 = text(t1_value);
				t2 = text(" - ");
				t3 = text(t3_value);
				t4 = text(" - ");
				t5 = text(t5_value);
			},
			m(target, anchor) {
				insert(target, li, anchor);
				append(li, t0);
				append(li, t1);
				append(li, t2);
				append(li, t3);
				append(li, t4);
				append(li, t5);
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1 && t1_value !== (t1_value = /*data*/ ctx[0].RelativePath + "")) set_data(t1, t1_value);
				if (dirty & /*data*/ 1 && t3_value !== (t3_value = /*data*/ ctx[0].Size + "")) set_data(t3, t3_value);
				if (dirty & /*data*/ 1 && t5_value !== (t5_value = /*data*/ ctx[0].Ticks + "")) set_data(t5, t5_value);
			},
			d(detaching) {
				if (detaching) {
					detach(li);
				}
			}
		};
	}

	// (5:0) {#if !data}
	function create_if_block$8(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "Right data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	function create_fragment$8(ctx) {
		let if_block_anchor;

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return create_if_block$8;
			return create_else_block$8;
		}

		let current_block_type = select_block_type(ctx);
		let if_block = current_block_type(ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_block.m(target, anchor);
				insert(target, if_block_anchor, anchor);
			},
			p(ctx, [dirty]) {
				if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
					if_block.p(ctx, dirty);
				} else {
					if_block.d(1);
					if_block = current_block_type(ctx);

					if (if_block) {
						if_block.c();
						if_block.m(if_block_anchor.parentNode, if_block_anchor);
					}
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_block.d(detaching);
			}
		};
	}

	function instance$8($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class Right extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$8, create_fragment$8, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\AreEqual.svelte generated by Svelte v4.2.20 */

	function get_each_context$6(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$7(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$6(get_each_context$6(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$6(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block$6(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1$6(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "AreEqual data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$7(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "AreEqual data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block$6(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("AreEqual:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$7(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$7, create_if_block_1$6, create_else_block$7];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$7($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class AreEqual extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$7, create_fragment$7, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\LeftSideIsNewer.svelte generated by Svelte v4.2.20 */

	function get_each_context$5(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$6(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$5(get_each_context$5(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$5(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block$5(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1$5(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "LeftSideIsNewer data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$6(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "LeftSideIsNewer data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block$5(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("LeftSideIsNewer:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$6(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$6, create_if_block_1$5, create_else_block$6];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$6($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class LeftSideIsNewer extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$6, create_fragment$6, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\LeftSideOnly.svelte generated by Svelte v4.2.20 */

	function get_each_context$4(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$5(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$4(get_each_context$4(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$4(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block$4(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1$4(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "LeftSideOnly data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$5(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "LeftSideOnly data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block$4(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("LeftSideOnly:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$5(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$5, create_if_block_1$4, create_else_block$5];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$5($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class LeftSideOnly extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$5, create_fragment$5, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\NotEqualBut.svelte generated by Svelte v4.2.20 */

	function get_each_context$3(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$4(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$3(get_each_context$3(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$3(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block$3(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1$3(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "NotEqualBut data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$4(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "NotEqualBut data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block$3(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("NotEqualBut:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$4(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$4, create_if_block_1$3, create_else_block$4];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$4($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class NotEqualBut extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$4, create_fragment$4, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\Records.svelte generated by Svelte v4.2.20 */

	function get_each_context$2(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (9:0) {:else}
	function create_else_block$3(ctx) {
		let t;
		let each_1_anchor;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i));
		}

		return {
			c() {
				t = text("Records:\n  ");

				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				insert(target, t, anchor);

				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$2(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
						} else {
							each_blocks[i] = create_each_block$2(child_ctx);
							each_blocks[i].c();
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					for (; i < each_blocks.length; i += 1) {
						each_blocks[i].d(1);
					}

					each_blocks.length = each_value.length;
				}
			},
			d(detaching) {
				if (detaching) {
					detach(t);
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (7:28) 
	function create_if_block_1$2(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "Records data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (5:0) {#if !data}
	function create_if_block$3(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "Records data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (11:2) {#each data as record}
	function create_each_block$2(ctx) {
		let li;
		let t_value = /*record*/ ctx[1].Left.Records + "";
		let t;

		return {
			c() {
				li = element("li");
				t = text(t_value);
			},
			m(target, anchor) {
				insert(target, li, anchor);
				append(li, t);
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1 && t_value !== (t_value = /*record*/ ctx[1].Left.Records + "")) set_data(t, t_value);
			},
			d(detaching) {
				if (detaching) {
					detach(li);
				}
			}
		};
	}

	function create_fragment$3(ctx) {
		let if_block_anchor;

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return create_if_block$3;
			if (/*data*/ ctx[0].length === 0) return create_if_block_1$2;
			return create_else_block$3;
		}

		let current_block_type = select_block_type(ctx);
		let if_block = current_block_type(ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_block.m(target, anchor);
				insert(target, if_block_anchor, anchor);
			},
			p(ctx, [dirty]) {
				if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
					if_block.p(ctx, dirty);
				} else {
					if_block.d(1);
					if_block = current_block_type(ctx);

					if (if_block) {
						if_block.c();
						if_block.m(if_block_anchor.parentNode, if_block_anchor);
					}
				}
			},
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_block.d(detaching);
			}
		};
	}

	function instance$3($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class Records extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$3, create_fragment$3, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\RightSideIsNewer.svelte generated by Svelte v4.2.20 */

	function get_each_context$1(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$2(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context$1(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block$1(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1$1(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "RightSideIsNewer data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$2(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "RightSideIsNewer data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block$1(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("RightSideIsNewer:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$2(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$2, create_if_block_1$1, create_else_block$2];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$2($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class RightSideIsNewer extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$2, create_fragment$2, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\RightSideOnly.svelte generated by Svelte v4.2.20 */

	function get_each_context(ctx, list, i) {
		const child_ctx = ctx.slice();
		child_ctx[1] = list[i];
		return child_ctx;
	}

	// (12:0) {:else}
	function create_else_block$1(ctx) {
		let each_1_anchor;
		let current;
		let each_value = ensure_array_like(/*data*/ ctx[0]);
		let each_blocks = [];

		for (let i = 0; i < each_value.length; i += 1) {
			each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
		}

		const out = i => transition_out(each_blocks[i], 1, 1, () => {
			each_blocks[i] = null;
		});

		return {
			c() {
				for (let i = 0; i < each_blocks.length; i += 1) {
					each_blocks[i].c();
				}

				each_1_anchor = empty();
			},
			m(target, anchor) {
				for (let i = 0; i < each_blocks.length; i += 1) {
					if (each_blocks[i]) {
						each_blocks[i].m(target, anchor);
					}
				}

				insert(target, each_1_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if (dirty & /*data*/ 1) {
					each_value = ensure_array_like(/*data*/ ctx[0]);
					let i;

					for (i = 0; i < each_value.length; i += 1) {
						const child_ctx = get_each_context(ctx, each_value, i);

						if (each_blocks[i]) {
							each_blocks[i].p(child_ctx, dirty);
							transition_in(each_blocks[i], 1);
						} else {
							each_blocks[i] = create_each_block(child_ctx);
							each_blocks[i].c();
							transition_in(each_blocks[i], 1);
							each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
						}
					}

					group_outros();

					for (i = each_value.length; i < each_blocks.length; i += 1) {
						out(i);
					}

					check_outros();
				}
			},
			i(local) {
				if (current) return;

				for (let i = 0; i < each_value.length; i += 1) {
					transition_in(each_blocks[i]);
				}

				current = true;
			},
			o(local) {
				each_blocks = each_blocks.filter(Boolean);

				for (let i = 0; i < each_blocks.length; i += 1) {
					transition_out(each_blocks[i]);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(each_1_anchor);
				}

				destroy_each(each_blocks, detaching);
			}
		};
	}

	// (10:28) 
	function create_if_block_1(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "RightSideOnly data is empty";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (8:0) {#if !data}
	function create_if_block$1(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "RightSideOnly data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (13:2) {#each data as segment}
	function create_each_block(ctx) {
		let t0;
		let left;
		let t1;
		let right;
		let current;
		left = new Left({ props: { data: /*segment*/ ctx[1].Left } });

		right = new Right({
				props: { data: /*segment*/ ctx[1].Right }
			});

		return {
			c() {
				t0 = text("RightSideOnly:\n    ");
				create_component(left.$$.fragment);
				t1 = space();
				create_component(right.$$.fragment);
			},
			m(target, anchor) {
				insert(target, t0, anchor);
				mount_component(left, target, anchor);
				insert(target, t1, anchor);
				mount_component(right, target, anchor);
				current = true;
			},
			p(ctx, dirty) {
				const left_changes = {};
				if (dirty & /*data*/ 1) left_changes.data = /*segment*/ ctx[1].Left;
				left.$set(left_changes);
				const right_changes = {};
				if (dirty & /*data*/ 1) right_changes.data = /*segment*/ ctx[1].Right;
				right.$set(right_changes);
			},
			i(local) {
				if (current) return;
				transition_in(left.$$.fragment, local);
				transition_in(right.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(left.$$.fragment, local);
				transition_out(right.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(t0);
					detach(t1);
				}

				destroy_component(left, detaching);
				destroy_component(right, detaching);
			}
		};
	}

	function create_fragment$1(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block$1, create_if_block_1, create_else_block$1];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[0]) return 0;
			if (/*data*/ ctx[0].length === 0) return 1;
			return 2;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, [dirty]) {
				let previous_block_index = current_block_type_index;
				current_block_type_index = select_block_type(ctx);

				if (current_block_type_index === previous_block_index) {
					if_blocks[current_block_type_index].p(ctx, dirty);
				} else {
					group_outros();

					transition_out(if_blocks[previous_block_index], 1, 1, () => {
						if_blocks[previous_block_index] = null;
					});

					check_outros();
					if_block = if_blocks[current_block_type_index];

					if (!if_block) {
						if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
						if_block.c();
					} else {
						if_block.p(ctx, dirty);
					}

					transition_in(if_block, 1);
					if_block.m(if_block_anchor.parentNode, if_block_anchor);
				}
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	function instance$1($$self, $$props, $$invalidate) {
		let { data } = $$props;

		$$self.$$set = $$props => {
			if ('data' in $$props) $$invalidate(0, data = $$props.data);
		};

		return [data];
	}

	class RightSideOnly extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance$1, create_fragment$1, safe_not_equal, { data: 0 });
		}
	}

	/* src\lib\Review.svelte generated by Svelte v4.2.20 */

	function create_catch_block(ctx) {
		let span;

		return {
			c() {
				span = element("span");
				span.textContent = `${/*error*/ ctx[5]}`;
			},
			m(target, anchor) {
				insert(target, span, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(span);
				}
			}
		};
	}

	// (24:0) {:then data}
	function create_then_block(ctx) {
		let current_block_type_index;
		let if_block;
		let if_block_anchor;
		let current;
		const if_block_creators = [create_if_block, create_else_block];
		const if_blocks = [];

		function select_block_type(ctx, dirty) {
			if (!/*data*/ ctx[4]) return 0;
			return 1;
		}

		current_block_type_index = select_block_type(ctx);
		if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);

		return {
			c() {
				if_block.c();
				if_block_anchor = empty();
			},
			m(target, anchor) {
				if_blocks[current_block_type_index].m(target, anchor);
				insert(target, if_block_anchor, anchor);
				current = true;
			},
			p(ctx, dirty) {
				if_block.p(ctx, dirty);
			},
			i(local) {
				if (current) return;
				transition_in(if_block);
				current = true;
			},
			o(local) {
				transition_out(if_block);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(if_block_anchor);
				}

				if_blocks[current_block_type_index].d(detaching);
			}
		};
	}

	// (28:2) {:else}
	function create_else_block(ctx) {
		let p;
		let t1;
		let areequal;
		let t2;
		let leftsideisnewer;
		let t3;
		let leftsideonly;
		let t4;
		let notequalbut;
		let t5;
		let records;
		let t6;
		let rightsideisnewer;
		let t7;
		let rightsideonly;
		let current;

		areequal = new AreEqual({
				props: { data: /*data*/ ctx[4].AreEqual }
			});

		leftsideisnewer = new LeftSideIsNewer({
				props: { data: /*data*/ ctx[4].LeftSideIsNewer }
			});

		leftsideonly = new LeftSideOnly({
				props: { data: /*data*/ ctx[4].LeftSideOnly }
			});

		notequalbut = new NotEqualBut({
				props: { data: /*data*/ ctx[4].NotEqualBut }
			});

		records = new Records({ props: { data: /*data*/ ctx[4].Records } });

		rightsideisnewer = new RightSideIsNewer({
				props: { data: /*data*/ ctx[4].RightSideIsNewer }
			});

		rightsideonly = new RightSideOnly({
				props: { data: /*data*/ ctx[4].RightSideOnly }
			});

		return {
			c() {
				p = element("p");
				p.textContent = "Review:";
				t1 = space();
				create_component(areequal.$$.fragment);
				t2 = space();
				create_component(leftsideisnewer.$$.fragment);
				t3 = space();
				create_component(leftsideonly.$$.fragment);
				t4 = space();
				create_component(notequalbut.$$.fragment);
				t5 = space();
				create_component(records.$$.fragment);
				t6 = space();
				create_component(rightsideisnewer.$$.fragment);
				t7 = space();
				create_component(rightsideonly.$$.fragment);
			},
			m(target, anchor) {
				insert(target, p, anchor);
				insert(target, t1, anchor);
				mount_component(areequal, target, anchor);
				insert(target, t2, anchor);
				mount_component(leftsideisnewer, target, anchor);
				insert(target, t3, anchor);
				mount_component(leftsideonly, target, anchor);
				insert(target, t4, anchor);
				mount_component(notequalbut, target, anchor);
				insert(target, t5, anchor);
				mount_component(records, target, anchor);
				insert(target, t6, anchor);
				mount_component(rightsideisnewer, target, anchor);
				insert(target, t7, anchor);
				mount_component(rightsideonly, target, anchor);
				current = true;
			},
			p: noop,
			i(local) {
				if (current) return;
				transition_in(areequal.$$.fragment, local);
				transition_in(leftsideisnewer.$$.fragment, local);
				transition_in(leftsideonly.$$.fragment, local);
				transition_in(notequalbut.$$.fragment, local);
				transition_in(records.$$.fragment, local);
				transition_in(rightsideisnewer.$$.fragment, local);
				transition_in(rightsideonly.$$.fragment, local);
				current = true;
			},
			o(local) {
				transition_out(areequal.$$.fragment, local);
				transition_out(leftsideisnewer.$$.fragment, local);
				transition_out(leftsideonly.$$.fragment, local);
				transition_out(notequalbut.$$.fragment, local);
				transition_out(records.$$.fragment, local);
				transition_out(rightsideisnewer.$$.fragment, local);
				transition_out(rightsideonly.$$.fragment, local);
				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(p);
					detach(t1);
					detach(t2);
					detach(t3);
					detach(t4);
					detach(t5);
					detach(t6);
					detach(t7);
				}

				destroy_component(areequal, detaching);
				destroy_component(leftsideisnewer, detaching);
				destroy_component(leftsideonly, detaching);
				destroy_component(notequalbut, detaching);
				destroy_component(records, detaching);
				destroy_component(rightsideisnewer, detaching);
				destroy_component(rightsideonly, detaching);
			}
		};
	}

	// (26:2) {#if !data}
	function create_if_block(ctx) {
		let p;

		return {
			c() {
				p = element("p");
				p.textContent = "Review data is null";
			},
			m(target, anchor) {
				insert(target, p, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(p);
				}
			}
		};
	}

	// (21:16)    <!-- optionally show something while promise is pending -->   <span>waiting</span> {:then data}
	function create_pending_block(ctx) {
		let span;

		return {
			c() {
				span = element("span");
				span.textContent = "waiting";
			},
			m(target, anchor) {
				insert(target, span, anchor);
			},
			p: noop,
			i: noop,
			o: noop,
			d(detaching) {
				if (detaching) {
					detach(span);
				}
			}
		};
	}

	function create_fragment(ctx) {
		let await_block_anchor;
		let current;

		let info = {
			ctx,
			current: null,
			token: null,
			hasCatch: true,
			pending: create_pending_block,
			then: create_then_block,
			catch: create_catch_block,
			value: 4,
			error: 5,
			blocks: [,,,]
		};

		handle_promise(/*promise*/ ctx[0], info);

		return {
			c() {
				await_block_anchor = empty();
				info.block.c();
			},
			m(target, anchor) {
				insert(target, await_block_anchor, anchor);
				info.block.m(target, info.anchor = anchor);
				info.mount = () => await_block_anchor.parentNode;
				info.anchor = await_block_anchor;
				current = true;
			},
			p(new_ctx, [dirty]) {
				ctx = new_ctx;
				update_await_block_branch(info, ctx, dirty);
			},
			i(local) {
				if (current) return;
				transition_in(info.block);
				current = true;
			},
			o(local) {
				for (let i = 0; i < 3; i += 1) {
					const block = info.blocks[i];
					transition_out(block);
				}

				current = false;
			},
			d(detaching) {
				if (detaching) {
					detach(await_block_anchor);
				}

				info.block.d(detaching);
				info.token = null;
				info = null;
			}
		};
	}

	function instance($$self, $$props, $$invalidate) {
		let { page } = $$props;
		let { json } = $$props;
		let { baseUrl } = $$props;

		let promise = fetch(baseUrl + page, {
			method: 'POST',
			body: json,
			headers: { 'Content-Type': 'application/json' }
		}).then(x => x.json());

		$$self.$$set = $$props => {
			if ('page' in $$props) $$invalidate(1, page = $$props.page);
			if ('json' in $$props) $$invalidate(2, json = $$props.json);
			if ('baseUrl' in $$props) $$invalidate(3, baseUrl = $$props.baseUrl);
		};

		return [promise, page, json, baseUrl];
	}

	class Review extends SvelteComponent {
		constructor(options) {
			super();
			init(this, options, instance, create_fragment, safe_not_equal, { page: 1, json: 2, baseUrl: 3 });
		}
	}

	var div = document.createElement('DIV');
	var script = document.currentScript;
	script.parentNode.insertBefore(div, script);

	const page = '/api/SyncV1/?';
	const baseUrl = 'http://localhost:5004';

	const json = `
{
  "LeftDirectory": "D:/Tmp/phares/VisualStudioCodeLeft",
  "RightDirectory": "D:/Tmp/phares/VisualStudioCode",
  "Records": [
    {
      "RelativePath": "D:/Tmp/phares/VisualStudioCode",
      "Size": 0,
      "Ticks": 0
    },
    {
      "RelativePath": "z-exclude-patterns.nsv",
      "Size": 230,
      "Ticks": 638843891271017574
    },
    {
      "RelativePath": "z-include-patterns.nsv",
      "Size": 4,
      "Ticks": 638796666663591762
    }
  ]
}
`;

	new Review({
	  target: div,
	  props: { page: page, baseUrl: baseUrl, json: json },
	});

})();