svelte-intersection-observer 0.9.2 → 0.10.1

package/lib/index.mjs

@@ -1,344 +1,609 @@
-function noop() { }
+/** @returns {void} */
+function noop() {}
+
+/**
+ * @template T
+ * @template S
+ * @param {T} tar
+ * @param {S} src
+ * @returns {T & S}
+ */
 function assign(tar, src) {
-    // @ts-ignore
-    for (const k in src)
-        tar[k] = src[k];
-    return tar;
+	// @ts-ignore
+	for (const k in src) tar[k] = src[k];
+	return /** @type {T & S} */ (tar);
 }
+
 function run(fn) {
-    return fn();
+	return fn();
 }
+
 function blank_object() {
-    return Object.create(null);
+	return Object.create(null);
 }
+
+/**
+ * @param {Function[]} fns
+ * @returns {void}
+ */
 function run_all(fns) {
-    fns.forEach(run);
+	fns.forEach(run);
 }
+
+/**
+ * @param {any} thing
+ * @returns {thing is Function}
+ */
 function is_function(thing) {
-    return typeof thing === 'function';
+	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');
+	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;
+	return Object.keys(obj).length === 0;
 }
+
 function create_slot(definition, ctx, $$scope, fn) {
-    if (definition) {
-        const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
-        return definition[0](slot_ctx);
-    }
+	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;
+	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_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
-    if (slot_changes) {
-        const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
-        slot.p(slot_context, slot_changes);
-    }
+	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;
 }
+
+/** @returns {void} */
+function update_slot_base(
+	slot,
+	slot_definition,
+	ctx,
+	$$scope,
+	slot_changes,
+	get_slot_context_fn
+) {
+	if (slot_changes) {
+		const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
+		slot.p(slot_context, slot_changes);
+	}
+}
+
+/** @returns {any[] | -1} */
 function get_all_dirty_from_scope($$scope) {
-    if ($$scope.ctx.length > 32) {
-        const dirty = [];
-        const length = $$scope.ctx.length / 32;
-        for (let i = 0; i < length; i++) {
-            dirty[i] = -1;
-        }
-        return dirty;
-    }
-    return -1;
+	if ($$scope.ctx.length > 32) {
+		const dirty = [];
+		const length = $$scope.ctx.length / 32;
+		for (let i = 0; i < length; i++) {
+			dirty[i] = -1;
+		}
+		return dirty;
+	}
+	return -1;
 }
+
+/**
+ * @param {Node} node
+ * @returns {void}
+ */
 function detach(node) {
-    node.parentNode.removeChild(node);
+	if (node.parentNode) {
+		node.parentNode.removeChild(node);
+	}
 }
+
+/**
+ * @param {Element} element
+ * @returns {ChildNode[]}
+ */
 function children(element) {
-    return Array.from(element.childNodes);
+	return Array.from(element.childNodes);
 }
-function custom_event(type, detail, bubbles = false) {
-    const e = document.createEvent('CustomEvent');
-    e.initCustomEvent(type, bubbles, false, detail);
-    return e;
+
+/**
+ * @template T
+ * @param {string} type
+ * @param {T} [detail]
+ * @param {{ bubbles?: boolean, cancelable?: boolean }} [options]
+ * @returns {CustomEvent<T>}
+ */
+function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
+	return new CustomEvent(type, { detail, bubbles, cancelable });
 }
 
+/**
+ * @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;
+	current_component = component;
 }
+
 function get_current_component() {
-    if (!current_component)
-        throw new Error('Function called outside component initialization');
-    return current_component;
-}
-function onMount(fn) {
-    get_current_component().$$.on_mount.push(fn);
-}
-function afterUpdate(fn) {
-    get_current_component().$$.after_update.push(fn);
+	if (!current_component) throw new Error('Function called outside component initialization');
+	return current_component;
 }
+
+/**
+ * Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).
+ * Event dispatchers are functions that can take two arguments: `name` and `detail`.
+ *
+ * Component events created with `createEventDispatcher` create a
+ * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).
+ * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).
+ * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)
+ * property and can contain any type of data.
+ *
+ * The event dispatcher can be typed to narrow the allowed event names and the type of the `detail` argument:
+ * ```ts
+ * const dispatch = createEventDispatcher<{
+ *  loaded: never; // does not take a detail argument
+ *  change: string; // takes a detail argument of type string, which is required
+ *  optional: number | null; // takes an optional detail argument of type number
+ * }>();
+ * ```
+ *
+ * https://svelte.dev/docs/svelte#createeventdispatcher
+ * @template {Record<string, any>} [EventMap=any]
+ * @returns {import('./public.js').EventDispatcher<EventMap>}
+ */
 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);
-            });
-        }
-    };
+	const component = get_current_component();
+	return (type, detail, { cancelable = false } = {}) => {
+		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 {string} */ (type), detail, { cancelable });
+			callbacks.slice().forEach((fn) => {
+				fn.call(component, event);
+			});
+			return !event.defaultPrevented;
+		}
+		return true;
+	};
 }
 
 const dirty_components = [];
 const binding_callbacks = [];
-const render_callbacks = [];
+
+let render_callbacks = [];
+
 const flush_callbacks = [];
-const resolved_promise = Promise.resolve();
+
+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);
-    }
-}
-function tick() {
-    schedule_update();
-    return resolved_promise;
+	if (!update_scheduled) {
+		update_scheduled = true;
+		resolved_promise.then(flush);
+	}
 }
+
+/** @returns {void} */
 function add_render_callback(fn) {
-    render_callbacks.push(fn);
+	render_callbacks.push(fn);
 }
-let flushing = false;
+
+// 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() {
-    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();
+	// 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);
-    }
+	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;
+
+/**
+ * @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);
-    }
+	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);
-    }
-}
-function mount_component(component, target, anchor, customElement) {
-    const { fragment, on_mount, on_destroy, after_update } = component.$$;
-    fragment && fragment.m(target, anchor);
-    if (!customElement) {
-        // 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);
+	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]
+ */
+
+/** @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) {
-        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 = [];
-    }
+	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));
-}
-function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
-    const parent_component = 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: [],
-        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) {
-            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, options.customElement);
-        flush();
-    }
-    set_current_component(parent_component);
+	if (component.$$.dirty[0] === -1) {
+		dirty_components.push(component);
+		schedule_update();
+		component.$$.dirty.fill(0);
+	}
+	component.$$.dirty[(i / 31) | 0] |= 1 << i % 31;
 }
+
+/** @returns {void} */
+function init(
+	component,
+	options,
+	instance,
+	create_fragment,
+	not_equal,
+	props,
+	append_styles,
+	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) {
+			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);
+}
+
 /**
  * Base class for Svelte components. Used when dev=false.
+ *
+ * @template {Record<string, any>} [Props=any]
+ * @template {Record<string, any>} [Events=any]
  */
 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;
-        }
-    }
-}
-
-/* src/IntersectionObserver.svelte generated by Svelte v3.44.2 */
+	/**
+	 * ### 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/IntersectionObserver.svelte generated by Svelte v4.1.0 */
 
 const get_default_slot_changes = dirty => ({
-	intersecting: dirty & /*intersecting*/ 2,
-	entry: dirty & /*entry*/ 1,
+	intersecting: dirty & /*intersecting*/ 1,
+	entry: dirty & /*entry*/ 2,
 	observer: dirty & /*observer*/ 4
 });
 
 const get_default_slot_context = ctx => ({
-	intersecting: /*intersecting*/ ctx[1],
-	entry: /*entry*/ ctx[0],
+	intersecting: /*intersecting*/ ctx[0],
+	entry: /*entry*/ ctx[1],
 	observer: /*observer*/ ctx[2]
 });
 
@@ -393,76 +658,29 @@ function instance($$self, $$props, $$invalidate) {
 	let { $$slots: slots = {}, $$scope } = $$props;
 	let { element = null } = $$props;
 	let { once = false } = $$props;
+	let { intersecting = false } = $$props;
 	let { root = null } = $$props;
 	let { rootMargin = "0px" } = $$props;
 	let { threshold = 0 } = $$props;
 	let { entry = null } = $$props;
-	let { intersecting = false } = $$props;
 	let { observer = null } = $$props;
-	const dispatch = createEventDispatcher();
-	let prevRootMargin = null;
-	let prevElement = null;
-
-	const initialize = () => {
-		$$invalidate(2, observer = new IntersectionObserver(entries => {
-				entries.forEach(_entry => {
-					$$invalidate(0, entry = _entry);
-					$$invalidate(1, intersecting = _entry.isIntersecting);
-				});
-			},
-		{ root, rootMargin, threshold }));
-	};
-
-	onMount(() => {
-		initialize();
-
-		return () => {
-			if (observer) observer.disconnect();
-		};
-	});
-
-	afterUpdate(async () => {
-		if (entry !== null) {
-			dispatch("observe", entry);
-
-			if (entry.isIntersecting) {
-				dispatch("intersect", entry);
-				if (once) observer.unobserve(element);
-			}
-		}
-
-		await tick();
-
-		if (element !== null && element !== prevElement) {
-			observer.observe(element);
-			if (prevElement !== null) observer.unobserve(prevElement);
-			prevElement = element;
-		}
-
-		if (prevRootMargin && rootMargin !== prevRootMargin) {
-			observer.disconnect();
-			prevElement = null;
-			initialize();
-		}
-
-		prevRootMargin = rootMargin;
-	});
+	createEventDispatcher();
 
 	$$self.$$set = $$props => {
 		if ('element' in $$props) $$invalidate(3, element = $$props.element);
 		if ('once' in $$props) $$invalidate(4, once = $$props.once);
+		if ('intersecting' in $$props) $$invalidate(0, intersecting = $$props.intersecting);
 		if ('root' in $$props) $$invalidate(5, root = $$props.root);
 		if ('rootMargin' in $$props) $$invalidate(6, rootMargin = $$props.rootMargin);
 		if ('threshold' in $$props) $$invalidate(7, threshold = $$props.threshold);
-		if ('entry' in $$props) $$invalidate(0, entry = $$props.entry);
-		if ('intersecting' in $$props) $$invalidate(1, intersecting = $$props.intersecting);
+		if ('entry' in $$props) $$invalidate(1, entry = $$props.entry);
 		if ('observer' in $$props) $$invalidate(2, observer = $$props.observer);
 		if ('$$scope' in $$props) $$invalidate(8, $$scope = $$props.$$scope);
 	};
 
 	return [
-		entry,
 		intersecting,
+		entry,
 		observer,
 		element,
 		once,
@@ -481,14 +699,14 @@ class IntersectionObserver_1 extends SvelteComponent {
 		init(this, options, instance, create_fragment, safe_not_equal, {
 			element: 3,
 			once: 4,
+			intersecting: 0,
 			root: 5,
 			rootMargin: 6,
 			threshold: 7,
-			entry: 0,
-			intersecting: 1,
+			entry: 1,
 			observer: 2
 		});
 	}
 }
 
-export default IntersectionObserver_1;
+export { IntersectionObserver_1 as default };