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/@rollup/plugin-alias/CHANGELOG.md

@@ -0,0 +1,92 @@
+# @rollup/plugin-alias ChangeLog
+
+## v3.1.2
+
+_2021-01-29_
+
+### Updates
+
+- chore: upgrade TypeScript (#708)
+- chore: add missing readonly to internal function (#680)
+- chore: fix TS error in function call (d04778c)
+- chore: update dependencies (b3b8efd)
+
+## v3.1.1
+
+_2020-06-05_
+
+### Bugfixes
+
+- fix: properly initialize custom resolvers (#426)
+
+## v3.1.0
+
+_2020-04-12_
+
+### Features
+
+- feat: Move to Typescript (#228)
+
+## v3.0.1
+
+_2020-02-01_
+
+### Updates
+
+- docs: Fix reference to plugin-node-resolve (#175)
+- chore: update dependencies (bcb53d8)
+- chore: update dependencies (e36540f)
+- chore: fix minor linting issue (a695579)
+
+## 3.0.0
+
+### Breaking Changes
+
+- feat(alias): built-in resolving algorithm is replaced in favor of Rollup's `this.resolve()` (#34)
+
+## 2.2.0
+
+_2019-10-21_
+
+- Support resolving `index.js` files in directories ([#64](https://github.com/rollup/rollup-plugin-alias/pull/64) by @jerriclynsjohn)
+
+## 2.1.0
+
+_2019-10-18_
+
+- Add support for object syntax ([#61](https://github.com/rollup/rollup-plugin-alias/pull/61) by @Andarist)
+
+## 2.0.1
+
+_2019-09-27_
+
+- Update dependencies ([#59](https://github.com/rollup/rollup-plugin-alias/pull/59) by @lukastaegert)
+- Make volume letter regexp case independent ([#57](https://github.com/rollup/rollup-plugin-alias/pull/57) by @MarekLacoAXA)
+
+## 2.0.0
+
+_2019-08-22_
+
+- Add RegExp support and strict order of entries ([#53](https://github.com/rollup/rollup-plugin-alias/pull/53) by @thiscantbeserious)
+
+### Breaking Changes
+
+Aliases always need to be provided as an array, see #53
+
+## 1.5.2
+
+- Update dependencies
+
+## 1.5.1
+
+- Update tests for Rollup@1.0 compatibility and tests ([#48](https://github.com/rollup/rollup-plugin-alias/pull/48))
+
+## 1.4.0
+
+- Various Windows fixes ([#22](https://github.com/rollup/rollup-plugin-alias/pull/22))
+- Don't try to alias entry file ([#29](https://github.com/rollup/rollup-plugin-alias/pull/29))
+
+## 1.3.0
+
+- Start maintaining a changelog
+- Fix `isFilePath` on Windows ([#3](https://github.com/rollup/rollup-plugin-alias/issues/3))

vendor/spatie/ignition/node_modules/@rollup/plugin-alias/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/plugin-alias/README.md

@@ -0,0 +1,174 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-alias
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-alias
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-alias
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-alias
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-alias
+
+🍣 A Rollup plugin for defining aliases when bundling packages.
+
+## Alias 101
+
+Suppose we have the following `import` defined in a hypothetical file:
+
+```javascript
+import batman from '../../../batman';
+```
+
+This probably doesn't look too bad on its own. But consider that may not be the only instance in your codebase, and that after a refactor this might be incorrect. With this plugin in place, you can alias `../../../batman` with `batman` for readability and maintainability. In the case of a refactor, only the alias would need to be changed, rather than navigating through the codebase and changing all imports.
+
+```javascript
+import batman from 'batman';
+```
+
+If this seems familiar to Webpack users, it should. This is plugin mimics the `resolve.extensions` and `resolve.alias` functionality in Webpack.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/plugin-alias --save-dev
+# or
+yarn add -D @rollup/plugin-alias
+```
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import alias from '@rollup/plugin-alias';
+
+module.exports = {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [
+    alias({
+      entries: [
+        { find: 'utils', replacement: '../../../utils' },
+        { find: 'batman-1.0.0', replacement: './joker-1.5.0' }
+      ]
+    })
+  ]
+};
+```
+
+Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api). If the build produces any errors, the plugin will write a 'alias' character to stderr, which should be audible on most systems.
+
+## Options
+
+### `customResolver`
+
+Type: `Function | Object`<br>
+Default: `null`
+
+Instructs the plugin to use an alternative resolving algorithm, rather than the Rollup's resolver. Please refer to the [Rollup documentation](https://rollupjs.org/guide/en/#hooks) for more information about the `resolveId` hook. For a detailed example, see: [Custom Resolvers](#custom-resolvers).
+
+### `entries`
+
+Type: `Object | Array[...Object]`<br>
+Default: `null`
+
+Specifies an `Object`, or an `Array` of `Object`, which defines aliases used to replace values in `import` or `require` statements. With either format, the order of the entries is important, in that the first defined rules are applied first. This option also supports [Regular Expression Alias](#regular-expression-aliases) matching.
+
+#### `Object` Format
+
+The `Object` format allows specifying aliases as a key, and the corresponding value as the actual `import` value. For example:
+
+```js
+alias({
+  entries: {
+    utils: '../../../utils',
+    'batman-1.0.0': './joker-1.5.0'
+  }
+});
+```
+
+#### `Array[...Object]` Format
+
+The `Array[...Object]` format allows specifying aliases as objects, which can be useful for complex key/value pairs.
+
+```js
+entries: [
+  { find: 'utils', replacement: '../../../utils' },
+  { find: 'batman-1.0.0', replacement: './joker-1.5.0' }
+];
+```
+
+## Regular Expression Aliases
+
+Regular Expressions can be used to search in a more distinct and complex manner. e.g. To perform partial replacements via sub-pattern matching.
+
+To remove something in front of an import and append an extension, use a pattern such as:
+
+```js
+{ find:/^i18n\!(.*)/, replacement: '$1.js' }
+```
+
+This would be useful for loaders, and files that were previously transpiled via the AMD module, to properly handle them in rollup as internals.
+
+To replace extensions with another, a pattern like the following might be used:
+
+```js
+{ find:/^(.*)\.js$/, replacement: '$1.alias' }
+```
+
+This would replace the file extension for all imports ending with `.js` to `.alias`.
+
+## Resolving algorithm
+
+This plugin uses resolver plugins specified for Rollup and eventually Rollup default algorithm. If you rely on Node specific features, you probably want [@rollup/plugin-node-resolve](https://www.npmjs.com/package/@rollup/plugin-node-resolve) in your setup.
+
+## Custom Resolvers
+
+The `customResolver` option can be leveraged to provide separate module resolution for an individual alias.
+
+Example:
+
+```javascript
+// rollup.config.js
+import alias from '@rollup/plugin-alias';
+import resolve from '@rollup/plugin-node-resolve';
+
+const customResolver = resolve({
+  extensions: ['.mjs', '.js', '.jsx', '.json', '.sass', '.scss']
+});
+const projectRootDir = path.resolve(__dirname);
+
+export default {
+  // ...
+  plugins: [
+    alias({
+      entries: [
+        {
+          find: 'src',
+          replacement: path.resolve(projectRootDir, 'src')
+          // OR place `customResolver` here. See explanation below.
+        }
+      ],
+      customResolver
+    }),
+    resolve()
+  ]
+};
+```
+
+In the example above the alias `src` is used, which uses the `node-resolve` algorithm for files _aliased_ with `src`, by passing the `customResolver` option. The `resolve()` plugin is kept separate in the plugins list for other files which are not _aliased_ with `src`. The `customResolver` option can be passed inside each `entries` item for granular control over resolving allowing each alias a preferred resolver.
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/plugin-alias/dist/index.es.js

@@ -0,0 +1,95 @@
+import { platform } from 'os';
+import slash from 'slash';
+
+const VOLUME = /^([A-Z]:)/i;
+const IS_WINDOWS = platform() === 'win32';
+const noop = () => null;
+function matches(pattern, importee) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(importee);
+    }
+    if (importee.length < pattern.length) {
+        return false;
+    }
+    if (importee === pattern) {
+        return true;
+    }
+    const importeeStartsWithKey = importee.indexOf(pattern) === 0;
+    const importeeHasSlashAfterKey = importee.substring(pattern.length)[0] === '/';
+    return importeeStartsWithKey && importeeHasSlashAfterKey;
+}
+function normalizeId(id) {
+    if (typeof id === 'string' && (IS_WINDOWS || VOLUME.test(id))) {
+        return slash(id.replace(VOLUME, ''));
+    }
+    return id;
+}
+function getEntries({ entries }) {
+    if (!entries) {
+        return [];
+    }
+    if (Array.isArray(entries)) {
+        return entries;
+    }
+    return Object.entries(entries).map(([key, value]) => {
+        return { find: key, replacement: value };
+    });
+}
+function getCustomResolver({ customResolver }, options) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
+    if (customResolver && typeof customResolver.resolveId === 'function') {
+        return customResolver.resolveId;
+    }
+    if (typeof options.customResolver === 'function') {
+        return options.customResolver;
+    }
+    if (options.customResolver && typeof options.customResolver.resolveId === 'function') {
+        return options.customResolver.resolveId;
+    }
+    return null;
+}
+function alias(options = {}) {
+    const entries = getEntries(options);
+    if (entries.length === 0) {
+        return {
+            name: 'alias',
+            resolveId: noop
+        };
+    }
+    return {
+        name: 'alias',
+        buildStart(inputOptions) {
+            return Promise.all([...entries, options].map(({ customResolver }) => customResolver &&
+                typeof customResolver === 'object' &&
+                typeof customResolver.buildStart === 'function' &&
+                customResolver.buildStart.call(this, inputOptions))).then(() => {
+                // enforce void return value
+            });
+        },
+        resolveId(importee, importer) {
+            const importeeId = normalizeId(importee);
+            const importerId = normalizeId(importer);
+            // First match is supposed to be the correct one
+            const matchedEntry = entries.find((entry) => matches(entry.find, importeeId));
+            if (!matchedEntry || !importerId) {
+                return null;
+            }
+            const updatedId = normalizeId(importeeId.replace(matchedEntry.find, matchedEntry.replacement));
+            const customResolver = getCustomResolver(matchedEntry, options);
+            if (customResolver) {
+                return customResolver.call(this, updatedId, importerId, {});
+            }
+            return this.resolve(updatedId, importer, { skipSelf: true }).then((resolved) => {
+                let finalResult = resolved;
+                if (!finalResult) {
+                    finalResult = { id: updatedId };
+                }
+                return finalResult;
+            });
+        }
+    };
+}
+
+export default alias;

vendor/spatie/ignition/node_modules/@rollup/plugin-alias/dist/index.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var os = require('os');
+var slash = require('slash');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var slash__default = /*#__PURE__*/_interopDefaultLegacy(slash);
+
+const VOLUME = /^([A-Z]:)/i;
+const IS_WINDOWS = os.platform() === 'win32';
+const noop = () => null;
+function matches(pattern, importee) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(importee);
+    }
+    if (importee.length < pattern.length) {
+        return false;
+    }
+    if (importee === pattern) {
+        return true;
+    }
+    const importeeStartsWithKey = importee.indexOf(pattern) === 0;
+    const importeeHasSlashAfterKey = importee.substring(pattern.length)[0] === '/';
+    return importeeStartsWithKey && importeeHasSlashAfterKey;
+}
+function normalizeId(id) {
+    if (typeof id === 'string' && (IS_WINDOWS || VOLUME.test(id))) {
+        return slash__default['default'](id.replace(VOLUME, ''));
+    }
+    return id;
+}
+function getEntries({ entries }) {
+    if (!entries) {
+        return [];
+    }
+    if (Array.isArray(entries)) {
+        return entries;
+    }
+    return Object.entries(entries).map(([key, value]) => {
+        return { find: key, replacement: value };
+    });
+}
+function getCustomResolver({ customResolver }, options) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
+    if (customResolver && typeof customResolver.resolveId === 'function') {
+        return customResolver.resolveId;
+    }
+    if (typeof options.customResolver === 'function') {
+        return options.customResolver;
+    }
+    if (options.customResolver && typeof options.customResolver.resolveId === 'function') {
+        return options.customResolver.resolveId;
+    }
+    return null;
+}
+function alias(options = {}) {
+    const entries = getEntries(options);
+    if (entries.length === 0) {
+        return {
+            name: 'alias',
+            resolveId: noop
+        };
+    }
+    return {
+        name: 'alias',
+        buildStart(inputOptions) {
+            return Promise.all([...entries, options].map(({ customResolver }) => customResolver &&
+                typeof customResolver === 'object' &&
+                typeof customResolver.buildStart === 'function' &&
+                customResolver.buildStart.call(this, inputOptions))).then(() => {
+                // enforce void return value
+            });
+        },
+        resolveId(importee, importer) {
+            const importeeId = normalizeId(importee);
+            const importerId = normalizeId(importer);
+            // First match is supposed to be the correct one
+            const matchedEntry = entries.find((entry) => matches(entry.find, importeeId));
+            if (!matchedEntry || !importerId) {
+                return null;
+            }
+            const updatedId = normalizeId(importeeId.replace(matchedEntry.find, matchedEntry.replacement));
+            const customResolver = getCustomResolver(matchedEntry, options);
+            if (customResolver) {
+                return customResolver.call(this, updatedId, importerId, {});
+            }
+            return this.resolve(updatedId, importer, { skipSelf: true }).then((resolved) => {
+                let finalResult = resolved;
+                if (!finalResult) {
+                    finalResult = { id: updatedId };
+                }
+                return finalResult;
+            });
+        }
+    };
+}
+
+module.exports = alias;

vendor/spatie/ignition/node_modules/@rollup/plugin-alias/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/plugin-alias/types/index.d.ts

@@ -0,0 +1,36 @@
+import { Plugin, PluginHooks } from 'rollup';
+
+export type ResolverFunction = PluginHooks['resolveId'];
+
+export interface ResolverObject {
+  buildStart?: PluginHooks['buildStart'];
+  resolveId: ResolverFunction;
+}
+
+export interface Alias {
+  find: string | RegExp;
+  replacement: string;
+  customResolver?: ResolverFunction | ResolverObject | null;
+}
+
+export interface RollupAliasOptions {
+  /**
+   * Instructs the plugin to use an alternative resolving algorithm,
+   * rather than the Rollup's resolver.
+   * @default null
+   */
+  customResolver?: ResolverFunction | ResolverObject | null;
+
+  /**
+   * Specifies an `Object`, or an `Array` of `Object`,
+   * which defines aliases used to replace values in `import` or `require` statements.
+   * With either format, the order of the entries is important,
+   * in that the first defined rules are applied first.
+   */
+  entries?: readonly Alias[] | { [find: string]: string };
+}
+
+/**
+ * 🍣 A Rollup plugin for defining aliases when bundling packages.
+ */
+export default function alias(options?: RollupAliasOptions): Plugin;

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/CHANGELOG.md

@@ -0,0 +1,284 @@
+# @rollup/plugin-babel ChangeLog
+
+## v5.3.0
+
+_2021-02-14_
+
+### Features
+
+- feat: add custom filter option (#767)
+- feat: pass rollup context as this context into override config function (#784)
+
+### Updates
+
+- docs: typo in README.md (#800)
+- chore: commit updated readme format (bfda6d8)
+
+## v5.2.3
+
+_2021-01-29_
+
+### Updates
+
+- docs: add usage with commonjs. fixes #622 (6b4b7b6)
+- docs: update export in README (#690)
+
+## v5.2.2
+
+_2020-11-30_
+
+### Bugfixes
+
+- fix: clone cached helper identifier before returning it (#584)
+- fix: strip hash and query param in extension filter (#533)
+
+## v5.2.1
+
+_2020-09-09_
+
+### Updates
+
+- chore: add deprecation/migration warnings for the runtime (#534)
+
+## v5.2.0
+
+_2020-08-13_
+
+### Features
+
+- feat: `export * as ns` support (#511)
+
+### Updates
+
+- chore: update dependencies (13526d6)
+
+## v5.1.0
+
+_2020-07-12_
+
+### Features
+
+- feat: add typings (#462)
+
+### Updates
+
+- docs: add note about excluding @babel/runtime helpers via regex (#483)
+
+## v5.0.4
+
+_2020-06-22_
+
+### Updates
+
+- docs: remove unused import in "Usage" example (#460)
+- docs: update node requirement in readme (#443)
+- docs: fix typo in readme (#447)
+
+## v5.0.3
+
+_2020-06-05_
+
+### Updates
+
+- docs: update `babelHelpers` description (#397)
+
+## v5.0.2
+
+_2020-05-20_
+
+### Bugfixes
+
+- fix: use loadPartialConfigAsync when it is available (#359)
+
+### Updates
+
+- docs: Cleanup misleading leftovers in the README (#377)
+- docs: correct breaking change note in v5 CHANGELOG (#368)
+
+## v5.0.1
+
+_2020-05-20_
+
+### Bugfixes
+
+- fix: use loadPartialConfigAsync when it is available (#359)
+
+### Updates
+
+- docs: Cleanup misleading leftovers in the README (#377)
+- docs: correct breaking change note in v5 CHANGELOG (#368)
+
+# @rollup/plugin-babel changelog
+
+## 5.0.0
+
+_2020-04-27_
+
+### Features
+
+- Added `getBabelOutputPlugin` and `createBabelOutputPluginFactory` exports which can be used to transform generated code
+- Added `skipPreflightCheck` option. The plugin performs some extra checks to see if the passed configuration is correct and matching its expectations. This comes with some runtime overhead and can slow down builds. If you know what you are doing and you are confident that you have configured things correctly you can disable those checks with this option.
+- Published as `@rollup/plugin-babel`
+
+### Updates
+
+- Default export exported as `getBabelInputPlugin` for symmetry with `getBabelOutputPlugin`
+
+### Breaking Changes
+
+- Minimum compatible Rollup version is 1.2.0
+- Minimum supported Node version is 10.0.0
+- `.custom` factory is now available as separate `createBabelInputPluginFactory` export
+- Removed `externalHelpers` & `runtimeHelpers` options. There is now a single `babelHelpers` option which can take one of `'bundled'`, `'inline'`, `'runtime'` and `'external'` as a value. The default is `'bundled'` which matches 4.x behavior, but it is recommended to configure this option explicitly.
+
+## 4.3.2
+
+- Fixed usage with `externalHelpers: true` option
+
+## 4.3.1
+
+- Add `.js` extension to the virtual babel helpers file (only matters when using `preserveModules` option in rollup)
+
+## 4.3.0
+
+- Added `.custom` builder.
+- Fail build when a plugin tries to add non existent babel helper
+
+## 4.2.0
+
+Allow `rollup@1` as peer dependency.
+
+## 4.1.0
+
+- Fixed "preflight check" for ignored files.
+- Return `null` when no transformation has been done (fixing source maps for this case)
+
+## 4.0.3
+
+Fixed fallback class transform in "preflight check".
+
+## 4.0.2
+
+Fixed `rollup` peer dependency.
+
+## 4.0.0
+
+Babel 7 compatible! (dropped Babel 6 compatibility though).
+
+Additionally:
+
+- Internal preflight checks are created now per plugin instance, so using 2 instances of rollup-plugin-babel (i.e. targeting 2 different set of files with include/exclude options) shouldn't conflict with each other
+- Transpiling by default only what Babel transpiles - files with those extensions: .js, .jsx, .es6, .es, .mjs. You can customize this with new `extensions` option. This also fixes long standing issue with rollup-plugin-babel trying to transform JSON files.
+
+## 3.0.3
+
+- Drop babel7 support. Use 4.0.0-beta if you use babel 7
+- Use "module" in addition to "jsnext:main" ([#150](https://github.com/rollup/rollup-plugin-babel/issues/150))
+- Remove unused babel helpers namespace declaration & expression ([#164](https://github.com/rollup/rollup-plugin-babel/issues/164))
+
+## 3.0.2
+
+- Fix regression with Babel 6 ([#158](https://github.com/rollup/rollup-plugin-babel/issues/158))
+
+## 3.0.1
+
+- Wasn't working, fix bug with transform (not using es2015-classes for preflight check)
+
+## 3.0.0
+
+- Drop Node 0.10/0.12 (Use native `Object.assign`)
+- Change `babel-core` to be a peerDependency
+- Support `babel-core` v7 as well as a peerDep (no changes necessary)
+
+## 2.7.1
+
+- Prevent erroneous warnings about duplicated runtime helpers ([#105](https://github.com/rollup/rollup-plugin-babel/issues/105))
+- Ignore `ignore` option in preflight check ([#102](https://github.com/rollup/rollup-plugin-babel/issues/102))
+- Allow custom `moduleName` with `runtime-helpers` ([#95](https://github.com/rollup/rollup-plugin-babel/issues/95))
+
+## 2.7.0
+
+- Add `externalHelpersWhitelist` option ([#92](https://github.com/rollup/rollup-plugin-babel/pull/92))
+- Ignore `only` option during preflight checks ([#98](https://github.com/rollup/rollup-plugin-babel/issues/98))
+- Use `options.onwarn` if available ([#84](https://github.com/rollup/rollup-plugin-babel/issues/84))
+- Update documentation and dependencies
+
+## 2.6.1
+
+- Return a `name`
+
+## 2.6.0
+
+- Use `\0` convention for helper module ID ([#64](https://github.com/rollup/rollup-plugin-babel/issues/64))
+
+## 2.5.1
+
+- Don't mutate `options.plugins` ([#47](https://github.com/rollup/rollup-plugin-babel/issues/47))
+
+## 2.5.0
+
+- Import `babelHelpers` rather than injecting them – allows `transform` function to be pure ([#rollup/658](https://github.com/rollup/rollup/pull/658#issuecomment-223876824))
+
+## 2.4.0
+
+- Add `externalHelpers` option ([#41](https://github.com/rollup/rollup-plugin-babel/pull/41))
+
+## 2.3.9
+
+- Do not rename Babel helpers ([#34](https://github.com/rollup/rollup-plugin-babel/pull/34))
+
+## 2.3.8
+
+- Create new version to (hopefully) solve bizarre CI issue
+
+## 2.3.7
+
+- Be less clever about renaming Babel helpers ([#19](https://github.com/rollup/rollup-plugin-babel/issues/19))
+
+## 2.3.6
+
+- Fix cache misses in preflight check ([#29](https://github.com/rollup/rollup-plugin-babel/pull/29))
+
+## 2.3.5
+
+- Use class transformer local to plugin, not project being built
+
+## 2.3.4
+
+- Ensure class transformer is present for preflight check, and only run check once per directory ([#23](https://github.com/rollup/rollup-plugin-babel/issues/23))
+
+## 2.3.3
+
+- Fix helper renaming ([#22](https://github.com/rollup/rollup-plugin-babel/issues/22))
+
+## 2.3.1-2
+
+- Include correct files in npm package
+
+## 2.3.0
+
+- Allow `transform-runtime` Babel plugin, if combined with `runtimeHelpers: true` option ([#17](https://github.com/rollup/rollup-plugin-babel/issues/17))
+- More permissive handling of helpers – only warn if inline helpers are duplicated
+- Handle plugins that change export patterns ([#18](https://github.com/rollup/rollup-plugin-babel/issues/18))
+
+## 2.2.0
+
+- Preflight checks are run per-file, to avoid configuration snafus ([#16](https://github.com/rollup/rollup-plugin-babel/issues/16))
+
+## 2.1.0
+
+- Generate sourcemaps by default
+
+## 2.0.1
+
+- Use object-assign ponyfill
+- Add travis support
+- Fix test
+
+## 2.0.0
+
+- Babel 6 compatible
+
+## 1.0.0
+
+- First release

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/plugin-babel/README.md

@@ -0,0 +1,380 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-babel
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-babel
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-babel
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-babel
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-babel
+
+🍣 A Rollup plugin for seamless integration between Rollup and Babel.
+
+## Why?
+
+If you're using Babel to transpile your ES6/7 code and Rollup to generate a standalone bundle, you have a couple of options:
+
+- run the code through Babel first, being careful to exclude the module transformer, or
+- run the code through Rollup first, and _then_ pass it to Babel.
+
+Both approaches have disadvantages – in the first case, on top of the additional configuration complexity, you may end up with Babel's helpers (like `classCallCheck`) repeated throughout your code (once for each module where the helpers are used). In the second case, transpiling is likely to be slower, because transpiling a large bundle is much more work for Babel than transpiling a set of small files.
+
+Either way, you have to worry about a place to put the intermediate files, and getting sourcemaps to behave becomes a royal pain.
+
+Using Rollup with `@rollup/plugin-babel` makes the process far easier.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v10.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+```bash
+npm install @rollup/plugin-babel --save-dev
+```
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import { babel } from '@rollup/plugin-babel';
+
+const config = {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'esm'
+  },
+  plugins: [babel({ babelHelpers: 'bundled' })]
+};
+
+export default config;
+```
+
+Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api).
+
+### Using With `@rollup/plugin-commonjs`
+
+When using `@rollup/plugin-babel` with `@rollup/plugin-commonjs` in the same Rollup configuration, it's important to note that `@rollup/plugin-commonjs` _must_ be placed before this plugin in the `plugins` array for the two to work together properly. e.g.
+
+```js
+import { babel } from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+
+const config = {
+  ...
+  plugins: [
+    commonjs(),
+    babel({ babelHelpers: 'bundled' })
+  ],
+};
+```
+
+## Options
+
+This plugin respects Babel [configuration files](https://babeljs.io/docs/en/configuration) by default and they are generally the best place to put your configuration.
+
+You can also run Babel on the generated chunks instead of the input files. Even though this is slower, it is the only way to transpile Rollup's auto-generated wrapper code to lower compatibility targets than ES5, see [Running Babel on the generated code](#running-babel-on-the-generated-code) for details.
+
+All options are as per the [Babel documentation](https://babeljs.io/docs/en/options), plus the following:
+
+### `exclude`
+
+Type: `String | RegExp | Array[...String|RegExp]`<br>
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should _ignore_. When relying on Babel configuration files you can only exclude additional files with this option, you cannot override what you have configured for Babel itself.
+
+### `include`
+
+Type: `String | RegExp | Array[...String|RegExp]`<br>
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should operate on. When relying on Babel configuration files you cannot include files already excluded there.
+
+### `filter`
+
+Type: (id: string) => boolean<br>
+
+Custom [filter function](https://github.com/rollup/plugins/tree/master/packages/pluginutils#createfilter) can be used to determine whether or not certain modules should be operated upon.
+
+Usage:
+
+```js
+import { createFilter } from '@rollup/pluginutils';
+const include = 'include/**.js';
+const exclude = 'exclude/**.js';
+const filter = createFilter(include, exclude, {});
+```
+
+### `extensions`
+
+Type: `Array[...String]`<br>
+Default: `['.js', '.jsx', '.es6', '.es', '.mjs']`
+
+An array of file extensions that Babel should transpile. If you want to transpile TypeScript files with this plugin it's essential to include `.ts` and `.tsx` in this option.
+
+### `babelHelpers`
+
+Type: `'bundled' | 'runtime' | 'inline' | 'external'`<br>
+Default: `'bundled'`
+
+It is recommended to configure this option explicitly (even if with its default value) so an informed decision is taken on how those babel helpers are inserted into the code.
+
+We recommend to follow these guidelines to determine the most appropriate value for your project:
+
+- `'runtime'` - you should use this especially when building libraries with Rollup. It has to be used in combination with `@babel/plugin-transform-runtime` and you should also specify `@babel/runtime` as dependency of your package. Don't forget to tell Rollup to treat the helpers imported from within the `@babel/runtime` module as external dependencies when bundling for `cjs` & `es` formats. This can be accomplished via regex (`external: [/@babel\/runtime/]`) or a function (`external: id => id.includes('@babel/runtime')`). It's important to not only specify `external: ['@babel/runtime']` since the helpers are imported from nested paths (e.g `@babel/runtime/helpers/get`) and [Rollup will only exclude modules that match strings exactly](https://rollupjs.org/guide/en/#peer-dependencies).
+- `'bundled'` - you should use this if you want your resulting bundle to contain those helpers (at most one copy of each). Useful especially if you bundle an application code.
+- `'external'` - use this only if you know what you are doing. It will reference helpers on **global** `babelHelpers` object. Used in combination with `@babel/plugin-external-helpers`.
+- `'inline'` - this is not recommended. Helpers will be inserted in each file using this option. This can cause serious code duplication. This is the default Babel behavior as Babel operates on isolated files - however, as Rollup is a bundler and is project-aware (and therefore likely operating across multiple input files), the default of this plugin is `"bundled"`.
+
+### `skipPreflightCheck`
+
+Type: `Boolean`<br>
+Default: `false`
+
+Before transpiling your input files this plugin also transpile a short piece of code **for each** input file. This is used to validate some misconfiguration errors, but for sufficiently big projects it can slow your build times so if you are confident about your configuration then you might disable those checks with this option.
+
+### External dependencies
+
+Ideally, you should only be transforming your source code, rather than running all of your external dependencies through Babel (to ignore external dependencies from being handled by this plugin you might use `exclude: 'node_modules/**'` option). If you have a dependency that exposes untranspiled ES6 source code that doesn't run in your target environment, then you may need to break this rule, but it often causes problems with unusual `.babelrc` files or mismatched versions of Babel.
+
+We encourage library authors not to distribute code that uses untranspiled ES6 features (other than modules) for this reason. Consumers of your library should _not_ have to transpile your ES6 code, any more than they should have to transpile your CoffeeScript, ClojureScript or TypeScript.
+
+Use `babelrc: false` to prevent Babel from using local (i.e. to your external dependencies) `.babelrc` files, relying instead on the configuration you pass in.
+
+### Helpers
+
+In some cases Babel uses _helpers_ to avoid repeating chunks of code – for example, if you use the `class` keyword, it will use a `classCallCheck` function to ensure that the class is instantiated correctly.
+
+By default, those helpers will be inserted at the top of the file being transformed, which can lead to duplication. This rollup plugin automatically deduplicates those helpers, keeping only one copy of each one used in the output bundle. Rollup will combine the helpers in a single block at the top of your bundle.
+
+You can customize how those helpers are being inserted into the transformed file with [`babelHelpers`](#babelhelpers) option.
+
+### Modules
+
+This is not needed since Babel 7 - it knows automatically that Rollup understands ES modules & that it shouldn't use any module transform with it. Unless you forcefully include a module transform in your Babel configuration.
+
+If you have been pointed to this section by an error thrown by this plugin, please check your Babel configuration files and disable any module transforms when running Rollup builds.
+
+## Running Babel on the generated code
+
+You can run `@rollup/plugin-babel` on the output files instead of the input files by using `getBabelOutputPlugin(...)`. This can be used to perform code transformations on the resulting chunks and is the only way to transform Rollup's auto-generated code. By default, the plugin will be applied to all outputs:
+
+```js
+// rollup.config.js
+import { getBabelOutputPlugin } from '@rollup/plugin-babel';
+
+export default {
+  input: 'main.js',
+  plugins: [
+    getBabelOutputPlugin({
+      presets: ['@babel/preset-env']
+    })
+  ],
+  output: [
+    { file: 'bundle.cjs.js', format: 'cjs' },
+    { file: 'bundle.esm.js', format: 'esm' }
+  ]
+};
+```
+
+If you only want to apply it to specific outputs, you can use it as an output plugin (requires at least Rollup v1.27.0):
+
+```js
+// rollup.config.js
+import { getBabelOutputPlugin } from '@rollup/plugin-babel';
+
+export default {
+  input: 'main.js',
+  output: [
+    { file: 'bundle.js', format: 'esm' },
+    {
+      file: 'bundle.es5.js',
+      format: 'esm',
+      plugins: [getBabelOutputPlugin({ presets: ['@babel/preset-env'] })]
+    }
+  ]
+};
+```
+
+The `include`, `exclude` and `extensions` options are ignored when the when using `getBabelOutputPlugin` and `createBabelOutputPluginFactory` will produce warnings, and there are a few more points to note that users should be aware of.
+
+You can also run the plugin twice on the code, once when processing the input files to transpile special syntax to JavaScript and once on the output to transpile to a lower compatibility target:
+
+```js
+// rollup.config.js
+import babel, { getBabelOutputPlugin } from '@rollup/plugin-babel';
+
+export default {
+  input: 'main.js',
+  plugins: [babel({ presets: ['@babel/preset-react'] })],
+  output: [
+    {
+      file: 'bundle.js',
+      format: 'esm',
+      plugins: [getBabelOutputPlugin({ presets: ['@babel/preset-env'] })]
+    }
+  ]
+};
+```
+
+### Babel configuration files
+
+Unlike the regular `babel` plugin, `getBabelOutputPlugin(...)` will **not** automatically search for [Babel configuration files](https://babeljs.io/docs/en/config-files). Besides passing in Babel options directly, however, you can specify a configuration file manually via Babel's [`configFile`](https://babeljs.io/docs/en/options#configfile) option:
+
+```js
+getBabelOutputPlugin({
+  configFile: path.resolve(__dirname, 'babel.config.js')
+});
+```
+
+### Using formats other than ES modules or CommonJS
+
+As `getBabelOutputPlugin(...)` will run _after_ Rollup has done all its transformations, it needs to make sure it preserves the semantics of Rollup's output format. This is especially important for Babel plugins that add, modify or remove imports or exports, but also for other transformations that add new variables as they can accidentally become global variables depending on the format. Therefore it is recommended that for formats other than `esm` or `cjs`, you set Rollup to use the `esm` output format and let Babel handle the transformation to another format, e.g. via
+
+```
+presets: [['@babel/preset-env', { modules: 'umd' }], ...]
+```
+
+to create a UMD/IIFE compatible output. If you want to use `getBabelOutputPlugin(...)` with other formats, you need to specify `allowAllFormats: true` as plugin option:
+
+```js
+rollup.rollup({...})
+.then(bundle => bundle.generate({
+  format: 'iife',
+  plugins: [getBabelOutputPlugin({
+    allowAllFormats: true,
+    // ...
+  })]
+}))
+```
+
+### Injected helpers
+
+By default, helpers e.g. when transpiling classes will be inserted at the top of each chunk. In contrast to when applying this plugin on the input files, helpers will not be deduplicated across chunks.
+
+Alternatively, you can use imported runtime helpers by adding the `@babel/transform-runtime` plugin. This will make `@babel/runtime` an external dependency of your project, see [@babel/plugin-transform-runtime](https://babeljs.io/docs/en/babel-plugin-transform-runtime) for details.
+
+Note that this will only work for `esm` and `cjs` formats, and you need to make sure to set the `useESModules` option of `@babel/plugin-transform-runtime` to `true` if you create ESM output:
+
+```js
+rollup.rollup({...})
+.then(bundle => bundle.generate({
+  format: 'esm',
+  plugins: [getBabelOutputPlugin({
+    presets: ['@babel/preset-env'],
+    plugins: [['@babel/plugin-transform-runtime', { useESModules: true }]]
+  })]
+}))
+```
+
+```js
+// input
+export default class Foo {}
+
+// output
+import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
+
+var Foo = function Foo() {
+  _classCallCheck(this, Foo);
+};
+
+export default Foo;
+```
+
+And for CommonJS:
+
+```js
+rollup.rollup({...})
+.then(bundle => bundle.generate({
+  format: 'cjs',
+  plugins: [getBabelOutputPlugin({
+    presets: ['@babel/preset-env'],
+    plugins: [['@babel/plugin-transform-runtime', { useESModules: false }]]
+  })]
+}))
+```
+
+```js
+// input
+export default class Foo {}
+
+// output
+('use strict');
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+
+var Foo = function Foo() {
+  _classCallCheck(this, Foo);
+};
+
+module.exports = Foo;
+```
+
+Another option is to use `@babel/plugin-external-helpers`, which will reference the global `babelHelpers` object. It is your responsibility to make sure this global variable exists.
+
+## Custom plugin builder
+
+`@rollup/plugin-babel` exposes a plugin-builder utility that allows users to add custom handling of Babel's configuration for each file that it processes.
+
+`createBabelInputPluginFactory` accepts a callback that will be called with the loader's instance of `babel` so that tooling can ensure that it using exactly the same `@babel/core` instance as the loader itself.
+
+It's main purpose is to allow other tools for configuration of transpilation without forcing people to add extra configuration but still allow for using their own babelrc / babel config files.
+
+### Example
+
+```js
+import { createBabelInputPluginFactory } from '@rollup/plugin-babel';
+
+export default createBabelInputPluginFactory(babelCore => {
+  function myPlugin() {
+    return {
+      visitor: {}
+    };
+  }
+
+  return {
+    // Passed the plugin options.
+    options({ opt1, opt2, ...pluginOptions }) {
+      return {
+        // Pull out any custom options that the plugin might have.
+        customOptions: { opt1, opt2 },
+
+        // Pass the options back with the two custom options removed.
+        pluginOptions
+      };
+    },
+
+    config(cfg /* Passed Babel's 'PartialConfig' object. */, { code, customOptions }) {
+      if (cfg.hasFilesystemConfig()) {
+        // Use the normal config
+        return cfg.options;
+      }
+
+      return {
+        ...cfg.options,
+        plugins: [
+          ...(cfg.options.plugins || []),
+
+          // Include a custom plugin in the options.
+          myPlugin
+        ]
+      };
+    },
+
+    result(result, { code, customOptions, config, transformOptions }) {
+      return {
+        ...result,
+        code: result.code + '\n// Generated by some custom plugin'
+      };
+    }
+  };
+});
+```
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/dist/index.es.js

@@ -0,0 +1,489 @@
+import * as babel from '@babel/core';
+import { transformAsync, loadPartialConfigAsync, loadPartialConfig, buildExternalHelpers, DEFAULT_EXTENSIONS } from '@babel/core';
+import { createFilter } from '@rollup/pluginutils';
+import { addNamed } from '@babel/helper-module-imports';
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+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;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+const BUNDLED = 'bundled';
+const INLINE = 'inline';
+const RUNTIME = 'runtime';
+const EXTERNAL = 'external'; // NOTE: DO NOT REMOVE the null character `\0` as it may be used by other plugins
+// e.g. https://github.com/rollup/rollup-plugin-node-resolve/blob/313a3e32f432f9eb18cc4c231cc7aac6df317a51/src/index.js#L74
+
+const HELPERS = '\0rollupPluginBabelHelpers.js';
+
+function importHelperPlugin({
+  types: t
+}) {
+  return {
+    pre(file) {
+      const cachedHelpers = {};
+      file.set('helperGenerator', name => {
+        if (!file.availableHelper(name)) {
+          return null;
+        }
+
+        if (cachedHelpers[name]) {
+          return t.cloneNode(cachedHelpers[name]);
+        }
+
+        return cachedHelpers[name] = addNamed(file.path, name, HELPERS);
+      });
+    }
+
+  };
+}
+
+const addBabelPlugin = (options, plugin) => {
+  return _objectSpread2(_objectSpread2({}, options), {}, {
+    plugins: options.plugins.concat(plugin)
+  });
+};
+const warned = {};
+function warnOnce(ctx, msg) {
+  if (warned[msg]) return;
+  warned[msg] = true;
+  ctx.warn(msg);
+}
+const regExpCharactersRegExp = /[\\^$.*+?()[\]{}|]/g;
+const escapeRegExpCharacters = str => str.replace(regExpCharactersRegExp, '\\$&');
+function stripQuery(id) {
+  // strip query params from import
+  const [bareId, query] = id.split('?');
+  const suffix = `${query ? `?${query}` : ''}`;
+  return {
+    bareId,
+    query,
+    suffix
+  };
+}
+
+const MODULE_ERROR = 'Rollup requires that your Babel configuration keeps ES6 module syntax intact. ' + 'Unfortunately it looks like your configuration specifies a module transformer ' + 'to replace ES6 modules with another module format. To continue you have to disable it.' + '\n\n' + "Most commonly it's a CommonJS transform added by @babel/preset-env - " + 'in such case you should disable it by adding `modules: false` option to that preset ' + '(described in more detail here - https://github.com/rollup/plugins/tree/master/packages/babel#modules ).';
+const UNEXPECTED_ERROR = 'An unexpected situation arose. Please raise an issue at ' + 'https://github.com/rollup/plugins/issues. Thanks!';
+const PREFLIGHT_TEST_STRING = '__ROLLUP__PREFLIGHT_CHECK_DO_NOT_TOUCH__';
+const PREFLIGHT_INPUT = `export default "${PREFLIGHT_TEST_STRING}";`;
+
+function helpersTestTransform() {
+  return {
+    visitor: {
+      StringLiteral(path, state) {
+        if (path.node.value === PREFLIGHT_TEST_STRING) {
+          path.replaceWith(state.file.addHelper('inherits'));
+        }
+      }
+
+    }
+  };
+}
+
+const mismatchError = (actual, expected, filename) => `You have declared using "${expected}" babelHelpers, but transforming ${filename} resulted in "${actual}". Please check your configuration.`;
+
+const inheritsHelperRe = /\/helpers\/(esm\/)?inherits/;
+async function preflightCheck(ctx, babelHelpers, transformOptions) {
+  const finalOptions = addBabelPlugin(transformOptions, helpersTestTransform);
+  const check = (await transformAsync(PREFLIGHT_INPUT, finalOptions)).code; // Babel sometimes splits ExportDefaultDeclaration into 2 statements, so we also check for ExportNamedDeclaration
+
+  if (!/export (d|{)/.test(check)) {
+    ctx.error(MODULE_ERROR);
+  }
+
+  if (inheritsHelperRe.test(check)) {
+    if (babelHelpers === RUNTIME) {
+      return;
+    }
+
+    ctx.error(mismatchError(RUNTIME, babelHelpers, transformOptions.filename));
+  }
+
+  if (check.includes('babelHelpers.inherits')) {
+    if (babelHelpers === EXTERNAL) {
+      return;
+    }
+
+    ctx.error(mismatchError(EXTERNAL, babelHelpers, transformOptions.filename));
+  } // test unminifiable string content
+
+
+  if (check.includes('Super expression must either be null or a function')) {
+    if (babelHelpers === INLINE || babelHelpers === BUNDLED) {
+      return;
+    }
+
+    if (babelHelpers === RUNTIME && !transformOptions.plugins.length) {
+      ctx.error(`You must use the \`@babel/plugin-transform-runtime\` plugin when \`babelHelpers\` is "${RUNTIME}".\n`);
+    }
+
+    ctx.error(mismatchError(INLINE, babelHelpers, transformOptions.filename));
+  }
+
+  ctx.error(UNEXPECTED_ERROR);
+}
+
+async function transformCode(inputCode, babelOptions, overrides, customOptions, ctx, finalizeOptions) {
+  // loadPartialConfigAsync has become available in @babel/core@7.8.0
+  const config = await (loadPartialConfigAsync || loadPartialConfig)(babelOptions); // file is ignored by babel
+
+  if (!config) {
+    return null;
+  }
+
+  let transformOptions = !overrides.config ? config.options : await overrides.config.call(ctx, config, {
+    code: inputCode,
+    customOptions
+  });
+
+  if (finalizeOptions) {
+    transformOptions = await finalizeOptions(transformOptions);
+  }
+
+  if (!overrides.result) {
+    const {
+      code,
+      map
+    } = await transformAsync(inputCode, transformOptions);
+    return {
+      code,
+      map
+    };
+  }
+
+  const result = await transformAsync(inputCode, transformOptions);
+  const {
+    code,
+    map
+  } = await overrides.result.call(ctx, result, {
+    code: inputCode,
+    customOptions,
+    config,
+    transformOptions
+  });
+  return {
+    code,
+    map
+  };
+}
+
+const unpackOptions = (_ref = {}) => {
+  let {
+    extensions = DEFAULT_EXTENSIONS,
+    // rollup uses sourcemap, babel uses sourceMaps
+    // just normalize them here so people don't have to worry about it
+    sourcemap = true,
+    sourcemaps = true,
+    sourceMap = true,
+    sourceMaps = true
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, ["extensions", "sourcemap", "sourcemaps", "sourceMap", "sourceMaps"]);
+
+  return _objectSpread2(_objectSpread2({
+    extensions,
+    plugins: [],
+    sourceMaps: sourcemap && sourcemaps && sourceMap && sourceMaps
+  }, rest), {}, {
+    caller: _objectSpread2({
+      name: '@rollup/plugin-babel'
+    }, rest.caller)
+  });
+};
+
+const warnAboutDeprecatedHelpersOption = ({
+  deprecatedOption,
+  suggestion
+}) => {
+  // eslint-disable-next-line no-console
+  console.warn(`\`${deprecatedOption}\` has been removed in favor a \`babelHelpers\` option. Try changing your configuration to \`${suggestion}\`. ` + `Refer to the documentation to learn more: https://github.com/rollup/plugins/tree/master/packages/babel#babelhelpers`);
+};
+
+const unpackInputPluginOptions = (_ref2, rollupVersion) => {
+  let {
+    skipPreflightCheck = false
+  } = _ref2,
+      rest = _objectWithoutProperties(_ref2, ["skipPreflightCheck"]);
+
+  if ('runtimeHelpers' in rest) {
+    warnAboutDeprecatedHelpersOption({
+      deprecatedOption: 'runtimeHelpers',
+      suggestion: `babelHelpers: 'runtime'`
+    });
+  } else if ('externalHelpers' in rest) {
+    warnAboutDeprecatedHelpersOption({
+      deprecatedOption: 'externalHelpers',
+      suggestion: `babelHelpers: 'external'`
+    });
+  } else if (!rest.babelHelpers) {
+    // eslint-disable-next-line no-console
+    console.warn("babelHelpers: 'bundled' option was used by default. It is recommended to configure this option explicitly, read more here: " + 'https://github.com/rollup/plugins/tree/master/packages/babel#babelhelpers');
+  }
+
+  return unpackOptions(_objectSpread2(_objectSpread2({}, rest), {}, {
+    skipPreflightCheck,
+    babelHelpers: rest.babelHelpers || BUNDLED,
+    caller: _objectSpread2({
+      supportsStaticESM: true,
+      supportsDynamicImport: true,
+      supportsTopLevelAwait: true,
+      // todo: remove version checks for 1.20 - 1.25 when we bump peer deps
+      supportsExportNamespaceFrom: !rollupVersion.match(/^1\.2[0-5]\./)
+    }, rest.caller)
+  }));
+};
+
+const unpackOutputPluginOptions = (options, {
+  format
+}) => unpackOptions(_objectSpread2(_objectSpread2({
+  configFile: false,
+  sourceType: format === 'es' ? 'module' : 'script'
+}, options), {}, {
+  caller: _objectSpread2({
+    supportsStaticESM: format === 'es'
+  }, options.caller)
+}));
+
+function getOptionsWithOverrides(pluginOptions = {}, overrides = {}) {
+  if (!overrides.options) return {
+    customOptions: null,
+    pluginOptionsWithOverrides: pluginOptions
+  };
+  const overridden = overrides.options(pluginOptions);
+
+  if (typeof overridden.then === 'function') {
+    throw new Error(".options hook can't be asynchronous. It should return `{ customOptions, pluginsOptions }` synchronously.");
+  }
+
+  return {
+    customOptions: overridden.customOptions || null,
+    pluginOptionsWithOverrides: overridden.pluginOptions || pluginOptions
+  };
+}
+
+const returnObject = () => {
+  return {};
+};
+
+function createBabelInputPluginFactory(customCallback = returnObject) {
+  const overrides = customCallback(babel);
+  return pluginOptions => {
+    const {
+      customOptions,
+      pluginOptionsWithOverrides
+    } = getOptionsWithOverrides(pluginOptions, overrides);
+    let babelHelpers;
+    let babelOptions;
+    let filter;
+    let skipPreflightCheck;
+    return {
+      name: 'babel',
+
+      options() {
+        // todo: remove options hook and hoist declarations when version checks are removed
+        let exclude;
+        let include;
+        let extensions;
+        let customFilter;
+
+        var _unpackInputPluginOpt = unpackInputPluginOptions(pluginOptionsWithOverrides, this.meta.rollupVersion);
+
+        ({
+          exclude,
+          extensions,
+          babelHelpers,
+          include,
+          filter: customFilter,
+          skipPreflightCheck
+        } = _unpackInputPluginOpt);
+        babelOptions = _objectWithoutProperties(_unpackInputPluginOpt, ["exclude", "extensions", "babelHelpers", "include", "filter", "skipPreflightCheck"]);
+        const extensionRegExp = new RegExp(`(${extensions.map(escapeRegExpCharacters).join('|')})$`);
+
+        if (customFilter && (include || exclude)) {
+          throw new Error('Could not handle include or exclude with custom filter together');
+        }
+
+        const userDefinedFilter = typeof customFilter === 'function' ? customFilter : createFilter(include, exclude);
+
+        filter = id => extensionRegExp.test(stripQuery(id).bareId) && userDefinedFilter(id);
+
+        return null;
+      },
+
+      resolveId(id) {
+        if (id !== HELPERS) {
+          return null;
+        }
+
+        return id;
+      },
+
+      load(id) {
+        if (id !== HELPERS) {
+          return null;
+        }
+
+        return buildExternalHelpers(null, 'module');
+      },
+
+      transform(code, filename) {
+        if (!filter(filename)) return null;
+        if (filename === HELPERS) return null;
+        return transformCode(code, _objectSpread2(_objectSpread2({}, babelOptions), {}, {
+          filename
+        }), overrides, customOptions, this, async transformOptions => {
+          if (!skipPreflightCheck) {
+            await preflightCheck(this, babelHelpers, transformOptions);
+          }
+
+          return babelHelpers === BUNDLED ? addBabelPlugin(transformOptions, importHelperPlugin) : transformOptions;
+        });
+      }
+
+    };
+  };
+}
+
+function getRecommendedFormat(rollupFormat) {
+  switch (rollupFormat) {
+    case 'amd':
+      return 'amd';
+
+    case 'iife':
+    case 'umd':
+      return 'umd';
+
+    case 'system':
+      return 'systemjs';
+
+    default:
+      return '<module format>';
+  }
+}
+
+function createBabelOutputPluginFactory(customCallback = returnObject) {
+  const overrides = customCallback(babel);
+  return pluginOptions => {
+    const {
+      customOptions,
+      pluginOptionsWithOverrides
+    } = getOptionsWithOverrides(pluginOptions, overrides);
+    return {
+      name: 'babel',
+
+      renderStart(outputOptions) {
+        const {
+          extensions,
+          include,
+          exclude,
+          allowAllFormats
+        } = pluginOptionsWithOverrides;
+
+        if (extensions || include || exclude) {
+          warnOnce(this, 'The "include", "exclude" and "extensions" options are ignored when transforming the output.');
+        }
+
+        if (!allowAllFormats && outputOptions.format !== 'es' && outputOptions.format !== 'cjs') {
+          this.error(`Using Babel on the generated chunks is strongly discouraged for formats other than "esm" or "cjs" as it can easily break wrapper code and lead to accidentally created global variables. Instead, you should set "output.format" to "esm" and use Babel to transform to another format, e.g. by adding "presets: [['@babel/env', { modules: '${getRecommendedFormat(outputOptions.format)}' }]]" to your Babel options. If you still want to proceed, add "allowAllFormats: true" to your plugin options.`);
+        }
+      },
+
+      renderChunk(code, chunk, outputOptions) {
+        /* eslint-disable no-unused-vars */
+        const _unpackOutputPluginOp = unpackOutputPluginOptions(pluginOptionsWithOverrides, outputOptions),
+              babelOptions = _objectWithoutProperties(_unpackOutputPluginOp, ["allowAllFormats", "exclude", "extensions", "externalHelpers", "externalHelpersWhitelist", "include", "runtimeHelpers"]);
+        /* eslint-enable no-unused-vars */
+
+
+        return transformCode(code, babelOptions, overrides, customOptions, this);
+      }
+
+    };
+  };
+} // export this for symmetry with output-related exports
+
+
+const getBabelInputPlugin = createBabelInputPluginFactory();
+const getBabelOutputPlugin = createBabelOutputPluginFactory();
+
+export default getBabelInputPlugin;
+export { getBabelInputPlugin as babel, createBabelInputPluginFactory, createBabelOutputPluginFactory, getBabelInputPlugin, getBabelOutputPlugin };

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/dist/index.js

@@ -0,0 +1,518 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var babel = require('@babel/core');
+var pluginutils = require('@rollup/pluginutils');
+var helperModuleImports = require('@babel/helper-module-imports');
+
+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 Object.freeze(n);
+}
+
+var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+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;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+const BUNDLED = 'bundled';
+const INLINE = 'inline';
+const RUNTIME = 'runtime';
+const EXTERNAL = 'external'; // NOTE: DO NOT REMOVE the null character `\0` as it may be used by other plugins
+// e.g. https://github.com/rollup/rollup-plugin-node-resolve/blob/313a3e32f432f9eb18cc4c231cc7aac6df317a51/src/index.js#L74
+
+const HELPERS = '\0rollupPluginBabelHelpers.js';
+
+function importHelperPlugin({
+  types: t
+}) {
+  return {
+    pre(file) {
+      const cachedHelpers = {};
+      file.set('helperGenerator', name => {
+        if (!file.availableHelper(name)) {
+          return null;
+        }
+
+        if (cachedHelpers[name]) {
+          return t.cloneNode(cachedHelpers[name]);
+        }
+
+        return cachedHelpers[name] = helperModuleImports.addNamed(file.path, name, HELPERS);
+      });
+    }
+
+  };
+}
+
+const addBabelPlugin = (options, plugin) => {
+  return _objectSpread2(_objectSpread2({}, options), {}, {
+    plugins: options.plugins.concat(plugin)
+  });
+};
+const warned = {};
+function warnOnce(ctx, msg) {
+  if (warned[msg]) return;
+  warned[msg] = true;
+  ctx.warn(msg);
+}
+const regExpCharactersRegExp = /[\\^$.*+?()[\]{}|]/g;
+const escapeRegExpCharacters = str => str.replace(regExpCharactersRegExp, '\\$&');
+function stripQuery(id) {
+  // strip query params from import
+  const [bareId, query] = id.split('?');
+  const suffix = `${query ? `?${query}` : ''}`;
+  return {
+    bareId,
+    query,
+    suffix
+  };
+}
+
+const MODULE_ERROR = 'Rollup requires that your Babel configuration keeps ES6 module syntax intact. ' + 'Unfortunately it looks like your configuration specifies a module transformer ' + 'to replace ES6 modules with another module format. To continue you have to disable it.' + '\n\n' + "Most commonly it's a CommonJS transform added by @babel/preset-env - " + 'in such case you should disable it by adding `modules: false` option to that preset ' + '(described in more detail here - https://github.com/rollup/plugins/tree/master/packages/babel#modules ).';
+const UNEXPECTED_ERROR = 'An unexpected situation arose. Please raise an issue at ' + 'https://github.com/rollup/plugins/issues. Thanks!';
+const PREFLIGHT_TEST_STRING = '__ROLLUP__PREFLIGHT_CHECK_DO_NOT_TOUCH__';
+const PREFLIGHT_INPUT = `export default "${PREFLIGHT_TEST_STRING}";`;
+
+function helpersTestTransform() {
+  return {
+    visitor: {
+      StringLiteral(path, state) {
+        if (path.node.value === PREFLIGHT_TEST_STRING) {
+          path.replaceWith(state.file.addHelper('inherits'));
+        }
+      }
+
+    }
+  };
+}
+
+const mismatchError = (actual, expected, filename) => `You have declared using "${expected}" babelHelpers, but transforming ${filename} resulted in "${actual}". Please check your configuration.`;
+
+const inheritsHelperRe = /\/helpers\/(esm\/)?inherits/;
+async function preflightCheck(ctx, babelHelpers, transformOptions) {
+  const finalOptions = addBabelPlugin(transformOptions, helpersTestTransform);
+  const check = (await babel.transformAsync(PREFLIGHT_INPUT, finalOptions)).code; // Babel sometimes splits ExportDefaultDeclaration into 2 statements, so we also check for ExportNamedDeclaration
+
+  if (!/export (d|{)/.test(check)) {
+    ctx.error(MODULE_ERROR);
+  }
+
+  if (inheritsHelperRe.test(check)) {
+    if (babelHelpers === RUNTIME) {
+      return;
+    }
+
+    ctx.error(mismatchError(RUNTIME, babelHelpers, transformOptions.filename));
+  }
+
+  if (check.includes('babelHelpers.inherits')) {
+    if (babelHelpers === EXTERNAL) {
+      return;
+    }
+
+    ctx.error(mismatchError(EXTERNAL, babelHelpers, transformOptions.filename));
+  } // test unminifiable string content
+
+
+  if (check.includes('Super expression must either be null or a function')) {
+    if (babelHelpers === INLINE || babelHelpers === BUNDLED) {
+      return;
+    }
+
+    if (babelHelpers === RUNTIME && !transformOptions.plugins.length) {
+      ctx.error(`You must use the \`@babel/plugin-transform-runtime\` plugin when \`babelHelpers\` is "${RUNTIME}".\n`);
+    }
+
+    ctx.error(mismatchError(INLINE, babelHelpers, transformOptions.filename));
+  }
+
+  ctx.error(UNEXPECTED_ERROR);
+}
+
+async function transformCode(inputCode, babelOptions, overrides, customOptions, ctx, finalizeOptions) {
+  // loadPartialConfigAsync has become available in @babel/core@7.8.0
+  const config = await (babel.loadPartialConfigAsync || babel.loadPartialConfig)(babelOptions); // file is ignored by babel
+
+  if (!config) {
+    return null;
+  }
+
+  let transformOptions = !overrides.config ? config.options : await overrides.config.call(ctx, config, {
+    code: inputCode,
+    customOptions
+  });
+
+  if (finalizeOptions) {
+    transformOptions = await finalizeOptions(transformOptions);
+  }
+
+  if (!overrides.result) {
+    const {
+      code,
+      map
+    } = await babel.transformAsync(inputCode, transformOptions);
+    return {
+      code,
+      map
+    };
+  }
+
+  const result = await babel.transformAsync(inputCode, transformOptions);
+  const {
+    code,
+    map
+  } = await overrides.result.call(ctx, result, {
+    code: inputCode,
+    customOptions,
+    config,
+    transformOptions
+  });
+  return {
+    code,
+    map
+  };
+}
+
+const unpackOptions = (_ref = {}) => {
+  let {
+    extensions = babel.DEFAULT_EXTENSIONS,
+    // rollup uses sourcemap, babel uses sourceMaps
+    // just normalize them here so people don't have to worry about it
+    sourcemap = true,
+    sourcemaps = true,
+    sourceMap = true,
+    sourceMaps = true
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, ["extensions", "sourcemap", "sourcemaps", "sourceMap", "sourceMaps"]);
+
+  return _objectSpread2(_objectSpread2({
+    extensions,
+    plugins: [],
+    sourceMaps: sourcemap && sourcemaps && sourceMap && sourceMaps
+  }, rest), {}, {
+    caller: _objectSpread2({
+      name: '@rollup/plugin-babel'
+    }, rest.caller)
+  });
+};
+
+const warnAboutDeprecatedHelpersOption = ({
+  deprecatedOption,
+  suggestion
+}) => {
+  // eslint-disable-next-line no-console
+  console.warn(`\`${deprecatedOption}\` has been removed in favor a \`babelHelpers\` option. Try changing your configuration to \`${suggestion}\`. ` + `Refer to the documentation to learn more: https://github.com/rollup/plugins/tree/master/packages/babel#babelhelpers`);
+};
+
+const unpackInputPluginOptions = (_ref2, rollupVersion) => {
+  let {
+    skipPreflightCheck = false
+  } = _ref2,
+      rest = _objectWithoutProperties(_ref2, ["skipPreflightCheck"]);
+
+  if ('runtimeHelpers' in rest) {
+    warnAboutDeprecatedHelpersOption({
+      deprecatedOption: 'runtimeHelpers',
+      suggestion: `babelHelpers: 'runtime'`
+    });
+  } else if ('externalHelpers' in rest) {
+    warnAboutDeprecatedHelpersOption({
+      deprecatedOption: 'externalHelpers',
+      suggestion: `babelHelpers: 'external'`
+    });
+  } else if (!rest.babelHelpers) {
+    // eslint-disable-next-line no-console
+    console.warn("babelHelpers: 'bundled' option was used by default. It is recommended to configure this option explicitly, read more here: " + 'https://github.com/rollup/plugins/tree/master/packages/babel#babelhelpers');
+  }
+
+  return unpackOptions(_objectSpread2(_objectSpread2({}, rest), {}, {
+    skipPreflightCheck,
+    babelHelpers: rest.babelHelpers || BUNDLED,
+    caller: _objectSpread2({
+      supportsStaticESM: true,
+      supportsDynamicImport: true,
+      supportsTopLevelAwait: true,
+      // todo: remove version checks for 1.20 - 1.25 when we bump peer deps
+      supportsExportNamespaceFrom: !rollupVersion.match(/^1\.2[0-5]\./)
+    }, rest.caller)
+  }));
+};
+
+const unpackOutputPluginOptions = (options, {
+  format
+}) => unpackOptions(_objectSpread2(_objectSpread2({
+  configFile: false,
+  sourceType: format === 'es' ? 'module' : 'script'
+}, options), {}, {
+  caller: _objectSpread2({
+    supportsStaticESM: format === 'es'
+  }, options.caller)
+}));
+
+function getOptionsWithOverrides(pluginOptions = {}, overrides = {}) {
+  if (!overrides.options) return {
+    customOptions: null,
+    pluginOptionsWithOverrides: pluginOptions
+  };
+  const overridden = overrides.options(pluginOptions);
+
+  if (typeof overridden.then === 'function') {
+    throw new Error(".options hook can't be asynchronous. It should return `{ customOptions, pluginsOptions }` synchronously.");
+  }
+
+  return {
+    customOptions: overridden.customOptions || null,
+    pluginOptionsWithOverrides: overridden.pluginOptions || pluginOptions
+  };
+}
+
+const returnObject = () => {
+  return {};
+};
+
+function createBabelInputPluginFactory(customCallback = returnObject) {
+  const overrides = customCallback(babel__namespace);
+  return pluginOptions => {
+    const {
+      customOptions,
+      pluginOptionsWithOverrides
+    } = getOptionsWithOverrides(pluginOptions, overrides);
+    let babelHelpers;
+    let babelOptions;
+    let filter;
+    let skipPreflightCheck;
+    return {
+      name: 'babel',
+
+      options() {
+        // todo: remove options hook and hoist declarations when version checks are removed
+        let exclude;
+        let include;
+        let extensions;
+        let customFilter;
+
+        var _unpackInputPluginOpt = unpackInputPluginOptions(pluginOptionsWithOverrides, this.meta.rollupVersion);
+
+        ({
+          exclude,
+          extensions,
+          babelHelpers,
+          include,
+          filter: customFilter,
+          skipPreflightCheck
+        } = _unpackInputPluginOpt);
+        babelOptions = _objectWithoutProperties(_unpackInputPluginOpt, ["exclude", "extensions", "babelHelpers", "include", "filter", "skipPreflightCheck"]);
+        const extensionRegExp = new RegExp(`(${extensions.map(escapeRegExpCharacters).join('|')})$`);
+
+        if (customFilter && (include || exclude)) {
+          throw new Error('Could not handle include or exclude with custom filter together');
+        }
+
+        const userDefinedFilter = typeof customFilter === 'function' ? customFilter : pluginutils.createFilter(include, exclude);
+
+        filter = id => extensionRegExp.test(stripQuery(id).bareId) && userDefinedFilter(id);
+
+        return null;
+      },
+
+      resolveId(id) {
+        if (id !== HELPERS) {
+          return null;
+        }
+
+        return id;
+      },
+
+      load(id) {
+        if (id !== HELPERS) {
+          return null;
+        }
+
+        return babel.buildExternalHelpers(null, 'module');
+      },
+
+      transform(code, filename) {
+        if (!filter(filename)) return null;
+        if (filename === HELPERS) return null;
+        return transformCode(code, _objectSpread2(_objectSpread2({}, babelOptions), {}, {
+          filename
+        }), overrides, customOptions, this, async transformOptions => {
+          if (!skipPreflightCheck) {
+            await preflightCheck(this, babelHelpers, transformOptions);
+          }
+
+          return babelHelpers === BUNDLED ? addBabelPlugin(transformOptions, importHelperPlugin) : transformOptions;
+        });
+      }
+
+    };
+  };
+}
+
+function getRecommendedFormat(rollupFormat) {
+  switch (rollupFormat) {
+    case 'amd':
+      return 'amd';
+
+    case 'iife':
+    case 'umd':
+      return 'umd';
+
+    case 'system':
+      return 'systemjs';
+
+    default:
+      return '<module format>';
+  }
+}
+
+function createBabelOutputPluginFactory(customCallback = returnObject) {
+  const overrides = customCallback(babel__namespace);
+  return pluginOptions => {
+    const {
+      customOptions,
+      pluginOptionsWithOverrides
+    } = getOptionsWithOverrides(pluginOptions, overrides);
+    return {
+      name: 'babel',
+
+      renderStart(outputOptions) {
+        const {
+          extensions,
+          include,
+          exclude,
+          allowAllFormats
+        } = pluginOptionsWithOverrides;
+
+        if (extensions || include || exclude) {
+          warnOnce(this, 'The "include", "exclude" and "extensions" options are ignored when transforming the output.');
+        }
+
+        if (!allowAllFormats && outputOptions.format !== 'es' && outputOptions.format !== 'cjs') {
+          this.error(`Using Babel on the generated chunks is strongly discouraged for formats other than "esm" or "cjs" as it can easily break wrapper code and lead to accidentally created global variables. Instead, you should set "output.format" to "esm" and use Babel to transform to another format, e.g. by adding "presets: [['@babel/env', { modules: '${getRecommendedFormat(outputOptions.format)}' }]]" to your Babel options. If you still want to proceed, add "allowAllFormats: true" to your plugin options.`);
+        }
+      },
+
+      renderChunk(code, chunk, outputOptions) {
+        /* eslint-disable no-unused-vars */
+        const _unpackOutputPluginOp = unpackOutputPluginOptions(pluginOptionsWithOverrides, outputOptions),
+              babelOptions = _objectWithoutProperties(_unpackOutputPluginOp, ["allowAllFormats", "exclude", "extensions", "externalHelpers", "externalHelpersWhitelist", "include", "runtimeHelpers"]);
+        /* eslint-enable no-unused-vars */
+
+
+        return transformCode(code, babelOptions, overrides, customOptions, this);
+      }
+
+    };
+  };
+} // export this for symmetry with output-related exports
+
+
+const getBabelInputPlugin = createBabelInputPluginFactory();
+const getBabelOutputPlugin = createBabelOutputPluginFactory();
+
+exports.babel = getBabelInputPlugin;
+exports.createBabelInputPluginFactory = createBabelInputPluginFactory;
+exports.createBabelOutputPluginFactory = createBabelOutputPluginFactory;
+exports.default = getBabelInputPlugin;
+exports.getBabelInputPlugin = getBabelInputPlugin;
+exports.getBabelOutputPlugin = getBabelOutputPlugin;

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/plugin-babel/types/index.d.ts

@@ -0,0 +1,133 @@
+import { Plugin, PluginContext, TransformPluginContext } from 'rollup';
+import { FilterPattern, CreateFilter } from '@rollup/pluginutils';
+import * as babelCore from '@babel/core';
+
+export interface RollupBabelInputPluginOptions
+  extends Omit<babelCore.TransformOptions, 'include' | 'exclude'> {
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in the build the plugin should operate on. When relying on Babel configuration files you cannot include files already excluded there.
+   * @default undefined;
+   */
+  include?: FilterPattern;
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in the build the plugin should ignore. When relaying on Babel configuration files you can only exclude additional files with this option, you cannot override what you have configured for Babel itself.
+   * @default undefined;
+   */
+  exclude?: FilterPattern;
+  /**
+   * Custom filter function can be used to determine whether or not certain modules should be operated upon.
+   * Example:
+   *   import { createFilter } from '@rollup/pluginutils';
+   *   const include = 'include/**.js';
+   *   const exclude = 'exclude/**.js';
+   *   const filter = createFilter(include, exclude, {});
+   * @default undefined;
+   */
+  filter?: ReturnType<CreateFilter>;
+  /**
+   * An array of file extensions that Babel should transpile. If you want to transpile TypeScript files with this plugin it's essential to include .ts and .tsx in this option.
+   * @default ['.js', '.jsx', '.es6', '.es', '.mjs']
+   */
+  extensions?: string[];
+  /**
+   * It is recommended to configure this option explicitly (even if with its default value) so an informed decision is taken on how those babel helpers are inserted into the code.
+   * @default 'bundled'
+   */
+  babelHelpers?: 'bundled' | 'runtime' | 'inline' | 'external';
+  /**
+   * Before transpiling your input files this plugin also transpile a short piece of code for each input file. This is used to validate some misconfiguration errors, but for sufficiently big projects it can slow your build times so if you are confident about your configuration then you might disable those checks with this option.
+   * @default false
+   */
+  skipPreflightCheck?: boolean;
+}
+
+export interface RollupBabelOutputPluginOptions
+  extends Omit<babelCore.TransformOptions, 'include' | 'exclude'> {
+  /**
+   * Use with other formats than UMD/IIFE.
+   * @default false
+   */
+  allowAllFormats?: boolean;
+}
+
+export type RollupBabelCustomInputPluginOptions = (
+  options: RollupBabelInputPluginOptions & Record<string, any>
+) => {
+  customOptions: Record<string, any>;
+  pluginOptions: RollupBabelInputPluginOptions;
+};
+export type RollupBabelCustomOutputPluginOptions = (
+  options: RollupBabelOutputPluginOptions & Record<string, any>
+) => {
+  customOptions: Record<string, any>;
+  pluginOptions: RollupBabelOutputPluginOptions;
+};
+export interface RollupBabelCustomPluginConfigOptions {
+  code: string;
+  customOptions: Record<string, any>;
+}
+export interface RollupBabelCustomPluginResultOptions {
+  code: string;
+  customOptions: Record<string, any>;
+  config: babelCore.PartialConfig;
+  transformOptions: babelCore.TransformOptions;
+}
+export type RollupBabelCustomInputPluginConfig = (
+  this: TransformPluginContext,
+  cfg: babelCore.PartialConfig,
+  options: RollupBabelCustomPluginConfigOptions
+) => babelCore.TransformOptions;
+export type RollupBabelCustomInputPluginResult = (
+  this: TransformPluginContext,
+  result: babelCore.BabelFileResult,
+  options: RollupBabelCustomPluginResultOptions
+) => babelCore.BabelFileResult;
+export type RollupBabelCustomOutputPluginConfig = (
+  this: PluginContext,
+  cfg: babelCore.PartialConfig,
+  options: RollupBabelCustomPluginConfigOptions
+) => babelCore.TransformOptions;
+export type RollupBabelCustomOutputPluginResult = (
+  this: PluginContext,
+  result: babelCore.BabelFileResult,
+  options: RollupBabelCustomPluginResultOptions
+) => babelCore.BabelFileResult;
+export interface RollupBabelCustomInputPlugin {
+  options?: RollupBabelCustomInputPluginOptions;
+  config?: RollupBabelCustomInputPluginConfig;
+  result?: RollupBabelCustomInputPluginResult;
+}
+export interface RollupBabelCustomOutputPlugin {
+  options?: RollupBabelCustomOutputPluginOptions;
+  config?: RollupBabelCustomOutputPluginConfig;
+  result?: RollupBabelCustomOutputPluginResult;
+}
+export type RollupBabelCustomInputPluginBuilder = (
+  babel: typeof babelCore
+) => RollupBabelCustomInputPlugin;
+export type RollupBabelCustomOutputPluginBuilder = (
+  babel: typeof babelCore
+) => RollupBabelCustomOutputPlugin;
+
+/**
+ * A Rollup plugin for seamless integration between Rollup and Babel.
+ * @param options - Plugin options.
+ * @returns Plugin instance.
+ */
+export function getBabelInputPlugin(options?: RollupBabelInputPluginOptions): Plugin;
+export function getBabelOutputPlugin(options?: RollupBabelOutputPluginOptions): Plugin;
+
+export function createBabelInputPluginFactory(
+  customCallback?: RollupBabelCustomInputPluginBuilder
+): typeof getBabelInputPlugin;
+export function createBabelOutputPluginFactory(
+  customCallback?: RollupBabelCustomOutputPluginBuilder
+): typeof getBabelOutputPlugin;
+
+/**
+ * A Rollup plugin for seamless integration between Rollup and Babel.
+ * @param options - Plugin options.
+ * @returns Plugin instance.
+ */
+export function babel(options?: RollupBabelInputPluginOptions): Plugin;
+export default babel;

vendor/spatie/ignition/node_modules/@rollup/plugin-commonjs/CHANGELOG.md

@@ -0,0 +1,518 @@
+# @rollup/plugin-commonjs ChangeLog
+
+## v17.1.0
+
+_2021-01-29_
+
+### Bugfixes
+
+- fix: correctly replace shorthand `require` (#764)
+
+### Features
+
+- feature: load dynamic commonjs modules from es `import` (#766)
+- feature: support cache/resolve access inside dynamic modules (#728)
+- feature: allow keeping `require` calls inside try-catch (#729)
+
+### Updates
+
+- chore: fix lint error (#719)
+
+## v17.0.0
+
+_2020-11-30_
+
+### Breaking Changes
+
+- feat!: reconstruct real es module from \_\_esModule marker (#537)
+
+## v16.0.0
+
+_2020-10-27_
+
+### Breaking Changes
+
+- feat!: Expose cjs detection and support offline caching (#604)
+
+### Bugfixes
+
+- fix: avoid wrapping `commonjsRegister` call in `createCommonjsModule(...)` (#602)
+- fix: register dynamic modules when a different loader (i.e typescript) loads the entry file (#599)
+- fix: fixed access to node_modules dynamic module with subfolder (i.e 'logform/json') (#601)
+
+### Features
+
+- feat: pass type of import to node-resolve (#611)
+
+## v15.1.0
+
+_2020-09-21_
+
+### Features
+
+- feat: inject \_\_esModule marker into ES namespaces and add Object prototype (#552)
+- feat: add requireReturnsDefault to types (#579)
+
+## v15.0.0
+
+_2020-08-13_
+
+### Breaking Changes
+
+- feat!: return the namespace by default when requiring ESM (#507)
+- fix!: fix interop when importing CJS that is transpiled ESM from an actual ESM (#501)
+
+### Bugfixes
+
+- fix: add .cjs to default file extensions. (#524)
+
+### Updates
+
+- chore: update dependencies (fe399e2)
+
+## v14.0.0
+
+_2020-07-13_
+
+### Release Notes
+
+This restores the fixes from v13.0.1, but as a semver compliant major version.
+
+## v13.0.2
+
+_2020-07-13_
+
+### Rollback
+
+Rolls back breaking change in v13.0.1 whereby the exported `unwrapExports` method was removed.
+
+## v13.0.1
+
+_2020-07-12_
+
+### Bugfixes
+
+- fix: prevent rewrite require.resolve (#446)
+- fix: Support \_\_esModule packages with a default export (#465)
+
+## v13.0.0
+
+_2020-06-05_
+
+### Breaking Changes
+
+- fix!: remove namedExports from types (#410)
+- fix!: do not create fake named exports (#427)
+
+### Bugfixes
+
+- fix: \_\_moduleExports in multi entry + inter dependencies (#415)
+
+## v12.0.0
+
+_2020-05-20_
+
+### Breaking Changes
+
+- feat: add kill-switch for mixed es-cjs modules (#358)
+- feat: set syntheticNamedExports for commonjs modules (#149)
+
+### Bugfixes
+
+- fix: expose the virtual `require` function on mock `module`. fixes #307 (#326)
+- fix: improved shouldWrap logic. fixes #304 (#355)
+
+### Features
+
+- feat: support for explicit module.require calls. fixes #310 (#325)
+
+## v11.1.0
+
+_2020-04-12_
+
+### Bugfixes
+
+- fix: produce legal variable names from filenames containing hyphens. (#201)
+
+### Features
+
+- feat: support dynamic require (#206)
+- feat: export properties defined using Object.defineProperty(exports, ..) (#222)
+
+### Updates
+
+- chore: snapshot mismatch running tests before publish (d6bbfdd)
+- test: add snapshots to all "function" tests (#218)
+
+## v11.0.2
+
+_2020-02-01_
+
+### Updates
+
+- docs: fix link for plugin-node-resolve (#170)
+- chore: update dependencies (5405eea)
+- chore: remove jsnext:main (#152)
+
+## v11.0.1
+
+_2020-01-04_
+
+### Bugfixes
+
+- fix: module.exports object spread (#121)
+
+## 11.0.0
+
+_2019-12-13_
+
+- **Breaking:** Minimum compatible Rollup version is 1.20.0
+- **Breaking:** Minimum supported Node version is 8.0.0
+- Published as @rollup/plugin-commonjs
+
+## 10.1.0
+
+_2019-08-27_
+
+- Normalize ids before looking up in named export map ([#406](https://github.com/rollup/rollup-plugin-commonjs/issues/406))
+- Update README.md with note on symlinks ([#405](https://github.com/rollup/rollup-plugin-commonjs/issues/405))
+
+## 10.0.2
+
+_2019-08-03_
+
+- Support preserveSymlinks: false ([#401](https://github.com/rollup/rollup-plugin-commonjs/issues/401))
+
+## 10.0.1
+
+_2019-06-27_
+
+- Make tests run with Node 6 again and update dependencies ([#389](https://github.com/rollup/rollup-plugin-commonjs/issues/389))
+- Handle builtins appropriately for resolve 1.11.0 ([#395](https://github.com/rollup/rollup-plugin-commonjs/issues/395))
+
+## 10.0.0
+
+_2019-05-15_
+
+- Use new Rollup@1.12 context functions, fix issue when resolveId returns an object ([#387](https://github.com/rollup/rollup-plugin-commonjs/issues/387))
+
+## 9.3.4
+
+_2019-04-04_
+
+- Make "extensions" optional ([#384](https://github.com/rollup/rollup-plugin-commonjs/issues/384))
+- Use same typing for include and exclude properties ([#385](https://github.com/rollup/rollup-plugin-commonjs/issues/385))
+
+## 9.3.3
+
+_2019-04-04_
+
+- Remove colon from module prefixes ([#371](https://github.com/rollup/rollup-plugin-commonjs/issues/371))
+
+## 9.3.2
+
+_2019-04-04_
+
+- Use shared extractAssignedNames, fix destructuring issue ([#303](https://github.com/rollup/rollup-plugin-commonjs/issues/303))
+
+## 9.3.1
+
+_2019-04-04_
+
+- Include typings in release ([#382](https://github.com/rollup/rollup-plugin-commonjs/issues/382))
+
+## 9.3.0
+
+_2019-04-03_
+
+- Add TypeScript types ([#363](https://github.com/rollup/rollup-plugin-commonjs/issues/363))
+
+## 9.2.3
+
+_2019-04-02_
+
+- Improve support for ES3 browsers ([#364](https://github.com/rollup/rollup-plugin-commonjs/issues/364))
+- Add note about monorepo usage to readme ([#372](https://github.com/rollup/rollup-plugin-commonjs/issues/372))
+- Add .js extension to generated helper file ([#373](https://github.com/rollup/rollup-plugin-commonjs/issues/373))
+
+## 9.2.2
+
+_2019-03-25_
+
+- Handle array destructuring assignment ([#379](https://github.com/rollup/rollup-plugin-commonjs/issues/379))
+
+## 9.2.1
+
+_2019-02-23_
+
+- Use correct context when manually resolving ids ([#370](https://github.com/rollup/rollup-plugin-commonjs/issues/370))
+
+## 9.2.0
+
+_2018-10-10_
+
+- Fix missing default warning, produce better code when importing known ESM default exports ([#349](https://github.com/rollup/rollup-plugin-commonjs/issues/349))
+- Refactor code and add prettier ([#346](https://github.com/rollup/rollup-plugin-commonjs/issues/346))
+
+## 9.1.8
+
+_2018-09-18_
+
+- Ignore virtual modules created by other plugins ([#327](https://github.com/rollup/rollup-plugin-commonjs/issues/327))
+- Add "location" and "process" to reserved words ([#330](https://github.com/rollup/rollup-plugin-commonjs/issues/330))
+
+## 9.1.6
+
+_2018-08-24_
+
+- Keep commonJS detection between instantiations ([#338](https://github.com/rollup/rollup-plugin-commonjs/issues/338))
+
+## 9.1.5
+
+_2018-08-09_
+
+- Handle object form of input ([#329](https://github.com/rollup/rollup-plugin-commonjs/issues/329))
+
+## 9.1.4
+
+_2018-07-27_
+
+- Make "from" a reserved word ([#320](https://github.com/rollup/rollup-plugin-commonjs/issues/320))
+
+## 9.1.3
+
+_2018-04-30_
+
+- Fix a caching issue ([#316](https://github.com/rollup/rollup-plugin-commonjs/issues/316))
+
+## 9.1.2
+
+_2018-04-30_
+
+- Re-publication of 9.1.0
+
+## 9.1.1
+
+_2018-04-30_
+
+- Fix ordering of modules when using rollup 0.58 ([#302](https://github.com/rollup/rollup-plugin-commonjs/issues/302))
+
+## 9.1.0
+
+- Do not automatically wrap modules with return statements in top level arrow functions ([#302](https://github.com/rollup/rollup-plugin-commonjs/issues/302))
+
+## 9.0.0
+
+- Make rollup a peer dependency with a version range ([#300](https://github.com/rollup/rollup-plugin-commonjs/issues/300))
+
+## 8.4.1
+
+- Re-release of 8.3.0 as #287 was actually a breaking change
+
+## 8.4.0
+
+- Better handle non-CJS files that contain CJS keywords ([#285](https://github.com/rollup/rollup-plugin-commonjs/issues/285))
+- Use rollup's plugin context`parse` function ([#287](https://github.com/rollup/rollup-plugin-commonjs/issues/287))
+- Improve error handling ([#288](https://github.com/rollup/rollup-plugin-commonjs/issues/288))
+
+## 8.3.0
+
+- Handle multiple entry points ([#283](https://github.com/rollup/rollup-plugin-commonjs/issues/283))
+- Extract named exports from exported object literals ([#272](https://github.com/rollup/rollup-plugin-commonjs/issues/272))
+- Fix when `options.external` is modified by other plugins ([#264](https://github.com/rollup/rollup-plugin-commonjs/issues/264))
+- Recognize static template strings in require statements ([#271](https://github.com/rollup/rollup-plugin-commonjs/issues/271))
+
+## 8.2.4
+
+- Don't import default from ES modules that don't export default ([#206](https://github.com/rollup/rollup-plugin-commonjs/issues/206))
+
+## 8.2.3
+
+- Prevent duplicate default exports ([#230](https://github.com/rollup/rollup-plugin-commonjs/pull/230))
+- Only include default export when it exists ([#226](https://github.com/rollup/rollup-plugin-commonjs/pull/226))
+- Deconflict `require` aliases ([#232](https://github.com/rollup/rollup-plugin-commonjs/issues/232))
+
+## 8.2.1
+
+- Fix magic-string deprecation warning
+
+## 8.2.0
+
+- Avoid using `index` as a variable name ([#208](https://github.com/rollup/rollup-plugin-commonjs/pull/208))
+
+## 8.1.1
+
+- Compatibility with 0.48 ([#220](https://github.com/rollup/rollup-plugin-commonjs/issues/220))
+
+## 8.1.0
+
+- Handle `options.external` correctly ([#212](https://github.com/rollup/rollup-plugin-commonjs/pull/212))
+- Support top-level return ([#195](https://github.com/rollup/rollup-plugin-commonjs/pull/195))
+
+## 8.0.2
+
+- Fix another `var` rewrite bug ([#181](https://github.com/rollup/rollup-plugin-commonjs/issues/181))
+
+## 8.0.1
+
+- Remove declarators within a var declaration correctly ([#179](https://github.com/rollup/rollup-plugin-commonjs/issues/179))
+
+## 8.0.0
+
+- Prefer the names dependencies are imported by for the common `var foo = require('foo')` pattern ([#176](https://github.com/rollup/rollup-plugin-commonjs/issues/176))
+
+## 7.1.0
+
+- Allow certain `require` statements to pass through unmolested ([#174](https://github.com/rollup/rollup-plugin-commonjs/issues/174))
+
+## 7.0.2
+
+- Handle duplicate default exports ([#158](https://github.com/rollup/rollup-plugin-commonjs/issues/158))
+
+## 7.0.1
+
+- Fix exports with parentheses ([#168](https://github.com/rollup/rollup-plugin-commonjs/issues/168))
+
+## 7.0.0
+
+- Rewrite `typeof module`, `typeof module.exports` and `typeof exports` as `'object'` ([#151](https://github.com/rollup/rollup-plugin-commonjs/issues/151))
+
+## 6.0.1
+
+- Don't overwrite globals ([#127](https://github.com/rollup/rollup-plugin-commonjs/issues/127))
+
+## 6.0.0
+
+- Rewrite top-level `define` as `undefined`, so AMD-first UMD blocks do not cause breakage ([#144](https://github.com/rollup/rollup-plugin-commonjs/issues/144))
+- Support ES2017 syntax ([#132](https://github.com/rollup/rollup-plugin-commonjs/issues/132))
+- Deconflict exported reserved keywords ([#116](https://github.com/rollup/rollup-plugin-commonjs/issues/116))
+
+## 5.0.5
+
+- Fix parenthesis wrapped exports ([#120](https://github.com/rollup/rollup-plugin-commonjs/issues/120))
+
+## 5.0.4
+
+- Ensure named exports are added to default export in optimised modules ([#112](https://github.com/rollup/rollup-plugin-commonjs/issues/112))
+
+## 5.0.3
+
+- Respect custom `namedExports` in optimised modules ([#35](https://github.com/rollup/rollup-plugin-commonjs/issues/35))
+
+## 5.0.2
+
+- Replace `require` (outside call expressions) with `commonjsRequire` helper ([#77](https://github.com/rollup/rollup-plugin-commonjs/issues/77), [#83](https://github.com/rollup/rollup-plugin-commonjs/issues/83))
+
+## 5.0.1
+
+- Deconflict against globals ([#84](https://github.com/rollup/rollup-plugin-commonjs/issues/84))
+
+## 5.0.0
+
+- Optimise modules that don't need to be wrapped in a function ([#106](https://github.com/rollup/rollup-plugin-commonjs/pull/106))
+- Ignore modules containing `import` and `export` statements ([#96](https://github.com/rollup/rollup-plugin-commonjs/pull/96))
+
+## 4.1.0
+
+- Ignore dead branches ([#93](https://github.com/rollup/rollup-plugin-commonjs/issues/93))
+
+## 4.0.1
+
+- Fix `ignoreGlobal` option ([#86](https://github.com/rollup/rollup-plugin-commonjs/pull/86))
+
+## 4.0.0
+
+- Better interop and smaller output ([#92](https://github.com/rollup/rollup-plugin-commonjs/pull/92))
+
+## 3.3.1
+
+- Deconflict export and local module ([rollup/rollup#554](https://github.com/rollup/rollup/issues/554))
+
+## 3.3.0
+
+- Keep the order of execution for require calls ([#43](https://github.com/rollup/rollup-plugin-commonjs/pull/43))
+- Use interopDefault as helper ([#42](https://github.com/rollup/rollup-plugin-commonjs/issues/42))
+
+## 3.2.0
+
+- Use named exports as a function when no default export is defined ([#524](https://github.com/rollup/rollup/issues/524))
+
+## 3.1.0
+
+- Replace `typeof require` with `'function'` ([#38](https://github.com/rollup/rollup-plugin-commonjs/issues/38))
+- Don't attempt to resolve entry file relative to importer ([#63](https://github.com/rollup/rollup-plugin-commonjs/issues/63))
+
+## 3.0.2
+
+- Handle multiple references to `global`
+
+## 3.0.1
+
+- Return a `name`
+
+## 3.0.0
+
+- Make `transform` stateless ([#71](https://github.com/rollup/rollup-plugin-commonjs/pull/71))
+- Support web worker `global` ([#50](https://github.com/rollup/rollup-plugin-commonjs/issues/50))
+- Ignore global with `options.ignoreGlobal` ([#48](https://github.com/rollup/rollup-plugin-commonjs/issues/48))
+
+## 2.2.1
+
+- Prevent false positives with `namedExports` ([#36](https://github.com/rollup/rollup-plugin-commonjs/issues/36))
+
+## 2.2.0
+
+- Rewrite top-level `this` expressions to mean the same as `global` ([#31](https://github.com/rollup/rollup-plugin-commonjs/issues/31))
+
+## 2.1.0
+
+- Optimised module wrappers ([#20](https://github.com/rollup/rollup-plugin-commonjs/pull/20))
+- Allow control over named exports via `options.namedExports` ([#18](https://github.com/rollup/rollup-plugin-commonjs/issues/18))
+- Handle bare imports correctly ([#23](https://github.com/rollup/rollup-plugin-commonjs/issues/23))
+- Blacklist all reserved words as export names ([#21](https://github.com/rollup/rollup-plugin-commonjs/issues/21))
+- Configure allowed file extensions via `options.extensions` ([#27](https://github.com/rollup/rollup-plugin-commonjs/pull/27))
+
+## 2.0.0
+
+- Support for transpiled modules – `exports.default` is used as the default export in place of `module.exports`, if applicable, and `__esModule` is not exported ([#16](https://github.com/rollup/rollup-plugin-commonjs/pull/16))
+
+## 1.4.0
+
+- Generate sourcemaps by default
+
+## 1.3.0
+
+- Handle references to `global` ([#6](https://github.com/rollup/rollup-plugin-commonjs/issues/6))
+
+## 1.2.0
+
+- Generate named exports where possible ([#5](https://github.com/rollup/rollup-plugin-commonjs/issues/5))
+- Handle shadowed `require`/`module`/`exports`
+
+## 1.1.0
+
+- Handle dots in filenames ([#3](https://github.com/rollup/rollup-plugin-commonjs/issues/3))
+- Wrap modules in IIFE for more readable output
+
+## 1.0.0
+
+- Stable release, now that Rollup supports plugins
+
+## 0.2.1
+
+- Allow mixed CommonJS/ES6 imports/exports
+- Use `var` instead of `let`
+
+## 0.2.0
+
+- Sourcemap support
+- Support `options.include` and `options.exclude`
+- Bail early if module is obviously not a CommonJS module
+
+## 0.1.1
+
+Add dist files to package (whoops!)
+
+## 0.1.0
+
+- First release

vendor/spatie/ignition/node_modules/@rollup/plugin-commonjs/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/plugin-commonjs/README.md

@@ -0,0 +1,346 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-commonjs
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-commonjs
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-commonjs
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-commonjs
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-commonjs
+
+🍣 A Rollup plugin to convert CommonJS modules to ES6, so they can be included in a Rollup bundle
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```bash
+npm install @rollup/plugin-commonjs --save-dev
+```
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import commonjs from '@rollup/plugin-commonjs';
+
+export default {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [commonjs()]
+};
+```
+
+Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api).
+
+## Options
+
+### `dynamicRequireTargets`
+
+Type: `string | string[]`<br>
+Default: `[]`
+
+Some modules contain dynamic `require` calls, or require modules that contain circular dependencies, which are not handled well by static imports.
+Including those modules as `dynamicRequireTargets` will simulate a CommonJS (NodeJS-like) environment for them with support for dynamic and circular dependencies.
+
+_Note: In extreme cases, this feature may result in some paths being rendered as absolute in the final bundle. The plugin tries to avoid exposing paths from the local machine, but if you are `dynamicRequirePaths` with paths that are far away from your project's folder, that may require replacing strings like `"/Users/John/Desktop/foo-project/"` -> `"/"`._
+
+Example:
+
+```js
+commonjs({
+  dynamicRequireTargets: [
+    // include using a glob pattern (either a string or an array of strings)
+    'node_modules/logform/*.js',
+
+    // exclude files that are known to not be required dynamically, this allows for better optimizations
+    '!node_modules/logform/index.js',
+    '!node_modules/logform/format.js',
+    '!node_modules/logform/levels.js',
+    '!node_modules/logform/browser.js'
+  ]
+});
+```
+
+### `exclude`
+
+Type: `string | string[]`<br>
+Default: `null`
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should _ignore_. By default, all files with extensions other than those in `extensions` or `".cjs"` are ignored, but you can exclude additional files. See also the `include` option.
+
+### `include`
+
+Type: `string | string[]`<br>
+Default: `null`
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default, all files with extension `".cjs"` or those in `extensions` are included, but you can narrow this list by only including specific files. These files will be analyzed and transpiled if either the analysis does not find ES module specific statements or `transformMixedEsModules` is `true`.
+
+### `extensions`
+
+Type: `string[]`<br>
+Default: `['.js']`
+
+For extensionless imports, search for extensions other than .js in the order specified. Note that you need to make sure that non-JavaScript files are transpiled by another plugin first.
+
+### `ignoreGlobal`
+
+Type: `boolean`<br>
+Default: `false`
+
+If true, uses of `global` won't be dealt with by this plugin.
+
+### `sourceMap`
+
+Type: `boolean`<br>
+Default: `true`
+
+If false, skips source map generation for CommonJS modules. This will improve performance.
+
+### `transformMixedEsModules`
+
+Type: `boolean`<br>
+Default: `false`
+
+Instructs the plugin whether to enable mixed module transformations. This is useful in scenarios with modules that contain a mix of ES `import` statements and CommonJS `require` expressions. Set to `true` if `require` calls should be transformed to imports in mixed modules, or `false` if the `require` expressions should survive the transformation. The latter can be important if the code contains environment detection, or you are coding for an environment with special treatment for `require` calls such as [ElectronJS](https://www.electronjs.org/). See also the "ignore" option.
+
+### `ignore`
+
+Type: `string[] | ((id: string) => boolean)`<br>
+Default: `[]`
+
+Sometimes you have to leave require statements unconverted. Pass an array containing the IDs or an `id => boolean` function.
+
+### `ignoreTryCatch`
+
+Type: `boolean | 'remove' | string[] | ((id: string) => boolean)`<br>
+Default: `false`
+
+In most cases, where `require` calls are inside a `try-catch` clause, they should be left unconverted as it requires an optional dependency that may or may not be installed beside the rolled up package.
+Due to the conversion of `require` to a static `import` - the call is hoisted to the top of the file, outside of the `try-catch` clause.
+
+- `true`: All `require` calls inside a `try` will be left unconverted.
+- `false`: All `require` calls inside a `try` will be converted as if the `try-catch` clause is not there.
+- `remove`: Remove all `require` calls from inside any `try` block.
+- `string[]`: Pass an array containing the IDs to left unconverted.
+- `((id: string) => boolean|'remove')`: Pass a function that control individual IDs.
+
+### `esmExternals`
+
+Type: `boolean | string[] | ((id: string) => boolean)`
+Default: `false`
+
+Controls how to render imports from external dependencies. By default, this plugin assumes that all external dependencies are CommonJS. This means they are rendered as default imports to be compatible with e.g. NodeJS where ES modules can only import a default export from a CommonJS dependency:
+
+```js
+// input
+const foo = require('foo');
+
+// output
+import foo from 'foo';
+```
+
+This is likely not desired for ES module dependencies: Here `require` should usually return the namespace to be compatible with how bundled modules are handled.
+
+If you set `esmExternals` to `true`, this plugins assumes that all external dependencies are ES modules and will adhere to the `requireReturnsDefault` option. If that option is not set, they will be rendered as namespace imports.
+
+You can also supply an array of ids to be treated as ES modules, or a function that will be passed each external id to determine if it is an ES module.
+
+### `requireReturnsDefault`
+
+Type: `boolean | "namespace" | "auto" | "preferred" | ((id: string) => boolean | "auto" | "preferred")`<br>
+Default: `false`
+
+Controls what is returned when requiring an ES module from a CommonJS file. When using the `esmExternals` option, this will also apply to external modules. By default, this plugin will render those imports as namespace imports, i.e.
+
+```js
+// input
+const foo = require('foo');
+
+// output
+import * as foo from 'foo';
+```
+
+This is in line with how other bundlers handle this situation and is also the most likely behaviour in case Node should ever support this. However there are some situations where this may not be desired:
+
+- There is code in an external dependency that cannot be changed where a `require` statement expects the default export to be returned from an ES module.
+- If the imported module is in the same bundle, Rollup will generate a namespace object for the imported module which can increase bundle size unnecessarily:
+
+  ```js
+  // input: main.js
+  const dep = require('./dep.js');
+  console.log(dep.default);
+
+  // input: dep.js
+  export default 'foo';
+
+  // output
+  var dep = 'foo';
+
+  var dep$1 = /*#__PURE__*/ Object.freeze({
+    __proto__: null,
+    default: dep
+  });
+
+  console.log(dep$1.default);
+  ```
+
+For these situations, you can change Rollup's behaviour either globally or per module. To change it globally, set the `requireReturnsDefault` option to one of the following values:
+
+- `false`: This is the default, requiring an ES module returns its namespace. This is the only option that will also add a marker `__esModule: true` to the namespace to support interop patterns in CommonJS modules that are transpiled ES modules.
+
+  ```js
+  // input
+  const dep = require('dep');
+  console.log(dep);
+
+  // output
+  import * as dep$1 from 'dep';
+
+  function getAugmentedNamespace(n) {
+    var a = Object.defineProperty({}, '__esModule', { value: true });
+    Object.keys(n).forEach(function (k) {
+      var d = Object.getOwnPropertyDescriptor(n, k);
+      Object.defineProperty(
+        a,
+        k,
+        d.get
+          ? d
+          : {
+              enumerable: true,
+              get: function () {
+                return n[k];
+              }
+            }
+      );
+    });
+    return a;
+  }
+
+  var dep = /*@__PURE__*/ getAugmentedNamespace(dep$1);
+
+  console.log(dep);
+  ```
+
+- `"namespace"`: Like `false`, requiring an ES module returns its namespace, but the plugin does not add the `__esModule` marker and thus creates more efficient code. For external dependencies when using `esmExternals: true`, no additional interop code is generated.
+
+  ```js
+  // output
+  import * as dep from 'dep';
+
+  console.log(dep);
+  ```
+
+- `"auto"`: This is complementary to how [`output.exports`](https://rollupjs.org/guide/en/#outputexports): `"auto"` works in Rollup: If a module has a default export and no named exports, requiring that module returns the default export. In all other cases, the namespace is returned. For external dependencies when using `esmExternals: true`, a corresponding interop helper is added:
+
+  ```js
+  // output
+  import * as dep$1 from 'dep';
+
+  function getDefaultExportFromNamespaceIfNotNamed(n) {
+    return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+  }
+
+  var dep = getDefaultExportFromNamespaceIfNotNamed(dep$1);
+
+  console.log(dep);
+  ```
+
+- `"preferred"`: If a module has a default export, requiring that module always returns the default export, no matter whether additional named exports exist. This is similar to how previous versions of this plugin worked. Again for external dependencies when using `esmExternals: true`, an interop helper is added:
+
+  ```js
+  // output
+  import * as dep$1 from 'dep';
+
+  function getDefaultExportFromNamespaceIfPresent(n) {
+    return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+  }
+
+  var dep = getDefaultExportFromNamespaceIfPresent(dep$1);
+
+  console.log(dep);
+  ```
+
+- `true`: This will always try to return the default export on require without checking if it actually exists. This can throw at build time if there is no default export. This is how external dependencies are handled when `esmExternals` is not used. The advantage over the other options is that, like `false`, this does not add an interop helper for external dependencies, keeping the code lean:
+
+  ```js
+  // output
+  import dep from 'dep';
+
+  console.log(dep);
+  ```
+
+To change this for individual modules, you can supply a function for `requireReturnsDefault` instead. This function will then be called once for each required ES module or external dependency with the corresponding id and allows you to return different values for different modules.
+
+## Using with @rollup/plugin-node-resolve
+
+Since most CommonJS packages you are importing are probably dependencies in `node_modules`, you may need to use [@rollup/plugin-node-resolve](https://github.com/rollup/plugins/tree/master/packages/node-resolve):
+
+```js
+// rollup.config.js
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+
+export default {
+  input: 'main.js',
+  output: {
+    file: 'bundle.js',
+    format: 'iife',
+    name: 'MyModule'
+  },
+  plugins: [resolve(), commonjs()]
+};
+```
+
+## Usage with symlinks
+
+Symlinks are common in monorepos and are also created by the `npm link` command. Rollup with `@rollup/plugin-node-resolve` resolves modules to their real paths by default. So `include` and `exclude` paths should handle real paths rather than symlinked paths (e.g. `../common/node_modules/**` instead of `node_modules/**`). You may also use a regular expression for `include` that works regardless of base path. Try this:
+
+```js
+commonjs({
+  include: /node_modules/
+});
+```
+
+Whether symlinked module paths are [realpathed](http://man7.org/linux/man-pages/man3/realpath.3.html) or preserved depends on Rollup's `preserveSymlinks` setting, which is false by default, matching Node.js' default behavior. Setting `preserveSymlinks` to true in your Rollup config will cause `import` and `export` to match based on symlinked paths instead.
+
+## Strict mode
+
+ES modules are _always_ parsed in strict mode. That means that certain non-strict constructs (like octal literals) will be treated as syntax errors when Rollup parses modules that use them. Some older CommonJS modules depend on those constructs, and if you depend on them your bundle will blow up. There's basically nothing we can do about that.
+
+Luckily, there is absolutely no good reason _not_ to use strict mode for everything — so the solution to this problem is to lobby the authors of those modules to update them.
+
+## Inter-plugin-communication
+
+This plugin exposes the result of its CommonJS file type detection for other plugins to use. You can access it via `this.getModuleInfo` or the `moduleParsed` hook:
+
+```js
+function cjsDetectionPlugin() {
+  return {
+    name: 'cjs-detection',
+    moduleParsed({
+      id,
+      meta: {
+        commonjs: { isCommonJS }
+      }
+    }) {
+      console.log(`File ${id} is CommonJS: ${isCommonJS}`);
+    }
+  };
+}
+```
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/plugin-commonjs/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/plugin-commonjs/types/index.d.ts

@@ -0,0 +1,170 @@
+import { FilterPattern } from '@rollup/pluginutils';
+import { Plugin } from 'rollup';
+
+type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
+
+interface RollupCommonJSOptions {
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can narrow
+   * this list by only including specific files. These files will be analyzed
+   * and transpiled if either the analysis does not find ES module specific
+   * statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: FilterPattern;
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: FilterPattern;
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>;
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean;
+  /**
+   * If false, skips source map generation for CommonJS modules. This will improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean;
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is hoisted
+   * to the top of the file, outside of the `try-catch` clause.
+   *
+   * - `true`: All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that control individual IDs.
+   *
+   * @default false
+   */
+  ignoreTryCatch?:
+    | boolean
+    | 'remove'
+    | ReadonlyArray<string>
+    | ((id: string) => boolean | 'remove');
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugins assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine if it is an ES
+   * module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?:
+    | RequireReturnsDefaultOption
+    | ((id: string) => RequireReturnsDefaultOption);
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like)  environment for them with support for dynamic and
+   * circular dependencies.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>;
+}
+
+/**
+ * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
+ */
+export default function commonjs(options?: RollupCommonJSOptions): Plugin;

vendor/spatie/ignition/node_modules/@rollup/plugin-json/CHANGELOG.md

@@ -0,0 +1,117 @@
+# @rollup/plugin-json ChangeLog
+
+## v4.1.0
+
+_2020-06-05_
+
+### Features
+
+- feat: log the filename when JSON.parse fails (#417)
+
+## v4.0.3
+
+_2020-04-19_
+
+### Updates
+
+- chore: add rollup 2 to peer range (06d9d29)
+
+## v4.0.2
+
+_2020-02-01_
+
+### Bugfixes
+
+- fix: correct type definitions (#161)
+
+### Updates
+
+- chore: update dependencies (e1d317b)
+
+## 4.0.1
+
+_2019-12-21_
+
+- fix(json): cannot be imported by rollup (#81)
+
+## 4.0.0
+
+_2019-03-18_
+
+- Pass all JSON data through dataToEsm to consistently support "compact" formatting, support empty keys, abandon Node 4 support, add prettier, update dependencies ([#53](https://github.com/rollup/rollup-plugin-json/issues/53))
+
+## 3.1.0
+
+_2018-09-13_
+
+- Expose "compact" and "namedExports" options ([#45](https://github.com/rollup/rollup-plugin-json/issues/45))
+- Update rollup-pluginutils to support null values in JSON ([#44](https://github.com/rollup/rollup-plugin-json/issues/44))
+- Update dependencies and ensure rollup@1.0 compatibility ([#46](https://github.com/rollup/rollup-plugin-json/issues/46))
+
+## 3.0.0
+
+_2018-05-11_
+
+- No longer create a fake AST to support tree-shaking with upcoming versions of rollup ([#41](https://github.com/rollup/rollup-plugin-json/issues/41))
+
+## 2.3.1
+
+_2018-05-11_
+
+- Update example in readme ([#38](https://github.com/rollup/rollup-plugin-json/issues/38))
+- Warn when using this version with upcoming rollup versions
+
+## 2.3.0
+
+_2017-06-03_
+
+- Always parse JSON, so malformed JSON is identified at bundle time ([#27](https://github.com/rollup/rollup-plugin-json/issues/27))
+
+## 2.2.0
+
+_2017-06-03_
+
+- Add `indent` option ([#24](https://github.com/rollup/rollup-plugin-json/issues/24))
+
+## 2.1.1
+
+_2017-04-09_
+
+- Add license to package.json ([#25](https://github.com/rollup/rollup-plugin-json/pull/25))
+
+## 2.1.0
+
+_2016-12-15_
+
+- Add support for `preferConst` option ([#16](https://github.com/rollup/rollup-plugin-json/pull/16))
+- Handle JSON files with no valid identifier keys ([#19](https://github.com/rollup/rollup-plugin-json/issues/19))
+
+## 2.0.2
+
+_2016-09-07_
+
+- Generate correct fake AST
+
+## 2.0.1
+
+_2016-06-23_
+
+- Return a `name`
+
+## 2.0.0
+
+_2015-11-05_
+
+- Generate fake AST to avoid unnecessary traversals within Rollup
+
+## 1.1.0
+
+_unpublished_
+
+- Generate named exports alongside default exports
+
+## 1.0.0
+
+_2015-10-25_
+
+- First release

vendor/spatie/ignition/node_modules/@rollup/plugin-json/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/plugin-json/README.md

@@ -0,0 +1,101 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-json
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-json
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-json
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-json
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-json
+
+🍣 A Rollup plugin which Converts .json files to ES6 modules.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/plugin-json --save-dev
+```
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import json from '@rollup/plugin-json';
+
+export default {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [json()]
+};
+```
+
+Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api).
+
+With an accompanying file `src/index.js`, the local `package.json` file would now be importable as seen below:
+
+```js
+// src/index.js
+import pkg from './package.json';
+console.log(`running version ${pkg.version}`);
+```
+
+## Options
+
+### `compact`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, instructs the plugin to ignore `indent` and generates the smallest code.
+
+### `exclude`
+
+Type: `String` | `Array[...String]`<br>
+Default: `null`
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should _ignore_. By default no files are ignored.
+
+### `include`
+
+Type: `String` | `Array[...String]`<br>
+Default: `null`
+
+A [minimatch pattern](https://github.com/isaacs/minimatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all files are targeted.
+
+### `indent`
+
+Type: `String`<br>
+Default: `'\t'`
+
+Specifies the indentation for the generated default export.
+
+### `namedExports`
+
+Type: `Boolean`<br>
+Default: `true`
+
+If `true`, instructs the plugin to generate a named export for every property of the JSON object.
+
+### `preferConst`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, instructs the plugin to declare properties as variables, using either `var` or `const`. This pertains to tree-shaking.
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/plugin-json/dist/index.es.js

@@ -0,0 +1,38 @@
+import { createFilter, dataToEsm } from '@rollup/pluginutils';
+
+function json(options) {
+  if ( options === void 0 ) options = {};
+
+  var filter = createFilter(options.include, options.exclude);
+  var indent = 'indent' in options ? options.indent : '\t';
+
+  return {
+    name: 'json',
+
+    // eslint-disable-next-line no-shadow
+    transform: function transform(json, id) {
+      if (id.slice(-5) !== '.json' || !filter(id)) { return null; }
+
+      try {
+        var parsed = JSON.parse(json);
+        return {
+          code: dataToEsm(parsed, {
+            preferConst: options.preferConst,
+            compact: options.compact,
+            namedExports: options.namedExports,
+            indent: indent
+          }),
+          map: { mappings: '' }
+        };
+      } catch (err) {
+        var message = 'Could not parse JSON file';
+        var position = parseInt(/[\d]/.exec(err.message)[0], 10);
+        this.warn({ message: message, id: id, position: position });
+        return null;
+      }
+    }
+  };
+}
+
+export default json;
+//# sourceMappingURL=index.es.js.map

vendor/spatie/ignition/node_modules/@rollup/plugin-json/dist/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../src/index.js"],"sourcesContent":["import { createFilter, dataToEsm } from '@rollup/pluginutils';\n\nexport default function json(options = {}) {\n  const filter = createFilter(options.include, options.exclude);\n  const indent = 'indent' in options ? options.indent : '\\t';\n\n  return {\n    name: 'json',\n\n    // eslint-disable-next-line no-shadow\n    transform(json, id) {\n      if (id.slice(-5) !== '.json' || !filter(id)) return null;\n\n      try {\n        const parsed = JSON.parse(json);\n        return {\n          code: dataToEsm(parsed, {\n            preferConst: options.preferConst,\n            compact: options.compact,\n            namedExports: options.namedExports,\n            indent\n          }),\n          map: { mappings: '' }\n        };\n      } catch (err) {\n        const message = 'Could not parse JSON file';\n        const position = parseInt(/[\\d]/.exec(err.message)[0], 10);\n        this.warn({ message, id, position });\n        return null;\n      }\n    }\n  };\n}\n"],"names":["const"],"mappings":";;AAEe,SAAS,IAAI,CAAC,OAAY,EAAE;mCAAP,GAAG;AAAK;AAC5C,EAAEA,IAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;AAChE,EAAEA,IAAM,MAAM,GAAG,QAAQ,IAAI,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;AAC7D;AACA,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,MAAM;AAChB;AACA;AACA,IAAI,6BAAS,CAAC,IAAI,EAAE,EAAE,EAAE;AACxB,MAAM,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAE,OAAO,IAAI,GAAC;AAC/D;AACA,MAAM,IAAI;AACV,QAAQA,IAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACxC,QAAQ,OAAO;AACf,UAAU,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE;AAClC,YAAY,WAAW,EAAE,OAAO,CAAC,WAAW;AAC5C,YAAY,OAAO,EAAE,OAAO,CAAC,OAAO;AACpC,YAAY,YAAY,EAAE,OAAO,CAAC,YAAY;AAC9C,oBAAY,MAAM;AAClB,WAAW,CAAC;AACZ,UAAU,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;AAC/B,SAAS,CAAC;AACV,OAAO,CAAC,OAAO,GAAG,EAAE;AACpB,QAAQA,IAAM,OAAO,GAAG,2BAA2B,CAAC;AACpD,QAAQA,IAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACnE,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAE,OAAO,MAAE,EAAE,YAAE,QAAQ,EAAE,CAAC,CAAC;AAC7C,QAAQ,OAAO,IAAI,CAAC;AACpB,OAAO;AACP,KAAK;AACL,GAAG,CAAC;AACJ;;;;"}

vendor/spatie/ignition/node_modules/@rollup/plugin-json/dist/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var pluginutils = require('@rollup/pluginutils');
+
+function json(options) {
+  if ( options === void 0 ) options = {};
+
+  var filter = pluginutils.createFilter(options.include, options.exclude);
+  var indent = 'indent' in options ? options.indent : '\t';
+
+  return {
+    name: 'json',
+
+    // eslint-disable-next-line no-shadow
+    transform: function transform(json, id) {
+      if (id.slice(-5) !== '.json' || !filter(id)) { return null; }
+
+      try {
+        var parsed = JSON.parse(json);
+        return {
+          code: pluginutils.dataToEsm(parsed, {
+            preferConst: options.preferConst,
+            compact: options.compact,
+            namedExports: options.namedExports,
+            indent: indent
+          }),
+          map: { mappings: '' }
+        };
+      } catch (err) {
+        var message = 'Could not parse JSON file';
+        var position = parseInt(/[\d]/.exec(err.message)[0], 10);
+        this.warn({ message: message, id: id, position: position });
+        return null;
+      }
+    }
+  };
+}
+
+module.exports = json;
+//# sourceMappingURL=index.js.map

vendor/spatie/ignition/node_modules/@rollup/plugin-json/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.js"],"sourcesContent":["import { createFilter, dataToEsm } from '@rollup/pluginutils';\n\nexport default function json(options = {}) {\n  const filter = createFilter(options.include, options.exclude);\n  const indent = 'indent' in options ? options.indent : '\\t';\n\n  return {\n    name: 'json',\n\n    // eslint-disable-next-line no-shadow\n    transform(json, id) {\n      if (id.slice(-5) !== '.json' || !filter(id)) return null;\n\n      try {\n        const parsed = JSON.parse(json);\n        return {\n          code: dataToEsm(parsed, {\n            preferConst: options.preferConst,\n            compact: options.compact,\n            namedExports: options.namedExports,\n            indent\n          }),\n          map: { mappings: '' }\n        };\n      } catch (err) {\n        const message = 'Could not parse JSON file';\n        const position = parseInt(/[\\d]/.exec(err.message)[0], 10);\n        this.warn({ message, id, position });\n        return null;\n      }\n    }\n  };\n}\n"],"names":["const","createFilter","dataToEsm"],"mappings":";;;;AAEe,SAAS,IAAI,CAAC,OAAY,EAAE;mCAAP,GAAG;AAAK;AAC5C,EAAEA,IAAM,MAAM,GAAGC,wBAAY,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;AAChE,EAAED,IAAM,MAAM,GAAG,QAAQ,IAAI,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;AAC7D;AACA,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,MAAM;AAChB;AACA;AACA,IAAI,6BAAS,CAAC,IAAI,EAAE,EAAE,EAAE;AACxB,MAAM,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,IAAE,OAAO,IAAI,GAAC;AAC/D;AACA,MAAM,IAAI;AACV,QAAQA,IAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACxC,QAAQ,OAAO;AACf,UAAU,IAAI,EAAEE,qBAAS,CAAC,MAAM,EAAE;AAClC,YAAY,WAAW,EAAE,OAAO,CAAC,WAAW;AAC5C,YAAY,OAAO,EAAE,OAAO,CAAC,OAAO;AACpC,YAAY,YAAY,EAAE,OAAO,CAAC,YAAY;AAC9C,oBAAY,MAAM;AAClB,WAAW,CAAC;AACZ,UAAU,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;AAC/B,SAAS,CAAC;AACV,OAAO,CAAC,OAAO,GAAG,EAAE;AACpB,QAAQF,IAAM,OAAO,GAAG,2BAA2B,CAAC;AACpD,QAAQA,IAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACnE,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAE,OAAO,MAAE,EAAE,YAAE,QAAQ,EAAE,CAAC,CAAC;AAC7C,QAAQ,OAAO,IAAI,CAAC;AACpB,OAAO;AACP,KAAK;AACL,GAAG,CAAC;AACJ;;;;"}

vendor/spatie/ignition/node_modules/@rollup/plugin-json/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/plugin-json/types/index.d.ts

@@ -0,0 +1,41 @@
+import { FilterPattern } from '@rollup/pluginutils';
+import { Plugin } from 'rollup';
+
+export interface RollupJsonOptions {
+  /**
+   * All JSON files will be parsed by default,
+   * but you can also specifically include files
+   */
+  include?: FilterPattern;
+  /**
+   * All JSON files will be parsed by default,
+   * but you can also specifically exclude files
+   */
+  exclude?: FilterPattern;
+  /**
+   * For tree-shaking, properties will be declared as variables, using
+   * either `var` or `const`.
+   * @default false
+   */
+  preferConst?: boolean;
+  /**
+   * Specify indentation for the generated default export
+   * @default '\t'
+   */
+  indent?: string;
+  /**
+   * Ignores indent and generates the smallest code
+   * @default false
+   */
+  compact?: boolean;
+  /**
+   * Generate a named export for every property of the JSON object
+   * @default true
+   */
+  namedExports?: boolean;
+}
+
+/**
+ * Convert .json files to ES6 modules
+ */
+export default function json(options?: RollupJsonOptions): Plugin;

vendor/spatie/ignition/node_modules/@rollup/plugin-node-resolve/CHANGELOG.md

@@ -0,0 +1,414 @@
+# @rollup/plugin-node-resolve ChangeLog
+
+## v11.2.1
+
+_2021-03-26_
+
+### Bugfixes
+
+- fix: fs.exists is incorrectly promisified (#835)
+
+## v11.2.0
+
+_2021-02-14_
+
+### Features
+
+- feat: add `ignoreSideEffectsForRoot` option (#694)
+
+### Updates
+
+- chore: mark `url` as an external and throw on warning (#783)
+- docs: clearer "Resolving Built-Ins" doc (#782)
+
+## v11.1.1
+
+_2021-01-29_
+
+### Bugfixes
+
+- fix: only log last resolve error (#750)
+
+### Updates
+
+- docs: add clarification on the order of package entrypoints (#768)
+
+## v11.1.0
+
+_2021-01-15_
+
+### Features
+
+- feat: support pkg imports and export array (#693)
+
+## v11.0.1
+
+_2020-12-14_
+
+### Bugfixes
+
+- fix: export map specificity (#675)
+- fix: add missing type import (#668)
+
+### Updates
+
+- docs: corrected word "yse" to "use" (#723)
+
+## v11.0.0
+
+_2020-11-30_
+
+### Breaking Changes
+
+- refactor!: simplify builtins and remove `customResolveOptions` (#656)
+- feat!: Mark built-ins as external (#627)
+- feat!: support package entry points (#540)
+
+### Bugfixes
+
+- fix: refactor handling builtins, do not log warning if no local version (#637)
+
+### Updates
+
+- docs: fix import statements in examples in README.md (#646)
+
+## v10.0.0
+
+_2020-10-27_
+
+### Breaking Changes
+
+- fix!: resolve hash in path (#588)
+
+### Bugfixes
+
+- fix: do not ignore exceptions (#564)
+
+## v9.0.0
+
+_2020-08-13_
+
+### Breaking Changes
+
+- chore: update dependencies (e632469)
+
+### Updates
+
+- refactor: remove deep-freeze from dependencies (#529)
+- chore: clean up changelog (84dfddb)
+
+## v8.4.0
+
+_2020-07-12_
+
+### Features
+
+- feat: preserve search params and hashes (#487)
+- feat: support .js imports in TypeScript (#480)
+
+### Updates
+
+- docs: fix named export use in readme (#456)
+- docs: correct mainFields valid values (#469)
+
+## v8.1.0
+
+_2020-06-22_
+
+### Features
+
+- feat: add native node es modules support (#413)
+
+## v8.0.1
+
+_2020-06-05_
+
+### Bugfixes
+
+- fix: handle nested entry modules with the resolveOnly option (#430)
+
+## v8.0.0
+
+_2020-05-20_
+
+### Breaking Changes
+
+- feat: Add default export (#361)
+- feat: export defaults (#301)
+
+### Bugfixes
+
+- fix: resolve local files if `resolveOption` is set (#337)
+
+### Updates
+
+- docs: correct misspelling (#343)
+
+## v7.1.3
+
+_2020-04-12_
+
+### Bugfixes
+
+- fix: resolve symlinked entry point properly (#291)
+
+## v7.1.2
+
+_2020-04-12_
+
+### Updates
+
+- docs: fix url (#289)
+
+## v7.1.1
+
+_2020-02-03_
+
+### Bugfixes
+
+- fix: main fields regression (#196)
+
+## v7.1.0
+
+_2020-02-01_
+
+### Updates
+
+- refactor: clean codebase and fix external warnings (#155)
+
+## v7.0.0
+
+_2020-01-07_
+
+### Breaking Changes
+
+- feat: dedupe by package name (#99)
+
+## v6.1.0
+
+_2020-01-04_
+
+### Bugfixes
+
+- fix: allow deduplicating custom module dirs (#101)
+
+### Features
+
+- feat: add rootDir option (#98)
+
+### Updates
+
+- docs: improve doc related to mainFields (#138)
+
+## 6.0.0
+
+_2019-11-25_
+
+- **Breaking:** Minimum compatible Rollup version is 1.20.0
+- **Breaking:** Minimum supported Node version is 8.0.0
+- Published as @rollup/plugin-node-resolve
+
+## 5.2.1 (unreleased)
+
+- add missing MIT license file ([#233](https://github.com/rollup/rollup-plugin-node-resolve/pull/233) by @kenjiO)
+- Fix incorrect example of config ([#239](https://github.com/rollup/rollup-plugin-node-resolve/pull/240) by @myshov)
+- Fix typo in readme ([#240](https://github.com/rollup/rollup-plugin-node-resolve/pull/240) by @LinusU)
+
+## 5.2.0 (2019-06-29)
+
+- dedupe accepts a function ([#225](https://github.com/rollup/rollup-plugin-node-resolve/pull/225) by @manucorporat)
+
+## 5.1.1 (2019-06-29)
+
+- Move Rollup version check to buildStart hook to avoid issues ([#232](https://github.com/rollup/rollup-plugin-node-resolve/pull/232) by @lukastaegert)
+
+## 5.1.0 (2019-06-22)
+
+- Fix path fragment inputs ([#229](https://github.com/rollup/rollup-plugin-node-resolve/pull/229) by @bterlson)
+
+## 5.0.4 (2019-06-22)
+
+- Treat sideEffects array as inclusion list ([#227](https://github.com/rollup/rollup-plugin-node-resolve/pull/227) by @mikeharder)
+
+## 5.0.3 (2019-06-16)
+
+- Make empty.js a virtual module ([#224](https://github.com/rollup/rollup-plugin-node-resolve/pull/224) by @manucorporat)
+
+## 5.0.2 (2019-06-13)
+
+- Support resolve 1.11.1, add built-in test ([#223](https://github.com/rollup/rollup-plugin-node-resolve/pull/223) by @bterlson)
+
+## 5.0.1 (2019-05-31)
+
+- Update to resolve@1.11.0 for better performance ([#220](https://github.com/rollup/rollup-plugin-node-resolve/pull/220) by @keithamus)
+
+## 5.0.0 (2019-05-15)
+
+- Replace bublé with babel, update dependencies ([#216](https://github.com/rollup/rollup-plugin-node-resolve/pull/216) by @mecurc)
+- Handle module side-effects ([#219](https://github.com/rollup/rollup-plugin-node-resolve/pull/219) by @lukastaegert)
+
+### Breaking Changes
+
+- Requires at least rollup@1.11.0 to work (v1.12.0 for module side-effects to be respected)
+- If used with rollup-plugin-commonjs, it should be at least v10.0.0
+
+## 4.2.4 (2019-05-11)
+
+- Add note on builtins to Readme ([#215](https://github.com/rollup/rollup-plugin-node-resolve/pull/215) by @keithamus)
+- Add issue templates ([#217](https://github.com/rollup/rollup-plugin-node-resolve/pull/217) by @mecurc)
+- Improve performance by caching `isDir` ([#218](https://github.com/rollup/rollup-plugin-node-resolve/pull/218) by @keithamus)
+
+## 4.2.3 (2019-04-11)
+
+- Fix ordering of jsnext:main when using the jsnext option ([#209](https://github.com/rollup/rollup-plugin-node-resolve/pull/209) by @lukastaegert)
+
+## 4.2.2 (2019-04-10)
+
+- Fix TypeScript typings (rename and export Options interface) ([#206](https://github.com/rollup/rollup-plugin-node-resolve/pull/206) by @Kocal)
+- Fix mainfields typing ([#207](https://github.com/rollup/rollup-plugin-node-resolve/pull/207) by @nicolashenry)
+
+## 4.2.1 (2019-04-06)
+
+- Respect setting the deprecated fields "module", "main", and "jsnext" ([#204](https://github.com/rollup/rollup-plugin-node-resolve/pull/204) by @nick-woodward)
+
+## 4.2.0 (2019-04-06)
+
+- Add new mainfields option ([#182](https://github.com/rollup/rollup-plugin-node-resolve/pull/182) by @keithamus)
+- Added dedupe option to prevent bundling the same package multiple times ([#201](https://github.com/rollup/rollup-plugin-node-resolve/pull/182) by @sormy)
+
+## 4.1.0 (2019-04-05)
+
+- Add TypeScript typings ([#189](https://github.com/rollup/rollup-plugin-node-resolve/pull/189) by @NotWoods)
+- Update dependencies ([#202](https://github.com/rollup/rollup-plugin-node-resolve/pull/202) by @lukastaegert)
+
+## 4.0.1 (2019-02-22)
+
+- Fix issue when external modules are specified in `package.browser` ([#143](https://github.com/rollup/rollup-plugin-node-resolve/pull/143) by @keithamus)
+- Fix `package.browser` mapping issue when `false` is specified ([#183](https://github.com/rollup/rollup-plugin-node-resolve/pull/183) by @allex)
+
+## 4.0.0 (2018-12-09)
+
+This release will support rollup@1.0
+
+### Features
+
+- Resolve modules used to define manual chunks ([#185](https://github.com/rollup/rollup-plugin-node-resolve/pull/185) by @mcshaman)
+- Update dependencies and plugin hook usage ([#187](https://github.com/rollup/rollup-plugin-node-resolve/pull/187) by @lukastaegert)
+
+## 3.4.0 (2018-09-04)
+
+This release now supports `.mjs` files by default
+
+### Features
+
+- feat: Support .mjs files by default (https://github.com/rollup/rollup-plugin-node-resolve/pull/151, by @leebyron)
+
+## 3.3.0 (2018-03-17)
+
+This release adds the `only` option
+
+### New Features
+
+- feat: add `only` option (#83; @arantes555)
+
+### Docs
+
+- docs: correct description of `jail` option (#120; @GeorgeTaveras1231)
+
+## 3.2.0 (2018-03-07)
+
+This release caches reading/statting of files, to improve speed.
+
+### Performance Improvements
+
+- perf: cache file stats/reads (#126; @keithamus)
+
+## 3.0.4 (unreleased)
+
+- Update lockfile [#137](https://github.com/rollup/rollup-plugin-node-resolve/issues/137)
+- Update rollup dependency [#138](https://github.com/rollup/rollup-plugin-node-resolve/issues/138)
+- Enable installation from Github [#142](https://github.com/rollup/rollup-plugin-node-resolve/issues/142)
+
+## 3.0.3
+
+- Fix [#130](https://github.com/rollup/rollup-plugin-node-resolve/issues/130) and [#131](https://github.com/rollup/rollup-plugin-node-resolve/issues/131)
+
+## 3.0.2
+
+- Ensure `pkg.browser` is an object if necessary ([#129](https://github.com/rollup/rollup-plugin-node-resolve/pull/129))
+
+## 3.0.1
+
+- Remove `browser-resolve` dependency ([#127](https://github.com/rollup/rollup-plugin-node-resolve/pull/127))
+
+## 3.0.0
+
+- [BREAKING] Remove `options.skip` ([#90](https://github.com/rollup/rollup-plugin-node-resolve/pull/90))
+- Add `modulesOnly` option ([#96](https://github.com/rollup/rollup-plugin-node-resolve/pull/96))
+
+## 2.1.1
+
+- Prevent `jail` from breaking builds on Windows ([#93](https://github.com/rollup/rollup-plugin-node-resolve/issues/93))
+
+## 2.1.0
+
+- Add `jail` option ([#53](https://github.com/rollup/rollup-plugin-node-resolve/pull/53))
+- Add `customResolveOptions` option ([#79](https://github.com/rollup/rollup-plugin-node-resolve/pull/79))
+- Support symlinked packages ([#82](https://github.com/rollup/rollup-plugin-node-resolve/pull/82))
+
+## 2.0.0
+
+- Add support `module` field in package.json as an official alternative to jsnext
+
+## 1.7.3
+
+- Error messages are more descriptive ([#50](https://github.com/rollup/rollup-plugin-node-resolve/issues/50))
+
+## 1.7.2
+
+- Allow entry point paths beginning with ./
+
+## 1.7.1
+
+- Return a `name`
+
+## 1.7.0
+
+- Allow relative IDs to be external ([#32](https://github.com/rollup/rollup-plugin-node-resolve/pull/32))
+
+## 1.6.0
+
+- Skip IDs containing null character
+
+## 1.5.0
+
+- Prefer built-in options, but allow opting out ([#28](https://github.com/rollup/rollup-plugin-node-resolve/pull/28))
+
+## 1.4.0
+
+- Pass `options.extensions` through to `node-resolve`
+
+## 1.3.0
+
+- `skip: true` skips all packages that don't satisfy the `main` or `jsnext` options ([#16](https://github.com/rollup/rollup-plugin-node-resolve/pull/16))
+
+## 1.2.1
+
+- Support scoped packages in `skip` option ([#15](https://github.com/rollup/rollup-plugin-node-resolve/issues/15))
+
+## 1.2.0
+
+- Support `browser` field ([#8](https://github.com/rollup/rollup-plugin-node-resolve/issues/8))
+- Get tests to pass on Windows
+
+## 1.1.0
+
+- Use node-resolve to handle various corner cases
+
+## 1.0.0
+
+- Add ES6 build, use Rollup 0.20.0
+
+## 0.1.0
+
+- First release

vendor/spatie/ignition/node_modules/@rollup/plugin-node-resolve/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/plugin-node-resolve/README.md

@@ -0,0 +1,227 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-node-resolve
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-node-resolve
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-node-resolve
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-node-resolve
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-node-resolve
+
+🍣 A Rollup plugin which locates modules using the [Node resolution algorithm](https://nodejs.org/api/modules.html#modules_all_together), for using third party modules in `node_modules`
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/plugin-node-resolve --save-dev
+```
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+
+export default {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [nodeResolve()]
+};
+```
+
+Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api).
+
+## Package entrypoints
+
+This plugin supports the package entrypoints feature from node js, specified in the `exports` or `imports` field of a package. Check the [official documentation](https://nodejs.org/api/packages.html#packages_package_entry_points) for more information on how this works. This is the default behavior. In the abscence of these fields, the fields in `mainFields` will be the ones to be used.
+
+## Options
+
+### `exportConditions`
+
+Type: `Array[...String]`<br>
+Default: `[]`
+
+Additional conditions of the package.json exports field to match when resolving modules. By default, this plugin looks for the `['default', 'module', 'import']` conditions when resolving imports.
+
+When using `@rollup/plugin-commonjs` v16 or higher, this plugin will use the `['default', 'module', 'require']` conditions when resolving require statements.
+
+Setting this option will add extra conditions on top of the default conditions. See https://nodejs.org/api/packages.html#packages_conditional_exports for more information.
+
+### `browser`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, instructs the plugin to use the `"browser"` property in `package.json` files to specify alternative files to load for bundling. This is useful when bundling for a browser environment. Alternatively, a value of `'browser'` can be added to the `mainFields` option. If `false`, any `"browser"` properties in package files will be ignored. This option takes precedence over `mainFields`.
+
+> This option does not work when a package is using [package entrypoints](https://nodejs.org/api/packages.html#packages_package_entry_points)
+
+### `moduleDirectories`
+
+Type: `Array[...String]`<br>
+Default: `['node_modules']`
+
+One or more directories in which to recursively look for modules.
+
+### `dedupe`
+
+Type: `Array[...String]`<br>
+Default: `[]`
+
+An `Array` of modules names, which instructs the plugin to force resolving for the specified modules to the root `node_modules`. Helps to prevent bundling the same package multiple times if package is imported from dependencies.
+
+```js
+dedupe: ['my-package', '@namespace/my-package'];
+```
+
+This will deduplicate bare imports such as:
+
+```js
+import 'my-package';
+import '@namespace/my-package';
+```
+
+And it will deduplicate deep imports such as:
+
+```js
+import 'my-package/foo.js';
+import '@namespace/my-package/bar.js';
+```
+
+### `extensions`
+
+Type: `Array[...String]`<br>
+Default: `['.mjs', '.js', '.json', '.node']`
+
+Specifies the extensions of files that the plugin will operate on.
+
+### `jail`
+
+Type: `String`<br>
+Default: `'/'`
+
+Locks the module search within specified path (e.g. chroot). Modules defined outside this path will be ignored by this plugin.
+
+### `mainFields`
+
+Type: `Array[...String]`<br>
+Default: `['module', 'main']`<br>
+Valid values: `['browser', 'jsnext:main', 'module', 'main']`
+
+Specifies the properties to scan within a `package.json`, used to determine the bundle entry point. The order of property names is significant, as the first-found property is used as the resolved entry point. If the array contains `'browser'`, key/values specified in the `package.json` `browser` property will be used.
+
+### `preferBuiltins`
+
+Type: `Boolean`<br>
+Default: `true` (with warnings if a builtin module is used over a local version. Set to `true` to disable warning.)
+
+If `true`, the plugin will prefer built-in modules (e.g. `fs`, `path`). If `false`, the plugin will look for locally installed modules of the same name.
+
+### `modulesOnly`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, inspect resolved files to assert that they are ES2015 modules.
+
+### `resolveOnly`
+
+Type: `Array[...String|RegExp]`<br>
+Default: `null`
+
+An `Array` which instructs the plugin to limit module resolution to those whose names match patterns in the array. _Note: Modules not matching any patterns will be marked as external._
+
+Example: `resolveOnly: ['batman', /^@batcave\/.*$/]`
+
+### `rootDir`
+
+Type: `String`<br>
+Default: `process.cwd()`
+
+Specifies the root directory from which to resolve modules. Typically used when resolving entry-point imports, and when resolving deduplicated modules. Useful when executing rollup in a package of a mono-repository.
+
+```
+// Set the root directory to be the parent folder
+rootDir: path.join(process.cwd(), '..')
+```
+
+## `ignoreSideEffectsForRoot`
+
+If you use the `sideEffects` property in the package.json, by default this is respected for files in the root package. Set to `true` to ignore the `sideEffects` configuration for the root package.
+
+## Preserving symlinks
+
+This plugin honours the rollup [`preserveSymlinks`](https://rollupjs.org/guide/en/#preservesymlinks) option.
+
+## Using with @rollup/plugin-commonjs
+
+Since most packages in your node_modules folder are probably legacy CommonJS rather than JavaScript modules, you may need to use [@rollup/plugin-commonjs](https://github.com/rollup/plugins/tree/master/packages/commonjs):
+
+```js
+// rollup.config.js
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+
+export default {
+  input: 'main.js',
+  output: {
+    file: 'bundle.js',
+    format: 'iife',
+    name: 'MyModule'
+  },
+  plugins: [nodeResolve(), commonjs()]
+};
+```
+
+## Resolving Built-Ins (like `fs`)
+
+By default this plugin will prefer built-ins over local modules, marking them as external.
+
+See [`preferBuiltins`](#preferbuiltins).
+
+To provide stubbed versions of Node built-ins, use a plugin like [rollup-plugin-node-polyfills](https://github.com/ionic-team/rollup-plugin-node-polyfills) and set `preferBuiltins` to `false`. e.g.
+
+```js
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import nodePolyfills from 'rollup-plugin-node-polyfills';
+export default ({
+  input: ...,
+  plugins: [
+    nodePolyfills(),
+    nodeResolve({ preferBuiltins: false })
+  ],
+  external: builtins,
+  output: ...
+})
+```
+
+## Resolving require statements
+
+According to [NodeJS module resolution](https://nodejs.org/api/packages.html#packages_package_entry_points) `require` statements should resolve using the `require` condition in the package exports field, while es modules should use the `import` condition.
+
+The node resolve plugin uses `import` by default, you can opt into using the `require` semantics by passing an extra option to the resolve function:
+
+```js
+this.resolve(importee, importer, {
+  skipSelf: true,
+  custom: { 'node-resolve': { isRequire: true } }
+});
+```
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/plugin-node-resolve/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/plugin-node-resolve/types/index.d.ts

@@ -0,0 +1,98 @@
+import { Plugin } from 'rollup';
+
+export const DEFAULTS: {
+  customResolveOptions: {};
+  dedupe: [];
+  extensions: ['.mjs', '.js', '.json', '.node'];
+  resolveOnly: [];
+};
+
+export interface RollupNodeResolveOptions {
+  /**
+   * Additional conditions of the package.json exports field to match when resolving modules.
+   * By default, this plugin looks for the `'default', 'module', 'import']` conditions when resolving imports.
+   *
+   * When using `@rollup/plugin-commonjs` v16 or higher, this plugin will use the
+   * `['default', 'module', 'import']` conditions when resolving require statements.
+   *
+   * Setting this option will add extra conditions on top of the default conditions.
+   * See https://nodejs.org/api/packages.html#packages_conditional_exports for more information.
+   */
+  exportConditions?: string[];
+
+  /**
+   * If `true`, instructs the plugin to use the `"browser"` property in `package.json`
+   * files to specify alternative files to load for bundling. This is useful when
+   * bundling for a browser environment. Alternatively, a value of `'browser'` can be
+   * added to the `mainFields` option. If `false`, any `"browser"` properties in
+   * package files will be ignored. This option takes precedence over `mainFields`.
+   * @default false
+   */
+  browser?: boolean;
+
+  /**
+   * One or more directories in which to recursively look for modules.
+   * @default ['node_modules']
+   */
+  moduleDirectories?: string[];
+
+  /**
+   * An `Array` of modules names, which instructs the plugin to force resolving for the
+   * specified modules to the root `node_modules`. Helps to prevent bundling the same
+   * package multiple times if package is imported from dependencies.
+   */
+  dedupe?: string[] | ((importee: string) => boolean);
+
+  /**
+   * Specifies the extensions of files that the plugin will operate on.
+   * @default [ '.mjs', '.js', '.json', '.node' ]
+   */
+  extensions?: readonly string[];
+
+  /**
+   * Locks the module search within specified path (e.g. chroot). Modules defined
+   * outside this path will be marked as external.
+   * @default '/'
+   */
+  jail?: string;
+
+  /**
+   * Specifies the properties to scan within a `package.json`, used to determine the
+   * bundle entry point.
+   * @default ['module', 'main']
+   */
+  mainFields?: readonly string[];
+
+  /**
+   * If `true`, inspect resolved files to assert that they are ES2015 modules.
+   * @default false
+   */
+  modulesOnly?: boolean;
+
+  /**
+   * If `true`, the plugin will prefer built-in modules (e.g. `fs`, `path`). If `false`,
+   * the plugin will look for locally installed modules of the same name.
+   * @default true
+   */
+  preferBuiltins?: boolean;
+
+  /**
+   * An `Array` which instructs the plugin to limit module resolution to those whose
+   * names match patterns in the array.
+   * @default []
+   */
+  resolveOnly?: ReadonlyArray<string | RegExp> | null;
+
+  /**
+   * Specifies the root directory from which to resolve modules. Typically used when
+   * resolving entry-point imports, and when resolving deduplicated modules.
+   * @default process.cwd()
+   */
+  rootDir?: string;
+}
+
+/**
+ * Locate modules using the Node resolution algorithm, for using third party modules in node_modules
+ */
+export function nodeResolve(options?: RollupNodeResolveOptions): Plugin;
+export default nodeResolve;

vendor/spatie/ignition/node_modules/@rollup/pluginutils/CHANGELOG.md

@@ -0,0 +1,315 @@
+# @rollup/pluginutils ChangeLog
+
+## v3.1.0
+
+_2020-06-05_
+
+### Bugfixes
+
+- fix: resolve relative paths starting with "./" (#180)
+
+### Features
+
+- feat: add native node es modules support (#419)
+
+### Updates
+
+- refactor: replace micromatch with picomatch. (#306)
+- chore: Don't bundle micromatch (#220)
+- chore: add missing typescript devDep (238b140)
+- chore: Use readonly arrays, add TSDoc (#187)
+- chore: Use typechecking (2ae08eb)
+
+## v3.0.10
+
+_2020-05-02_
+
+### Bugfixes
+
+- fix: resolve relative paths starting with "./" (#180)
+
+### Updates
+
+- refactor: replace micromatch with picomatch. (#306)
+- chore: Don't bundle micromatch (#220)
+- chore: add missing typescript devDep (238b140)
+- chore: Use readonly arrays, add TSDoc (#187)
+- chore: Use typechecking (2ae08eb)
+
+## v3.0.9
+
+_2020-04-12_
+
+### Updates
+
+- chore: support Rollup v2
+
+## v3.0.8
+
+_2020-02-01_
+
+### Bugfixes
+
+- fix: resolve relative paths starting with "./" (#180)
+
+### Updates
+
+- chore: add missing typescript devDep (238b140)
+- chore: Use readonly arrays, add TSDoc (#187)
+- chore: Use typechecking (2ae08eb)
+
+## v3.0.7
+
+_2020-02-01_
+
+### Bugfixes
+
+- fix: resolve relative paths starting with "./" (#180)
+
+### Updates
+
+- chore: Use readonly arrays, add TSDoc (#187)
+- chore: Use typechecking (2ae08eb)
+
+## v3.0.6
+
+_2020-01-27_
+
+### Bugfixes
+
+- fix: resolve relative paths starting with "./" (#180)
+
+## v3.0.5
+
+_2020-01-25_
+
+### Bugfixes
+
+- fix: bring back named exports (#176)
+
+## v3.0.4
+
+_2020-01-10_
+
+### Bugfixes
+
+- fix: keep for(const..) out of scope (#151)
+
+## v3.0.3
+
+_2020-01-07_
+
+### Bugfixes
+
+- fix: createFilter Windows regression (#141)
+
+### Updates
+
+- test: fix windows path failure (0a0de65)
+- chore: fix test script (5eae320)
+
+## v3.0.2
+
+_2020-01-04_
+
+### Bugfixes
+
+- fix: makeLegalIdentifier - potentially unsafe input for blacklisted identifier (#116)
+
+### Updates
+
+- docs: Fix documented type of createFilter's include/exclude (#123)
+- chore: update minor linting correction (bcbf9d2)
+
+## 3.0.1
+
+- fix: Escape glob characters in folder (#84)
+
+## 3.0.0
+
+_2019-11-25_
+
+- **Breaking:** Minimum compatible Rollup version is 1.20.0
+- **Breaking:** Minimum supported Node version is 8.0.0
+- Published as @rollup/plugins-image
+
+## 2.8.2
+
+_2019-09-13_
+
+- Handle optional catch parameter in attachScopes ([#70](https://github.com/rollup/rollup-pluginutils/pulls/70))
+
+## 2.8.1
+
+_2019-06-04_
+
+- Support serialization of many edge cases ([#64](https://github.com/rollup/rollup-pluginutils/issues/64))
+
+## 2.8.0
+
+_2019-05-30_
+
+- Bundle updated micromatch dependency ([#60](https://github.com/rollup/rollup-pluginutils/issues/60))
+
+## 2.7.1
+
+_2019-05-17_
+
+- Do not ignore files with a leading "." in createFilter ([#62](https://github.com/rollup/rollup-pluginutils/issues/62))
+
+## 2.7.0
+
+_2019-05-15_
+
+- Add `resolve` option to createFilter ([#59](https://github.com/rollup/rollup-pluginutils/issues/59))
+
+## 2.6.0
+
+_2019-04-04_
+
+- Add `extractAssignedNames` ([#59](https://github.com/rollup/rollup-pluginutils/issues/59))
+- Provide dedicated TypeScript typings file ([#58](https://github.com/rollup/rollup-pluginutils/issues/58))
+
+## 2.5.0
+
+_2019-03-18_
+
+- Generalize dataToEsm type ([#55](https://github.com/rollup/rollup-pluginutils/issues/55))
+- Handle empty keys in dataToEsm ([#56](https://github.com/rollup/rollup-pluginutils/issues/56))
+
+## 2.4.1
+
+_2019-02-16_
+
+- Remove unnecessary dependency
+
+## 2.4.0
+
+_2019-02-16_
+Update dependencies to solve micromatch vulnerability ([#53](https://github.com/rollup/rollup-pluginutils/issues/53))
+
+## 2.3.3
+
+_2018-09-19_
+
+- Revert micromatch update ([#43](https://github.com/rollup/rollup-pluginutils/issues/43))
+
+## 2.3.2
+
+_2018-09-18_
+
+- Bumb micromatch dependency ([#36](https://github.com/rollup/rollup-pluginutils/issues/36))
+- Bumb dependencies ([#41](https://github.com/rollup/rollup-pluginutils/issues/41))
+- Split up tests ([#40](https://github.com/rollup/rollup-pluginutils/issues/40))
+
+## 2.3.1
+
+_2018-08-06_
+
+- Fixed ObjectPattern scope in attachScopes to recognise { ...rest } syntax ([#37](https://github.com/rollup/rollup-pluginutils/issues/37))
+
+## 2.3.0
+
+_2018-05-21_
+
+- Add option to not generate named exports ([#32](https://github.com/rollup/rollup-pluginutils/issues/32))
+
+## 2.2.1
+
+_2018-05-21_
+
+- Support `null` serialization ([#34](https://github.com/rollup/rollup-pluginutils/issues/34))
+
+## 2.2.0
+
+_2018-05-11_
+
+- Improve white-space handling in `dataToEsm` and add `prepare` script ([#31](https://github.com/rollup/rollup-pluginutils/issues/31))
+
+## 2.1.1
+
+_2018-05-09_
+
+- Update dependencies
+
+## 2.1.0
+
+_2018-05-08_
+
+- Add `dataToEsm` helper to create named exports from objects ([#29](https://github.com/rollup/rollup-pluginutils/issues/29))
+- Support literal keys in object patterns ([#27](https://github.com/rollup/rollup-pluginutils/issues/27))
+- Support function declarations without id in `attachScopes` ([#28](https://github.com/rollup/rollup-pluginutils/issues/28))
+
+## 2.0.1
+
+_2017-01-03_
+
+- Don't add extension to file with trailing dot ([#14](https://github.com/rollup/rollup-pluginutils/issues/14))
+
+## 2.0.0
+
+_2017-01-03_
+
+- Use `micromatch` instead of `minimatch` ([#19](https://github.com/rollup/rollup-pluginutils/issues/19))
+- Allow `createFilter` to take regexes ([#5](https://github.com/rollup/rollup-pluginutils/issues/5))
+
+## 1.5.2
+
+_2016-08-29_
+
+- Treat `arguments` as a reserved word ([#10](https://github.com/rollup/rollup-pluginutils/issues/10))
+
+## 1.5.1
+
+_2016-06-24_
+
+- Add all declarators in a var declaration to scope, not just the first
+
+## 1.5.0
+
+_2016-06-07_
+
+- Exclude IDs with null character (`\0`)
+
+## 1.4.0
+
+_2016-06-07_
+
+- Workaround minimatch issue ([#6](https://github.com/rollup/rollup-pluginutils/pull/6))
+- Exclude non-string IDs in `createFilter`
+
+## 1.3.1
+
+_2015-12-16_
+
+- Build with Rollup directly, rather than via Gobble
+
+## 1.3.0
+
+_2015-12-16_
+
+- Use correct path separator on Windows
+
+## 1.2.0
+
+_2015-11-02_
+
+- Add `attachScopes` and `makeLegalIdentifier`
+
+## 1.1.0
+
+2015-10-24\*
+
+- Add `addExtension` function
+
+## 1.0.1
+
+_2015-10-24_
+
+- Include dist files in package
+
+## 1.0.0
+
+_2015-10-24_
+
+- First release

vendor/spatie/ignition/node_modules/@rollup/pluginutils/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+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/@rollup/pluginutils/README.md

@@ -0,0 +1,237 @@
+[npm]: https://img.shields.io/npm/v/@rollup/pluginutils
+[npm-url]: https://www.npmjs.com/package/@rollup/pluginutils
+[size]: https://packagephobia.now.sh/badge?p=@rollup/pluginutils
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/pluginutils
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/pluginutils
+
+A set of utility functions commonly used by 🍣 Rollup plugins.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/pluginutils --save-dev
+```
+
+## Usage
+
+```js
+import utils from '@rollup/pluginutils';
+//...
+```
+
+## API
+
+Available utility functions are listed below:
+
+_Note: Parameter names immediately followed by a `?` indicate that the parameter is optional._
+
+### addExtension
+
+Adds an extension to a module ID if one does not exist.
+
+Parameters: `(filename: String, ext?: String)`<br>
+Returns: `String`
+
+```js
+import { addExtension } from '@rollup/pluginutils';
+
+export default function myPlugin(options = {}) {
+  return {
+    resolveId(code, id) {
+      // only adds an extension if there isn't one already
+      id = addExtension(id); // `foo` -> `foo.js`, `foo.js -> foo.js`
+      id = addExtension(id, '.myext'); // `foo` -> `foo.myext`, `foo.js -> `foo.js`
+    }
+  };
+}
+```
+
+### attachScopes
+
+Attaches `Scope` objects to the relevant nodes of an AST. Each `Scope` object has a `scope.contains(name)` method that returns `true` if a given name is defined in the current scope or a parent scope.
+
+Parameters: `(ast: Node, propertyName?: String)`<br>
+Returns: `Object`
+
+See [rollup-plugin-inject](https://github.com/rollup/rollup-plugin-inject) or [rollup-plugin-commonjs](https://github.com/rollup/rollup-plugin-commonjs) for an example of usage.
+
+```js
+import { attachScopes } from '@rollup/pluginutils';
+import { walk } from 'estree-walker';
+
+export default function myPlugin(options = {}) {
+  return {
+    transform(code) {
+      const ast = this.parse(code);
+
+      let scope = attachScopes(ast, 'scope');
+
+      walk(ast, {
+        enter(node) {
+          if (node.scope) scope = node.scope;
+
+          if (!scope.contains('foo')) {
+            // `foo` is not defined, so if we encounter it,
+            // we assume it's a global
+          }
+        },
+        leave(node) {
+          if (node.scope) scope = scope.parent;
+        }
+      });
+    }
+  };
+}
+```
+
+### createFilter
+
+Constructs a filter function which can be used to determine whether or not certain modules should be operated upon.
+
+Parameters: `(include?: <minmatch>, exclude?: <minmatch>, options?: Object)`<br>
+Returns: `String`
+
+#### `include` and `exclude`
+
+Type: `String | RegExp | Array[...String|RegExp]`<br>
+
+A valid [`minimatch`](https://www.npmjs.com/package/minimatch) pattern, or array of patterns. If `options.include` is omitted or has zero length, filter will return `true` by default. Otherwise, an ID must match one or more of the `minimatch` patterns, and must not match any of the `options.exclude` patterns.
+
+#### `options`
+
+##### `resolve`
+
+Type: `String | Boolean | null`
+
+Optionally resolves the patterns against a directory other than `process.cwd()`. If a `String` is specified, then the value will be used as the base directory. Relative paths will be resolved against `process.cwd()` first. If `false`, then the patterns will not be resolved against any directory. This can be useful if you want to create a filter for virtual module names.
+
+#### Usage
+
+```js
+import { createFilter } from '@rollup/pluginutils';
+
+export default function myPlugin(options = {}) {
+  // assume that the myPlugin accepts options of `options.include` and `options.exclude`
+  var filter = createFilter(options.include, options.exclude, {
+    resolve: '/my/base/dir'
+  });
+
+  return {
+    transform(code, id) {
+      if (!filter(id)) return;
+
+      // proceed with the transformation...
+    }
+  };
+}
+```
+
+### dataToEsm
+
+Transforms objects into tree-shakable ES Module imports.
+
+Parameters: `(data: Object)`<br>
+Returns: `String`
+
+#### `data`
+
+Type: `Object`
+
+An object to transform into an ES module.
+
+#### Usage
+
+```js
+import { dataToEsm } from '@rollup/pluginutils';
+
+const esModuleSource = dataToEsm(
+  {
+    custom: 'data',
+    to: ['treeshake']
+  },
+  {
+    compact: false,
+    indent: '\t',
+    preferConst: false,
+    objectShorthand: false,
+    namedExports: true
+  }
+);
+/*
+Outputs the string ES module source:
+  export const custom = 'data';
+  export const to = ['treeshake'];
+  export default { custom, to };
+*/
+```
+
+### extractAssignedNames
+
+Extracts the names of all assignment targets based upon specified patterns.
+
+Parameters: `(param: Node)`<br>
+Returns: `Array[...String]`
+
+#### `param`
+
+Type: `Node`
+
+An `acorn` AST Node.
+
+#### Usage
+
+```js
+import { extractAssignedNames } from '@rollup/pluginutils';
+import { walk } from 'estree-walker';
+
+export default function myPlugin(options = {}) {
+  return {
+    transform(code) {
+      const ast = this.parse(code);
+
+      walk(ast, {
+        enter(node) {
+          if (node.type === 'VariableDeclarator') {
+            const declaredNames = extractAssignedNames(node.id);
+            // do something with the declared names
+            // e.g. for `const {x, y: z} = ... => declaredNames = ['x', 'z']
+          }
+        }
+      });
+    }
+  };
+}
+```
+
+### makeLegalIdentifier
+
+Constructs a bundle-safe identifier from a `String`.
+
+Parameters: `(str: String)`<br>
+Returns: `String`
+
+#### Usage
+
+```js
+import { makeLegalIdentifier } from '@rollup/pluginutils';
+
+makeLegalIdentifier('foo-bar'); // 'foo_bar'
+makeLegalIdentifier('typeof'); // '_typeof'
+```
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

vendor/spatie/ignition/node_modules/@rollup/pluginutils/dist/cjs/index.js

@@ -0,0 +1,447 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var path = require('path');
+var pm = _interopDefault(require('picomatch'));
+
+const addExtension = function addExtension(filename, ext = '.js') {
+    let result = `${filename}`;
+    if (!path.extname(filename))
+        result += ext;
+    return result;
+};
+
+function walk(ast, { enter, leave }) {
+	return visit(ast, null, enter, leave);
+}
+
+let should_skip = false;
+let should_remove = false;
+let replacement = null;
+const context = {
+	skip: () => should_skip = true,
+	remove: () => should_remove = true,
+	replace: (node) => replacement = node
+};
+
+function replace(parent, prop, index, node) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop][index] = node;
+		} else {
+			parent[prop] = node;
+		}
+	}
+}
+
+function remove(parent, prop, index) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop].splice(index, 1);
+		} else {
+			delete parent[prop];
+		}
+	}
+}
+
+function visit(
+	node,
+	parent,
+	enter,
+	leave,
+	prop,
+	index
+) {
+	if (node) {
+		if (enter) {
+			const _should_skip = should_skip;
+			const _should_remove = should_remove;
+			const _replacement = replacement;
+			should_skip = false;
+			should_remove = false;
+			replacement = null;
+
+			enter.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const skipped = should_skip;
+			const removed = should_remove;
+
+			should_skip = _should_skip;
+			should_remove = _should_remove;
+			replacement = _replacement;
+
+			if (skipped) return node;
+			if (removed) return null;
+		}
+
+		for (const key in node) {
+			const value = (node )[key];
+
+			if (typeof value !== 'object') {
+				continue;
+			}
+
+			else if (Array.isArray(value)) {
+				for (let j = 0, k = 0; j < value.length; j += 1, k += 1) {
+					if (value[j] !== null && typeof value[j].type === 'string') {
+						if (!visit(value[j], node, enter, leave, key, k)) {
+							// removed
+							j--;
+						}
+					}
+				}
+			}
+
+			else if (value !== null && typeof value.type === 'string') {
+				visit(value, node, enter, leave, key, null);
+			}
+		}
+
+		if (leave) {
+			const _replacement = replacement;
+			const _should_remove = should_remove;
+			replacement = null;
+			should_remove = false;
+
+			leave.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const removed = should_remove;
+
+			replacement = _replacement;
+			should_remove = _should_remove;
+
+			if (removed) return null;
+		}
+	}
+
+	return node;
+}
+
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+
+const blockDeclarations = {
+    const: true,
+    let: true
+};
+class Scope {
+    constructor(options = {}) {
+        this.parent = options.parent;
+        this.isBlockScope = !!options.block;
+        this.declarations = Object.create(null);
+        if (options.params) {
+            options.params.forEach((param) => {
+                extractAssignedNames(param).forEach((name) => {
+                    this.declarations[name] = true;
+                });
+            });
+        }
+    }
+    addDeclaration(node, isBlockDeclaration, isVar) {
+        if (!isBlockDeclaration && this.isBlockScope) {
+            // it's a `var` or function node, and this
+            // is a block scope, so we need to go up
+            this.parent.addDeclaration(node, isBlockDeclaration, isVar);
+        }
+        else if (node.id) {
+            extractAssignedNames(node.id).forEach((name) => {
+                this.declarations[name] = true;
+            });
+        }
+    }
+    contains(name) {
+        return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);
+    }
+}
+const attachScopes = function attachScopes(ast, propertyName = 'scope') {
+    let scope = new Scope();
+    walk(ast, {
+        enter(n, parent) {
+            const node = n;
+            // function foo () {...}
+            // class Foo {...}
+            if (/(Function|Class)Declaration/.test(node.type)) {
+                scope.addDeclaration(node, false, false);
+            }
+            // var foo = 1
+            if (node.type === 'VariableDeclaration') {
+                const { kind } = node;
+                const isBlockDeclaration = blockDeclarations[kind];
+                // don't add const/let declarations in the body of a for loop #113
+                const parentType = parent ? parent.type : '';
+                if (!(isBlockDeclaration && /ForOfStatement/.test(parentType))) {
+                    node.declarations.forEach((declaration) => {
+                        scope.addDeclaration(declaration, isBlockDeclaration, true);
+                    });
+                }
+            }
+            let newScope;
+            // create new function scope
+            if (/Function/.test(node.type)) {
+                const func = node;
+                newScope = new Scope({
+                    parent: scope,
+                    block: false,
+                    params: func.params
+                });
+                // named function expressions - the name is considered
+                // part of the function's scope
+                if (func.type === 'FunctionExpression' && func.id) {
+                    newScope.addDeclaration(func, false, false);
+                }
+            }
+            // create new block scope
+            if (node.type === 'BlockStatement' && !/Function/.test(parent.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // catch clause has its own block scope
+            if (node.type === 'CatchClause') {
+                newScope = new Scope({
+                    parent: scope,
+                    params: node.param ? [node.param] : [],
+                    block: true
+                });
+            }
+            if (newScope) {
+                Object.defineProperty(node, propertyName, {
+                    value: newScope,
+                    configurable: true
+                });
+                scope = newScope;
+            }
+        },
+        leave(n) {
+            const node = n;
+            if (node[propertyName])
+                scope = scope.parent;
+        }
+    });
+    return scope;
+};
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false) {
+        return id;
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = path.resolve(resolutionBase || '')
+        .split(path.sep)
+        .join('/')
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return path.posix.join(basePath, id);
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (/\0/.test(id))
+            return false;
+        const pathId = id.split(path.sep).join('/');
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+
+function stringify(obj) {
+    return (JSON.stringify(obj) || 'undefined').replace(/[\u2028\u2029]/g, (char) => `\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+}
+function serializeArray(arr, indent, baseIndent) {
+    let output = '[';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    for (let i = 0; i < arr.length; i++) {
+        const key = arr[i];
+        output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}]`;
+}
+function serializeObject(obj, indent, baseIndent) {
+    let output = '{';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    const entries = Object.entries(obj);
+    for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        const stringKey = makeLegalIdentifier(key) === key ? key : stringify(key);
+        output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(value, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}}`;
+}
+function serialize(obj, indent, baseIndent) {
+    if (obj === Infinity)
+        return 'Infinity';
+    if (obj === -Infinity)
+        return '-Infinity';
+    if (obj === 0 && 1 / obj === -Infinity)
+        return '-0';
+    if (obj instanceof Date)
+        return `new Date(${obj.getTime()})`;
+    if (obj instanceof RegExp)
+        return obj.toString();
+    if (obj !== obj)
+        return 'NaN'; // eslint-disable-line no-self-compare
+    if (Array.isArray(obj))
+        return serializeArray(obj, indent, baseIndent);
+    if (obj === null)
+        return 'null';
+    if (typeof obj === 'object')
+        return serializeObject(obj, indent, baseIndent);
+    return stringify(obj);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
+    const _ = options.compact ? '' : ' ';
+    const n = options.compact ? '' : '\n';
+    const declarationType = options.preferConst ? 'const' : 'var';
+    if (options.namedExports === false ||
+        typeof data !== 'object' ||
+        Array.isArray(data) ||
+        data instanceof Date ||
+        data instanceof RegExp ||
+        data === null) {
+        const code = serialize(data, options.compact ? null : t, '');
+        const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
+        return `export default${magic}${code};`;
+    }
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (key === makeLegalIdentifier(key)) {
+            if (options.objectShorthand)
+                defaultExportRows.push(key);
+            else
+                defaultExportRows.push(`${key}:${_}${key}`);
+            namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+        }
+        else {
+            defaultExportRows.push(`${stringify(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
+        }
+    }
+    return `${namedExportCode}export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+};
+
+// TODO: remove this in next major
+var index = {
+    addExtension,
+    attachScopes,
+    createFilter,
+    dataToEsm,
+    extractAssignedNames,
+    makeLegalIdentifier
+};
+
+exports.addExtension = addExtension;
+exports.attachScopes = attachScopes;
+exports.createFilter = createFilter;
+exports.dataToEsm = dataToEsm;
+exports.default = index;
+exports.extractAssignedNames = extractAssignedNames;
+exports.makeLegalIdentifier = makeLegalIdentifier;

vendor/spatie/ignition/node_modules/@rollup/pluginutils/dist/es/index.js

@@ -0,0 +1,436 @@
+import { extname, sep, resolve, posix } from 'path';
+import pm from 'picomatch';
+
+const addExtension = function addExtension(filename, ext = '.js') {
+    let result = `${filename}`;
+    if (!extname(filename))
+        result += ext;
+    return result;
+};
+
+function walk(ast, { enter, leave }) {
+	return visit(ast, null, enter, leave);
+}
+
+let should_skip = false;
+let should_remove = false;
+let replacement = null;
+const context = {
+	skip: () => should_skip = true,
+	remove: () => should_remove = true,
+	replace: (node) => replacement = node
+};
+
+function replace(parent, prop, index, node) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop][index] = node;
+		} else {
+			parent[prop] = node;
+		}
+	}
+}
+
+function remove(parent, prop, index) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop].splice(index, 1);
+		} else {
+			delete parent[prop];
+		}
+	}
+}
+
+function visit(
+	node,
+	parent,
+	enter,
+	leave,
+	prop,
+	index
+) {
+	if (node) {
+		if (enter) {
+			const _should_skip = should_skip;
+			const _should_remove = should_remove;
+			const _replacement = replacement;
+			should_skip = false;
+			should_remove = false;
+			replacement = null;
+
+			enter.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const skipped = should_skip;
+			const removed = should_remove;
+
+			should_skip = _should_skip;
+			should_remove = _should_remove;
+			replacement = _replacement;
+
+			if (skipped) return node;
+			if (removed) return null;
+		}
+
+		for (const key in node) {
+			const value = (node )[key];
+
+			if (typeof value !== 'object') {
+				continue;
+			}
+
+			else if (Array.isArray(value)) {
+				for (let j = 0, k = 0; j < value.length; j += 1, k += 1) {
+					if (value[j] !== null && typeof value[j].type === 'string') {
+						if (!visit(value[j], node, enter, leave, key, k)) {
+							// removed
+							j--;
+						}
+					}
+				}
+			}
+
+			else if (value !== null && typeof value.type === 'string') {
+				visit(value, node, enter, leave, key, null);
+			}
+		}
+
+		if (leave) {
+			const _replacement = replacement;
+			const _should_remove = should_remove;
+			replacement = null;
+			should_remove = false;
+
+			leave.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const removed = should_remove;
+
+			replacement = _replacement;
+			should_remove = _should_remove;
+
+			if (removed) return null;
+		}
+	}
+
+	return node;
+}
+
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+
+const blockDeclarations = {
+    const: true,
+    let: true
+};
+class Scope {
+    constructor(options = {}) {
+        this.parent = options.parent;
+        this.isBlockScope = !!options.block;
+        this.declarations = Object.create(null);
+        if (options.params) {
+            options.params.forEach((param) => {
+                extractAssignedNames(param).forEach((name) => {
+                    this.declarations[name] = true;
+                });
+            });
+        }
+    }
+    addDeclaration(node, isBlockDeclaration, isVar) {
+        if (!isBlockDeclaration && this.isBlockScope) {
+            // it's a `var` or function node, and this
+            // is a block scope, so we need to go up
+            this.parent.addDeclaration(node, isBlockDeclaration, isVar);
+        }
+        else if (node.id) {
+            extractAssignedNames(node.id).forEach((name) => {
+                this.declarations[name] = true;
+            });
+        }
+    }
+    contains(name) {
+        return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);
+    }
+}
+const attachScopes = function attachScopes(ast, propertyName = 'scope') {
+    let scope = new Scope();
+    walk(ast, {
+        enter(n, parent) {
+            const node = n;
+            // function foo () {...}
+            // class Foo {...}
+            if (/(Function|Class)Declaration/.test(node.type)) {
+                scope.addDeclaration(node, false, false);
+            }
+            // var foo = 1
+            if (node.type === 'VariableDeclaration') {
+                const { kind } = node;
+                const isBlockDeclaration = blockDeclarations[kind];
+                // don't add const/let declarations in the body of a for loop #113
+                const parentType = parent ? parent.type : '';
+                if (!(isBlockDeclaration && /ForOfStatement/.test(parentType))) {
+                    node.declarations.forEach((declaration) => {
+                        scope.addDeclaration(declaration, isBlockDeclaration, true);
+                    });
+                }
+            }
+            let newScope;
+            // create new function scope
+            if (/Function/.test(node.type)) {
+                const func = node;
+                newScope = new Scope({
+                    parent: scope,
+                    block: false,
+                    params: func.params
+                });
+                // named function expressions - the name is considered
+                // part of the function's scope
+                if (func.type === 'FunctionExpression' && func.id) {
+                    newScope.addDeclaration(func, false, false);
+                }
+            }
+            // create new block scope
+            if (node.type === 'BlockStatement' && !/Function/.test(parent.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // catch clause has its own block scope
+            if (node.type === 'CatchClause') {
+                newScope = new Scope({
+                    parent: scope,
+                    params: node.param ? [node.param] : [],
+                    block: true
+                });
+            }
+            if (newScope) {
+                Object.defineProperty(node, propertyName, {
+                    value: newScope,
+                    configurable: true
+                });
+                scope = newScope;
+            }
+        },
+        leave(n) {
+            const node = n;
+            if (node[propertyName])
+                scope = scope.parent;
+        }
+    });
+    return scope;
+};
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false) {
+        return id;
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = resolve(resolutionBase || '')
+        .split(sep)
+        .join('/')
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return posix.join(basePath, id);
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (/\0/.test(id))
+            return false;
+        const pathId = id.split(sep).join('/');
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+
+function stringify(obj) {
+    return (JSON.stringify(obj) || 'undefined').replace(/[\u2028\u2029]/g, (char) => `\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+}
+function serializeArray(arr, indent, baseIndent) {
+    let output = '[';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    for (let i = 0; i < arr.length; i++) {
+        const key = arr[i];
+        output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}]`;
+}
+function serializeObject(obj, indent, baseIndent) {
+    let output = '{';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    const entries = Object.entries(obj);
+    for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        const stringKey = makeLegalIdentifier(key) === key ? key : stringify(key);
+        output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(value, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}}`;
+}
+function serialize(obj, indent, baseIndent) {
+    if (obj === Infinity)
+        return 'Infinity';
+    if (obj === -Infinity)
+        return '-Infinity';
+    if (obj === 0 && 1 / obj === -Infinity)
+        return '-0';
+    if (obj instanceof Date)
+        return `new Date(${obj.getTime()})`;
+    if (obj instanceof RegExp)
+        return obj.toString();
+    if (obj !== obj)
+        return 'NaN'; // eslint-disable-line no-self-compare
+    if (Array.isArray(obj))
+        return serializeArray(obj, indent, baseIndent);
+    if (obj === null)
+        return 'null';
+    if (typeof obj === 'object')
+        return serializeObject(obj, indent, baseIndent);
+    return stringify(obj);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
+    const _ = options.compact ? '' : ' ';
+    const n = options.compact ? '' : '\n';
+    const declarationType = options.preferConst ? 'const' : 'var';
+    if (options.namedExports === false ||
+        typeof data !== 'object' ||
+        Array.isArray(data) ||
+        data instanceof Date ||
+        data instanceof RegExp ||
+        data === null) {
+        const code = serialize(data, options.compact ? null : t, '');
+        const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
+        return `export default${magic}${code};`;
+    }
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (key === makeLegalIdentifier(key)) {
+            if (options.objectShorthand)
+                defaultExportRows.push(key);
+            else
+                defaultExportRows.push(`${key}:${_}${key}`);
+            namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+        }
+        else {
+            defaultExportRows.push(`${stringify(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
+        }
+    }
+    return `${namedExportCode}export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+};
+
+// TODO: remove this in next major
+var index = {
+    addExtension,
+    attachScopes,
+    createFilter,
+    dataToEsm,
+    extractAssignedNames,
+    makeLegalIdentifier
+};
+
+export default index;
+export { addExtension, attachScopes, createFilter, dataToEsm, extractAssignedNames, makeLegalIdentifier };

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../../../../rollup/dist/bin/rollup

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/@types/estree/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    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/@rollup/pluginutils/node_modules/@types/estree/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/estree`
+
+# Summary
+This package contains type definitions for ESTree AST specification (https://github.com/estree/estree).
+
+# Details
+Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree
+
+Additional Details
+ * Last updated: Tue, 17 Apr 2018 20:22:09 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by RReverser <https://github.com/RReverser>.

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/@types/estree/index.d.ts

@@ -0,0 +1,548 @@
+// Type definitions for ESTree AST specification
+// Project: https://github.com/estree/estree
+// Definitions by: RReverser <https://github.com/RReverser>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inhereted fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null;
+  range?: [number, number];
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Array<Comment>;
+  trailingComments?: Array<Comment>;
+}
+
+export type Node =
+    Identifier | Literal | Program | Function | SwitchCase | CatchClause |
+    VariableDeclarator | Statement | Expression | Property |
+    AssignmentProperty | Super | TemplateElement | SpreadElement | Pattern |
+    ClassBody | Class | MethodDefinition | ModuleDeclaration | ModuleSpecifier;
+
+export interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+
+interface SourceLocation {
+  source?: string | null;
+  start: Position;
+  end: Position;
+}
+
+export interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+
+export interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Statement | ModuleDeclaration>;
+  comments?: Array<Comment>;
+}
+
+interface BaseFunction extends BaseNode {
+  params: Array<Pattern>;
+  generator?: boolean;
+  async?: boolean;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+
+export type Function =
+    FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement =
+    ExpressionStatement | BlockStatement | EmptyStatement |
+    DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement |
+    BreakStatement | ContinueStatement | IfStatement | SwitchStatement |
+    ThrowStatement | TryStatement | WhileStatement | DoWhileStatement |
+    ForStatement | ForInStatement | ForOfStatement | Declaration;
+
+interface BaseStatement extends BaseNode { }
+
+export interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Array<Statement>;
+  innerComments?: Array<Comment>;
+}
+
+export interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null;
+}
+
+export interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null;
+}
+
+export interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null;
+}
+
+export interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: Array<SwitchCase>;
+}
+
+export interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null;
+}
+
+export interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null;
+  finalizer?: BlockStatement | null;
+}
+
+export interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null;
+  test?: Expression | null;
+  update?: Expression | null;
+  body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+
+export type Declaration =
+      FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+interface BaseDeclaration extends BaseStatement { }
+
+export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: Array<VariableDeclarator>;
+  kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null;
+}
+
+type Expression =
+    ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression |
+    ArrowFunctionExpression | YieldExpression | Literal | UnaryExpression |
+    UpdateExpression | BinaryExpression | AssignmentExpression |
+    LogicalExpression | MemberExpression | ConditionalExpression |
+    CallExpression | NewExpression | SequenceExpression | TemplateLiteral |
+    TaggedTemplateExpression | ClassExpression | MetaProperty | Identifier |
+    AwaitExpression;
+
+export interface BaseExpression extends BaseNode { }
+
+export interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property>;
+}
+
+export interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Array<Expression>;
+}
+
+export interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+}
+
+export interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression;
+  computed: boolean;
+}
+
+export type Pattern =
+    Identifier | ObjectPattern | ArrayPattern | RestElement |
+    AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode { }
+
+export interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null;
+  consequent: Array<Statement>;
+}
+
+export interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern;
+  body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string;
+}
+
+export type UnaryOperator =
+    "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+    "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" |
+    ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" |
+    "instanceof";
+
+export type LogicalOperator = "||" | "&&";
+
+export type AssignmentOperator =
+    "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" |
+    "|=" | "^=" | "&=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+}
+
+export interface Super extends BaseNode {
+  type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null;
+  delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    cooked: string;
+    raw: string;
+  };
+}
+
+export interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty>;
+}
+
+export interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern>;
+}
+
+export interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null;
+  body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition>;
+}
+
+export interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+
+export interface ClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null;
+}
+
+export interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+
+export type ModuleDeclaration =
+    ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration |
+    ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode { }
+
+export type ModuleSpecifier =
+    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier |
+    ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source?: Literal | null;
+}
+
+export interface ExportSpecifier extends BaseModuleSpecifier {
+  type: "ExportSpecifier";
+  exported: Identifier;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: Declaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/CHANGELOG.md

@@ -0,0 +1,79 @@
+# changelog
+
+## 1.0.1
+
+* Relax node type to `BaseNode` ([#17](https://github.com/Rich-Harris/estree-walker/pull/17))
+
+## 1.0.0
+
+* Don't cache child keys
+
+## 0.9.0
+
+* Add `this.remove()` method
+
+## 0.8.1
+
+* Fix pkg.files
+
+## 0.8.0
+
+* Adopt `estree` types
+
+## 0.7.0
+
+* Add a `this.replace(node)` method
+
+## 0.6.1
+
+* Only traverse nodes that exist and have a type ([#9](https://github.com/Rich-Harris/estree-walker/pull/9))
+* Only cache keys for nodes with a type ([#8](https://github.com/Rich-Harris/estree-walker/pull/8))
+
+## 0.6.0
+
+* Fix walker context type
+* Update deps, remove unncessary Bublé transformation
+
+## 0.5.2
+
+* Add types to package
+
+## 0.5.1
+
+* Prevent context corruption when `walk()` is called during a walk
+
+## 0.5.0
+
+* Export `childKeys`, for manually fixing in case of malformed ASTs
+
+## 0.4.0
+
+* Add TypeScript typings ([#3](https://github.com/Rich-Harris/estree-walker/pull/3))
+
+## 0.3.1
+
+* Include `pkg.repository` ([#2](https://github.com/Rich-Harris/estree-walker/pull/2))
+
+## 0.3.0
+
+* More predictable ordering
+
+## 0.2.1
+
+* Keep `context` shape
+
+## 0.2.0
+
+* Add ES6 build
+
+## 0.1.3
+
+* npm snafu
+
+## 0.1.2
+
+* Pass current prop and index to `enter`/`leave` callbacks
+
+## 0.1.1
+
+* First release

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/README.md

@@ -0,0 +1,48 @@
+# estree-walker
+
+Simple utility for walking an [ESTree](https://github.com/estree/estree)-compliant AST, such as one generated by [acorn](https://github.com/marijnh/acorn).
+
+
+## Installation
+
+```bash
+npm i estree-walker
+```
+
+
+## Usage
+
+```js
+var walk = require( 'estree-walker' ).walk;
+var acorn = require( 'acorn' );
+
+ast = acorn.parse( sourceCode, options ); // https://github.com/acornjs/acorn
+
+walk( ast, {
+  enter: function ( node, parent, prop, index ) {
+    // some code happens
+  },
+  leave: function ( node, parent, prop, index ) {
+  	// some code happens
+  }
+});
+```
+
+Inside the `enter` function, calling `this.skip()` will prevent the node's children being walked, or the `leave` function (which is optional) being called.
+
+Call `this.replace(new_node)` in either `enter` or `leave` to replace the current node with a new one.
+
+Call `this.remove()` in either `enter` or `leave` to remove the current node.
+
+## Why not use estraverse?
+
+The ESTree spec is evolving to accommodate ES6/7. I've had a couple of experiences where [estraverse](https://github.com/estools/estraverse) was unable to handle an AST generated by recent versions of acorn, because it hard-codes visitor keys.
+
+estree-walker, by contrast, simply enumerates a node's properties to find child nodes (and child lists of nodes), and is therefore resistant to spec changes. It's also much smaller. (The performance, if you're wondering, is basically identical.)
+
+None of which should be taken as criticism of estraverse, which has more features and has been battle-tested in many more situations, and for which I'm very grateful.
+
+
+## License
+
+MIT

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/dist/estree-walker.umd.js

@@ -0,0 +1,135 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(factory((global.estreeWalker = {})));
+}(this, (function (exports) { 'use strict';
+
+	function walk(ast, { enter, leave }) {
+		return visit(ast, null, enter, leave);
+	}
+
+	let should_skip = false;
+	let should_remove = false;
+	let replacement = null;
+	const context = {
+		skip: () => should_skip = true,
+		remove: () => should_remove = true,
+		replace: (node) => replacement = node
+	};
+
+	function replace(parent, prop, index, node) {
+		if (parent) {
+			if (index !== null) {
+				parent[prop][index] = node;
+			} else {
+				parent[prop] = node;
+			}
+		}
+	}
+
+	function remove(parent, prop, index) {
+		if (parent) {
+			if (index !== null) {
+				parent[prop].splice(index, 1);
+			} else {
+				delete parent[prop];
+			}
+		}
+	}
+
+	function visit(
+		node,
+		parent,
+		enter,
+		leave,
+		prop,
+		index
+	) {
+		if (node) {
+			if (enter) {
+				const _should_skip = should_skip;
+				const _should_remove = should_remove;
+				const _replacement = replacement;
+				should_skip = false;
+				should_remove = false;
+				replacement = null;
+
+				enter.call(context, node, parent, prop, index);
+
+				if (replacement) {
+					node = replacement;
+					replace(parent, prop, index, node);
+				}
+
+				if (should_remove) {
+					remove(parent, prop, index);
+				}
+
+				const skipped = should_skip;
+				const removed = should_remove;
+
+				should_skip = _should_skip;
+				should_remove = _should_remove;
+				replacement = _replacement;
+
+				if (skipped) return node;
+				if (removed) return null;
+			}
+
+			for (const key in node) {
+				const value = (node )[key];
+
+				if (typeof value !== 'object') {
+					continue;
+				}
+
+				else if (Array.isArray(value)) {
+					for (let j = 0, k = 0; j < value.length; j += 1, k += 1) {
+						if (value[j] !== null && typeof value[j].type === 'string') {
+							if (!visit(value[j], node, enter, leave, key, k)) {
+								// removed
+								j--;
+							}
+						}
+					}
+				}
+
+				else if (value !== null && typeof value.type === 'string') {
+					visit(value, node, enter, leave, key, null);
+				}
+			}
+
+			if (leave) {
+				const _replacement = replacement;
+				const _should_remove = should_remove;
+				replacement = null;
+				should_remove = false;
+
+				leave.call(context, node, parent, prop, index);
+
+				if (replacement) {
+					node = replacement;
+					replace(parent, prop, index, node);
+				}
+
+				if (should_remove) {
+					remove(parent, prop, index);
+				}
+
+				const removed = should_remove;
+
+				replacement = _replacement;
+				should_remove = _should_remove;
+
+				if (removed) return null;
+			}
+		}
+
+		return node;
+	}
+
+	exports.walk = walk;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/dist/estree-walker.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estree-walker.umd.js","sources":["../src/estree-walker.js"],"sourcesContent":["export function walk(ast, { enter, leave }) {\n\tvisit(ast, null, enter, leave);\n}\n\nlet shouldSkip = false;\nconst context = { skip: () => shouldSkip = true };\n\nexport const childKeys = {};\n\nconst toString = Object.prototype.toString;\n\nfunction isArray(thing) {\n\treturn toString.call(thing) === '[object Array]';\n}\n\nfunction visit(node, parent, enter, leave, prop, index) {\n\tif (!node) return;\n\n\tif (enter) {\n\t\tconst _shouldSkip = shouldSkip;\n\t\tshouldSkip = false;\n\t\tenter.call(context, node, parent, prop, index);\n\t\tconst skipped = shouldSkip;\n\t\tshouldSkip = _shouldSkip;\n\n\t\tif (skipped) return;\n\t}\n\n\tconst keys = childKeys[node.type] || (\n\t\tchildKeys[node.type] = Object.keys(node).filter(key => typeof node[key] === 'object')\n\t);\n\n\tfor (let i = 0; i < keys.length; i += 1) {\n\t\tconst key = keys[i];\n\t\tconst value = node[key];\n\n\t\tif (isArray(value)) {\n\t\t\tfor (let j = 0; j < value.length; j += 1) {\n\t\t\t\tvisit(value[j], node, enter, leave, key, j);\n\t\t\t}\n\t\t}\n\n\t\telse if (value && value.type) {\n\t\t\tvisit(value, node, enter, leave, key, null);\n\t\t}\n\t}\n\n\tif (leave) {\n\t\tleave(node, parent, prop, index);\n\t}\n}\n"],"names":[],"mappings":";;;;;;CAAO,SAAS,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;CAC5C,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;CAChC,CAAC;;CAED,IAAI,UAAU,GAAG,KAAK,CAAC;CACvB,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,MAAM,UAAU,GAAG,IAAI,EAAE,CAAC;;AAElD,AAAY,OAAC,SAAS,GAAG,EAAE,CAAC;;CAE5B,MAAM,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC;;CAE3C,SAAS,OAAO,CAAC,KAAK,EAAE;CACxB,CAAC,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,gBAAgB,CAAC;CAClD,CAAC;;CAED,SAAS,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;CACxD,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO;;CAEnB,CAAC,IAAI,KAAK,EAAE;CACZ,EAAE,MAAM,WAAW,GAAG,UAAU,CAAC;CACjC,EAAE,UAAU,GAAG,KAAK,CAAC;CACrB,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;CACjD,EAAE,MAAM,OAAO,GAAG,UAAU,CAAC;CAC7B,EAAE,UAAU,GAAG,WAAW,CAAC;;CAE3B,EAAE,IAAI,OAAO,EAAE,OAAO;CACtB,EAAE;;CAEF,CAAC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;CAClC,EAAE,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC;CACvF,EAAE,CAAC;;CAEH,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;CAC1C,EAAE,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;CACtB,EAAE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;;CAE1B,EAAE,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE;CACtB,GAAG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;CAC7C,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAChD,IAAI;CACJ,GAAG;;CAEH,OAAO,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE;CAChC,GAAG,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;CAC/C,GAAG;CACH,EAAE;;CAEF,CAAC,IAAI,KAAK,EAAE;CACZ,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;CACnC,EAAE;CACF,CAAC;;;;;;;;;;;;;"}

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/src/estree-walker.js

@@ -0,0 +1,125 @@
+function walk(ast, { enter, leave }) {
+	return visit(ast, null, enter, leave);
+}
+
+let should_skip = false;
+let should_remove = false;
+let replacement = null;
+const context = {
+	skip: () => should_skip = true,
+	remove: () => should_remove = true,
+	replace: (node) => replacement = node
+};
+
+function replace(parent, prop, index, node) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop][index] = node;
+		} else {
+			parent[prop] = node;
+		}
+	}
+}
+
+function remove(parent, prop, index) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop].splice(index, 1);
+		} else {
+			delete parent[prop];
+		}
+	}
+}
+
+function visit(
+	node,
+	parent,
+	enter,
+	leave,
+	prop,
+	index
+) {
+	if (node) {
+		if (enter) {
+			const _should_skip = should_skip;
+			const _should_remove = should_remove;
+			const _replacement = replacement;
+			should_skip = false;
+			should_remove = false;
+			replacement = null;
+
+			enter.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const skipped = should_skip;
+			const removed = should_remove;
+
+			should_skip = _should_skip;
+			should_remove = _should_remove;
+			replacement = _replacement;
+
+			if (skipped) return node;
+			if (removed) return null;
+		}
+
+		for (const key in node) {
+			const value = (node )[key];
+
+			if (typeof value !== 'object') {
+				continue;
+			}
+
+			else if (Array.isArray(value)) {
+				for (let j = 0, k = 0; j < value.length; j += 1, k += 1) {
+					if (value[j] !== null && typeof value[j].type === 'string') {
+						if (!visit(value[j], node, enter, leave, key, k)) {
+							// removed
+							j--;
+						}
+					}
+				}
+			}
+
+			else if (value !== null && typeof value.type === 'string') {
+				visit(value, node, enter, leave, key, null);
+			}
+		}
+
+		if (leave) {
+			const _replacement = replacement;
+			const _should_remove = should_remove;
+			replacement = null;
+			should_remove = false;
+
+			leave.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const removed = should_remove;
+
+			replacement = _replacement;
+			should_remove = _should_remove;
+
+			if (removed) return null;
+		}
+	}
+
+	return node;
+}
+
+export { walk };

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/src/index.ts

@@ -0,0 +1,144 @@
+import { BaseNode } from "estree";
+
+type WalkerContext = {
+	skip: () => void;
+	remove: () => void;
+	replace: (node: BaseNode) => void;
+};
+
+type WalkerHandler = (
+	this: WalkerContext,
+	node: BaseNode,
+	parent: BaseNode,
+	key: string,
+	index: number
+) => void
+
+type Walker = {
+	enter?: WalkerHandler;
+	leave?: WalkerHandler;
+}
+
+export function walk(ast: BaseNode, { enter, leave }: Walker) {
+	return visit(ast, null, enter, leave);
+}
+
+let should_skip = false;
+let should_remove = false;
+let replacement: BaseNode = null;
+const context: WalkerContext = {
+	skip: () => should_skip = true,
+	remove: () => should_remove = true,
+	replace: (node: BaseNode) => replacement = node
+};
+
+function replace(parent: any, prop: string, index: number, node: BaseNode) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop][index] = node;
+		} else {
+			parent[prop] = node;
+		}
+	}
+}
+
+function remove(parent: any, prop: string, index: number) {
+	if (parent) {
+		if (index !== null) {
+			parent[prop].splice(index, 1);
+		} else {
+			delete parent[prop];
+		}
+	}
+}
+
+function visit(
+	node: BaseNode,
+	parent: BaseNode,
+	enter: WalkerHandler,
+	leave: WalkerHandler,
+	prop?: string,
+	index?: number
+) {
+	if (node) {
+		if (enter) {
+			const _should_skip = should_skip;
+			const _should_remove = should_remove;
+			const _replacement = replacement;
+			should_skip = false;
+			should_remove = false;
+			replacement = null;
+
+			enter.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const skipped = should_skip;
+			const removed = should_remove;
+
+			should_skip = _should_skip;
+			should_remove = _should_remove;
+			replacement = _replacement;
+
+			if (skipped) return node;
+			if (removed) return null;
+		}
+
+		for (const key in node) {
+			const value = (node as any)[key];
+
+			if (typeof value !== 'object') {
+				continue;
+			}
+
+			else if (Array.isArray(value)) {
+				for (let j = 0, k = 0; j < value.length; j += 1, k += 1) {
+					if (value[j] !== null && typeof value[j].type === 'string') {
+						if (!visit(value[j], node, enter, leave, key, k)) {
+							// removed
+							j--;
+						}
+					}
+				}
+			}
+
+			else if (value !== null && typeof value.type === 'string') {
+				visit(value, node, enter, leave, key, null);
+			}
+		}
+
+		if (leave) {
+			const _replacement = replacement;
+			const _should_remove = should_remove;
+			replacement = null;
+			should_remove = false;
+
+			leave.call(context, node, parent, prop, index);
+
+			if (replacement) {
+				node = replacement;
+				replace(parent, prop, index, node);
+			}
+
+			if (should_remove) {
+				remove(parent, prop, index);
+			}
+
+			const removed = should_remove;
+
+			replacement = _replacement;
+			should_remove = _should_remove;
+
+			if (removed) return null;
+		}
+	}
+
+	return node;
+}

vendor/spatie/ignition/node_modules/@rollup/pluginutils/node_modules/estree-walker/types/index.d.ts

@@ -0,0 +1,13 @@
+import { BaseNode } from "estree";
+declare type WalkerContext = {
+    skip: () => void;
+    remove: () => void;
+    replace: (node: BaseNode) => void;
+};
+declare type WalkerHandler = (this: WalkerContext, node: BaseNode, parent: BaseNode, key: string, index: number) => void;
+declare type Walker = {
+    enter?: WalkerHandler;
+    leave?: WalkerHandler;
+};
+export declare function walk(ast: BaseNode, { enter, leave }: Walker): BaseNode;
+export {};

vendor/spatie/ignition/node_modules/@rollup/pluginutils/types/index.d.ts

@@ -0,0 +1,86 @@
+// eslint-disable-next-line import/no-unresolved
+import { BaseNode } from 'estree';
+
+export interface AttachedScope {
+  parent?: AttachedScope;
+  isBlockScope: boolean;
+  declarations: { [key: string]: boolean };
+  addDeclaration(node: BaseNode, isBlockDeclaration: boolean, isVar: boolean): void;
+  contains(name: string): boolean;
+}
+
+export interface DataToEsmOptions {
+  compact?: boolean;
+  indent?: string;
+  namedExports?: boolean;
+  objectShorthand?: boolean;
+  preferConst?: boolean;
+}
+
+/**
+ * A valid `minimatch` pattern, or array of patterns.
+ */
+export type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+
+/**
+ * Adds an extension to a module ID if one does not exist.
+ */
+export function addExtension(filename: string, ext?: string): string;
+
+/**
+ * Attaches `Scope` objects to the relevant nodes of an AST.
+ * Each `Scope` object has a `scope.contains(name)` method that returns `true`
+ * if a given name is defined in the current scope or a parent scope.
+ */
+export function attachScopes(ast: BaseNode, propertyName?: string): AttachedScope;
+
+/**
+ * Constructs a filter function which can be used to determine whether or not
+ * certain modules should be operated upon.
+ * @param include If `include` is omitted or has zero length, filter will return `true` by default.
+ * @param exclude ID must not match any of the `exclude` patterns.
+ * @param options Optionally resolves the patterns against a directory other than `process.cwd()`.
+ * If a `string` is specified, then the value will be used as the base directory.
+ * Relative paths will be resolved against `process.cwd()` first.
+ * If `false`, then the patterns will not be resolved against any directory.
+ * This can be useful if you want to create a filter for virtual module names.
+ */
+export function createFilter(
+  include?: FilterPattern,
+  exclude?: FilterPattern,
+  options?: { resolve?: string | false | null }
+): (id: string | unknown) => boolean;
+
+/**
+ * Transforms objects into tree-shakable ES Module imports.
+ * @param data An object to transform into an ES module.
+ */
+export function dataToEsm(data: unknown, options?: DataToEsmOptions): string;
+
+/**
+ * Extracts the names of all assignment targets based upon specified patterns.
+ * @param param An `acorn` AST Node.
+ */
+export function extractAssignedNames(param: BaseNode): string[];
+
+/**
+ * Constructs a bundle-safe identifier from a `string`.
+ */
+export function makeLegalIdentifier(str: string): string;
+
+export type AddExtension = typeof addExtension;
+export type AttachScopes = typeof attachScopes;
+export type CreateFilter = typeof createFilter;
+export type ExtractAssignedNames = typeof extractAssignedNames;
+export type MakeLegalIdentifier = typeof makeLegalIdentifier;
+export type DataToEsm = typeof dataToEsm;
+
+declare const defaultExport: {
+  addExtension: AddExtension;
+  attachScopes: AttachScopes;
+  createFilter: CreateFilter;
+  dataToEsm: DataToEsm;
+  extractAssignedNames: ExtractAssignedNames;
+  makeLegalIdentifier: MakeLegalIdentifier;
+};
+export default defaultExport;