svelte-intersection-observer 0.10.2 → 1.1.0

package/lib/index.js

@@ -1,720 +0,0 @@
-(function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-	typeof define === 'function' && define.amd ? define(factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global["svelte-intersection-observer"] = factory());
-})(this, (function () { 'use strict';
-
-	/** @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 /** @type {T & S} */ (tar);
-	}
-
-	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;
-	}
-
-	function create_slot(definition, ctx, $$scope, fn) {
-		if (definition) {
-			const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
-			return definition[0](slot_ctx);
-		}
-	}
-
-	function get_slot_context(definition, ctx, $$scope, fn) {
-		return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
-	}
-
-	function get_slot_changes(definition, $$scope, dirty, fn) {
-		if (definition[2] && fn) {
-			const lets = definition[2](fn(dirty));
-			if ($$scope.dirty === undefined) {
-				return lets;
-			}
-			if (typeof lets === 'object') {
-				const merged = [];
-				const len = Math.max($$scope.dirty.length, lets.length);
-				for (let i = 0; i < len; i += 1) {
-					merged[i] = $$scope.dirty[i] | lets[i];
-				}
-				return merged;
-			}
-			return $$scope.dirty | lets;
-		}
-		return $$scope.dirty;
-	}
-
-	/** @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;
-	}
-
-	/**
-	 * @param {Node} node
-	 * @returns {void}
-	 */
-	function detach(node) {
-		if (node.parentNode) {
-			node.parentNode.removeChild(node);
-		}
-	}
-
-	/**
-	 * @param {Element} element
-	 * @returns {ChildNode[]}
-	 */
-	function children(element) {
-		return Array.from(element.childNodes);
-	}
-
-	/**
-	 * @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;
-	}
-
-	function get_current_component() {
-		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, { 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 = [];
-
-	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;
-
-	/**
-	 * @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]
-	 */
-
-	/** @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;
-	}
-
-	/** @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 {
-		/**
-		 * ### 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*/ 1,
-		entry: dirty & /*entry*/ 2,
-		observer: dirty & /*observer*/ 4
-	});
-
-	const get_default_slot_context = ctx => ({
-		intersecting: /*intersecting*/ ctx[0],
-		entry: /*entry*/ ctx[1],
-		observer: /*observer*/ ctx[2]
-	});
-
-	function create_fragment(ctx) {
-		let current;
-		const default_slot_template = /*#slots*/ ctx[9].default;
-		const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[8], get_default_slot_context);
-
-		return {
-			c() {
-				if (default_slot) default_slot.c();
-			},
-			m(target, anchor) {
-				if (default_slot) {
-					default_slot.m(target, anchor);
-				}
-
-				current = true;
-			},
-			p(ctx, [dirty]) {
-				if (default_slot) {
-					if (default_slot.p && (!current || dirty & /*$$scope, intersecting, entry, observer*/ 263)) {
-						update_slot_base(
-							default_slot,
-							default_slot_template,
-							ctx,
-							/*$$scope*/ ctx[8],
-							!current
-							? get_all_dirty_from_scope(/*$$scope*/ ctx[8])
-							: get_slot_changes(default_slot_template, /*$$scope*/ ctx[8], dirty, get_default_slot_changes),
-							get_default_slot_context
-						);
-					}
-				}
-			},
-			i(local) {
-				if (current) return;
-				transition_in(default_slot, local);
-				current = true;
-			},
-			o(local) {
-				transition_out(default_slot, local);
-				current = false;
-			},
-			d(detaching) {
-				if (default_slot) default_slot.d(detaching);
-			}
-		};
-	}
-
-	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 { observer = null } = $$props;
-		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(1, entry = $$props.entry);
-			if ('observer' in $$props) $$invalidate(2, observer = $$props.observer);
-			if ('$$scope' in $$props) $$invalidate(8, $$scope = $$props.$$scope);
-		};
-
-		return [
-			intersecting,
-			entry,
-			observer,
-			element,
-			once,
-			root,
-			rootMargin,
-			threshold,
-			$$scope,
-			slots
-		];
-	}
-
-	class IntersectionObserver_1 extends SvelteComponent {
-		constructor(options) {
-			super();
-
-			init(this, options, instance, create_fragment, safe_not_equal, {
-				element: 3,
-				once: 4,
-				intersecting: 0,
-				root: 5,
-				rootMargin: 6,
-				threshold: 7,
-				entry: 1,
-				observer: 2
-			});
-		}
-	}
-
-	return IntersectionObserver_1;
-
-}));