Fix bin/publish: copy docs.dist from project root

Fix bin/publish: use correct .env path for rspade_system
Fix bin/publish script: prevent grep exit code 1 from terminating script

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/spatie/ignition/node_modules/react-intersection-observer/InView.d.ts

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { IntersectionObserverProps, PlainChildrenProps } from './index';
+declare type State = {
+    inView: boolean;
+    entry?: IntersectionObserverEntry;
+};
+/**
+ ## Render props
+
+ To use the `<InView>` component, you pass it a function. It will be called
+ whenever the state changes, with the new value of `inView`. In addition to the
+ `inView` prop, children also receive a `ref` that should be set on the
+ containing DOM element. This is the element that the IntersectionObserver will
+ monitor.
+
+ If you need it, you can also access the
+ [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+ on `entry`, giving you access to all the details about the current intersection
+ state.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView>
+ {({ inView, ref, entry }) => (
+      <div ref={ref}>
+        <h2>{`Header inside viewport ${inView}.`}</h2>
+      </div>
+    )}
+ </InView>
+ );
+
+ export default Component;
+ ```
+
+ ## Plain children
+
+ You can pass any element to the `<InView />`, and it will handle creating the
+ wrapping DOM element. Add a handler to the `onChange` method, and control the
+ state in your own component. Any extra props you add to `<InView>` will be
+ passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+ <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+ </InView>
+ );
+
+ export default Component;
+ ```
+ */
+export declare class InView extends React.Component<IntersectionObserverProps | PlainChildrenProps, State> {
+    static displayName: string;
+    static defaultProps: {
+        threshold: number;
+        triggerOnce: boolean;
+        initialInView: boolean;
+    };
+    constructor(props: IntersectionObserverProps | PlainChildrenProps);
+    componentDidUpdate(prevProps: IntersectionObserverProps): void;
+    componentWillUnmount(): void;
+    node: Element | null;
+    _unobserveCb: (() => void) | null;
+    observeNode(): void;
+    unobserve(): void;
+    handleNode: (node?: Element | null | undefined) => void;
+    handleChange: (inView: boolean, entry: IntersectionObserverEntry) => void;
+    render(): React.ReactNode;
+}
+export {};

vendor/spatie/ignition/node_modules/react-intersection-observer/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 React Intersection Observer authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/spatie/ignition/node_modules/react-intersection-observer/README.md

@@ -0,0 +1,453 @@
+# react-intersection-observer
+
+[![Version Badge][npm-version-svg]][package-url]
+[![GZipped size][npm-minzip-svg]][bundlephobia-url]
+[![Test][test-image]][test-url] [![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+React implementation of the
+[Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)
+to tell you when an element enters or leaves the viewport. Contains both a
+[Hooks](#hooks-), [render props](#render-props) and
+[plain children](#plain-children) implementation.
+
+**Storybook Demo:**
+[https://react-intersection-observer.vercel.app](https://react-intersection-observer.vercel.app)
+
+## Features
+
+- 🎣 **Hooks or Component API** - With `useInView` it's easier than ever to
+  monitor elements
+- ⚡️ **Optimized performance** - Reuses Intersection Observer instances where
+  possible
+- ⚙️ **Matches native API** - Intuitive to use
+- 🧪 **Ready to test** - Mocks the Intersection Observer for easy testing with
+  [Jest](https://jestjs.io/)
+- 🌳 **Tree-shakeable** - Only include the parts you use
+- 💥 **Tiny bundle** [~1.7 kB gzipped][bundlephobia-url]
+
+## Installation
+
+Install using [Yarn](https://yarnpkg.com):
+
+```sh
+yarn add react-intersection-observer
+```
+
+or NPM:
+
+```sh
+npm install react-intersection-observer --save
+```
+
+## Usage
+
+### `useInView` hook
+
+```js
+// Use object destructing, so you don't need to remember the exact order
+const { ref, inView, entry } = useInView(options);
+
+// Or array destructing, making it easy to customize the field names
+const [ref, inView, entry] = useInView(options);
+```
+
+The `useInView` hook makes it easy to monitor the `inView` state of your
+components. Call the `useInView` hook with the (optional) [options](#options)
+you need. It will return an array containing a `ref`, the `inView` status and
+the current
+[`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+Assign the `ref` to the DOM element you want to monitor, and the hook will
+report the status.
+
+```jsx
+import React from 'react';
+import { useInView } from 'react-intersection-observer';
+
+const Component = () => {
+  const { ref, inView, entry } = useInView({
+    /* Optional options */
+    threshold: 0,
+  });
+
+  return (
+    <div ref={ref}>
+      <h2>{`Header inside viewport ${inView}.`}</h2>
+    </div>
+  );
+};
+```
+
+[![Edit useInView](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/useinview-ud2vo?fontsize=14&hidenavigation=1&theme=dark)
+
+### Render props
+
+To use the `<InView>` component, you pass it a function. It will be called
+whenever the state changes, with the new value of `inView`. In addition to the
+`inView` prop, children also receive a `ref` that should be set on the
+containing DOM element. This is the element that the IntersectionObserver will
+monitor.
+
+If you need it, you can also access the
+[`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+on `entry`, giving you access to all the details about the current intersection
+state.
+
+```jsx
+import { InView } from 'react-intersection-observer';
+
+const Component = () => (
+  <InView>
+    {({ inView, ref, entry }) => (
+      <div ref={ref}>
+        <h2>{`Header inside viewport ${inView}.`}</h2>
+      </div>
+    )}
+  </InView>
+);
+
+export default Component;
+```
+
+[![Edit InView render props](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/inview-render-props-hvhcb?fontsize=14&hidenavigation=1&theme=dark)
+
+### Plain children
+
+You can pass any element to the `<InView />`, and it will handle creating the
+wrapping DOM element. Add a handler to the `onChange` method, and control the
+state in your own component. Any extra props you add to `<InView>` will be
+passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+```jsx
+import { InView } from 'react-intersection-observer';
+
+const Component = () => (
+  <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+    <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+  </InView>
+);
+
+export default Component;
+```
+
+[![Edit InView plain children](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/inview-plain-children-vv51y?fontsize=14&hidenavigation=1&theme=dark)
+
+> ⚠️ When rendering a plain child, make sure you keep your HTML output semantic.
+> Change the `as` to match the context, and add a `className` to style the
+> `<InView />`. The component does not support Ref Forwarding, so if you need a
+> `ref` to the HTML element, use the Render Props version instead.
+
+## API
+
+### Options
+
+Provide these as the options argument in the `useInView` hook or as props on the
+**`<InView />`** component.
+
+| Name                   | Type                   | Default   | Required | Description                                                                                                                                                                                                                                                                                     |
+| ---------------------- | ---------------------- | --------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **root**               | `Element`              | document  | false    | The IntersectionObserver interface's read-only root property identifies the Element or Document whose bounds are treated as the bounding box of the viewport for the element which is the observer's target. If the root is `null`, then the bounds of the actual document viewport are used.   |
+| **rootMargin**         | `string`               | '0px'     | false    | Margin around the root. Can have values similar to the CSS margin property, e.g. "10px 20px 30px 40px" (top, right, bottom, left).                                                                                                                                                              |
+| **threshold**          | `number` \| `number[]` | 0         | false    | Number between `0` and `1` indicating the percentage that should be visible before triggering. Can also be an array of numbers, to create multiple trigger points.                                                                                                                              |
+| **trackVisibility** 🧪 | `boolean`              | false     | false    | A boolean indicating whether this IntersectionObserver will track visibility changes on the target.                                                                                                                                                                                             |
+| **delay** 🧪           | `number`               | undefined | false    | A number indicating the minimum delay in milliseconds between notifications from this observer for a given target. This must be set to at least `100` if `trackVisibility` is `true`.                                                                                                           |
+| **skip**               | `boolean`              | false     | false    | Skip creating the IntersectionObserver. You can use this to enable and disable the observer as needed. If `skip` is set while `inView`, the current state will still be kept.                                                                                                                   |
+| **triggerOnce**        | `boolean`              | false     | false    | Only trigger the observer once.                                                                                                                                                                                                                                                                 |
+| **initialInView**      | `boolean`              | false     | false    | Set the initial value of the `inView` boolean. This can be used if you expect the element to be in the viewport to start with, and you want to trigger something when it leaves.                                                                                                                |
+| **fallbackInView**     | `boolean`              | undefined | false    | If the `IntersectionObserver` API isn't available in the client, the default behavior is to throw an Error. You can set a specific fallback behavior, and the `inView` value will be set to this instead of failing. To set a global default, you can set it with the `defaultFallbackInView()` |
+
+### InView Props
+
+The **`<InView />`** component also accepts the following props:
+
+| Name         | Type                                                     | Default | Required | Description                                                                                                                                                                                                                                                                                                                   |
+| ------------ | -------------------------------------------------------- | ------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **as**       | `string`                                                 | 'div'   | false    | Render the wrapping element as this element. Defaults to `div`.                                                                                                                                                                                                                                                               |
+| **children** | `({ref, inView, entry}) => React.ReactNode`, `ReactNode` |         | true     | Children expects a function that receives an object containing the `inView` boolean and a `ref` that should be assigned to the element root. Alternatively pass a plain child, to have the `<InView />` deal with the wrapping element. You will also get the `IntersectionObserverEntry` as `entry, giving you more details. |
+| **onChange** | `(inView, entry) => void`                                |         | false    | Call this function whenever the in view state changes. It will receive the `inView` boolean, alongside the current `IntersectionObserverEntry`.                                                                                                                                                                               |
+
+### IntersectionObserver v2 🧪
+
+The new
+[v2 implementation of IntersectionObserver](https://developers.google.com/web/updates/2019/02/intersectionobserver-v2)
+extends the original API, so you can track if the element is covered by another
+element or has filters applied to it. Useful for blocking clickjacking attempts
+or tracking ad exposure.
+
+To use it, you'll need to add the new `trackVisibility` and `delay` options.
+When you get the `entry` back, you can then monitor if `isVisible` is `true`.
+
+```jsx
+const TrackVisible = () => {
+  const { ref, entry } = useInView({ trackVisibility: true, delay: 100 });
+  return <div ref={ref}>{entry?.isVisible}</div>;
+};
+```
+
+This is still a very new addition, so check
+[caniuse](https://caniuse.com/#feat=intersectionobserver-v2) for current browser
+support. If `trackVisibility` has been set, and the current browser doesn't
+support it, a fallback has been added to always report `isVisible` as `true`.
+
+It's not added to the TypeScript `lib.d.ts` file yet, so you will also have to
+extend the `IntersectionObserverEntry` with the `isVisible` boolean.
+
+## Recipes
+
+The `IntersectionObserver` itself is just a simple but powerful tool. Here's a
+few ideas for how you can use it.
+
+- [Lazy image load](docs/Recipes.md#lazy-image-load)
+- [Trigger animations](docs/Recipes.md#trigger-animations)
+- [Track impressions](docs/Recipes.md#track-impressions) _(Google Analytics, Tag
+  Manager, etc)_
+
+## FAQ
+
+### How can I assign multiple refs to a component?
+
+You can wrap multiple `ref` assignments in a single `useCallback`:
+
+```jsx
+import React, { useRef } from 'react';
+import { useInView } from 'react-intersection-observer';
+
+function Component(props) {
+  const ref = useRef();
+  const [inViewRef, inView] = useInView();
+
+  // Use `useCallback` so we don't recreate the function on each render - Could result in infinite loop
+  const setRefs = useCallback(
+    (node) => {
+      // Ref's from useRef needs to have the node assigned to `current`
+      ref.current = node;
+      // Callback refs, like the one from `useInView`, is a function that takes the node as an argument
+      inViewRef(node);
+    },
+    [inViewRef],
+  );
+
+  return <div ref={setRefs}>Shared ref is visible: {inView}</div>;
+}
+```
+
+### `rootMargin` isn't working as expected
+
+When using `rootMargin`, the margin gets added to the current `root` - If your
+application is running inside a `<iframe>`, or you have defined a custom `root`
+this will not be the current viewport.
+
+You can read more about this on these links:
+
+- [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API#The_intersection_root_and_root_margin)
+- [w3c/IntersectionObserver: IntersectionObserver rootMargin ignored within iframe](https://github.com/w3c/IntersectionObserver/issues/283#issuecomment-507397917)
+- [w3c/IntersectionObserver: Cannot track intersection with an iframe's viewport](https://github.com/w3c/IntersectionObserver/issues/372)
+- [w3c/Support iframe viewport tracking](https://github.com/w3c/IntersectionObserver/pull/465)
+
+## Testing
+
+In order to write meaningful tests, the `IntersectionObserver` needs to be
+mocked. If you are writing your tests in Jest, you can use the included
+`test-utils.js`. It mocks the `IntersectionObserver`, and includes a few methods
+to assist with faking the `inView` state. When setting the `isIntersecting`
+value you can pass either a `boolean` value or a threshold between `0` and `1`.
+
+### `test-utils.js`
+
+You can use these test utilities as imports in individual files OR you can globally mock Intersection Observer for all Jest tests. If you use a library or an application with a lot of Intersection Observer usage, you may wish to globally mock it; however, the official recommendation is to be purposeful about your mocking and do so on a per-usage basis.
+
+#### Indvidual Methods
+
+Import these from `react-intersection-observer/test-utils`.
+
+**`mockAllIsIntersecting(isIntersecting:boolean | number)`**  
+Set `isIntersecting` on all current IntersectionObserver instances.
+
+**`mockIsIntersecting(element:Element, isIntersecting:boolean | number)`**  
+Set `isIntersecting` for the IntersectionObserver of a specific element.
+
+**`intersectionMockInstance(element:Element): IntersectionObserver`**  
+Call the `intersectionMockInstance` method with an element, to get the (mocked)
+`IntersectionObserver` instance. You can use this to spy on the `observe` and
+`unobserve` methods.
+
+#### Global Intersection Observer Behavior
+
+##### Use Fallback
+
+You can create a [Jest setup file](https://jestjs.io/docs/configuration#setupfiles-array) that leverages the [unsupported fallback](https://github.com/thebuilder/react-intersection-observer#unsupported-fallback) option. In this case, you only mock the IntersectionObserver in test files were you actively import `react-intersection-observer/test-utils`:
+
+```js
+import { defaultFallbackInView } from 'react-intersection-observer';
+
+defaultFallbackInView(true); // or 'false' - whichever consistent behavior makes the most sense for your use case.
+```
+
+##### Mock Everywhere
+
+In your Jest config, add `'react-intersection-observer/test-utils'` to the array value for the [`setupFilesAfterEnv`](https://jestjs.io/docs/configuration#setupfilesafterenv-array) option.
+
+
+```js
+module.exports = {
+ // other config lines
+ setupFilesAfterEnv: ['react-intersection-observer/test-utils'],
+ // other config lines
+};
+```
+
+### Test Example
+
+```js
+import React from 'react';
+import { screen, render } from '@testing-library/react';
+import { useInView } from 'react-intersection-observer';
+import { mockAllIsIntersecting } from 'react-intersection-observer/test-utils';
+
+const HookComponent = ({ options }) => {
+  const [ref, inView] = useInView(options);
+  return <div ref={ref}>{inView.toString()}</div>;
+};
+
+test('should create a hook inView', () => {
+  render(<HookComponent />);
+
+  // This causes all (existing) IntersectionObservers to be set as intersecting
+  mockAllIsIntersecting(true);
+  screen.getByText('true');
+});
+
+test('should create a hook inView with threshold', () => {
+  render(<HookComponent options={{ threshold: 0.3 }} />);
+
+  mockAllIsIntersecting(0.1);
+  screen.getByText('false');
+
+  // Once the threshold has been passed, it will trigger inView.
+  mockAllIsIntersecting(0.3);
+  screen.getByText('true');
+});
+```
+
+## Intersection Observer
+
+[Intersection Observer](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)
+is the API used to determine if an element is inside the viewport or not.
+[Browser support is really good](http://caniuse.com/#feat=intersectionobserver) -
+With
+[Safari adding support in 12.1](https://webkit.org/blog/8718/new-webkit-features-in-safari-12-1/),
+all major browsers now support Intersection Observers natively. Add the
+polyfill, so it doesn't break on older versions of iOS and IE11.
+
+### Unsupported fallback
+
+If the client doesn't have support for the `IntersectionObserver`, then the
+default behavior is to throw an error. This will crash the React application,
+unless you capture it with an Error Boundary.
+
+If you prefer, you can set a fallback `inView` value to use if the
+`IntersectionObserver` doesn't exist. This will make
+`react-intersection-observer` fail gracefully, but you must ensure your
+application can correctly handle all your observers firing either `true` or
+`false` at the same time.
+
+You can set the fallback globally:
+
+```js
+import { defaultFallbackInView } from 'react-intersection-observer';
+defaultFallbackInView(true); // or 'false'
+```
+
+You can also define the fallback locally on `useInView` or `<InView>` as an
+option. This will override the global fallback value.
+
+```jsx
+import React from 'react';
+import { useInView } from 'react-intersection-observer';
+
+const Component = () => {
+  const { ref, inView, entry } = useInView({
+    fallbackInView: true,
+  });
+
+  return (
+    <div ref={ref}>
+      <h2>{`Header inside viewport ${inView}.`}</h2>
+    </div>
+  );
+};
+```
+
+### Polyfill
+
+You can import the
+[polyfill](https://www.npmjs.com/package/intersection-observer) directly or use
+a service like [polyfill.io](https://polyfill.io/v2/docs/) to add it when
+needed.
+
+```sh
+yarn add intersection-observer
+```
+
+Then import it in your app:
+
+```js
+import 'intersection-observer';
+```
+
+If you are using Webpack (or similar) you could use
+[dynamic imports](https://webpack.js.org/api/module-methods/#import-), to load
+the Polyfill only if needed. A basic implementation could look something like
+this:
+
+```js
+/**
+ * Do feature detection, to figure out which polyfills needs to be imported.
+ **/
+async function loadPolyfills() {
+  if (typeof window.IntersectionObserver === 'undefined') {
+    await import('intersection-observer');
+  }
+}
+```
+
+## Low level API
+
+You can access the [`observe`](src/observe.ts) method, that
+`react-intersection-observer` uses internally to create and destroy
+IntersectionObserver instances. This allows you to handle more advanced use
+cases, where you need full control over when and how observers are created.
+
+```js
+import { observe } from 'react-intersection-observer';
+const destroy = observe(element, callback, options);
+```
+
+| Name         | Type                       | Required | Description                                               |
+| ------------ | -------------------------- | -------- | --------------------------------------------------------- |
+| **element**  | `Element`                  | true     | DOM element to observe                                    |
+| **callback** | `ObserverInstanceCallback` | true     | The callback function that IntersectionObserver will call |
+| **options**  | `IntersectionObserverInit` | false    | The options for the IntersectionObserver                  |
+
+The `observe` method returns an `unobserve` function, that you must call in
+order to destroy the observer again.
+
+> ⚠️ You most likely won't need this, but it can be useful if you need to handle
+> IntersectionObservers outside React, or need full control over how instances
+> are created.
+
+[package-url]: https://npmjs.org/package/react-intersection-observer
+[npm-version-svg]: https://img.shields.io/npm/v/react-intersection-observer.svg
+[npm-minzip-svg]:
+  https://img.shields.io/bundlephobia/minzip/react-intersection-observer.svg
+[bundlephobia-url]:
+  https://bundlephobia.com/result?p=react-intersection-observer
+[license-image]: http://img.shields.io/npm/l/react-intersection-observer.svg
+[license-url]: LICENSE
+[downloads-image]: http://img.shields.io/npm/dm/react-intersection-observer.svg
+[downloads-url]:
+  http://npm-stat.com/charts.html?package=react-intersection-observer
+[test-image]:
+  https://github.com/thebuilder/react-intersection-observer/workflows/Test/badge.svg
+[test-url]:
+  https://github.com/thebuilder/react-intersection-observer/actions?query=workflow%3ATest

vendor/spatie/ignition/node_modules/react-intersection-observer/index.d.ts

@@ -0,0 +1,73 @@
+import * as React from 'react';
+import { InView } from './InView';
+export { InView } from './InView';
+export { useInView } from './useInView';
+export { observe, defaultFallbackInView } from './observe';
+export default InView;
+declare type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export declare type ObserverInstanceCallback = (inView: boolean, entry: IntersectionObserverEntry) => void;
+interface RenderProps {
+    inView: boolean;
+    entry: IntersectionObserverEntry | undefined;
+    ref: React.RefObject<any> | ((node?: Element | null) => void);
+}
+export interface IntersectionOptions extends IntersectionObserverInit {
+    /** The IntersectionObserver interface's read-only `root` property identifies the Element or Document whose bounds are treated as the bounding box of the viewport for the element which is the observer's target. If the `root` is null, then the bounds of the actual document viewport are used.*/
+    root?: Element | null;
+    /** Margin around the root. Can have values similar to the CSS margin property, e.g. `10px 20px 30px 40px` (top, right, bottom, left). */
+    rootMargin?: string;
+    /** Number between `0` and `1` indicating the percentage that should be visible before triggering. Can also be an `array` of numbers, to create multiple trigger points. */
+    threshold?: number | number[];
+    /** Only trigger the inView callback once */
+    triggerOnce?: boolean;
+    /** Skip assigning the observer to the `ref` */
+    skip?: boolean;
+    /** Set the initial value of the `inView` boolean. This can be used if you expect the element to be in the viewport to start with, and you want to trigger something when it leaves. */
+    initialInView?: boolean;
+    /** Fallback to this inView state if the IntersectionObserver is unsupported, and a polyfill wasn't loaded */
+    fallbackInView?: boolean;
+    /** IntersectionObserver v2 - Track the actual visibility of the element */
+    trackVisibility?: boolean;
+    /** IntersectionObserver v2 - Set a minimum delay between notifications */
+    delay?: number;
+}
+export interface IntersectionObserverProps extends IntersectionOptions {
+    /**
+     * Children expects a function that receives an object
+     * contain an `inView` boolean and `ref` that should be
+     * assigned to the element root.
+     */
+    children: (fields: RenderProps) => React.ReactNode;
+    /** Call this function whenever the in view state changes */
+    onChange?: (inView: boolean, entry: IntersectionObserverEntry) => void;
+}
+/**
+ * Types specific to the PlainChildren rendering of InView
+ * */
+export declare type PlainChildrenProps = IntersectionOptions & {
+    children?: React.ReactNode;
+    /**
+     * Render the wrapping element as this element.
+     * @default `'div'`
+     */
+    as?: React.ReactType<any>;
+    /**
+     * Element tag to use for the wrapping component
+     * @deprecated Replace with the 'as' prop
+     */
+    tag?: React.ReactType<any>;
+    /** Call this function whenever the in view state changes */
+    onChange?: (inView: boolean, entry: IntersectionObserverEntry) => void;
+} & Omit<React.HTMLProps<HTMLElement>, 'onChange'>;
+/**
+ * The Hook response supports both array and object destructing
+ */
+export declare type InViewHookResponse = [
+    (node?: Element | null) => void,
+    boolean,
+    IntersectionObserverEntry | undefined
+] & {
+    ref: (node?: Element | null) => void;
+    inView: boolean;
+    entry?: IntersectionObserverEntry;
+};

vendor/spatie/ignition/node_modules/react-intersection-observer/observe.d.ts

@@ -0,0 +1,22 @@
+import { ObserverInstanceCallback } from './index';
+/**
+ * What should be the default behavior if the IntersectionObserver is unsupported?
+ * Ideally the polyfill has been loaded, you can have the following happen:
+ * - `undefined`: Throw an error
+ * - `true` or `false`: Set the `inView` value to this regardless of intersection state
+ * **/
+export declare function defaultFallbackInView(inView: boolean | undefined): void;
+/**
+ * Convert the options to a string Id, based on the values.
+ * Ensures we can reuse the same observer when observing elements with the same options.
+ * @param options
+ */
+export declare function optionsToId(options: IntersectionObserverInit): string;
+/**
+ * @param element - DOM Element to observe
+ * @param callback - Callback function to trigger when intersection status changes
+ * @param options - Intersection Observer options
+ * @param fallbackInView - Fallback inView value.
+ * @return Function - Cleanup function that should be triggered to unregister the observer
+ */
+export declare function observe(element: Element, callback: ObserverInstanceCallback, options?: IntersectionObserverInit, fallbackInView?: boolean | undefined): () => void;

vendor/spatie/ignition/node_modules/react-intersection-observer/react-intersection-observer.esm.js

@@ -0,0 +1,455 @@
+import * as React from 'react';
+import { useEffect } from 'react';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+const observerMap = new Map();
+const RootIds = new WeakMap();
+let rootId = 0;
+let unsupportedValue = undefined;
+/**
+ * What should be the default behavior if the IntersectionObserver is unsupported?
+ * Ideally the polyfill has been loaded, you can have the following happen:
+ * - `undefined`: Throw an error
+ * - `true` or `false`: Set the `inView` value to this regardless of intersection state
+ * **/
+
+function defaultFallbackInView(inView) {
+  unsupportedValue = inView;
+}
+/**
+ * Generate a unique ID for the root element
+ * @param root
+ */
+
+function getRootId(root) {
+  if (!root) return '0';
+  if (RootIds.has(root)) return RootIds.get(root);
+  rootId += 1;
+  RootIds.set(root, rootId.toString());
+  return RootIds.get(root);
+}
+/**
+ * Convert the options to a string Id, based on the values.
+ * Ensures we can reuse the same observer when observing elements with the same options.
+ * @param options
+ */
+
+
+function optionsToId(options) {
+  return Object.keys(options).sort().filter(key => options[key] !== undefined).map(key => {
+    return `${key}_${key === 'root' ? getRootId(options.root) : options[key]}`;
+  }).toString();
+}
+
+function createObserver(options) {
+  // Create a unique ID for this observer instance, based on the root, root margin and threshold.
+  let id = optionsToId(options);
+  let instance = observerMap.get(id);
+
+  if (!instance) {
+    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.
+    const elements = new Map();
+    let thresholds;
+    const observer = new IntersectionObserver(entries => {
+      entries.forEach(entry => {
+        var _elements$get;
+
+        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.
+        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0
+        const inView = entry.isIntersecting && thresholds.some(threshold => entry.intersectionRatio >= threshold); // @ts-ignore support IntersectionObserver v2
+
+        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {
+          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.
+          // @ts-ignore
+          entry.isVisible = inView;
+        }
+
+        (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(callback => {
+          callback(inView, entry);
+        });
+      });
+    }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options
+
+    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
+    instance = {
+      id,
+      observer,
+      elements
+    };
+    observerMap.set(id, instance);
+  }
+
+  return instance;
+}
+/**
+ * @param element - DOM Element to observe
+ * @param callback - Callback function to trigger when intersection status changes
+ * @param options - Intersection Observer options
+ * @param fallbackInView - Fallback inView value.
+ * @return Function - Cleanup function that should be triggered to unregister the observer
+ */
+
+
+function observe(element, callback, options = {}, fallbackInView = unsupportedValue) {
+  if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {
+    const bounds = element.getBoundingClientRect();
+    callback(fallbackInView, {
+      isIntersecting: fallbackInView,
+      target: element,
+      intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,
+      time: 0,
+      boundingClientRect: bounds,
+      intersectionRect: bounds,
+      rootBounds: bounds
+    });
+    return () => {// Nothing to cleanup
+    };
+  } // An observer with the same options can be reused, so lets use this fact
+
+
+  const {
+    id,
+    observer,
+    elements
+  } = createObserver(options); // Register the callback listener for this element
+
+  let callbacks = elements.get(element) || [];
+
+  if (!elements.has(element)) {
+    elements.set(element, callbacks);
+  }
+
+  callbacks.push(callback);
+  observer.observe(element);
+  return function unobserve() {
+    // Remove the callback from the callback list
+    callbacks.splice(callbacks.indexOf(callback), 1);
+
+    if (callbacks.length === 0) {
+      // No more callback exists for element, so destroy it
+      elements.delete(element);
+      observer.unobserve(element);
+    }
+
+    if (elements.size === 0) {
+      // No more elements are being observer by this instance, so destroy it
+      observer.disconnect();
+      observerMap.delete(id);
+    }
+  };
+}
+
+const _excluded = ["children", "as", "tag", "triggerOnce", "threshold", "root", "rootMargin", "onChange", "skip", "trackVisibility", "delay", "initialInView", "fallbackInView"];
+
+function isPlainChildren(props) {
+  return typeof props.children !== 'function';
+}
+/**
+ ## Render props
+
+ To use the `<InView>` component, you pass it a function. It will be called
+ whenever the state changes, with the new value of `inView`. In addition to the
+ `inView` prop, children also receive a `ref` that should be set on the
+ containing DOM element. This is the element that the IntersectionObserver will
+ monitor.
+
+ If you need it, you can also access the
+ [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+ on `entry`, giving you access to all the details about the current intersection
+ state.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView>
+ {({ inView, ref, entry }) => (
+      <div ref={ref}>
+        <h2>{`Header inside viewport ${inView}.`}</h2>
+      </div>
+    )}
+ </InView>
+ );
+
+ export default Component;
+ ```
+
+ ## Plain children
+
+ You can pass any element to the `<InView />`, and it will handle creating the
+ wrapping DOM element. Add a handler to the `onChange` method, and control the
+ state in your own component. Any extra props you add to `<InView>` will be
+ passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+ <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+ </InView>
+ );
+
+ export default Component;
+ ```
+ */
+
+
+class InView extends React.Component {
+  constructor(props) {
+    super(props);
+    this.node = null;
+    this._unobserveCb = null;
+
+    this.handleNode = node => {
+      if (this.node) {
+        // Clear the old observer, before we start observing a new element
+        this.unobserve();
+
+        if (!node && !this.props.triggerOnce && !this.props.skip) {
+          // Reset the state if we get a new node, and we aren't ignoring updates
+          this.setState({
+            inView: !!this.props.initialInView,
+            entry: undefined
+          });
+        }
+      }
+
+      this.node = node ? node : null;
+      this.observeNode();
+    };
+
+    this.handleChange = (inView, entry) => {
+      if (inView && this.props.triggerOnce) {
+        // If `triggerOnce` is true, we should stop observing the element.
+        this.unobserve();
+      }
+
+      if (!isPlainChildren(this.props)) {
+        // Store the current State, so we can pass it to the children in the next render update
+        // There's no reason to update the state for plain children, since it's not used in the rendering.
+        this.setState({
+          inView,
+          entry
+        });
+      }
+
+      if (this.props.onChange) {
+        // If the user is actively listening for onChange, always trigger it
+        this.props.onChange(inView, entry);
+      }
+    };
+
+    this.state = {
+      inView: !!props.initialInView,
+      entry: undefined
+    };
+  }
+
+  componentDidUpdate(prevProps) {
+    // If a IntersectionObserver option changed, reinit the observer
+    if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {
+      this.unobserve();
+      this.observeNode();
+    }
+  }
+
+  componentWillUnmount() {
+    this.unobserve();
+    this.node = null;
+  }
+
+  observeNode() {
+    if (!this.node || this.props.skip) return;
+    const {
+      threshold,
+      root,
+      rootMargin,
+      trackVisibility,
+      delay,
+      fallbackInView
+    } = this.props;
+    this._unobserveCb = observe(this.node, this.handleChange, {
+      threshold,
+      root,
+      rootMargin,
+      // @ts-ignore
+      trackVisibility,
+      // @ts-ignore
+      delay
+    }, fallbackInView);
+  }
+
+  unobserve() {
+    if (this._unobserveCb) {
+      this._unobserveCb();
+
+      this._unobserveCb = null;
+    }
+  }
+
+  render() {
+    if (!isPlainChildren(this.props)) {
+      const {
+        inView,
+        entry
+      } = this.state;
+      return this.props.children({
+        inView,
+        entry,
+        ref: this.handleNode
+      });
+    }
+
+    const _this$props = this.props,
+          {
+      children,
+      as,
+      tag
+    } = _this$props,
+          props = _objectWithoutPropertiesLoose(_this$props, _excluded);
+
+    return /*#__PURE__*/React.createElement(as || tag || 'div', _extends({
+      ref: this.handleNode
+    }, props), children);
+  }
+
+}
+InView.displayName = 'InView';
+InView.defaultProps = {
+  threshold: 0,
+  triggerOnce: false,
+  initialInView: false
+};
+
+/**
+ * React Hooks make it easy to monitor the `inView` state of your components. Call
+ * the `useInView` hook with the (optional) [options](#options) you need. It will
+ * return an array containing a `ref`, the `inView` status and the current
+ * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+ * Assign the `ref` to the DOM element you want to monitor, and the hook will
+ * report the status.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { useInView } from 'react-intersection-observer';
+ *
+ * const Component = () => {
+ *   const { ref, inView, entry } = useInView({
+ *       threshold: 0,
+ *   });
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <h2>{`Header inside viewport ${inView}.`}</h2>
+ *     </div>
+ *   );
+ * };
+ * ```
+ */
+
+function useInView({
+  threshold,
+  delay,
+  trackVisibility,
+  rootMargin,
+  root,
+  triggerOnce,
+  skip,
+  initialInView,
+  fallbackInView
+} = {}) {
+  const unobserve = React.useRef();
+  const [state, setState] = React.useState({
+    inView: !!initialInView
+  });
+  const setRef = React.useCallback(node => {
+    if (unobserve.current !== undefined) {
+      unobserve.current();
+      unobserve.current = undefined;
+    } // Skip creating the observer
+
+
+    if (skip) return;
+
+    if (node) {
+      unobserve.current = observe(node, (inView, entry) => {
+        setState({
+          inView,
+          entry
+        });
+
+        if (entry.isIntersecting && triggerOnce && unobserve.current) {
+          // If it should only trigger once, unobserve the element after it's inView
+          unobserve.current();
+          unobserve.current = undefined;
+        }
+      }, {
+        root,
+        rootMargin,
+        threshold,
+        // @ts-ignore
+        trackVisibility,
+        // @ts-ignore
+        delay
+      }, fallbackInView);
+    }
+  }, // We break the rule here, because we aren't including the actual `threshold` variable
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [// If the threshold is an array, convert it to a string so it won't change between renders.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  Array.isArray(threshold) ? threshold.toString() : threshold, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);
+  /* eslint-disable-next-line */
+
+  useEffect(() => {
+    if (!unobserve.current && state.entry && !triggerOnce && !skip) {
+      // If we don't have a ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)
+      // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView
+      setState({
+        inView: !!initialInView
+      });
+    }
+  });
+  const result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.
+
+  result.ref = result[0];
+  result.inView = result[1];
+  result.entry = result[2];
+  return result;
+}
+
+export { InView, InView as default, defaultFallbackInView, observe, useInView };
+//# sourceMappingURL=react-intersection-observer.esm.js.map

vendor/spatie/ignition/node_modules/react-intersection-observer/react-intersection-observer.js

@@ -0,0 +1,516 @@
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return n;
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+var observerMap = new Map();
+var RootIds = new WeakMap();
+var rootId = 0;
+var unsupportedValue = undefined;
+/**
+ * What should be the default behavior if the IntersectionObserver is unsupported?
+ * Ideally the polyfill has been loaded, you can have the following happen:
+ * - `undefined`: Throw an error
+ * - `true` or `false`: Set the `inView` value to this regardless of intersection state
+ * **/
+
+function defaultFallbackInView(inView) {
+  unsupportedValue = inView;
+}
+/**
+ * Generate a unique ID for the root element
+ * @param root
+ */
+
+function getRootId(root) {
+  if (!root) return '0';
+  if (RootIds.has(root)) return RootIds.get(root);
+  rootId += 1;
+  RootIds.set(root, rootId.toString());
+  return RootIds.get(root);
+}
+/**
+ * Convert the options to a string Id, based on the values.
+ * Ensures we can reuse the same observer when observing elements with the same options.
+ * @param options
+ */
+
+
+function optionsToId(options) {
+  return Object.keys(options).sort().filter(function (key) {
+    return options[key] !== undefined;
+  }).map(function (key) {
+    return key + "_" + (key === 'root' ? getRootId(options.root) : options[key]);
+  }).toString();
+}
+
+function createObserver(options) {
+  // Create a unique ID for this observer instance, based on the root, root margin and threshold.
+  var id = optionsToId(options);
+  var instance = observerMap.get(id);
+
+  if (!instance) {
+    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.
+    var elements = new Map();
+    var thresholds;
+    var observer = new IntersectionObserver(function (entries) {
+      entries.forEach(function (entry) {
+        var _elements$get;
+
+        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.
+        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0
+        var inView = entry.isIntersecting && thresholds.some(function (threshold) {
+          return entry.intersectionRatio >= threshold;
+        }); // @ts-ignore support IntersectionObserver v2
+
+        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {
+          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.
+          // @ts-ignore
+          entry.isVisible = inView;
+        }
+
+        (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(function (callback) {
+          callback(inView, entry);
+        });
+      });
+    }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options
+
+    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
+    instance = {
+      id: id,
+      observer: observer,
+      elements: elements
+    };
+    observerMap.set(id, instance);
+  }
+
+  return instance;
+}
+/**
+ * @param element - DOM Element to observe
+ * @param callback - Callback function to trigger when intersection status changes
+ * @param options - Intersection Observer options
+ * @param fallbackInView - Fallback inView value.
+ * @return Function - Cleanup function that should be triggered to unregister the observer
+ */
+
+
+function observe(element, callback, options, fallbackInView) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (fallbackInView === void 0) {
+    fallbackInView = unsupportedValue;
+  }
+
+  if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {
+    var bounds = element.getBoundingClientRect();
+    callback(fallbackInView, {
+      isIntersecting: fallbackInView,
+      target: element,
+      intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,
+      time: 0,
+      boundingClientRect: bounds,
+      intersectionRect: bounds,
+      rootBounds: bounds
+    });
+    return function () {// Nothing to cleanup
+    };
+  } // An observer with the same options can be reused, so lets use this fact
+
+
+  var _createObserver = createObserver(options),
+      id = _createObserver.id,
+      observer = _createObserver.observer,
+      elements = _createObserver.elements; // Register the callback listener for this element
+
+
+  var callbacks = elements.get(element) || [];
+
+  if (!elements.has(element)) {
+    elements.set(element, callbacks);
+  }
+
+  callbacks.push(callback);
+  observer.observe(element);
+  return function unobserve() {
+    // Remove the callback from the callback list
+    callbacks.splice(callbacks.indexOf(callback), 1);
+
+    if (callbacks.length === 0) {
+      // No more callback exists for element, so destroy it
+      elements["delete"](element);
+      observer.unobserve(element);
+    }
+
+    if (elements.size === 0) {
+      // No more elements are being observer by this instance, so destroy it
+      observer.disconnect();
+      observerMap["delete"](id);
+    }
+  };
+}
+
+var _excluded = ["children", "as", "tag", "triggerOnce", "threshold", "root", "rootMargin", "onChange", "skip", "trackVisibility", "delay", "initialInView", "fallbackInView"];
+
+function isPlainChildren(props) {
+  return typeof props.children !== 'function';
+}
+/**
+ ## Render props
+
+ To use the `<InView>` component, you pass it a function. It will be called
+ whenever the state changes, with the new value of `inView`. In addition to the
+ `inView` prop, children also receive a `ref` that should be set on the
+ containing DOM element. This is the element that the IntersectionObserver will
+ monitor.
+
+ If you need it, you can also access the
+ [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+ on `entry`, giving you access to all the details about the current intersection
+ state.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView>
+ {({ inView, ref, entry }) => (
+      <div ref={ref}>
+        <h2>{`Header inside viewport ${inView}.`}</h2>
+      </div>
+    )}
+ </InView>
+ );
+
+ export default Component;
+ ```
+
+ ## Plain children
+
+ You can pass any element to the `<InView />`, and it will handle creating the
+ wrapping DOM element. Add a handler to the `onChange` method, and control the
+ state in your own component. Any extra props you add to `<InView>` will be
+ passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+ <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+ </InView>
+ );
+
+ export default Component;
+ ```
+ */
+
+
+var InView = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(InView, _React$Component);
+
+  function InView(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.node = null;
+    _this._unobserveCb = null;
+
+    _this.handleNode = function (node) {
+      if (_this.node) {
+        // Clear the old observer, before we start observing a new element
+        _this.unobserve();
+
+        if (!node && !_this.props.triggerOnce && !_this.props.skip) {
+          // Reset the state if we get a new node, and we aren't ignoring updates
+          _this.setState({
+            inView: !!_this.props.initialInView,
+            entry: undefined
+          });
+        }
+      }
+
+      _this.node = node ? node : null;
+
+      _this.observeNode();
+    };
+
+    _this.handleChange = function (inView, entry) {
+      if (inView && _this.props.triggerOnce) {
+        // If `triggerOnce` is true, we should stop observing the element.
+        _this.unobserve();
+      }
+
+      if (!isPlainChildren(_this.props)) {
+        // Store the current State, so we can pass it to the children in the next render update
+        // There's no reason to update the state for plain children, since it's not used in the rendering.
+        _this.setState({
+          inView: inView,
+          entry: entry
+        });
+      }
+
+      if (_this.props.onChange) {
+        // If the user is actively listening for onChange, always trigger it
+        _this.props.onChange(inView, entry);
+      }
+    };
+
+    _this.state = {
+      inView: !!props.initialInView,
+      entry: undefined
+    };
+    return _this;
+  }
+
+  var _proto = InView.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    // If a IntersectionObserver option changed, reinit the observer
+    if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {
+      this.unobserve();
+      this.observeNode();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.unobserve();
+    this.node = null;
+  };
+
+  _proto.observeNode = function observeNode() {
+    if (!this.node || this.props.skip) return;
+    var _this$props = this.props,
+        threshold = _this$props.threshold,
+        root = _this$props.root,
+        rootMargin = _this$props.rootMargin,
+        trackVisibility = _this$props.trackVisibility,
+        delay = _this$props.delay,
+        fallbackInView = _this$props.fallbackInView;
+    this._unobserveCb = observe(this.node, this.handleChange, {
+      threshold: threshold,
+      root: root,
+      rootMargin: rootMargin,
+      // @ts-ignore
+      trackVisibility: trackVisibility,
+      // @ts-ignore
+      delay: delay
+    }, fallbackInView);
+  };
+
+  _proto.unobserve = function unobserve() {
+    if (this._unobserveCb) {
+      this._unobserveCb();
+
+      this._unobserveCb = null;
+    }
+  };
+
+  _proto.render = function render() {
+    if (!isPlainChildren(this.props)) {
+      var _this$state = this.state,
+          inView = _this$state.inView,
+          entry = _this$state.entry;
+      return this.props.children({
+        inView: inView,
+        entry: entry,
+        ref: this.handleNode
+      });
+    }
+
+    var _this$props2 = this.props,
+        children = _this$props2.children,
+        as = _this$props2.as,
+        tag = _this$props2.tag,
+        props = _objectWithoutPropertiesLoose(_this$props2, _excluded);
+
+    return /*#__PURE__*/React__namespace.createElement(as || tag || 'div', _extends({
+      ref: this.handleNode
+    }, props), children);
+  };
+
+  return InView;
+}(React__namespace.Component);
+InView.displayName = 'InView';
+InView.defaultProps = {
+  threshold: 0,
+  triggerOnce: false,
+  initialInView: false
+};
+
+/**
+ * React Hooks make it easy to monitor the `inView` state of your components. Call
+ * the `useInView` hook with the (optional) [options](#options) you need. It will
+ * return an array containing a `ref`, the `inView` status and the current
+ * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+ * Assign the `ref` to the DOM element you want to monitor, and the hook will
+ * report the status.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { useInView } from 'react-intersection-observer';
+ *
+ * const Component = () => {
+ *   const { ref, inView, entry } = useInView({
+ *       threshold: 0,
+ *   });
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <h2>{`Header inside viewport ${inView}.`}</h2>
+ *     </div>
+ *   );
+ * };
+ * ```
+ */
+
+function useInView(_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      threshold = _ref.threshold,
+      delay = _ref.delay,
+      trackVisibility = _ref.trackVisibility,
+      rootMargin = _ref.rootMargin,
+      root = _ref.root,
+      triggerOnce = _ref.triggerOnce,
+      skip = _ref.skip,
+      initialInView = _ref.initialInView,
+      fallbackInView = _ref.fallbackInView;
+
+  var unobserve = React__namespace.useRef();
+
+  var _React$useState = React__namespace.useState({
+    inView: !!initialInView
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var setRef = React__namespace.useCallback(function (node) {
+    if (unobserve.current !== undefined) {
+      unobserve.current();
+      unobserve.current = undefined;
+    } // Skip creating the observer
+
+
+    if (skip) return;
+
+    if (node) {
+      unobserve.current = observe(node, function (inView, entry) {
+        setState({
+          inView: inView,
+          entry: entry
+        });
+
+        if (entry.isIntersecting && triggerOnce && unobserve.current) {
+          // If it should only trigger once, unobserve the element after it's inView
+          unobserve.current();
+          unobserve.current = undefined;
+        }
+      }, {
+        root: root,
+        rootMargin: rootMargin,
+        threshold: threshold,
+        // @ts-ignore
+        trackVisibility: trackVisibility,
+        // @ts-ignore
+        delay: delay
+      }, fallbackInView);
+    }
+  }, // We break the rule here, because we aren't including the actual `threshold` variable
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [// If the threshold is an array, convert it to a string so it won't change between renders.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  Array.isArray(threshold) ? threshold.toString() : threshold, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);
+  /* eslint-disable-next-line */
+
+  React.useEffect(function () {
+    if (!unobserve.current && state.entry && !triggerOnce && !skip) {
+      // If we don't have a ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)
+      // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView
+      setState({
+        inView: !!initialInView
+      });
+    }
+  });
+  var result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.
+
+  result.ref = result[0];
+  result.inView = result[1];
+  result.entry = result[2];
+  return result;
+}
+
+exports.InView = InView;
+exports["default"] = InView;
+exports.defaultFallbackInView = defaultFallbackInView;
+exports.observe = observe;
+exports.useInView = useInView;
+//# sourceMappingURL=react-intersection-observer.js.map

vendor/spatie/ignition/node_modules/react-intersection-observer/react-intersection-observer.m.js

@@ -0,0 +1,493 @@
+import * as React from 'react';
+import { useEffect } from 'react';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+var observerMap = new Map();
+var RootIds = new WeakMap();
+var rootId = 0;
+var unsupportedValue = undefined;
+/**
+ * What should be the default behavior if the IntersectionObserver is unsupported?
+ * Ideally the polyfill has been loaded, you can have the following happen:
+ * - `undefined`: Throw an error
+ * - `true` or `false`: Set the `inView` value to this regardless of intersection state
+ * **/
+
+function defaultFallbackInView(inView) {
+  unsupportedValue = inView;
+}
+/**
+ * Generate a unique ID for the root element
+ * @param root
+ */
+
+function getRootId(root) {
+  if (!root) return '0';
+  if (RootIds.has(root)) return RootIds.get(root);
+  rootId += 1;
+  RootIds.set(root, rootId.toString());
+  return RootIds.get(root);
+}
+/**
+ * Convert the options to a string Id, based on the values.
+ * Ensures we can reuse the same observer when observing elements with the same options.
+ * @param options
+ */
+
+
+function optionsToId(options) {
+  return Object.keys(options).sort().filter(function (key) {
+    return options[key] !== undefined;
+  }).map(function (key) {
+    return key + "_" + (key === 'root' ? getRootId(options.root) : options[key]);
+  }).toString();
+}
+
+function createObserver(options) {
+  // Create a unique ID for this observer instance, based on the root, root margin and threshold.
+  var id = optionsToId(options);
+  var instance = observerMap.get(id);
+
+  if (!instance) {
+    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.
+    var elements = new Map();
+    var thresholds;
+    var observer = new IntersectionObserver(function (entries) {
+      entries.forEach(function (entry) {
+        var _elements$get;
+
+        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.
+        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0
+        var inView = entry.isIntersecting && thresholds.some(function (threshold) {
+          return entry.intersectionRatio >= threshold;
+        }); // @ts-ignore support IntersectionObserver v2
+
+        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {
+          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.
+          // @ts-ignore
+          entry.isVisible = inView;
+        }
+
+        (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(function (callback) {
+          callback(inView, entry);
+        });
+      });
+    }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options
+
+    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
+    instance = {
+      id: id,
+      observer: observer,
+      elements: elements
+    };
+    observerMap.set(id, instance);
+  }
+
+  return instance;
+}
+/**
+ * @param element - DOM Element to observe
+ * @param callback - Callback function to trigger when intersection status changes
+ * @param options - Intersection Observer options
+ * @param fallbackInView - Fallback inView value.
+ * @return Function - Cleanup function that should be triggered to unregister the observer
+ */
+
+
+function observe(element, callback, options, fallbackInView) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (fallbackInView === void 0) {
+    fallbackInView = unsupportedValue;
+  }
+
+  if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {
+    var bounds = element.getBoundingClientRect();
+    callback(fallbackInView, {
+      isIntersecting: fallbackInView,
+      target: element,
+      intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,
+      time: 0,
+      boundingClientRect: bounds,
+      intersectionRect: bounds,
+      rootBounds: bounds
+    });
+    return function () {// Nothing to cleanup
+    };
+  } // An observer with the same options can be reused, so lets use this fact
+
+
+  var _createObserver = createObserver(options),
+      id = _createObserver.id,
+      observer = _createObserver.observer,
+      elements = _createObserver.elements; // Register the callback listener for this element
+
+
+  var callbacks = elements.get(element) || [];
+
+  if (!elements.has(element)) {
+    elements.set(element, callbacks);
+  }
+
+  callbacks.push(callback);
+  observer.observe(element);
+  return function unobserve() {
+    // Remove the callback from the callback list
+    callbacks.splice(callbacks.indexOf(callback), 1);
+
+    if (callbacks.length === 0) {
+      // No more callback exists for element, so destroy it
+      elements["delete"](element);
+      observer.unobserve(element);
+    }
+
+    if (elements.size === 0) {
+      // No more elements are being observer by this instance, so destroy it
+      observer.disconnect();
+      observerMap["delete"](id);
+    }
+  };
+}
+
+var _excluded = ["children", "as", "tag", "triggerOnce", "threshold", "root", "rootMargin", "onChange", "skip", "trackVisibility", "delay", "initialInView", "fallbackInView"];
+
+function isPlainChildren(props) {
+  return typeof props.children !== 'function';
+}
+/**
+ ## Render props
+
+ To use the `<InView>` component, you pass it a function. It will be called
+ whenever the state changes, with the new value of `inView`. In addition to the
+ `inView` prop, children also receive a `ref` that should be set on the
+ containing DOM element. This is the element that the IntersectionObserver will
+ monitor.
+
+ If you need it, you can also access the
+ [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+ on `entry`, giving you access to all the details about the current intersection
+ state.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView>
+ {({ inView, ref, entry }) => (
+      <div ref={ref}>
+        <h2>{`Header inside viewport ${inView}.`}</h2>
+      </div>
+    )}
+ </InView>
+ );
+
+ export default Component;
+ ```
+
+ ## Plain children
+
+ You can pass any element to the `<InView />`, and it will handle creating the
+ wrapping DOM element. Add a handler to the `onChange` method, and control the
+ state in your own component. Any extra props you add to `<InView>` will be
+ passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+ ```jsx
+ import { InView } from 'react-intersection-observer';
+
+ const Component = () => (
+ <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+ <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+ </InView>
+ );
+
+ export default Component;
+ ```
+ */
+
+
+var InView = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(InView, _React$Component);
+
+  function InView(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.node = null;
+    _this._unobserveCb = null;
+
+    _this.handleNode = function (node) {
+      if (_this.node) {
+        // Clear the old observer, before we start observing a new element
+        _this.unobserve();
+
+        if (!node && !_this.props.triggerOnce && !_this.props.skip) {
+          // Reset the state if we get a new node, and we aren't ignoring updates
+          _this.setState({
+            inView: !!_this.props.initialInView,
+            entry: undefined
+          });
+        }
+      }
+
+      _this.node = node ? node : null;
+
+      _this.observeNode();
+    };
+
+    _this.handleChange = function (inView, entry) {
+      if (inView && _this.props.triggerOnce) {
+        // If `triggerOnce` is true, we should stop observing the element.
+        _this.unobserve();
+      }
+
+      if (!isPlainChildren(_this.props)) {
+        // Store the current State, so we can pass it to the children in the next render update
+        // There's no reason to update the state for plain children, since it's not used in the rendering.
+        _this.setState({
+          inView: inView,
+          entry: entry
+        });
+      }
+
+      if (_this.props.onChange) {
+        // If the user is actively listening for onChange, always trigger it
+        _this.props.onChange(inView, entry);
+      }
+    };
+
+    _this.state = {
+      inView: !!props.initialInView,
+      entry: undefined
+    };
+    return _this;
+  }
+
+  var _proto = InView.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    // If a IntersectionObserver option changed, reinit the observer
+    if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {
+      this.unobserve();
+      this.observeNode();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.unobserve();
+    this.node = null;
+  };
+
+  _proto.observeNode = function observeNode() {
+    if (!this.node || this.props.skip) return;
+    var _this$props = this.props,
+        threshold = _this$props.threshold,
+        root = _this$props.root,
+        rootMargin = _this$props.rootMargin,
+        trackVisibility = _this$props.trackVisibility,
+        delay = _this$props.delay,
+        fallbackInView = _this$props.fallbackInView;
+    this._unobserveCb = observe(this.node, this.handleChange, {
+      threshold: threshold,
+      root: root,
+      rootMargin: rootMargin,
+      // @ts-ignore
+      trackVisibility: trackVisibility,
+      // @ts-ignore
+      delay: delay
+    }, fallbackInView);
+  };
+
+  _proto.unobserve = function unobserve() {
+    if (this._unobserveCb) {
+      this._unobserveCb();
+
+      this._unobserveCb = null;
+    }
+  };
+
+  _proto.render = function render() {
+    if (!isPlainChildren(this.props)) {
+      var _this$state = this.state,
+          inView = _this$state.inView,
+          entry = _this$state.entry;
+      return this.props.children({
+        inView: inView,
+        entry: entry,
+        ref: this.handleNode
+      });
+    }
+
+    var _this$props2 = this.props,
+        children = _this$props2.children,
+        as = _this$props2.as,
+        tag = _this$props2.tag,
+        props = _objectWithoutPropertiesLoose(_this$props2, _excluded);
+
+    return /*#__PURE__*/React.createElement(as || tag || 'div', _extends({
+      ref: this.handleNode
+    }, props), children);
+  };
+
+  return InView;
+}(React.Component);
+InView.displayName = 'InView';
+InView.defaultProps = {
+  threshold: 0,
+  triggerOnce: false,
+  initialInView: false
+};
+
+/**
+ * React Hooks make it easy to monitor the `inView` state of your components. Call
+ * the `useInView` hook with the (optional) [options](#options) you need. It will
+ * return an array containing a `ref`, the `inView` status and the current
+ * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+ * Assign the `ref` to the DOM element you want to monitor, and the hook will
+ * report the status.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { useInView } from 'react-intersection-observer';
+ *
+ * const Component = () => {
+ *   const { ref, inView, entry } = useInView({
+ *       threshold: 0,
+ *   });
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <h2>{`Header inside viewport ${inView}.`}</h2>
+ *     </div>
+ *   );
+ * };
+ * ```
+ */
+
+function useInView(_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      threshold = _ref.threshold,
+      delay = _ref.delay,
+      trackVisibility = _ref.trackVisibility,
+      rootMargin = _ref.rootMargin,
+      root = _ref.root,
+      triggerOnce = _ref.triggerOnce,
+      skip = _ref.skip,
+      initialInView = _ref.initialInView,
+      fallbackInView = _ref.fallbackInView;
+
+  var unobserve = React.useRef();
+
+  var _React$useState = React.useState({
+    inView: !!initialInView
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var setRef = React.useCallback(function (node) {
+    if (unobserve.current !== undefined) {
+      unobserve.current();
+      unobserve.current = undefined;
+    } // Skip creating the observer
+
+
+    if (skip) return;
+
+    if (node) {
+      unobserve.current = observe(node, function (inView, entry) {
+        setState({
+          inView: inView,
+          entry: entry
+        });
+
+        if (entry.isIntersecting && triggerOnce && unobserve.current) {
+          // If it should only trigger once, unobserve the element after it's inView
+          unobserve.current();
+          unobserve.current = undefined;
+        }
+      }, {
+        root: root,
+        rootMargin: rootMargin,
+        threshold: threshold,
+        // @ts-ignore
+        trackVisibility: trackVisibility,
+        // @ts-ignore
+        delay: delay
+      }, fallbackInView);
+    }
+  }, // We break the rule here, because we aren't including the actual `threshold` variable
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [// If the threshold is an array, convert it to a string so it won't change between renders.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  Array.isArray(threshold) ? threshold.toString() : threshold, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);
+  /* eslint-disable-next-line */
+
+  useEffect(function () {
+    if (!unobserve.current && state.entry && !triggerOnce && !skip) {
+      // If we don't have a ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)
+      // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView
+      setState({
+        inView: !!initialInView
+      });
+    }
+  });
+  var result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.
+
+  result.ref = result[0];
+  result.inView = result[1];
+  result.entry = result[2];
+  return result;
+}
+
+export { InView, InView as default, defaultFallbackInView, observe, useInView };
+//# sourceMappingURL=react-intersection-observer.m.js.map

vendor/spatie/ignition/node_modules/react-intersection-observer/react-intersection-observer.umd.js

@@ -0,0 +1,521 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
+  (global = global || self, factory(global.ReactIntersectionObserver = {}, global.react));
+})(this, (function (exports, React) {
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n["default"] = e;
+    return n;
+  }
+
+  var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+  function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+
+    _setPrototypeOf(subClass, superClass);
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+
+    return target;
+  }
+
+  var observerMap = new Map();
+  var RootIds = new WeakMap();
+  var rootId = 0;
+  var unsupportedValue = undefined;
+  /**
+   * What should be the default behavior if the IntersectionObserver is unsupported?
+   * Ideally the polyfill has been loaded, you can have the following happen:
+   * - `undefined`: Throw an error
+   * - `true` or `false`: Set the `inView` value to this regardless of intersection state
+   * **/
+
+  function defaultFallbackInView(inView) {
+    unsupportedValue = inView;
+  }
+  /**
+   * Generate a unique ID for the root element
+   * @param root
+   */
+
+  function getRootId(root) {
+    if (!root) return '0';
+    if (RootIds.has(root)) return RootIds.get(root);
+    rootId += 1;
+    RootIds.set(root, rootId.toString());
+    return RootIds.get(root);
+  }
+  /**
+   * Convert the options to a string Id, based on the values.
+   * Ensures we can reuse the same observer when observing elements with the same options.
+   * @param options
+   */
+
+
+  function optionsToId(options) {
+    return Object.keys(options).sort().filter(function (key) {
+      return options[key] !== undefined;
+    }).map(function (key) {
+      return key + "_" + (key === 'root' ? getRootId(options.root) : options[key]);
+    }).toString();
+  }
+
+  function createObserver(options) {
+    // Create a unique ID for this observer instance, based on the root, root margin and threshold.
+    var id = optionsToId(options);
+    var instance = observerMap.get(id);
+
+    if (!instance) {
+      // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.
+      var elements = new Map();
+      var thresholds;
+      var observer = new IntersectionObserver(function (entries) {
+        entries.forEach(function (entry) {
+          var _elements$get;
+
+          // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.
+          // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0
+          var inView = entry.isIntersecting && thresholds.some(function (threshold) {
+            return entry.intersectionRatio >= threshold;
+          }); // @ts-ignore support IntersectionObserver v2
+
+          if (options.trackVisibility && typeof entry.isVisible === 'undefined') {
+            // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.
+            // @ts-ignore
+            entry.isVisible = inView;
+          }
+
+          (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(function (callback) {
+            callback(inView, entry);
+          });
+        });
+      }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options
+
+      thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
+      instance = {
+        id: id,
+        observer: observer,
+        elements: elements
+      };
+      observerMap.set(id, instance);
+    }
+
+    return instance;
+  }
+  /**
+   * @param element - DOM Element to observe
+   * @param callback - Callback function to trigger when intersection status changes
+   * @param options - Intersection Observer options
+   * @param fallbackInView - Fallback inView value.
+   * @return Function - Cleanup function that should be triggered to unregister the observer
+   */
+
+
+  function observe(element, callback, options, fallbackInView) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    if (fallbackInView === void 0) {
+      fallbackInView = unsupportedValue;
+    }
+
+    if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {
+      var bounds = element.getBoundingClientRect();
+      callback(fallbackInView, {
+        isIntersecting: fallbackInView,
+        target: element,
+        intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,
+        time: 0,
+        boundingClientRect: bounds,
+        intersectionRect: bounds,
+        rootBounds: bounds
+      });
+      return function () {// Nothing to cleanup
+      };
+    } // An observer with the same options can be reused, so lets use this fact
+
+
+    var _createObserver = createObserver(options),
+        id = _createObserver.id,
+        observer = _createObserver.observer,
+        elements = _createObserver.elements; // Register the callback listener for this element
+
+
+    var callbacks = elements.get(element) || [];
+
+    if (!elements.has(element)) {
+      elements.set(element, callbacks);
+    }
+
+    callbacks.push(callback);
+    observer.observe(element);
+    return function unobserve() {
+      // Remove the callback from the callback list
+      callbacks.splice(callbacks.indexOf(callback), 1);
+
+      if (callbacks.length === 0) {
+        // No more callback exists for element, so destroy it
+        elements["delete"](element);
+        observer.unobserve(element);
+      }
+
+      if (elements.size === 0) {
+        // No more elements are being observer by this instance, so destroy it
+        observer.disconnect();
+        observerMap["delete"](id);
+      }
+    };
+  }
+
+  var _excluded = ["children", "as", "tag", "triggerOnce", "threshold", "root", "rootMargin", "onChange", "skip", "trackVisibility", "delay", "initialInView", "fallbackInView"];
+
+  function isPlainChildren(props) {
+    return typeof props.children !== 'function';
+  }
+  /**
+   ## Render props
+
+   To use the `<InView>` component, you pass it a function. It will be called
+   whenever the state changes, with the new value of `inView`. In addition to the
+   `inView` prop, children also receive a `ref` that should be set on the
+   containing DOM element. This is the element that the IntersectionObserver will
+   monitor.
+
+   If you need it, you can also access the
+   [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)
+   on `entry`, giving you access to all the details about the current intersection
+   state.
+
+   ```jsx
+   import { InView } from 'react-intersection-observer';
+
+   const Component = () => (
+   <InView>
+   {({ inView, ref, entry }) => (
+        <div ref={ref}>
+          <h2>{`Header inside viewport ${inView}.`}</h2>
+        </div>
+      )}
+   </InView>
+   );
+
+   export default Component;
+   ```
+
+   ## Plain children
+
+   You can pass any element to the `<InView />`, and it will handle creating the
+   wrapping DOM element. Add a handler to the `onChange` method, and control the
+   state in your own component. Any extra props you add to `<InView>` will be
+   passed to the HTML element, allowing you set the `className`, `style`, etc.
+
+   ```jsx
+   import { InView } from 'react-intersection-observer';
+
+   const Component = () => (
+   <InView as="div" onChange={(inView, entry) => console.log('Inview:', inView)}>
+   <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
+   </InView>
+   );
+
+   export default Component;
+   ```
+   */
+
+
+  var InView = /*#__PURE__*/function (_React$Component) {
+    _inheritsLoose(InView, _React$Component);
+
+    function InView(props) {
+      var _this;
+
+      _this = _React$Component.call(this, props) || this;
+      _this.node = null;
+      _this._unobserveCb = null;
+
+      _this.handleNode = function (node) {
+        if (_this.node) {
+          // Clear the old observer, before we start observing a new element
+          _this.unobserve();
+
+          if (!node && !_this.props.triggerOnce && !_this.props.skip) {
+            // Reset the state if we get a new node, and we aren't ignoring updates
+            _this.setState({
+              inView: !!_this.props.initialInView,
+              entry: undefined
+            });
+          }
+        }
+
+        _this.node = node ? node : null;
+
+        _this.observeNode();
+      };
+
+      _this.handleChange = function (inView, entry) {
+        if (inView && _this.props.triggerOnce) {
+          // If `triggerOnce` is true, we should stop observing the element.
+          _this.unobserve();
+        }
+
+        if (!isPlainChildren(_this.props)) {
+          // Store the current State, so we can pass it to the children in the next render update
+          // There's no reason to update the state for plain children, since it's not used in the rendering.
+          _this.setState({
+            inView: inView,
+            entry: entry
+          });
+        }
+
+        if (_this.props.onChange) {
+          // If the user is actively listening for onChange, always trigger it
+          _this.props.onChange(inView, entry);
+        }
+      };
+
+      _this.state = {
+        inView: !!props.initialInView,
+        entry: undefined
+      };
+      return _this;
+    }
+
+    var _proto = InView.prototype;
+
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+      // If a IntersectionObserver option changed, reinit the observer
+      if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {
+        this.unobserve();
+        this.observeNode();
+      }
+    };
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      this.unobserve();
+      this.node = null;
+    };
+
+    _proto.observeNode = function observeNode() {
+      if (!this.node || this.props.skip) return;
+      var _this$props = this.props,
+          threshold = _this$props.threshold,
+          root = _this$props.root,
+          rootMargin = _this$props.rootMargin,
+          trackVisibility = _this$props.trackVisibility,
+          delay = _this$props.delay,
+          fallbackInView = _this$props.fallbackInView;
+      this._unobserveCb = observe(this.node, this.handleChange, {
+        threshold: threshold,
+        root: root,
+        rootMargin: rootMargin,
+        // @ts-ignore
+        trackVisibility: trackVisibility,
+        // @ts-ignore
+        delay: delay
+      }, fallbackInView);
+    };
+
+    _proto.unobserve = function unobserve() {
+      if (this._unobserveCb) {
+        this._unobserveCb();
+
+        this._unobserveCb = null;
+      }
+    };
+
+    _proto.render = function render() {
+      if (!isPlainChildren(this.props)) {
+        var _this$state = this.state,
+            inView = _this$state.inView,
+            entry = _this$state.entry;
+        return this.props.children({
+          inView: inView,
+          entry: entry,
+          ref: this.handleNode
+        });
+      }
+
+      var _this$props2 = this.props,
+          children = _this$props2.children,
+          as = _this$props2.as,
+          tag = _this$props2.tag,
+          props = _objectWithoutPropertiesLoose(_this$props2, _excluded);
+
+      return /*#__PURE__*/React__namespace.createElement(as || tag || 'div', _extends({
+        ref: this.handleNode
+      }, props), children);
+    };
+
+    return InView;
+  }(React__namespace.Component);
+  InView.displayName = 'InView';
+  InView.defaultProps = {
+    threshold: 0,
+    triggerOnce: false,
+    initialInView: false
+  };
+
+  /**
+   * React Hooks make it easy to monitor the `inView` state of your components. Call
+   * the `useInView` hook with the (optional) [options](#options) you need. It will
+   * return an array containing a `ref`, the `inView` status and the current
+   * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+   * Assign the `ref` to the DOM element you want to monitor, and the hook will
+   * report the status.
+   *
+   * @example
+   * ```jsx
+   * import React from 'react';
+   * import { useInView } from 'react-intersection-observer';
+   *
+   * const Component = () => {
+   *   const { ref, inView, entry } = useInView({
+   *       threshold: 0,
+   *   });
+   *
+   *   return (
+   *     <div ref={ref}>
+   *       <h2>{`Header inside viewport ${inView}.`}</h2>
+   *     </div>
+   *   );
+   * };
+   * ```
+   */
+
+  function useInView(_temp) {
+    var _ref = _temp === void 0 ? {} : _temp,
+        threshold = _ref.threshold,
+        delay = _ref.delay,
+        trackVisibility = _ref.trackVisibility,
+        rootMargin = _ref.rootMargin,
+        root = _ref.root,
+        triggerOnce = _ref.triggerOnce,
+        skip = _ref.skip,
+        initialInView = _ref.initialInView,
+        fallbackInView = _ref.fallbackInView;
+
+    var unobserve = React__namespace.useRef();
+
+    var _React$useState = React__namespace.useState({
+      inView: !!initialInView
+    }),
+        state = _React$useState[0],
+        setState = _React$useState[1];
+
+    var setRef = React__namespace.useCallback(function (node) {
+      if (unobserve.current !== undefined) {
+        unobserve.current();
+        unobserve.current = undefined;
+      } // Skip creating the observer
+
+
+      if (skip) return;
+
+      if (node) {
+        unobserve.current = observe(node, function (inView, entry) {
+          setState({
+            inView: inView,
+            entry: entry
+          });
+
+          if (entry.isIntersecting && triggerOnce && unobserve.current) {
+            // If it should only trigger once, unobserve the element after it's inView
+            unobserve.current();
+            unobserve.current = undefined;
+          }
+        }, {
+          root: root,
+          rootMargin: rootMargin,
+          threshold: threshold,
+          // @ts-ignore
+          trackVisibility: trackVisibility,
+          // @ts-ignore
+          delay: delay
+        }, fallbackInView);
+      }
+    }, // We break the rule here, because we aren't including the actual `threshold` variable
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [// If the threshold is an array, convert it to a string so it won't change between renders.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    Array.isArray(threshold) ? threshold.toString() : threshold, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);
+    /* eslint-disable-next-line */
+
+    React.useEffect(function () {
+      if (!unobserve.current && state.entry && !triggerOnce && !skip) {
+        // If we don't have a ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)
+        // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView
+        setState({
+          inView: !!initialInView
+        });
+      }
+    });
+    var result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.
+
+    result.ref = result[0];
+    result.inView = result[1];
+    result.entry = result[2];
+    return result;
+  }
+
+  exports.InView = InView;
+  exports["default"] = InView;
+  exports.defaultFallbackInView = defaultFallbackInView;
+  exports.observe = observe;
+  exports.useInView = useInView;
+
+}));
+//# sourceMappingURL=react-intersection-observer.umd.js.map

vendor/spatie/ignition/node_modules/react-intersection-observer/useInView.d.ts

@@ -0,0 +1,28 @@
+import { InViewHookResponse, IntersectionOptions } from './index';
+/**
+ * React Hooks make it easy to monitor the `inView` state of your components. Call
+ * the `useInView` hook with the (optional) [options](#options) you need. It will
+ * return an array containing a `ref`, the `inView` status and the current
+ * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).
+ * Assign the `ref` to the DOM element you want to monitor, and the hook will
+ * report the status.
+ *
+ * @example
+ * ```jsx
+ * import React from 'react';
+ * import { useInView } from 'react-intersection-observer';
+ *
+ * const Component = () => {
+ *   const { ref, inView, entry } = useInView({
+ *       threshold: 0,
+ *   });
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <h2>{`Header inside viewport ${inView}.`}</h2>
+ *     </div>
+ *   );
+ * };
+ * ```
+ */
+export declare function useInView({ threshold, delay, trackVisibility, rootMargin, root, triggerOnce, skip, initialInView, fallbackInView, }?: IntersectionOptions): InViewHookResponse;