Project Init

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.

node_modules/@rollup/plugin-babel/README.md

@@ -0,0 +1,404 @@
+[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 (v14.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: 'es'
+  },
+  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 [picomatch pattern](https://github.com/micromatch/picomatch), 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 [picomatch pattern](https://github.com/micromatch/picomatch), 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.es.js', format: 'es' }
+  ]
+};
+```
+
+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: 'es' },
+    {
+      file: 'bundle.es5.js',
+      format: 'es',
+      plugins: [getBabelOutputPlugin({ presets: ['@babel/preset-env'] })]
+    }
+  ]
+};
+```
+
+The `include`, `exclude` and `extensions` options are ignored when using `getBabelOutputPlugin` and `createBabelOutputPluginFactory` will produce warnings, and there are a few more points to note that users should be aware of.
+
+When transforming generated code, you can instead control which chunks are processed by matching their manual chunk names via the `includeChunks`/`excludeChunks` options. These patterns are matched against `chunk.name` as provided to Rollup's `renderChunk` hook and are especially useful to skip already-transpiled/minified vendor chunks:
+
+```js
+// rollup.config.js
+import { getBabelOutputPlugin } from '@rollup/plugin-babel';
+
+export default {
+  input: 'main.js',
+  manualChunks(id) {
+    if (id.includes('big-library')) return 'vendor';
+  },
+  output: {
+    format: 'es',
+    plugins: [
+      getBabelOutputPlugin({
+        presets: ['@babel/preset-env'],
+        // Do not transform the 'vendor' manual chunk
+        excludeChunks: ['vendor']
+      })
+    ]
+  }
+};
+```
+
+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: 'es',
+      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 `es` or `cjs`, you set Rollup to use the `es` 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 `es` and `cjs` formats, and you need to make sure to set the `useESModules` option of `@babel/plugin-transform-runtime` to `true` if you create ES output:
+
+```js
+rollup.rollup({...})
+.then(bundle => bundle.generate({
+  format: 'es',
+  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)

node_modules/@rollup/plugin-babel/dist/cjs/index.js

@@ -0,0 +1,410 @@
+'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 _interopNamespaceDefault(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__*/_interopNamespaceDefault(babel);
+
+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 {
+    ...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.`;
+
+// Revert to /\/helpers\/(esm\/)?inherits/ when Babel 8 gets released, this was fixed in https://github.com/babel/babel/issues/14185
+const inheritsHelperRe = /[\\/]+helpers[\\/]+(esm[\\/]+)?inherits/;
+async function preflightCheck(ctx, babelHelpers, transformOptions) {
+  const finalOptions = addBabelPlugin(transformOptions, helpersTestTransform);
+  const check = (await babel__namespace.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__namespace.loadPartialConfigAsync || babel__namespace.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__namespace.transformAsync(inputCode, transformOptions);
+    return {
+      code,
+      map
+    };
+  }
+  const result = await babel__namespace.transformAsync(inputCode, transformOptions);
+  const {
+    code,
+    map
+  } = await overrides.result.call(ctx, result, {
+    code: inputCode,
+    customOptions,
+    config,
+    transformOptions
+  });
+  return {
+    code,
+    map
+  };
+}
+
+const unpackOptions = ({
+  extensions = babel__namespace.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,
+  ...rest
+} = {}) => {
+  return {
+    extensions,
+    plugins: [],
+    sourceMaps: sourcemap && sourcemaps && sourceMap && sourceMaps,
+    ...rest,
+    caller: {
+      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 = ({
+  skipPreflightCheck = false,
+  ...rest
+}, rollupVersion) => {
+  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({
+    ...rest,
+    skipPreflightCheck,
+    babelHelpers: rest.babelHelpers || BUNDLED,
+    caller: {
+      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({
+  configFile: false,
+  sourceType: format === 'es' ? 'module' : 'script',
+  ...options,
+  caller: {
+    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;
+        ({
+          exclude,
+          extensions,
+          babelHelpers,
+          include,
+          filter: customFilter,
+          skipPreflightCheck,
+          ...babelOptions
+        } = unpackInputPluginOptions(pluginOptionsWithOverrides, this.meta.rollupVersion));
+        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__namespace.buildExternalHelpers(null, 'module');
+      },
+      transform(code, filename) {
+        if (!filter(filename)) return null;
+        if (filename === HELPERS) return null;
+        return transformCode(code, {
+          ...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);
+
+    // cache for chunk name filter (includeChunks/excludeChunks)
+    let chunkNameFilter;
+    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 {
+          allowAllFormats,
+          includeChunks,
+          excludeChunks,
+          exclude,
+          extensions,
+          externalHelpers,
+          externalHelpersWhitelist,
+          include,
+          runtimeHelpers,
+          ...babelOptions
+        } = unpackOutputPluginOptions(pluginOptionsWithOverrides, outputOptions);
+        /* eslint-enable no-unused-vars */
+        // If includeChunks/excludeChunks are specified, filter by chunk.name
+        if (includeChunks != null || excludeChunks != null) {
+          if (!chunkNameFilter) {
+            chunkNameFilter = pluginutils.createFilter(includeChunks, excludeChunks, {
+              resolve: false
+            });
+          }
+          if (!chunkNameFilter(chunk.name)) {
+            // Skip transforming this chunk
+            return null;
+          }
+        }
+        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;
+module.exports = Object.assign(exports.default, exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,381 @@
+import * as babel from '@babel/core';
+import { createFilter } from '@rollup/pluginutils';
+import { addNamed } from '@babel/helper-module-imports';
+
+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 {
+    ...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.`;
+
+// Revert to /\/helpers\/(esm\/)?inherits/ when Babel 8 gets released, this was fixed in https://github.com/babel/babel/issues/14185
+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 = ({
+  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,
+  ...rest
+} = {}) => {
+  return {
+    extensions,
+    plugins: [],
+    sourceMaps: sourcemap && sourcemaps && sourceMap && sourceMaps,
+    ...rest,
+    caller: {
+      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 = ({
+  skipPreflightCheck = false,
+  ...rest
+}, rollupVersion) => {
+  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({
+    ...rest,
+    skipPreflightCheck,
+    babelHelpers: rest.babelHelpers || BUNDLED,
+    caller: {
+      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({
+  configFile: false,
+  sourceType: format === 'es' ? 'module' : 'script',
+  ...options,
+  caller: {
+    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;
+        ({
+          exclude,
+          extensions,
+          babelHelpers,
+          include,
+          filter: customFilter,
+          skipPreflightCheck,
+          ...babelOptions
+        } = unpackInputPluginOptions(pluginOptionsWithOverrides, this.meta.rollupVersion));
+        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 babel.buildExternalHelpers(null, 'module');
+      },
+      transform(code, filename) {
+        if (!filter(filename)) return null;
+        if (filename === HELPERS) return null;
+        return transformCode(code, {
+          ...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);
+
+    // cache for chunk name filter (includeChunks/excludeChunks)
+    let chunkNameFilter;
+    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 {
+          allowAllFormats,
+          includeChunks,
+          excludeChunks,
+          exclude,
+          extensions,
+          externalHelpers,
+          externalHelpersWhitelist,
+          include,
+          runtimeHelpers,
+          ...babelOptions
+        } = unpackOutputPluginOptions(pluginOptionsWithOverrides, outputOptions);
+        /* eslint-enable no-unused-vars */
+        // If includeChunks/excludeChunks are specified, filter by chunk.name
+        if (includeChunks != null || excludeChunks != null) {
+          if (!chunkNameFilter) {
+            chunkNameFilter = createFilter(includeChunks, excludeChunks, {
+              resolve: false
+            });
+          }
+          if (!chunkNameFilter(chunk.name)) {
+            // Skip transforming this chunk
+            return null;
+          }
+        }
+        return transformCode(code, babelOptions, overrides, customOptions, this);
+      }
+    };
+  };
+}
+
+// export this for symmetry with output-related exports
+const getBabelInputPlugin = createBabelInputPluginFactory();
+const getBabelOutputPlugin = createBabelOutputPluginFactory();
+
+export { getBabelInputPlugin as babel, createBabelInputPluginFactory, createBabelOutputPluginFactory, getBabelInputPlugin as default, getBabelInputPlugin, getBabelOutputPlugin };
+//# sourceMappingURL=index.js.map

node_modules/@rollup/plugin-babel/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-babel/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@rollup/plugin-babel",
+  "version": "6.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Seamless integration between Rollup and Babel.",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/babel"
+  },
+  "author": "Rich Harris",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/babel#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "rollup-plugin",
+    "babel",
+    "es2015",
+    "es6"
+  ],
+  "peerDependencies": {
+    "@babel/core": "^7.0.0",
+    "@types/babel__core": "^7.1.9",
+    "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    },
+    "@types/babel__core": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@babel/helper-module-imports": "^7.18.6",
+    "@rollup/pluginutils": "^5.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.19.1",
+    "@babel/plugin-external-helpers": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.19.1",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.19.1",
+    "@babel/preset-env": "^7.19.1",
+    "@rollup/plugin-json": "^5.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@types/babel__core": "^7.1.9",
+    "rollup": "^4.0.0-24",
+    "source-map": "^0.7.4"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "contributors": [
+    "Bogdan Chadkin <trysound@yandex.ru>",
+    "Mateusz Burzyński <mateuszburzynski@gmail.com> (https://github.com/Andarist)"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc types/index.d.ts test/types.ts --noEmit"
+  }
+}

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

@@ -0,0 +1,143 @@
+import type { Plugin, PluginContext, TransformPluginContext } from 'rollup';
+import type { FilterPattern, CreateFilter } from '@rollup/pluginutils';
+import type * as babelCore from '@babel/core';
+
+export interface RollupBabelInputPluginOptions
+  extends Omit<babelCore.TransformOptions, 'include' | 'exclude'> {
+  /**
+   * A picomatch 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 picomatch 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;
+  /**
+   * Limit transforming of generated code to specific manual chunks by name.
+   * These patterns are matched against the `chunk.name` value in Rollup's `renderChunk` hook.
+   */
+  includeChunks?: FilterPattern;
+  /**
+   * Exclude specific manual chunks by name from transforming the generated code.
+   * These patterns are matched against the `chunk.name` value in Rollup's `renderChunk` hook.
+   */
+  excludeChunks?: FilterPattern;
+}
+
+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;

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.

node_modules/@rollup/plugin-commonjs/README.md

@@ -0,0 +1,451 @@
+[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 (v14.0.0+) and Rollup v2.68.0+. If you are using [`@rollup/plugin-node-resolve`](https://github.com/rollup/plugins/tree/master/packages/node-resolve), it should be v13.0.6+.
+
+## 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).
+
+When used together with the node-resolve plugin
+
+## Options
+
+### `strictRequires`
+
+Type: `"auto" | boolean | "debug" | string[]`<br>
+Default: `"auto"`
+
+By default, this plugin will try to hoist `require` statements as imports to the top of each file. While this works well for many code bases and allows for very efficient ESM output, it does not perfectly capture CommonJS semantics as the initialisation order of required modules will be different. The resultant side effects can include log statements being emitted in a different order, and some code that is dependent on the initialisation order of polyfills in require statements may not work. But it is especially problematic when there are circular `require` calls between CommonJS modules as those often rely on the lazy execution of nested `require` calls.
+
+Setting this option to `true` will wrap all CommonJS files in functions which are executed when they are required for the first time, preserving NodeJS semantics. This is the safest setting and should be used if the generated code does not work correctly with `"auto"`. Note that `strictRequires: true` can have a small impact on the size and performance of generated code, but less so if the code is minified.
+
+The default value of `"auto"` will only wrap CommonJS files when they are part of a CommonJS dependency cycle, e.g. an index file that is required by some of its dependencies, or if they are only required in a potentially "conditional" way like from within an if-statement or a function. All other CommonJS files are hoisted. This is the recommended setting for most code bases. Note that the detection of conditional requires can be subject to race conditions if there are both conditional and unconditional requires of the same file, which in edge cases may result in inconsistencies between builds. If you think this is a problem for you, you can avoid this by using any value other than `"auto"` or `"debug"`.
+
+`false` will entirely prevent wrapping and hoist all files. This may still work depending on the nature of cyclic dependencies but will often cause problems.
+
+You can also provide a [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, to only specify a subset of files which should be wrapped in functions for proper `require` semantics.
+
+`"debug"` works like `"auto"` but after bundling, it will display a warning containing a list of ids that have been wrapped which can be used as picomatch pattern for fine-tuning or to avoid the potential race conditions mentioned for `"auto"`.
+
+### `dynamicRequireTargets`
+
+Type: `string | string[]`<br>
+Default: `[]`
+
+_Note: In previous versions, this option would spin up a rather comprehensive mock environment that was capable of handling modules that manipulate `require.cache`. This is no longer supported. If you rely on this e.g. when using request-promise-native, use version 21 of this plugin._
+
+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 dependencies. It also enables `strictRequires` for those modules, see above.
+
+_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'
+  ]
+});
+```
+
+### `dynamicRequireRoot`
+
+Type: `string`<br>
+Default: `process.cwd()`
+
+To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/` may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your home directory name. By default it uses the current working directory.
+
+### `exclude`
+
+Type: `string | string[]`<br>
+Default: `null`
+
+A [picomatch pattern](https://github.com/micromatch/picomatch), 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 [picomatch pattern](https://github.com/micromatch/picomatch), 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: `true`
+
+In most cases, where `require` calls to external dependencies 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 external `require` calls inside a `try` will be left unconverted.
+- `false`: All external `require` calls inside a `try` will be converted as if the `try-catch` clause is not there.
+- `remove`: Remove all external `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.
+
+Note that non-external requires will not be ignored by this option.
+
+### `ignoreDynamicRequires`
+
+Type: `boolean`
+Default: false
+
+Some `require` calls cannot be resolved statically to be translated to imports, e.g.
+
+```js
+function wrappedRequire(target) {
+  return require(target);
+}
+wrappedRequire('foo');
+wrappedRequire('bar');
+```
+
+When this option is set to `false`, the generated code will either directly throw an error when such a call is encountered or, when `dynamicRequireTargets` is used, when such a call cannot be resolved with a configured dynamic require target.
+
+Setting this option to `true` will instead leave the `require` call in the code or use it as a fallback for `dynamicRequireTargets`.
+
+### `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.
+
+### `defaultIsModuleExports`
+
+Type: `boolean | "auto"`<br>
+Default: `"auto"`
+
+Controls what is the default export when importing a CommonJS file from an ES module.
+
+- `true`: The value of the default export is `module.exports`. This currently matches the behavior of Node.js when importing a CommonJS file.
+  ```js
+  // mod.cjs
+  exports.default = 3;
+  ```
+  ```js
+  import foo from './mod.cjs';
+  console.log(foo); // { default: 3 }
+  ```
+- `false`: The value of the default export is `exports.default`.
+  ```js
+  // mod.cjs
+  exports.default = 3;
+  ```
+  ```js
+  import foo from './mod.cjs';
+  console.log(foo); // 3
+  ```
+- `"auto"`: The value of the default export is `exports.default` if the CommonJS file has an `exports.__esModule === true` property; otherwise it's `module.exports`. This makes it possible to import
+  the default export of ES modules compiled to CommonJS as if they were not compiled.
+  ```js
+  // mod.cjs
+  exports.default = 3;
+  ```
+  ```js
+  // mod-compiled.cjs
+  exports.__esModule = true;
+  exports.default = 3;
+  ```
+  ```js
+  import foo from './mod.cjs';
+  import bar from './mod-compiled.cjs';
+  console.log(foo); // { default: 3 }
+  console.log(bar); // 3
+  ```
+
+### `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) {
+    if (n.__esModule) return n;
+    var f = n.default;
+    if (typeof f == 'function') {
+      var a = function a() {
+        if (this instanceof a) {
+          return Reflect.construct(f, arguments, this.constructor);
+        }
+        return f.apply(this, arguments);
+      };
+      a.prototype = f.prototype;
+    } else a = {};
+    Object.defineProperty(a, '__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: [commonjs(), resolve()]
+};
+```
+
+## 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)

node_modules/@rollup/plugin-commonjs/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-commonjs/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@rollup/plugin-commonjs",
+  "version": "25.0.8",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Convert CommonJS modules to ES2015",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/commonjs"
+  },
+  "author": "Rich Harris <richard.a.harris@gmail.com>",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/commonjs/#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "npm",
+    "modules",
+    "commonjs",
+    "require"
+  ],
+  "peerDependencies": {
+    "rollup": "^2.68.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.1",
+    "commondir": "^1.0.1",
+    "estree-walker": "^2.0.2",
+    "glob": "^8.0.3",
+    "is-reference": "1.2.1",
+    "magic-string": "^0.30.3"
+  },
+  "devDependencies": {
+    "@rollup/plugin-json": "^5.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "locate-character": "^2.0.5",
+    "require-relative": "^0.8.7",
+    "rollup": "^4.0.0-24",
+    "shx": "^0.3.4",
+    "source-map": "^0.7.4",
+    "source-map-support": "^0.5.21",
+    "typescript": "^4.8.3"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose && pnpm test:ts",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc types/index.d.ts test/types.ts --noEmit"
+  }
+}

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

@@ -0,0 +1,233 @@
+import type { FilterPattern } from '@rollup/pluginutils';
+import type { Plugin } from 'rollup';
+
+type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
+type DefaultIsModuleExportsOption = boolean | 'auto';
+
+interface RollupCommonJSOptions {
+  /**
+   * A picomatch 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 picomatch 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;
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: 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;
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a picomatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * picomatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | FilterPattern;
+  /**
+   * 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 the `try-catch` clause.
+   *
+   * - `true`: Default. 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 controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  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 plugin 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 whether 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);
+
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?:
+    | DefaultIsModuleExportsOption
+    | ((id: string) => DefaultIsModuleExportsOption);
+  /**
+   * 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
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * 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>;
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string;
+}
+
+/**
+ * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
+ */
+export default function commonjs(options?: RollupCommonJSOptions): Plugin;

node_modules/@rollup/plugin-image/README.md

@@ -0,0 +1,91 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-image
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-image
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-image
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-image
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-image
+
+🍣 A Rollup plugin which imports JPG, PNG, GIF, SVG, and WebP files.
+
+Images are encoded using base64, which means they will be 33% larger than the size on disk. You should therefore only use this for small images where the convenience of having them available on startup (e.g. rendering immediately to a canvas without co-ordinating asynchronous loading of several images) outweighs the cost.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v14.0.0+) and Rollup v1.20.0+.
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/plugin-image --save-dev
+```
+
+## Usage
+
+Assuming a `src/index.js` exists and contains code like the following:
+
+```js
+import logo from './rollup.png';
+
+console.log(logo);
+```
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+import image from '@rollup/plugin-image';
+
+export default {
+  input: 'src/index.js',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [image()]
+};
+```
+
+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).
+
+Once the bundle is executed, the `console.log` will display the Base64 encoded representation of the image.
+
+## Options
+
+### `dom`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, instructs the plugin to generate an ES Module which exports a DOM `Image` which can be used with a browser's DOM. Otherwise, the plugin generates an ES Module which exports a `default const` containing the Base64 representation of the image.
+
+Using this option set to `true`, the export can be used as such:
+
+```js
+import logo from './rollup.png';
+document.body.appendChild(logo);
+```
+
+### `exclude`
+
+Type: `String` | `Array[...String]`<br>
+Default: `null`
+
+A [picomatch pattern](https://github.com/micromatch/picomatch), 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 [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all files are targeted.
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

node_modules/@rollup/plugin-image/dist/cjs/index.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var path = require('path');
+var pluginutils = require('@rollup/pluginutils');
+var svgToMiniDataURI = require('mini-svg-data-uri');
+
+var defaults = {
+  dom: false,
+  exclude: null,
+  include: null
+};
+
+var mimeTypes = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp'
+};
+
+var domTemplate = function (ref) {
+  var dataUri = ref.dataUri;
+
+  return ("\n  var img = new Image();\n  img.src = \"" + dataUri + "\";\n  export default img;\n");
+};
+
+var constTemplate = function (ref) {
+  var dataUri = ref.dataUri;
+
+  return ("\n  var img = \"" + dataUri + "\";\n  export default img;\n");
+};
+
+var getDataUri = function (ref) {
+    var format = ref.format;
+    var isSvg = ref.isSvg;
+    var mime = ref.mime;
+    var source = ref.source;
+
+    return isSvg ? svgToMiniDataURI(source) : ("data:" + mime + ";" + format + "," + source);
+};
+
+function image(opts) {
+  if ( opts === void 0 ) opts = {};
+
+  var options = Object.assign({}, defaults, opts);
+  var filter = pluginutils.createFilter(options.include, options.exclude);
+
+  return {
+    name: 'image',
+
+    load: function load(id) {
+      if (!filter(id)) {
+        return null;
+      }
+
+      var mime = mimeTypes[path.extname(id)];
+      if (!mime) {
+        // not an image
+        return null;
+      }
+
+      this.addWatchFile(id);
+      var isSvg = mime === mimeTypes['.svg'];
+      var format = isSvg ? 'utf-8' : 'base64';
+      var source = fs.readFileSync(id, format).replace(/[\r\n]+/gm, '');
+      var dataUri = getDataUri({ format: format, isSvg: isSvg, mime: mime, source: source });
+      var code = options.dom ? domTemplate({ dataUri: dataUri }) : constTemplate({ dataUri: dataUri });
+
+      return code.trim();
+    }
+  };
+}
+
+exports.default = image;
+module.exports = Object.assign(exports.default, exports);
+//# sourceMappingURL=index.js.map

node_modules/@rollup/plugin-image/dist/es/index.js

@@ -0,0 +1,75 @@
+import { readFileSync } from 'fs';
+import { extname } from 'path';
+import { createFilter } from '@rollup/pluginutils';
+import svgToMiniDataURI from 'mini-svg-data-uri';
+
+var defaults = {
+  dom: false,
+  exclude: null,
+  include: null
+};
+
+var mimeTypes = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp'
+};
+
+var domTemplate = function (ref) {
+  var dataUri = ref.dataUri;
+
+  return ("\n  var img = new Image();\n  img.src = \"" + dataUri + "\";\n  export default img;\n");
+};
+
+var constTemplate = function (ref) {
+  var dataUri = ref.dataUri;
+
+  return ("\n  var img = \"" + dataUri + "\";\n  export default img;\n");
+};
+
+var getDataUri = function (ref) {
+    var format = ref.format;
+    var isSvg = ref.isSvg;
+    var mime = ref.mime;
+    var source = ref.source;
+
+    return isSvg ? svgToMiniDataURI(source) : ("data:" + mime + ";" + format + "," + source);
+};
+
+function image(opts) {
+  if ( opts === void 0 ) opts = {};
+
+  var options = Object.assign({}, defaults, opts);
+  var filter = createFilter(options.include, options.exclude);
+
+  return {
+    name: 'image',
+
+    load: function load(id) {
+      if (!filter(id)) {
+        return null;
+      }
+
+      var mime = mimeTypes[extname(id)];
+      if (!mime) {
+        // not an image
+        return null;
+      }
+
+      this.addWatchFile(id);
+      var isSvg = mime === mimeTypes['.svg'];
+      var format = isSvg ? 'utf-8' : 'base64';
+      var source = readFileSync(id, format).replace(/[\r\n]+/gm, '');
+      var dataUri = getDataUri({ format: format, isSvg: isSvg, mime: mime, source: source });
+      var code = options.dom ? domTemplate({ dataUri: dataUri }) : constTemplate({ dataUri: dataUri });
+
+      return code.trim();
+    }
+  };
+}
+
+export { image as default };
+//# sourceMappingURL=index.js.map

node_modules/@rollup/plugin-image/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-image/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@rollup/plugin-image",
+  "version": "3.0.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Import JPG, PNG, GIF, SVG, and WebP files",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/image"
+  },
+  "author": "Rich Harris",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/image/#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose",
+    "prebuild": "del-cli dist",
+    "prepare": "if [ ! -d 'dist' ]; then pnpm build; fi",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root plugin:release --pkg $npm_package_name",
+    "test": "ava"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "images",
+    "modules"
+  ],
+  "peerDependencies": {
+    "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.1",
+    "mini-svg-data-uri": "^1.4.4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-buble": "^1.0.0",
+    "rollup": "^4.0.0-24"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  }
+}

node_modules/@rollup/plugin-image/types/index.d.ts

@@ -0,0 +1,34 @@
+import type { FilterPattern } from '@rollup/pluginutils';
+import type { Plugin } from 'rollup';
+
+interface RollupImageOptions {
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+   * should operate on.
+   * By default all files are targeted.
+   */
+  include?: FilterPattern;
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+   * should _ignore_.
+   * By default no files are ignored.
+   */
+  exclude?: FilterPattern;
+  /**
+   * If `true`, instructs the plugin to generate an ES Module which exports a DOM `Image` which can
+   * be used with a browser's DOM.
+   * Otherwise, the plugin generates an ES Module which exports a `default const` containing the
+   * Base64 representation of the image.
+   *
+   * Using this option set to `true`, the export can be used as such:
+   *
+   * @example
+   * import logo from './rollup.png';
+   * document.body.appendChild(logo);
+   *
+   * @default false
+   */
+  dom?: boolean;
+}
+
+export default function image(options?: RollupImageOptions): Plugin;

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.

node_modules/@rollup/plugin-json/README.md

@@ -0,0 +1,110 @@
+[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 (v14.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 { readFileSync } from 'fs';
+
+const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
+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 [picomatch pattern](https://github.com/micromatch/picomatch), 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 [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all files are targeted.
+
+### `includeArbitraryNames`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true` and `namedExports` is `true`, generates a named export for not a valid identifier properties of the JSON object by leveraging the ["Arbitrary Module Namespace Identifier Names" feature](https://github.com/tc39/ecma262/pull/2154).
+
+### `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)

node_modules/@rollup/plugin-json/dist/cjs/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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(code, id) {
+      if (id.slice(-5) !== '.json' || !filter(id)) { return null; }
+
+      try {
+        var parsed = JSON.parse(code);
+        return {
+          code: pluginutils.dataToEsm(parsed, {
+            preferConst: options.preferConst,
+            compact: options.compact,
+            namedExports: options.namedExports,
+            includeArbitraryNames: options.includeArbitraryNames,
+            indent: indent
+          }),
+          map: { mappings: '' }
+        };
+      } catch (err) {
+        var message = 'Could not parse JSON file';
+        this.error({ message: message, id: id, cause: err });
+        return null;
+      }
+    }
+  };
+}
+
+exports.default = json;
+module.exports = Object.assign(exports.default, exports);
+//# sourceMappingURL=index.js.map

node_modules/@rollup/plugin-json/dist/es/index.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(code, id) {
+      if (id.slice(-5) !== '.json' || !filter(id)) { return null; }
+
+      try {
+        var parsed = JSON.parse(code);
+        return {
+          code: dataToEsm(parsed, {
+            preferConst: options.preferConst,
+            compact: options.compact,
+            namedExports: options.namedExports,
+            includeArbitraryNames: options.includeArbitraryNames,
+            indent: indent
+          }),
+          map: { mappings: '' }
+        };
+      } catch (err) {
+        var message = 'Could not parse JSON file';
+        this.error({ message: message, id: id, cause: err });
+        return null;
+      }
+    }
+  };
+}
+
+export { json as default };
+//# sourceMappingURL=index.js.map

node_modules/@rollup/plugin-json/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-json/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@rollup/plugin-json",
+  "version": "6.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Convert .json files to ES6 modules",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/json"
+  },
+  "author": "rollup",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/json#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "json",
+    "es2015",
+    "npm",
+    "modules"
+  ],
+  "peerDependencies": {
+    "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.1.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-buble": "^1.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "rollup": "^4.0.0-24",
+    "source-map-support": "^0.5.21"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose && pnpm test:ts",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc types/index.d.ts test/types.ts --noEmit"
+  }
+}

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

@@ -0,0 +1,41 @@
+import type { FilterPattern } from '@rollup/pluginutils';
+import type { 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;

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.

node_modules/@rollup/plugin-node-resolve/README.md

@@ -0,0 +1,293 @@
+[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 (v14.0.0+) and Rollup v2.78.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.
+
+In order to get the [resolution behavior of Node.js](https://nodejs.org/api/packages.html#packages_conditional_exports), set this to `['node']`.
+
+### `browser`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, instructs the plugin to use the browser module resolutions in `package.json` and adds `'browser'` to `exportConditions` if it is not present so browser conditionals in `exports` are applied. If `false`, any browser properties in package files will be ignored. Alternatively, a value of `'browser'` can be added to both the `mainFields` and `exportConditions` options, however 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']`
+
+A list of directory names in which to recursively look for modules.
+
+### `modulePaths`
+
+Type: `Array[...String]`<br>
+Default: `[]`
+
+A list of absolute paths to additional locations to search for modules. [This is analogous to setting the `NODE_PATH` environment variable for node](https://nodejs.org/api/modules.html#loading-from-the-global-folders).
+
+### `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 | (module: string) => 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.
+
+Alternatively, you may pass in a function that returns a boolean to confirm whether the plugin should prefer built-in modules. e.g.
+
+```js
+preferBuiltins: (module) => module !== 'punycode';
+```
+
+will not treat `punycode` as a built-in module
+
+### `modulesOnly`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If `true`, inspect resolved files to assert that they are ES2015 modules.
+
+### `resolveOnly`
+
+Type: `Array[...String|RegExp] | (module: string) => boolean`<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._
+
+Alternatively, you may pass in a function that returns a boolean to confirm whether the module should be included or not.
+
+Examples:
+
+- `resolveOnly: ['batman', /^@batcave\/.*$/]`
+- `resolveOnly: module => !module.includes('joker')`
+
+### `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.
+
+### `allowExportsFolderMapping`
+
+Older Node versions supported exports mappings of folders like
+
+```json
+{
+  "exports": {
+    "./foo/": "./dist/foo/"
+  }
+}
+```
+
+This was deprecated with Node 14 and removed in Node 17, instead it is recommended to use exports patterns like
+
+```json
+{
+  "exports": {
+    "./foo/*": "./dist/foo/*"
+  }
+}
+```
+
+But for backwards compatibility this behavior is still supported by enabling the `allowExportsFolderMapping` (defaults to `true`).
+The default value might change in a futur major release.
+
+## 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 } }
+});
+```
+
+## Resolve Options
+
+After this plugin resolved an import id to its target file in `node_modules`, it will invoke `this.resolve` again with the resolved id. It will pass the following information in the resolve options:
+
+```js
+this.resolve(resolved.id, importer, {
+  custom: {
+    'node-resolve': {
+      resolved, // the object with information from node.js resolve
+      importee // the original import id
+    }
+  }
+});
+```
+
+Your plugin can use the `importee` information to map an original import to its resolved file in `node_modules`, in a plugin hook such as `resolveId`.
+
+The `resolved` object contains the resolved id, which is passed as the first parameter. It also has a property `moduleSideEffects`, which may contain the value from the npm `package.json` field `sideEffects` or `null`.
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

node_modules/@rollup/plugin-node-resolve/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-node-resolve/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@rollup/plugin-node-resolve",
+  "version": "15.3.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Locate and bundle third-party dependencies in node_modules",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/node-resolve"
+  },
+  "author": "Rich Harris <richard.a.harris@gmail.com>",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/node-resolve/#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "es2015",
+    "npm",
+    "modules"
+  ],
+  "peerDependencies": {
+    "rollup": "^2.78.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.1",
+    "@types/resolve": "1.20.2",
+    "deepmerge": "^4.2.2",
+    "is-module": "^1.0.0",
+    "resolve": "^1.22.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.19.1",
+    "@babel/plugin-transform-typescript": "^7.10.5",
+    "@rollup/plugin-babel": "^6.0.0",
+    "@rollup/plugin-commonjs": "^23.0.0",
+    "@rollup/plugin-json": "^5.0.0",
+    "es5-ext": "^0.10.62",
+    "rollup": "^4.0.0-24",
+    "source-map": "^0.7.4",
+    "string-capitalize": "^1.0.1"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "pnpm test:ts && ava",
+    "test:ts": "tsc types/index.d.ts test/types.ts --noEmit"
+  }
+}

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

@@ -0,0 +1,115 @@
+import type { 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;
+
+  /**
+   * A list of directory names in which to recursively look for modules.
+   * @default ['node_modules']
+   */
+  moduleDirectories?: string[];
+
+  /**
+   * A list of absolute paths to additional locations to search for modules.
+   * This is analogous to setting the `NODE_PATH` environment variable for node.
+   * @default []
+   */
+  modulePaths?: 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.
+   *
+   * If a function is provided, it will be called to determine whether to prefer built-ins.
+   * @default true
+   */
+  preferBuiltins?: boolean | ((module: string) => 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 | ((module: string) => boolean);
+
+  /**
+   * 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;
+
+  /**
+   * Allow folder mappings in package exports (trailing /)
+   * This was deprecated in Node 14 and removed with Node 17, see DEP0148.
+   * So this option might be changed to default to `false` in a future release.
+   * @default true
+   */
+  allowExportsFolderMapping?: boolean;
+}
+
+/**
+ * Locate modules using the Node resolution algorithm, for using third party modules in node_modules
+ */
+export function nodeResolve(options?: RollupNodeResolveOptions): Plugin;
+export default nodeResolve;

node_modules/@rollup/plugin-typescript/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.

node_modules/@rollup/plugin-typescript/README.md

@@ -0,0 +1,394 @@
+[npm]: https://img.shields.io/npm/v/@rollup/plugin-typescript
+[npm-url]: https://www.npmjs.com/package/@rollup/plugin-typescript
+[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-typescript
+[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-typescript
+
+[![npm][npm]][npm-url]
+[![size][size]][size-url]
+[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com)
+
+# @rollup/plugin-typescript
+
+🍣 A Rollup plugin for seamless integration between Rollup and Typescript.
+
+## Requirements
+
+This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v14.0.0+) and Rollup v2.14.0+. This plugin also requires at least [TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html).
+
+## Install
+
+Using npm:
+
+```console
+npm install @rollup/plugin-typescript --save-dev
+```
+
+Note that both `typescript` and `tslib` are peer dependencies of this plugin that need to be installed separately.
+
+## Why?
+
+See [@rollup/plugin-babel](https://github.com/rollup/plugins/tree/master/packages/babel).
+
+## Usage
+
+Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin:
+
+```js
+// rollup.config.js
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: {
+    dir: 'output',
+    format: 'cjs'
+  },
+  plugins: [typescript()]
+};
+```
+
+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
+
+The plugin loads any [`compilerOptions`](http://www.typescriptlang.org/docs/handbook/compiler-options.html) from the `tsconfig.json` file by default. Passing options to the plugin directly overrides those options:
+
+```js
+...
+export default {
+  input: './main.ts',
+  plugins: [
+      typescript({ compilerOptions: {lib: ["es5", "es6", "dom"], target: "es5"}})
+  ]
+}
+```
+
+The following options are unique to `@rollup/plugin-typescript`:
+
+### `exclude`
+
+Type: `String` | `Array[...String]`<br>
+Default: `null`
+
+A [picomatch pattern](https://github.com/micromatch/picomatch), 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 [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all `.ts` and `.tsx` files are targeted. If your `tsconfig.json` (or plugin `compilerOptions`) sets `allowJs: true`, the default include expands to also cover `.js`, `.jsx`, `.mjs`, and `.cjs` files so that JavaScript sources are downleveled by TypeScript as well.
+
+> Note: When `allowJs` is enabled and no `outDir` is configured, this plugin creates a temporary output directory for TypeScript emit to avoid TS5055 (overwriting input files). The effective `outDir` (whether user-provided or the temporary one) is excluded from plugin processing to prevent re-processing emitted files. The temporary directory is removed after a non-watch build completes; in watch mode it is removed when the watcher stops.
+>
+> When `allowJs` expands the default include and you have not specified patterns via `include`/`exclude`, the plugin also excludes `**/node_modules/**` by default to avoid transforming third-party code.
+
+### `filterRoot`
+
+Type: `String` | `Boolean`<br>
+Default: `rootDir` ?? `tsConfig.compilerOptions.rootDir` ?? `process.cwd()`
+
+Optionally resolves the include and exclude 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.
+
+By default, patterns resolve against the rootDir set in your TS config file.
+
+This can fix plugin errors when parsing files outside the current working directory (process.cwd()).
+
+### `tsconfig`
+
+Type: `String` | `Boolean`<br>
+Default: `true`
+
+When set to false, ignores any options specified in the config file. If set to a string that corresponds to a file path, the specified file will be used as config file.
+
+### `typescript`
+
+Type: `import('typescript')`<br>
+Default: _peer dependency_
+
+Overrides the TypeScript module used for transpilation.
+
+```js
+typescript({
+  typescript: require('some-fork-of-typescript')
+});
+```
+
+### `tslib`
+
+Type: `String`<br>
+Default: _peer dependency_
+
+Overrides the injected TypeScript helpers with a custom version.
+
+```js
+typescript({
+  tslib: require.resolve('some-fork-of-tslib')
+});
+```
+
+### `transformers`
+
+Type: `{ [before | after | afterDeclarations]: TransformerFactory[] } | ((program: ts.Program) => ts.CustomTransformers)`<br>
+Default: `undefined`
+
+Allows registration of TypeScript custom transformers at any of the supported stages:
+
+- **before**: transformers will execute before the TypeScript's own transformers on raw TypeScript files
+- **after**: transformers will execute after the TypeScript transformers on transpiled code
+- **afterDeclarations**: transformers will execute after declaration file generation allowing to modify existing declaration files
+
+Supported transformer factories:
+
+- all **built-in** TypeScript custom transformer factories:
+
+  - `import('typescript').TransformerFactory` annotated **TransformerFactory** below
+  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** below
+
+- **ProgramTransformerFactory** represents a transformer factory allowing the resulting transformer to grab a reference to the **Program** instance
+
+  ```js
+  {
+    type: 'program',
+    // An optional `getProgram` getter is provided in all modes. In non‑watch it returns
+    // the same Program as the first argument. In watch mode, when the
+    // `recreateTransformersOnRebuild` option is enabled, the getter reflects the latest
+    // Program across rebuilds; otherwise it refers to the initial Program.
+    factory: (program: Program, getProgram?: () => Program) =>
+      TransformerFactory | CustomTransformerFactory
+  }
+  ```
+
+- **TypeCheckerTransformerFactory** represents a transformer factory allowing the resulting transformer to grab a reference to the **TypeChecker** instance
+  ```js
+  {
+    type: 'typeChecker',
+    factory: (typeChecker: TypeChecker) => TransformerFactory | CustomTransformerFactory
+  }
+  ```
+
+```js
+typescript({
+  transformers: {
+    before: [
+      {
+        // Allow the transformer to get a Program reference in its factory.
+        // Prefer deferring `getProgram()` usage to transformation time so watch
+        // mode can see the freshest Program when `recreateTransformersOnRebuild`
+        // is enabled.
+        type: 'program',
+        factory: (program, getProgram) => {
+          const get = getProgram ?? (() => program);
+          return (context) => (source) => {
+            const latest = get();
+            // use `latest` here
+            return ts.visitEachChild(source, (n) => n, context);
+          };
+        }
+      },
+      {
+        type: 'typeChecker',
+        factory: (typeChecker) => {
+          // Allow the transformer to get a TypeChecker reference in its factory
+          return TypeCheckerRequiringTransformerFactory(typeChecker);
+        }
+      }
+    ],
+    after: [
+      // You can use normal transformers directly
+      require('custom-transformer-based-on-Context')
+    ],
+    afterDeclarations: [
+      // Or even define in place
+      function fixDeclarationFactory(context) {
+        return function fixDeclaration(source) {
+          function visitor(node) {
+            // Do real work here
+
+            return ts.visitEachChild(node, visitor, context);
+          }
+
+          return ts.visitEachChild(source, visitor, context);
+        };
+      }
+    ]
+  }
+});
+```
+
+Alternatively, the transformers can be created inside a factory.
+
+Supported transformer factories:
+
+- all **built-in** TypeScript custom transformer factories:
+
+  - `import('typescript').TransformerFactory` annotated **TransformerFactory** below
+  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** below
+
+The example above could be written like this:
+
+```js
+typescript({
+  transformers: function (program) {
+    return {
+      before: [
+        ProgramRequiringTransformerFactory(program),
+        TypeCheckerRequiringTransformerFactory(program.getTypeChecker())
+      ],
+      after: [
+        // You can use normal transformers directly
+        require('custom-transformer-based-on-Context')
+      ],
+      afterDeclarations: [
+        // Or even define in place
+        function fixDeclarationFactory(context) {
+          return function fixDeclaration(source) {
+            function visitor(node) {
+              // Do real work here
+
+              return ts.visitEachChild(node, visitor, context);
+            }
+
+            return ts.visitEachChild(source, visitor, context);
+          };
+        }
+      ]
+    };
+  }
+});
+```
+
+Note on watch mode
+
+By default (legacy behavior), this plugin reuses the same custom transformer factories for the lifetime of a watch session. Advanced users can opt into recreating factories on every TypeScript rebuild by enabling the `recreateTransformersOnRebuild` option. When enabled, both `program`- and `typeChecker`-based factories are rebuilt per watch cycle, and `getProgram()` (when used) reflects the latest Program across rebuilds.
+
+### `recreateTransformersOnRebuild`
+
+Type: `Boolean`<br>
+Default: `false` (legacy behavior)
+
+When `true`, the plugin recreates custom transformer factories on each TypeScript watch rebuild. This ensures factories capture the current `Program`/`TypeChecker` per cycle and that the optional `getProgram()` getter provided to `program`-based factories reflects the latest `Program` across rebuilds. Most users do not need this; enable it if your transformers depend on up‑to‑date Program/TypeChecker identities.
+
+```js
+// Opt-in to per-rebuild transformer recreation in watch mode
+typescript({
+  recreateTransformersOnRebuild: true,
+  transformers: {
+    before: [
+      {
+        type: 'program',
+        factory(program, getProgram) {
+          /* ... */
+        }
+      }
+    ]
+  }
+});
+```
+
+### `cacheDir`
+
+Type: `String`<br>
+Default: _.rollup.cache_
+
+When compiling with `incremental` or `composite` options the plugin will
+store compiled files in this folder. This allows the use of incremental
+compilation.
+
+```js
+typescript({
+  cacheDir: '.rollup.tscache'
+});
+```
+
+### `noForceEmit`
+
+Type: `Boolean`<br>
+Default: `false`
+
+Earlier version of `@rollup/plugin-typescript` required that the `compilerOptions` `noEmit` and `emitDeclarationOnly` both false to guarantee that source code was fed into the next plugin/output. This is no longer true. This option disables the plugin forcing the values of those options and instead defers to the values set in `tsconfig.json`.
+
+`noForceEmit` can be very useful if you use with `@rollup/plugin-babel` and `@babel/preset-typescript`. Having `@rollup/plugin-typescript` only do typechecking / declarations with `"emitDeclarationOnly": true` while deferring to `@rollup/plugin-babel` for transpilation can dramatically reduce `rollup` build times for large projects.
+
+### Typescript compiler options
+
+Some of Typescript's [CompilerOptions](https://www.typescriptlang.org/docs/handbook/compiler-options.html) affect how Rollup builds files.
+
+#### `noEmitOnError`
+
+Type: `Boolean`<br>
+Default: `false`
+
+If a type error is detected, the Rollup build is aborted when this option is set to true.
+
+#### `files`, `include`, `exclude`
+
+Type: `Array[...String]`<br>
+Default: `[]`
+
+Declaration files are automatically included if they are listed in the `files` field in your `tsconfig.json` file. Source files in these fields are ignored as Rollup's configuration is used instead.
+
+#### Ignored options
+
+These compiler options are ignored by Rollup:
+
+- `noEmitHelpers`, `importHelpers`: The `tslib` helper module always must be used.
+- `noEmit`, `emitDeclarationOnly`: Typescript needs to emit code for the plugin to work with.
+  - _Note: While this was true for early iterations of `@rollup/plugin-typescript`, it is no longer. To override this behavior, and defer to `tsconfig.json` for these options, see the [`noForceEmit`](#noForceEmit) option_
+- `noResolve`: Preventing Typescript from resolving code may break compilation
+
+### Importing CommonJS
+
+Though it is not recommended, it is possible to configure this plugin to handle imports of CommonJS files from TypeScript. For this, you need to specify `CommonJS` as the module format and add [`@rollup/plugin-commonjs`](https://github.com/rollup/plugins/tree/master/packages/commonjs) to transpile the CommonJS output generated by TypeScript to ES Modules so that rollup can process it.
+
+```js
+// rollup.config.js
+import typescript from '@rollup/plugin-typescript';
+import commonjs from '@rollup/plugin-commonjs';
+
+export default {
+  input: './main.ts',
+  plugins: [
+    typescript({ compilerOptions: { module: 'CommonJS' } }),
+    commonjs({ extensions: ['.js', '.ts'] }) // the ".ts" extension is required
+  ]
+};
+```
+
+Note that this will often result in less optimal output.
+
+### Preserving JSX output
+
+Whenever choosing to preserve JSX output to be further consumed by another transform step via `tsconfig` `compilerOptions` by setting `jsx: 'preserve'` or [overriding options](#options), please bear in mind that, by itself, this plugin won't be able to preserve JSX output, usually failing with:
+
+```sh
+[!] Error: Unexpected token (Note that you need plugins to import files that are not JavaScript)
+file.tsx (1:15)
+1: export default <span>Foobar</span>
+                  ^
+```
+
+To prevent that, make sure to use the acorn plugin, namely `acorn-jsx`, which will make Rollup's parser acorn handle JSX tokens. (See https://rollupjs.org/guide/en/#acorninjectplugins)
+
+After adding `acorn-jsx` plugin, your Rollup config would look like the following, correctly preserving your JSX output.
+
+```js
+import jsx from 'acorn-jsx';
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  // … other options …
+  acornInjectPlugins: [jsx()],
+  plugins: [typescript({ compilerOptions: { jsx: 'preserve' } })]
+};
+```
+
+### Faster compiling
+
+Previous versions of this plugin used Typescript's `transpileModule` API, which is faster but does not perform typechecking and does not support cross-file features like `const enum`s and emit-less types. If you want this behaviour, you can use [@rollup/plugin-sucrase](https://github.com/rollup/plugins/tree/master/packages/sucrase) instead.
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

node_modules/@rollup/plugin-typescript/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/plugin-typescript/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@rollup/plugin-typescript",
+  "version": "12.3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Seamless integration between Rollup and TypeScript.",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/typescript"
+  },
+  "author": "Oskar Segersvärd",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/typescript/#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "typescript",
+    "es2015"
+  ],
+  "peerDependencies": {
+    "rollup": "^2.14.0||^3.0.0||^4.0.0",
+    "tslib": "*",
+    "typescript": ">=3.7.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    },
+    "tslib": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.1.0",
+    "resolve": "^1.22.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-buble": "^1.0.0",
+    "@rollup/plugin-commonjs": "^23.0.0",
+    "@types/node": "^14.18.30",
+    "@types/resolve": "^1.20.2",
+    "buble": "^0.20.0",
+    "rollup": "^4.0.0-24",
+    "typescript": "^4.8.3"
+  },
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose --serial",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc --noEmit"
+  }
+}

node_modules/@rollup/plugin-typescript/types/index.d.ts

@@ -0,0 +1,134 @@
+/* eslint-disable no-use-before-define */
+import type _typescript from 'typescript';
+
+import type { FilterPattern } from '@rollup/pluginutils';
+import type { Plugin } from 'rollup';
+import type {
+  CompilerOptions,
+  CompilerOptionsValue,
+  CustomTransformers,
+  Program,
+  TsConfigSourceFile,
+  TypeChecker
+} from 'typescript';
+
+type ElementType<T extends Array<any> | undefined> = T extends (infer U)[] ? U : never;
+
+export type TransformerStage = keyof CustomTransformers;
+type StagedTransformerFactory<T extends TransformerStage> = ElementType<CustomTransformers[T]>;
+type TransformerFactory<T extends TransformerStage> =
+  | StagedTransformerFactory<T>
+  | ProgramTransformerFactory<T>
+  | TypeCheckerTransformerFactory<T>;
+
+export type CustomTransformerFactories = {
+  [stage in TransformerStage]?: Array<TransformerFactory<stage>>;
+};
+
+interface ProgramTransformerFactory<T extends TransformerStage> {
+  type: 'program';
+
+  /**
+   * Factory receives the current Program and may also receive a getter for retrieving
+   * the Program at call time. The getter may be provided in all modes. In non-watch it
+   * returns the same Program as the first argument. In watch mode:
+   *  - When `recreateTransformersOnRebuild` is enabled (plugin option), the getter
+   *    reflects the latest Program across rebuilds.
+   *  - When disabled (default, legacy behavior), factories are reused and the getter
+   *    refers to the initial Program from when the factory was created.
+   * The second parameter remains optional for backwards compatibility with existing
+   * transformer factories.
+   */
+  factory(program: Program, getProgram?: () => Program): StagedTransformerFactory<T>;
+}
+
+interface TypeCheckerTransformerFactory<T extends TransformerStage> {
+  type: 'typeChecker';
+
+  factory(typeChecker: TypeChecker): StagedTransformerFactory<T>;
+}
+
+export interface RollupTypescriptPluginOptions {
+  /**
+   * If using incremental this is the folder where the cached
+   * files will be created and kept for Typescript incremental
+   * compilation.
+   */
+  cacheDir?: string;
+  /**
+   * Determine which files are transpiled by Typescript (all `.ts` and
+   * `.tsx` files by default).
+   */
+  include?: FilterPattern;
+  /**
+   * Determine which files are ignored by Typescript
+   */
+  exclude?: FilterPattern;
+  /**
+   * Sets the `resolve` value for the underlying filter function.  If not set will use the `rootDir` property
+   * @see {@link https://github.com/rollup/plugins/tree/master/packages/pluginutils#createfilter} @rollup/pluginutils `createFilter`
+   */
+  filterRoot?: string | false;
+  /**
+   * When set to false, ignores any options specified in the config file.
+   * If set to a string that corresponds to a file path, the specified file
+   * will be used as config file.
+   */
+  tsconfig?: string | false;
+  /**
+   * Overrides TypeScript used for transpilation
+   */
+  typescript?: typeof _typescript;
+  /**
+   * Overrides the injected TypeScript helpers with a custom version.
+   */
+  tslib?: Promise<string> | string;
+  /**
+   * TypeScript custom transformers
+   */
+  transformers?: CustomTransformerFactories | ((program: Program) => CustomTransformers);
+  /**
+   * When set to false, force non-cached files to always be emitted in the output directory.output
+   * If not set, will default to true with a warning.
+   */
+  outputToFilesystem?: boolean;
+  /**
+   * Pass additional compiler options to the plugin.
+   */
+  compilerOptions?: PartialCompilerOptions;
+  /**
+   * Override force setting of `noEmit` and `emitDeclarationOnly` and use what is defined in `tsconfig.json`
+   */
+  noForceEmit?: boolean;
+  /**
+   * Advanced: when true, recreate custom transformer factories on each TypeScript
+   * watch rebuild so that `program`/`typeChecker`-based factories are rebuilt and
+   * `getProgram()` (when used) reflects the latest Program across rebuilds.
+   * Defaults to false (legacy behavior), which reuses factories for the lifetime
+   * of the watch session.
+   */
+  recreateTransformersOnRebuild?: boolean;
+}
+
+export interface FlexibleCompilerOptions extends CompilerOptions {
+  [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined | any;
+}
+
+/** Properties of `CompilerOptions` that are normally enums */
+export type EnumCompilerOptions = 'module' | 'moduleResolution' | 'newLine' | 'jsx' | 'target';
+
+/** JSON representation of Typescript compiler options */
+export type JsonCompilerOptions = Omit<FlexibleCompilerOptions, EnumCompilerOptions> &
+  Record<EnumCompilerOptions, string>;
+
+/** Compiler options set by the plugin user. */
+export type PartialCompilerOptions =
+  | Partial<FlexibleCompilerOptions>
+  | Partial<JsonCompilerOptions>;
+
+export type RollupTypescriptOptions = RollupTypescriptPluginOptions & PartialCompilerOptions;
+
+/**
+ * Seamless integration between Rollup and Typescript.
+ */
+export default function typescript(options?: RollupTypescriptOptions): Plugin;

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.

node_modules/@rollup/pluginutils/README.md

@@ -0,0 +1,313 @@
+[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
+
+The plugin utils require an [LTS](https://github.com/nodejs/Release) Node version (v14.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/plugins/tree/master/packages/inject) or [@rollup/plugin-commonjs](https://github.com/rollup/plugins/tree/master/packages/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?: <picomatch>, exclude?: <picomatch>, options?: Object)`<br>
+Returns: `(id: string | unknown) => boolean`
+
+#### `include` and `exclude`
+
+Type: `String | RegExp | Array[...String|RegExp]`<br>
+
+A valid [`picomatch`](https://github.com/micromatch/picomatch#globbing-features) 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 `picomatch` patterns, and must not match any of the `options.exclude` patterns.
+
+Note that `picomatch` patterns are very similar to [`minimatch`](https://github.com/isaacs/minimatch#readme) patterns, and in most use cases, they are interchangeable. If you have more specific pattern matching needs, you can view [this comparison table](https://github.com/micromatch/picomatch#library-comparisons) to learn more about where the libraries differ.
+
+#### `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, options: DataToEsmOptions)`<br>
+Returns: `String`
+
+#### `data`
+
+Type: `Object`
+
+An object to transform into an ES module.
+
+#### `options`
+
+Type: `DataToEsmOptions`
+
+_Note: Please see the TypeScript definition for complete documentation of these options_
+
+#### Usage
+
+```js
+import { dataToEsm } from '@rollup/pluginutils';
+
+const esModuleSource = dataToEsm(
+  {
+    custom: 'data',
+    to: ['treeshake']
+  },
+  {
+    compact: false,
+    indent: '\t',
+    preferConst: true,
+    objectShorthand: true,
+    namedExports: true,
+    includeArbitraryNames: false
+  }
+);
+/*
+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']
+          }
+        }
+      });
+    }
+  };
+}
+```
+
+### exactRegex
+
+Constructs a RegExp that matches the exact string specified. This is useful for plugin hook filters.
+
+Parameters: `(str: String | Array[...String], flags?: String)`<br>
+Returns: `RegExp`
+
+#### Usage
+
+```js
+import { exactRegex } from '@rollup/pluginutils';
+
+exactRegex('foobar'); // /^foobar$/
+exactRegex(['foo', 'bar']); // /^(?:foo|bar)$/
+exactRegex('foo(bar)', 'i'); // /^foo\(bar\)$/i
+```
+
+### 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'
+```
+
+### normalizePath
+
+Converts path separators to forward slash.
+
+Parameters: `(filename: String)`<br>
+Returns: `String`
+
+#### Usage
+
+```js
+import { normalizePath } from '@rollup/pluginutils';
+
+normalizePath('foo\\bar'); // 'foo/bar'
+normalizePath('foo/bar'); // 'foo/bar'
+```
+
+### prefixRegex
+
+Constructs a RegExp that matches a value that has the specified prefix. This is useful for plugin hook filters.
+
+Parameters: `(str: String | Array[...String], flags?: String)`<br>
+Returns: `RegExp`
+
+#### Usage
+
+```js
+import { prefixRegex } from '@rollup/pluginutils';
+
+prefixRegex('foobar'); // /^foobar/
+prefixRegex(['foo', 'bar']); // /^(?:foo|bar)/
+prefixRegex('foo(bar)', 'i'); // /^foo\(bar\)/i
+```
+
+### suffixRegex
+
+Constructs a RegExp that matches a value that has the specified suffix. This is useful for plugin hook filters.
+
+Parameters: `(str: String | Array[...String], flags?: String)`<br>
+Returns: `RegExp`
+
+#### Usage
+
+```js
+import { suffixRegex } from '@rollup/pluginutils';
+
+suffixRegex('foobar'); // /foobar$/
+suffixRegex(['foo', 'bar']); // /(?:foo|bar)$/
+suffixRegex('foo(bar)', 'i'); // /foo\(bar\)$/i
+```
+
+## Meta
+
+[CONTRIBUTING](/.github/CONTRIBUTING.md)
+
+[LICENSE (MIT)](/LICENSE)

node_modules/@rollup/pluginutils/dist/cjs/index.js

@@ -0,0 +1,407 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var estreeWalker = require('estree-walker');
+var pm = require('picomatch');
+
+const addExtension = function addExtension(filename, ext = '.js') {
+    let result = `${filename}`;
+    if (!path.extname(filename))
+        result += ext;
+    return result;
+};
+
+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();
+    estreeWalker.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];
+                node.declarations.forEach((declaration) => {
+                    scope.addDeclaration(declaration, isBlockDeclaration, true);
+                });
+            }
+            let newScope;
+            // create new function scope
+            if (node.type.includes('Function')) {
+                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 for scope
+            if (/For(?:In|Of)?Statement/.test(node.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // create new block scope
+            if (node.type === 'BlockStatement' && !parent.type.includes('Function')) {
+                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];
+}
+
+const normalizePathRegExp = new RegExp(`\\${path.win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, path.posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || path.isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath(path.resolve(resolutionBase || ''))
+        // 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, normalizePath(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);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            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 (typeof obj === 'object' && obj !== null) {
+        if (Array.isArray(obj))
+            return serializeArray(obj, indent, baseIndent);
+        if (obj instanceof Date)
+            return `new Date(${obj.getTime()})`;
+        if (obj instanceof RegExp)
+            return obj.toString();
+        return serializeObject(obj, indent, baseIndent);
+    }
+    if (typeof obj === 'number') {
+        if (obj === Infinity)
+            return 'Infinity';
+        if (obj === -Infinity)
+            return '-Infinity';
+        if (obj === 0)
+            return 1 / obj === Infinity ? '0' : '-0';
+        if (obj !== obj)
+            return 'NaN'; // eslint-disable-line no-self-compare
+    }
+    if (typeof obj === 'symbol') {
+        const key = Symbol.keyFor(obj);
+        // eslint-disable-next-line no-undefined
+        if (key !== undefined)
+            return `Symbol.for(${stringify(key)})`;
+    }
+    if (typeof obj === 'bigint')
+        return `${obj}n`;
+    return stringify(obj);
+}
+// isWellFormed exists from Node.js 20
+const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
+function isWellFormedString(input) {
+    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
+    if (hasStringIsWellFormed)
+        return input.isWellFormed();
+    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
+    return !/\p{Surrogate}/u.test(input);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    var _a, _b;
+    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 maxUnderbarPrefixLength = 0;
+    for (const key of Object.keys(data)) {
+        const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        if (underbarPrefixLength > maxUnderbarPrefixLength) {
+            maxUnderbarPrefixLength = underbarPrefixLength;
+        }
+    }
+    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    const arbitraryNameExportRows = [];
+    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, '')}`);
+            if (options.includeArbitraryNames && isWellFormedString(key)) {
+                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+            }
+        }
+    }
+    const arbitraryExportCode = arbitraryNameExportRows.length > 0
+        ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}`
+        : '';
+    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
+};
+
+function exactRegex(str, flags) {
+    return new RegExp(`^${combineMultipleStrings(str)}$`, flags);
+}
+function prefixRegex(str, flags) {
+    return new RegExp(`^${combineMultipleStrings(str)}`, flags);
+}
+function suffixRegex(str, flags) {
+    return new RegExp(`${combineMultipleStrings(str)}$`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+    return str.replace(escapeRegexRE, '\\$&');
+}
+function combineMultipleStrings(str) {
+    if (Array.isArray(str)) {
+        const escapeStr = str.map(escapeRegex).join('|');
+        if (escapeStr && str.length > 1) {
+            return `(?:${escapeStr})`;
+        }
+        return escapeStr;
+    }
+    return escapeRegex(str);
+}
+
+// TODO: remove this in next major
+var index = {
+    addExtension,
+    attachScopes,
+    createFilter,
+    dataToEsm,
+    exactRegex,
+    extractAssignedNames,
+    makeLegalIdentifier,
+    normalizePath,
+    prefixRegex,
+    suffixRegex
+};
+
+exports.addExtension = addExtension;
+exports.attachScopes = attachScopes;
+exports.createFilter = createFilter;
+exports.dataToEsm = dataToEsm;
+exports.default = index;
+exports.exactRegex = exactRegex;
+exports.extractAssignedNames = extractAssignedNames;
+exports.makeLegalIdentifier = makeLegalIdentifier;
+exports.normalizePath = normalizePath;
+exports.prefixRegex = prefixRegex;
+exports.suffixRegex = suffixRegex;
+module.exports = Object.assign(exports.default, exports);
+//# sourceMappingURL=index.js.map

node_modules/@rollup/pluginutils/dist/es/index.js

@@ -0,0 +1,392 @@
+import { extname, win32, posix, isAbsolute, resolve } from 'path';
+import { walk } from 'estree-walker';
+import pm from 'picomatch';
+
+const addExtension = function addExtension(filename, ext = '.js') {
+    let result = `${filename}`;
+    if (!extname(filename))
+        result += ext;
+    return result;
+};
+
+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];
+                node.declarations.forEach((declaration) => {
+                    scope.addDeclaration(declaration, isBlockDeclaration, true);
+                });
+            }
+            let newScope;
+            // create new function scope
+            if (node.type.includes('Function')) {
+                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 for scope
+            if (/For(?:In|Of)?Statement/.test(node.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // create new block scope
+            if (node.type === 'BlockStatement' && !parent.type.includes('Function')) {
+                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];
+}
+
+const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath(resolve(resolutionBase || ''))
+        // 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, normalizePath(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);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher instanceof RegExp) {
+                matcher.lastIndex = 0;
+            }
+            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 (typeof obj === 'object' && obj !== null) {
+        if (Array.isArray(obj))
+            return serializeArray(obj, indent, baseIndent);
+        if (obj instanceof Date)
+            return `new Date(${obj.getTime()})`;
+        if (obj instanceof RegExp)
+            return obj.toString();
+        return serializeObject(obj, indent, baseIndent);
+    }
+    if (typeof obj === 'number') {
+        if (obj === Infinity)
+            return 'Infinity';
+        if (obj === -Infinity)
+            return '-Infinity';
+        if (obj === 0)
+            return 1 / obj === Infinity ? '0' : '-0';
+        if (obj !== obj)
+            return 'NaN'; // eslint-disable-line no-self-compare
+    }
+    if (typeof obj === 'symbol') {
+        const key = Symbol.keyFor(obj);
+        // eslint-disable-next-line no-undefined
+        if (key !== undefined)
+            return `Symbol.for(${stringify(key)})`;
+    }
+    if (typeof obj === 'bigint')
+        return `${obj}n`;
+    return stringify(obj);
+}
+// isWellFormed exists from Node.js 20
+const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
+function isWellFormedString(input) {
+    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
+    if (hasStringIsWellFormed)
+        return input.isWellFormed();
+    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
+    return !/\p{Surrogate}/u.test(input);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    var _a, _b;
+    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 maxUnderbarPrefixLength = 0;
+    for (const key of Object.keys(data)) {
+        const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        if (underbarPrefixLength > maxUnderbarPrefixLength) {
+            maxUnderbarPrefixLength = underbarPrefixLength;
+        }
+    }
+    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    const arbitraryNameExportRows = [];
+    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, '')}`);
+            if (options.includeArbitraryNames && isWellFormedString(key)) {
+                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+            }
+        }
+    }
+    const arbitraryExportCode = arbitraryNameExportRows.length > 0
+        ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}`
+        : '';
+    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
+};
+
+function exactRegex(str, flags) {
+    return new RegExp(`^${combineMultipleStrings(str)}$`, flags);
+}
+function prefixRegex(str, flags) {
+    return new RegExp(`^${combineMultipleStrings(str)}`, flags);
+}
+function suffixRegex(str, flags) {
+    return new RegExp(`${combineMultipleStrings(str)}$`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+    return str.replace(escapeRegexRE, '\\$&');
+}
+function combineMultipleStrings(str) {
+    if (Array.isArray(str)) {
+        const escapeStr = str.map(escapeRegex).join('|');
+        if (escapeStr && str.length > 1) {
+            return `(?:${escapeStr})`;
+        }
+        return escapeStr;
+    }
+    return escapeRegex(str);
+}
+
+// TODO: remove this in next major
+var index = {
+    addExtension,
+    attachScopes,
+    createFilter,
+    dataToEsm,
+    exactRegex,
+    extractAssignedNames,
+    makeLegalIdentifier,
+    normalizePath,
+    prefixRegex,
+    suffixRegex
+};
+
+export { addExtension, attachScopes, createFilter, dataToEsm, index as default, exactRegex, extractAssignedNames, makeLegalIdentifier, normalizePath, prefixRegex, suffixRegex };
+//# sourceMappingURL=index.js.map

node_modules/@rollup/pluginutils/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@rollup/pluginutils/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@rollup/pluginutils",
+  "version": "5.3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "A set of utility functions commonly used by Rollup plugins",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/pluginutils"
+  },
+  "author": "Rich Harris <richard.a.harris@gmail.com>",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/pluginutils#readme",
+  "bugs": {
+    "url": "https://github.com/rollup/plugins/issues"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "type": "commonjs",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "utils"
+  ],
+  "peerDependencies": {
+    "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@types/estree": "^1.0.0",
+    "estree-walker": "^2.0.2",
+    "picomatch": "^4.0.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^23.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@rollup/plugin-typescript": "^9.0.1",
+    "@types/node": "^14.18.30",
+    "@types/picomatch": "^2.3.0",
+    "acorn": "^8.8.0",
+    "rollup": "^4.0.0-24",
+    "typescript": "^4.8.3"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "nyc": {
+    "extension": [
+      ".js",
+      ".ts"
+    ]
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build --sourcemap",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc --noEmit"
+  }
+}

node_modules/@rollup/pluginutils/types/index.d.ts

@@ -0,0 +1,125 @@
+import type { 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;
+  /**
+   * @desc When this option is set, dataToEsm will generate a named export for keys that
+   * are not a valid identifier, by leveraging the "Arbitrary Module Namespace Identifier
+   * Names" feature. See: https://github.com/tc39/ecma262/pull/2154
+   */
+  includeArbitraryNames?: boolean;
+  indent?: string;
+  namedExports?: boolean;
+  objectShorthand?: boolean;
+  preferConst?: boolean;
+}
+
+/**
+ * A valid `picomatch` glob 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;
+
+/**
+ * Constructs a RegExp that matches the exact string specified.
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ */
+export function exactRegex(str: string | string[], flags?: string): RegExp;
+
+/**
+ * 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;
+
+/**
+ * Converts path separators to forward slash.
+ */
+export function normalizePath(filename: string): string;
+
+/**
+ * Constructs a RegExp that matches a value that has the specified prefix.
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ */
+export function prefixRegex(str: string | string[], flags?: string): RegExp;
+
+/**
+ * Constructs a RegExp that matches a value that has the specified suffix.
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ */
+export function suffixRegex(str: string | string[], flags?: string): RegExp;
+
+export type AddExtension = typeof addExtension;
+export type AttachScopes = typeof attachScopes;
+export type CreateFilter = typeof createFilter;
+export type ExactRegex = typeof exactRegex;
+export type ExtractAssignedNames = typeof extractAssignedNames;
+export type MakeLegalIdentifier = typeof makeLegalIdentifier;
+export type NormalizePath = typeof normalizePath;
+export type DataToEsm = typeof dataToEsm;
+export type PrefixRegex = typeof prefixRegex;
+export type SuffixRegex = typeof suffixRegex;
+
+declare const defaultExport: {
+  addExtension: AddExtension;
+  attachScopes: AttachScopes;
+  createFilter: CreateFilter;
+  dataToEsm: DataToEsm;
+  exactRegex: ExactRegex;
+  extractAssignedNames: ExtractAssignedNames;
+  makeLegalIdentifier: MakeLegalIdentifier;
+  normalizePath: NormalizePath;
+  prefixRegex: PrefixRegex;
+  suffixRegex: SuffixRegex;
+};
+export default defaultExport;

node_modules/@rollup/rollup-darwin-arm64/README.md

@@ -0,0 +1,3 @@
+# `@rollup/rollup-darwin-arm64`
+
+This is the **aarch64-apple-darwin** binary for `rollup`

node_modules/@rollup/rollup-darwin-arm64/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@rollup/rollup-darwin-arm64",
+  "version": "4.60.4",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "rollup.darwin-arm64.node"
+  ],
+  "description": "Native bindings for Rollup",
+  "author": "Lukas Taegert-Atkinson",
+  "homepage": "https://rollupjs.org/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rollup/rollup.git"
+  },
+  "main": "./rollup.darwin-arm64.node"
+}