Index: frontend/node_modules/@rollup/plugin-node-resolve/CHANGELOG.md =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,414 @@ +# @rollup/plugin-node-resolve ChangeLog + +## v11.2.1 + +_2021-03-26_ + +### Bugfixes + +- fix: fs.exists is incorrectly promisified (#835) + +## v11.2.0 + +_2021-02-14_ + +### Features + +- feat: add `ignoreSideEffectsForRoot` option (#694) + +### Updates + +- chore: mark `url` as an external and throw on warning (#783) +- docs: clearer "Resolving Built-Ins" doc (#782) + +## v11.1.1 + +_2021-01-29_ + +### Bugfixes + +- fix: only log last resolve error (#750) + +### Updates + +- docs: add clarification on the order of package entrypoints (#768) + +## v11.1.0 + +_2021-01-15_ + +### Features + +- feat: support pkg imports and export array (#693) + +## v11.0.1 + +_2020-12-14_ + +### Bugfixes + +- fix: export map specificity (#675) +- fix: add missing type import (#668) + +### Updates + +- docs: corrected word "yse" to "use" (#723) + +## v11.0.0 + +_2020-11-30_ + +### Breaking Changes + +- refactor!: simplify builtins and remove `customResolveOptions` (#656) +- feat!: Mark built-ins as external (#627) +- feat!: support package entry points (#540) + +### Bugfixes + +- fix: refactor handling builtins, do not log warning if no local version (#637) + +### Updates + +- docs: fix import statements in examples in README.md (#646) + +## v10.0.0 + +_2020-10-27_ + +### Breaking Changes + +- fix!: resolve hash in path (#588) + +### Bugfixes + +- fix: do not ignore exceptions (#564) + +## v9.0.0 + +_2020-08-13_ + +### Breaking Changes + +- chore: update dependencies (e632469) + +### Updates + +- refactor: remove deep-freeze from dependencies (#529) +- chore: clean up changelog (84dfddb) + +## v8.4.0 + +_2020-07-12_ + +### Features + +- feat: preserve search params and hashes (#487) +- feat: support .js imports in TypeScript (#480) + +### Updates + +- docs: fix named export use in readme (#456) +- docs: correct mainFields valid values (#469) + +## v8.1.0 + +_2020-06-22_ + +### Features + +- feat: add native node es modules support (#413) + +## v8.0.1 + +_2020-06-05_ + +### Bugfixes + +- fix: handle nested entry modules with the resolveOnly option (#430) + +## v8.0.0 + +_2020-05-20_ + +### Breaking Changes + +- feat: Add default export (#361) +- feat: export defaults (#301) + +### Bugfixes + +- fix: resolve local files if `resolveOption` is set (#337) + +### Updates + +- docs: correct misspelling (#343) + +## v7.1.3 + +_2020-04-12_ + +### Bugfixes + +- fix: resolve symlinked entry point properly (#291) + +## v7.1.2 + +_2020-04-12_ + +### Updates + +- docs: fix url (#289) + +## v7.1.1 + +_2020-02-03_ + +### Bugfixes + +- fix: main fields regression (#196) + +## v7.1.0 + +_2020-02-01_ + +### Updates + +- refactor: clean codebase and fix external warnings (#155) + +## v7.0.0 + +_2020-01-07_ + +### Breaking Changes + +- feat: dedupe by package name (#99) + +## v6.1.0 + +_2020-01-04_ + +### Bugfixes + +- fix: allow deduplicating custom module dirs (#101) + +### Features + +- feat: add rootDir option (#98) + +### Updates + +- docs: improve doc related to mainFields (#138) + +## 6.0.0 + +_2019-11-25_ + +- **Breaking:** Minimum compatible Rollup version is 1.20.0 +- **Breaking:** Minimum supported Node version is 8.0.0 +- Published as @rollup/plugin-node-resolve + +## 5.2.1 (unreleased) + +- add missing MIT license file ([#233](https://github.com/rollup/rollup-plugin-node-resolve/pull/233) by @kenjiO) +- Fix incorrect example of config ([#239](https://github.com/rollup/rollup-plugin-node-resolve/pull/240) by @myshov) +- Fix typo in readme ([#240](https://github.com/rollup/rollup-plugin-node-resolve/pull/240) by @LinusU) + +## 5.2.0 (2019-06-29) + +- dedupe accepts a function ([#225](https://github.com/rollup/rollup-plugin-node-resolve/pull/225) by @manucorporat) + +## 5.1.1 (2019-06-29) + +- Move Rollup version check to buildStart hook to avoid issues ([#232](https://github.com/rollup/rollup-plugin-node-resolve/pull/232) by @lukastaegert) + +## 5.1.0 (2019-06-22) + +- Fix path fragment inputs ([#229](https://github.com/rollup/rollup-plugin-node-resolve/pull/229) by @bterlson) + +## 5.0.4 (2019-06-22) + +- Treat sideEffects array as inclusion list ([#227](https://github.com/rollup/rollup-plugin-node-resolve/pull/227) by @mikeharder) + +## 5.0.3 (2019-06-16) + +- Make empty.js a virtual module ([#224](https://github.com/rollup/rollup-plugin-node-resolve/pull/224) by @manucorporat) + +## 5.0.2 (2019-06-13) + +- Support resolve 1.11.1, add built-in test ([#223](https://github.com/rollup/rollup-plugin-node-resolve/pull/223) by @bterlson) + +## 5.0.1 (2019-05-31) + +- Update to resolve@1.11.0 for better performance ([#220](https://github.com/rollup/rollup-plugin-node-resolve/pull/220) by @keithamus) + +## 5.0.0 (2019-05-15) + +- Replace bublé with babel, update dependencies ([#216](https://github.com/rollup/rollup-plugin-node-resolve/pull/216) by @mecurc) +- Handle module side-effects ([#219](https://github.com/rollup/rollup-plugin-node-resolve/pull/219) by @lukastaegert) + +### Breaking Changes + +- Requires at least rollup@1.11.0 to work (v1.12.0 for module side-effects to be respected) +- If used with rollup-plugin-commonjs, it should be at least v10.0.0 + +## 4.2.4 (2019-05-11) + +- Add note on builtins to Readme ([#215](https://github.com/rollup/rollup-plugin-node-resolve/pull/215) by @keithamus) +- Add issue templates ([#217](https://github.com/rollup/rollup-plugin-node-resolve/pull/217) by @mecurc) +- Improve performance by caching `isDir` ([#218](https://github.com/rollup/rollup-plugin-node-resolve/pull/218) by @keithamus) + +## 4.2.3 (2019-04-11) + +- Fix ordering of jsnext:main when using the jsnext option ([#209](https://github.com/rollup/rollup-plugin-node-resolve/pull/209) by @lukastaegert) + +## 4.2.2 (2019-04-10) + +- Fix TypeScript typings (rename and export Options interface) ([#206](https://github.com/rollup/rollup-plugin-node-resolve/pull/206) by @Kocal) +- Fix mainfields typing ([#207](https://github.com/rollup/rollup-plugin-node-resolve/pull/207) by @nicolashenry) + +## 4.2.1 (2019-04-06) + +- Respect setting the deprecated fields "module", "main", and "jsnext" ([#204](https://github.com/rollup/rollup-plugin-node-resolve/pull/204) by @nick-woodward) + +## 4.2.0 (2019-04-06) + +- Add new mainfields option ([#182](https://github.com/rollup/rollup-plugin-node-resolve/pull/182) by @keithamus) +- Added dedupe option to prevent bundling the same package multiple times ([#201](https://github.com/rollup/rollup-plugin-node-resolve/pull/182) by @sormy) + +## 4.1.0 (2019-04-05) + +- Add TypeScript typings ([#189](https://github.com/rollup/rollup-plugin-node-resolve/pull/189) by @NotWoods) +- Update dependencies ([#202](https://github.com/rollup/rollup-plugin-node-resolve/pull/202) by @lukastaegert) + +## 4.0.1 (2019-02-22) + +- Fix issue when external modules are specified in `package.browser` ([#143](https://github.com/rollup/rollup-plugin-node-resolve/pull/143) by @keithamus) +- Fix `package.browser` mapping issue when `false` is specified ([#183](https://github.com/rollup/rollup-plugin-node-resolve/pull/183) by @allex) + +## 4.0.0 (2018-12-09) + +This release will support rollup@1.0 + +### Features + +- Resolve modules used to define manual chunks ([#185](https://github.com/rollup/rollup-plugin-node-resolve/pull/185) by @mcshaman) +- Update dependencies and plugin hook usage ([#187](https://github.com/rollup/rollup-plugin-node-resolve/pull/187) by @lukastaegert) + +## 3.4.0 (2018-09-04) + +This release now supports `.mjs` files by default + +### Features + +- feat: Support .mjs files by default (https://github.com/rollup/rollup-plugin-node-resolve/pull/151, by @leebyron) + +## 3.3.0 (2018-03-17) + +This release adds the `only` option + +### New Features + +- feat: add `only` option (#83; @arantes555) + +### Docs + +- docs: correct description of `jail` option (#120; @GeorgeTaveras1231) + +## 3.2.0 (2018-03-07) + +This release caches reading/statting of files, to improve speed. + +### Performance Improvements + +- perf: cache file stats/reads (#126; @keithamus) + +## 3.0.4 (unreleased) + +- Update lockfile [#137](https://github.com/rollup/rollup-plugin-node-resolve/issues/137) +- Update rollup dependency [#138](https://github.com/rollup/rollup-plugin-node-resolve/issues/138) +- Enable installation from Github [#142](https://github.com/rollup/rollup-plugin-node-resolve/issues/142) + +## 3.0.3 + +- Fix [#130](https://github.com/rollup/rollup-plugin-node-resolve/issues/130) and [#131](https://github.com/rollup/rollup-plugin-node-resolve/issues/131) + +## 3.0.2 + +- Ensure `pkg.browser` is an object if necessary ([#129](https://github.com/rollup/rollup-plugin-node-resolve/pull/129)) + +## 3.0.1 + +- Remove `browser-resolve` dependency ([#127](https://github.com/rollup/rollup-plugin-node-resolve/pull/127)) + +## 3.0.0 + +- [BREAKING] Remove `options.skip` ([#90](https://github.com/rollup/rollup-plugin-node-resolve/pull/90)) +- Add `modulesOnly` option ([#96](https://github.com/rollup/rollup-plugin-node-resolve/pull/96)) + +## 2.1.1 + +- Prevent `jail` from breaking builds on Windows ([#93](https://github.com/rollup/rollup-plugin-node-resolve/issues/93)) + +## 2.1.0 + +- Add `jail` option ([#53](https://github.com/rollup/rollup-plugin-node-resolve/pull/53)) +- Add `customResolveOptions` option ([#79](https://github.com/rollup/rollup-plugin-node-resolve/pull/79)) +- Support symlinked packages ([#82](https://github.com/rollup/rollup-plugin-node-resolve/pull/82)) + +## 2.0.0 + +- Add support `module` field in package.json as an official alternative to jsnext + +## 1.7.3 + +- Error messages are more descriptive ([#50](https://github.com/rollup/rollup-plugin-node-resolve/issues/50)) + +## 1.7.2 + +- Allow entry point paths beginning with ./ + +## 1.7.1 + +- Return a `name` + +## 1.7.0 + +- Allow relative IDs to be external ([#32](https://github.com/rollup/rollup-plugin-node-resolve/pull/32)) + +## 1.6.0 + +- Skip IDs containing null character + +## 1.5.0 + +- Prefer built-in options, but allow opting out ([#28](https://github.com/rollup/rollup-plugin-node-resolve/pull/28)) + +## 1.4.0 + +- Pass `options.extensions` through to `node-resolve` + +## 1.3.0 + +- `skip: true` skips all packages that don't satisfy the `main` or `jsnext` options ([#16](https://github.com/rollup/rollup-plugin-node-resolve/pull/16)) + +## 1.2.1 + +- Support scoped packages in `skip` option ([#15](https://github.com/rollup/rollup-plugin-node-resolve/issues/15)) + +## 1.2.0 + +- Support `browser` field ([#8](https://github.com/rollup/rollup-plugin-node-resolve/issues/8)) +- Get tests to pass on Windows + +## 1.1.0 + +- Use node-resolve to handle various corner cases + +## 1.0.0 + +- Add ES6 build, use Rollup 0.20.0 + +## 0.1.0 + +- First release Index: frontend/node_modules/@rollup/plugin-node-resolve/LICENSE =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -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. Index: frontend/node_modules/@rollup/plugin-node-resolve/README.md =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,227 @@ +[npm]: https://img.shields.io/npm/v/@rollup/plugin-node-resolve +[npm-url]: https://www.npmjs.com/package/@rollup/plugin-node-resolve +[size]: https://packagephobia.now.sh/badge?p=@rollup/plugin-node-resolve +[size-url]: https://packagephobia.now.sh/result?p=@rollup/plugin-node-resolve + +[![npm][npm]][npm-url] +[![size][size]][size-url] +[![libera manifesto](https://img.shields.io/badge/libera-manifesto-lightgrey.svg)](https://liberamanifesto.com) + +# @rollup/plugin-node-resolve + +🍣 A Rollup plugin which locates modules using the [Node resolution algorithm](https://nodejs.org/api/modules.html#modules_all_together), for using third party modules in `node_modules` + +## Requirements + +This plugin requires an [LTS](https://github.com/nodejs/Release) Node version (v8.0.0+) and Rollup v1.20.0+. + +## Install + +Using npm: + +```console +npm install @rollup/plugin-node-resolve --save-dev +``` + +## Usage + +Create a `rollup.config.js` [configuration file](https://www.rollupjs.org/guide/en/#configuration-files) and import the plugin: + +```js +import { nodeResolve } from '@rollup/plugin-node-resolve'; + +export default { + input: 'src/index.js', + output: { + dir: 'output', + format: 'cjs' + }, + plugins: [nodeResolve()] +}; +``` + +Then call `rollup` either via the [CLI](https://www.rollupjs.org/guide/en/#command-line-reference) or the [API](https://www.rollupjs.org/guide/en/#javascript-api). + +## Package entrypoints + +This plugin supports the package entrypoints feature from node js, specified in the `exports` or `imports` field of a package. Check the [official documentation](https://nodejs.org/api/packages.html#packages_package_entry_points) for more information on how this works. This is the default behavior. In the abscence of these fields, the fields in `mainFields` will be the ones to be used. + +## Options + +### `exportConditions` + +Type: `Array[...String]`
+Default: `[]` + +Additional conditions of the package.json exports field to match when resolving modules. By default, this plugin looks for the `['default', 'module', 'import']` conditions when resolving imports. + +When using `@rollup/plugin-commonjs` v16 or higher, this plugin will use the `['default', 'module', 'require']` conditions when resolving require statements. + +Setting this option will add extra conditions on top of the default conditions. See https://nodejs.org/api/packages.html#packages_conditional_exports for more information. + +### `browser` + +Type: `Boolean`
+Default: `false` + +If `true`, instructs the plugin to use the `"browser"` property in `package.json` files to specify alternative files to load for bundling. This is useful when bundling for a browser environment. Alternatively, a value of `'browser'` can be added to the `mainFields` option. If `false`, any `"browser"` properties in package files will be ignored. This option takes precedence over `mainFields`. + +> This option does not work when a package is using [package entrypoints](https://nodejs.org/api/packages.html#packages_package_entry_points) + +### `moduleDirectories` + +Type: `Array[...String]`
+Default: `['node_modules']` + +One or more directories in which to recursively look for modules. + +### `dedupe` + +Type: `Array[...String]`
+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]`
+Default: `['.mjs', '.js', '.json', '.node']` + +Specifies the extensions of files that the plugin will operate on. + +### `jail` + +Type: `String`
+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]`
+Default: `['module', 'main']`
+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`
+Default: `true` (with warnings if a builtin module is used over a local version. Set to `true` to disable warning.) + +If `true`, the plugin will prefer built-in modules (e.g. `fs`, `path`). If `false`, the plugin will look for locally installed modules of the same name. + +### `modulesOnly` + +Type: `Boolean`
+Default: `false` + +If `true`, inspect resolved files to assert that they are ES2015 modules. + +### `resolveOnly` + +Type: `Array[...String|RegExp]`
+Default: `null` + +An `Array` which instructs the plugin to limit module resolution to those whose names match patterns in the array. _Note: Modules not matching any patterns will be marked as external._ + +Example: `resolveOnly: ['batman', /^@batcave\/.*$/]` + +### `rootDir` + +Type: `String`
+Default: `process.cwd()` + +Specifies the root directory from which to resolve modules. Typically used when resolving entry-point imports, and when resolving deduplicated modules. Useful when executing rollup in a package of a mono-repository. + +``` +// Set the root directory to be the parent folder +rootDir: path.join(process.cwd(), '..') +``` + +## `ignoreSideEffectsForRoot` + +If you use the `sideEffects` property in the package.json, by default this is respected for files in the root package. Set to `true` to ignore the `sideEffects` configuration for the root package. + +## Preserving symlinks + +This plugin honours the rollup [`preserveSymlinks`](https://rollupjs.org/guide/en/#preservesymlinks) option. + +## Using with @rollup/plugin-commonjs + +Since most packages in your node_modules folder are probably legacy CommonJS rather than JavaScript modules, you may need to use [@rollup/plugin-commonjs](https://github.com/rollup/plugins/tree/master/packages/commonjs): + +```js +// rollup.config.js +import { nodeResolve } from '@rollup/plugin-node-resolve'; +import commonjs from '@rollup/plugin-commonjs'; + +export default { + input: 'main.js', + output: { + file: 'bundle.js', + format: 'iife', + name: 'MyModule' + }, + plugins: [nodeResolve(), commonjs()] +}; +``` + +## Resolving Built-Ins (like `fs`) + +By default this plugin will prefer built-ins over local modules, marking them as external. + +See [`preferBuiltins`](#preferbuiltins). + +To provide stubbed versions of Node built-ins, use a plugin like [rollup-plugin-node-polyfills](https://github.com/ionic-team/rollup-plugin-node-polyfills) and set `preferBuiltins` to `false`. e.g. + +```js +import { nodeResolve } from '@rollup/plugin-node-resolve'; +import nodePolyfills from 'rollup-plugin-node-polyfills'; +export default ({ + input: ..., + plugins: [ + nodePolyfills(), + nodeResolve({ preferBuiltins: false }) + ], + external: builtins, + output: ... +}) +``` + +## Resolving require statements + +According to [NodeJS module resolution](https://nodejs.org/api/packages.html#packages_package_entry_points) `require` statements should resolve using the `require` condition in the package exports field, while es modules should use the `import` condition. + +The node resolve plugin uses `import` by default, you can opt into using the `require` semantics by passing an extra option to the resolve function: + +```js +this.resolve(importee, importer, { + skipSelf: true, + custom: { 'node-resolve': { isRequire: true } } +}); +``` + +## Meta + +[CONTRIBUTING](/.github/CONTRIBUTING.md) + +[LICENSE (MIT)](/LICENSE) Index: frontend/node_modules/@rollup/plugin-node-resolve/dist/cjs/index.js =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/dist/cjs/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/dist/cjs/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1089 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var path = require('path'); +var builtinList = require('builtin-modules'); +var deepMerge = require('deepmerge'); +var isModule = require('is-module'); +var fs = require('fs'); +var util = require('util'); +var url = require('url'); +var resolve = require('resolve'); +var pluginutils = require('@rollup/pluginutils'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var path__default = /*#__PURE__*/_interopDefaultLegacy(path); +var builtinList__default = /*#__PURE__*/_interopDefaultLegacy(builtinList); +var deepMerge__default = /*#__PURE__*/_interopDefaultLegacy(deepMerge); +var isModule__default = /*#__PURE__*/_interopDefaultLegacy(isModule); +var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs); +var resolve__default = /*#__PURE__*/_interopDefaultLegacy(resolve); + +const access = util.promisify(fs__default['default'].access); +const readFile = util.promisify(fs__default['default'].readFile); +const realpath = util.promisify(fs__default['default'].realpath); +const stat = util.promisify(fs__default['default'].stat); +async function exists(filePath) { + try { + await access(filePath); + return true; + } catch { + return false; + } +} + +const onError = (error) => { + if (error.code === 'ENOENT') { + return false; + } + throw error; +}; + +const makeCache = (fn) => { + const cache = new Map(); + const wrapped = async (param, done) => { + if (cache.has(param) === false) { + cache.set( + param, + fn(param).catch((err) => { + cache.delete(param); + throw err; + }) + ); + } + + try { + const result = cache.get(param); + const value = await result; + return done(null, value); + } catch (error) { + return done(error); + } + }; + + wrapped.clear = () => cache.clear(); + + return wrapped; +}; + +const isDirCached = makeCache(async (file) => { + try { + const stats = await stat(file); + return stats.isDirectory(); + } catch (error) { + return onError(error); + } +}); + +const isFileCached = makeCache(async (file) => { + try { + const stats = await stat(file); + return stats.isFile(); + } catch (error) { + return onError(error); + } +}); + +const readCachedFile = makeCache(readFile); + +// returns the imported package name for bare module imports +function getPackageName(id) { + if (id.startsWith('.') || id.startsWith('/')) { + return null; + } + + const split = id.split('/'); + + // @my-scope/my-package/foo.js -> @my-scope/my-package + // @my-scope/my-package -> @my-scope/my-package + if (split[0][0] === '@') { + return `${split[0]}/${split[1]}`; + } + + // my-package/foo.js -> my-package + // my-package -> my-package + return split[0]; +} + +function getMainFields(options) { + let mainFields; + if (options.mainFields) { + ({ mainFields } = options); + } else { + mainFields = ['module', 'main']; + } + if (options.browser && mainFields.indexOf('browser') === -1) { + return ['browser'].concat(mainFields); + } + if (!mainFields.length) { + throw new Error('Please ensure at least one `mainFields` value is specified'); + } + return mainFields; +} + +function getPackageInfo(options) { + const { + cache, + extensions, + pkg, + mainFields, + preserveSymlinks, + useBrowserOverrides, + rootDir, + ignoreSideEffectsForRoot + } = options; + let { pkgPath } = options; + + if (cache.has(pkgPath)) { + return cache.get(pkgPath); + } + + // browserify/resolve doesn't realpath paths returned in its packageFilter callback + if (!preserveSymlinks) { + pkgPath = fs.realpathSync(pkgPath); + } + + const pkgRoot = path.dirname(pkgPath); + + const packageInfo = { + // copy as we are about to munge the `main` field of `pkg`. + packageJson: { ...pkg }, + + // path to package.json file + packageJsonPath: pkgPath, + + // directory containing the package.json + root: pkgRoot, + + // which main field was used during resolution of this module (main, module, or browser) + resolvedMainField: 'main', + + // whether the browser map was used to resolve the entry point to this module + browserMappedMain: false, + + // the entry point of the module with respect to the selected main field and any + // relevant browser mappings. + resolvedEntryPoint: '' + }; + + let overriddenMain = false; + for (let i = 0; i < mainFields.length; i++) { + const field = mainFields[i]; + if (typeof pkg[field] === 'string') { + pkg.main = pkg[field]; + packageInfo.resolvedMainField = field; + overriddenMain = true; + break; + } + } + + const internalPackageInfo = { + cachedPkg: pkg, + hasModuleSideEffects: () => null, + hasPackageEntry: overriddenMain !== false || mainFields.indexOf('main') !== -1, + packageBrowserField: + useBrowserOverrides && + typeof pkg.browser === 'object' && + Object.keys(pkg.browser).reduce((browser, key) => { + let resolved = pkg.browser[key]; + if (resolved && resolved[0] === '.') { + resolved = path.resolve(pkgRoot, resolved); + } + /* eslint-disable no-param-reassign */ + browser[key] = resolved; + if (key[0] === '.') { + const absoluteKey = path.resolve(pkgRoot, key); + browser[absoluteKey] = resolved; + if (!path.extname(key)) { + extensions.reduce((subBrowser, ext) => { + subBrowser[absoluteKey + ext] = subBrowser[key]; + return subBrowser; + }, browser); + } + } + return browser; + }, {}), + packageInfo + }; + + const browserMap = internalPackageInfo.packageBrowserField; + if ( + useBrowserOverrides && + typeof pkg.browser === 'object' && + // eslint-disable-next-line no-prototype-builtins + browserMap.hasOwnProperty(pkg.main) + ) { + packageInfo.resolvedEntryPoint = browserMap[pkg.main]; + packageInfo.browserMappedMain = true; + } else { + // index.node is technically a valid default entrypoint as well... + packageInfo.resolvedEntryPoint = path.resolve(pkgRoot, pkg.main || 'index.js'); + packageInfo.browserMappedMain = false; + } + + if (!ignoreSideEffectsForRoot || rootDir !== pkgRoot) { + const packageSideEffects = pkg.sideEffects; + if (typeof packageSideEffects === 'boolean') { + internalPackageInfo.hasModuleSideEffects = () => packageSideEffects; + } else if (Array.isArray(packageSideEffects)) { + internalPackageInfo.hasModuleSideEffects = pluginutils.createFilter(packageSideEffects, null, { + resolve: pkgRoot + }); + } + } + + cache.set(pkgPath, internalPackageInfo); + return internalPackageInfo; +} + +function normalizeInput(input) { + if (Array.isArray(input)) { + return input; + } else if (typeof input === 'object') { + return Object.values(input); + } + + // otherwise it's a string + return [input]; +} + +/* eslint-disable no-await-in-loop */ + +const fileExists = util.promisify(fs__default['default'].exists); + +function isModuleDir(current, moduleDirs) { + return moduleDirs.some((dir) => current.endsWith(dir)); +} + +async function findPackageJson(base, moduleDirs) { + const { root } = path__default['default'].parse(base); + let current = base; + + while (current !== root && !isModuleDir(current, moduleDirs)) { + const pkgJsonPath = path__default['default'].join(current, 'package.json'); + if (await fileExists(pkgJsonPath)) { + const pkgJsonString = fs__default['default'].readFileSync(pkgJsonPath, 'utf-8'); + return { pkgJson: JSON.parse(pkgJsonString), pkgPath: current, pkgJsonPath }; + } + current = path__default['default'].resolve(current, '..'); + } + return null; +} + +function isUrl(str) { + try { + return !!new URL(str); + } catch (_) { + return false; + } +} + +function isConditions(exports) { + return typeof exports === 'object' && Object.keys(exports).every((k) => !k.startsWith('.')); +} + +function isMappings(exports) { + return typeof exports === 'object' && !isConditions(exports); +} + +function isMixedExports(exports) { + const keys = Object.keys(exports); + return keys.some((k) => k.startsWith('.')) && keys.some((k) => !k.startsWith('.')); +} + +function createBaseErrorMsg(importSpecifier, importer) { + return `Could not resolve import "${importSpecifier}" in ${importer}`; +} + +function createErrorMsg(context, reason, internal) { + const { importSpecifier, importer, pkgJsonPath } = context; + const base = createBaseErrorMsg(importSpecifier, importer); + const field = internal ? 'imports' : 'exports'; + return `${base} using ${field} defined in ${pkgJsonPath}.${reason ? ` ${reason}` : ''}`; +} + +class ResolveError extends Error {} + +class InvalidConfigurationError extends ResolveError { + constructor(context, reason) { + super(createErrorMsg(context, `Invalid "exports" field. ${reason}`)); + } +} + +class InvalidModuleSpecifierError extends ResolveError { + constructor(context, internal) { + super(createErrorMsg(context, internal)); + } +} + +class InvalidPackageTargetError extends ResolveError { + constructor(context, reason) { + super(createErrorMsg(context, reason)); + } +} + +/* eslint-disable no-await-in-loop, no-undefined */ + +function includesInvalidSegments(pathSegments, moduleDirs) { + return pathSegments + .split('/') + .slice(1) + .some((t) => ['.', '..', ...moduleDirs].includes(t)); +} + +async function resolvePackageTarget(context, { target, subpath, pattern, internal }) { + if (typeof target === 'string') { + if (!pattern && subpath.length > 0 && !target.endsWith('/')) { + throw new InvalidModuleSpecifierError(context); + } + + if (!target.startsWith('./')) { + if (internal && !['/', '../'].some((p) => target.startsWith(p)) && !isUrl(target)) { + // this is a bare package import, remap it and resolve it using regular node resolve + if (pattern) { + const result = await context.resolveId( + target.replace(/\*/g, subpath), + context.pkgURL.href + ); + return result ? url.pathToFileURL(result.location) : null; + } + + const result = await context.resolveId(`${target}${subpath}`, context.pkgURL.href); + return result ? url.pathToFileURL(result.location) : null; + } + throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`); + } + + if (includesInvalidSegments(target, context.moduleDirs)) { + throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`); + } + + const resolvedTarget = new URL(target, context.pkgURL); + if (!resolvedTarget.href.startsWith(context.pkgURL.href)) { + throw new InvalidPackageTargetError( + context, + `Resolved to ${resolvedTarget.href} which is outside package ${context.pkgURL.href}` + ); + } + + if (includesInvalidSegments(subpath, context.moduleDirs)) { + throw new InvalidModuleSpecifierError(context); + } + + if (pattern) { + return resolvedTarget.href.replace(/\*/g, subpath); + } + return new URL(subpath, resolvedTarget).href; + } + + if (Array.isArray(target)) { + let lastError; + for (const item of target) { + try { + const resolved = await resolvePackageTarget(context, { + target: item, + subpath, + pattern, + internal + }); + + // return if defined or null, but not undefined + if (resolved !== undefined) { + return resolved; + } + } catch (error) { + if (!(error instanceof InvalidPackageTargetError)) { + throw error; + } else { + lastError = error; + } + } + } + + if (lastError) { + throw lastError; + } + return null; + } + + if (target && typeof target === 'object') { + for (const [key, value] of Object.entries(target)) { + if (key === 'default' || context.conditions.includes(key)) { + const resolved = await resolvePackageTarget(context, { + target: value, + subpath, + pattern, + internal + }); + + // return if defined or null, but not undefined + if (resolved !== undefined) { + return resolved; + } + } + } + return undefined; + } + + if (target === null) { + return null; + } + + throw new InvalidPackageTargetError(context, `Invalid exports field.`); +} + +/* eslint-disable no-await-in-loop */ + +async function resolvePackageImportsExports(context, { matchKey, matchObj, internal }) { + if (!matchKey.endsWith('*') && matchKey in matchObj) { + const target = matchObj[matchKey]; + const resolved = await resolvePackageTarget(context, { target, subpath: '', internal }); + return resolved; + } + + const expansionKeys = Object.keys(matchObj) + .filter((k) => k.endsWith('/') || k.endsWith('*')) + .sort((a, b) => b.length - a.length); + + for (const expansionKey of expansionKeys) { + const prefix = expansionKey.substring(0, expansionKey.length - 1); + + if (expansionKey.endsWith('*') && matchKey.startsWith(prefix)) { + const target = matchObj[expansionKey]; + const subpath = matchKey.substring(expansionKey.length - 1); + const resolved = await resolvePackageTarget(context, { + target, + subpath, + pattern: true, + internal + }); + return resolved; + } + + if (matchKey.startsWith(expansionKey)) { + const target = matchObj[expansionKey]; + const subpath = matchKey.substring(expansionKey.length); + + const resolved = await resolvePackageTarget(context, { target, subpath, internal }); + return resolved; + } + } + + throw new InvalidModuleSpecifierError(context, internal); +} + +async function resolvePackageExports(context, subpath, exports) { + if (isMixedExports(exports)) { + throw new InvalidConfigurationError( + context, + 'All keys must either start with ./, or without one.' + ); + } + + if (subpath === '.') { + let mainExport; + // If exports is a String or Array, or an Object containing no keys starting with ".", then + if (typeof exports === 'string' || Array.isArray(exports) || isConditions(exports)) { + mainExport = exports; + } else if (isMappings(exports)) { + mainExport = exports['.']; + } + + if (mainExport) { + const resolved = await resolvePackageTarget(context, { target: mainExport, subpath: '' }); + if (resolved) { + return resolved; + } + } + } else if (isMappings(exports)) { + const resolvedMatch = await resolvePackageImportsExports(context, { + matchKey: subpath, + matchObj: exports + }); + + if (resolvedMatch) { + return resolvedMatch; + } + } + + throw new InvalidModuleSpecifierError(context); +} + +async function resolvePackageImports({ + importSpecifier, + importer, + moduleDirs, + conditions, + resolveId +}) { + const result = await findPackageJson(importer, moduleDirs); + if (!result) { + throw new Error(createBaseErrorMsg('. Could not find a parent package.json.')); + } + + const { pkgPath, pkgJsonPath, pkgJson } = result; + const pkgURL = url.pathToFileURL(`${pkgPath}/`); + const context = { + importer, + importSpecifier, + moduleDirs, + pkgURL, + pkgJsonPath, + conditions, + resolveId + }; + + const { imports } = pkgJson; + if (!imports) { + throw new InvalidModuleSpecifierError(context, true); + } + + if (importSpecifier === '#' || importSpecifier.startsWith('#/')) { + throw new InvalidModuleSpecifierError(context, 'Invalid import specifier.'); + } + + return resolvePackageImportsExports(context, { + matchKey: importSpecifier, + matchObj: imports, + internal: true + }); +} + +const resolveImportPath = util.promisify(resolve__default['default']); +const readFile$1 = util.promisify(fs__default['default'].readFile); + +async function getPackageJson(importer, pkgName, resolveOptions, moduleDirectories) { + if (importer) { + const selfPackageJsonResult = await findPackageJson(importer, moduleDirectories); + if (selfPackageJsonResult && selfPackageJsonResult.pkgJson.name === pkgName) { + // the referenced package name is the current package + return selfPackageJsonResult; + } + } + + try { + const pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions); + const pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8')); + return { pkgJsonPath, pkgJson }; + } catch (_) { + return null; + } +} + +async function resolveId({ + importer, + importSpecifier, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot +}) { + let hasModuleSideEffects = () => null; + let hasPackageEntry = true; + let packageBrowserField = false; + let packageInfo; + + const filter = (pkg, pkgPath) => { + const info = getPackageInfo({ + cache: packageInfoCache, + extensions, + pkg, + pkgPath, + mainFields, + preserveSymlinks, + useBrowserOverrides, + rootDir, + ignoreSideEffectsForRoot + }); + + ({ packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = info); + + return info.cachedPkg; + }; + + const resolveOptions = { + basedir: baseDir, + readFile: readCachedFile, + isFile: isFileCached, + isDirectory: isDirCached, + extensions, + includeCoreModules: false, + moduleDirectory: moduleDirectories, + preserveSymlinks, + packageFilter: filter + }; + + let location; + + const pkgName = getPackageName(importSpecifier); + if (importSpecifier.startsWith('#')) { + // this is a package internal import, resolve using package imports field + const resolveResult = await resolvePackageImports({ + importSpecifier, + importer, + moduleDirs: moduleDirectories, + conditions: exportConditions, + resolveId(id, parent) { + return resolveId({ + importSpecifier: id, + importer: parent, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories + }); + } + }); + location = url.fileURLToPath(resolveResult); + } else if (pkgName) { + // it's a bare import, find the package.json and resolve using package exports if available + const result = await getPackageJson(importer, pkgName, resolveOptions, moduleDirectories); + + if (result && result.pkgJson.exports) { + const { pkgJson, pkgJsonPath } = result; + try { + const subpath = + pkgName === importSpecifier ? '.' : `.${importSpecifier.substring(pkgName.length)}`; + const pkgDr = pkgJsonPath.replace('package.json', ''); + const pkgURL = url.pathToFileURL(pkgDr); + + const context = { + importer, + importSpecifier, + moduleDirs: moduleDirectories, + pkgURL, + pkgJsonPath, + conditions: exportConditions + }; + const resolvedPackageExport = await resolvePackageExports( + context, + subpath, + pkgJson.exports + ); + location = url.fileURLToPath(resolvedPackageExport); + } catch (error) { + if (error instanceof ResolveError) { + return error; + } + throw error; + } + } + } + + if (!location) { + // package has no imports or exports, use classic node resolve + try { + location = await resolveImportPath(importSpecifier, resolveOptions); + } catch (error) { + if (error.code !== 'MODULE_NOT_FOUND') { + throw error; + } + return null; + } + } + + if (!preserveSymlinks) { + if (await exists(location)) { + location = await realpath(location); + } + } + + return { + location, + hasModuleSideEffects, + hasPackageEntry, + packageBrowserField, + packageInfo + }; +} + +// Resolve module specifiers in order. Promise resolves to the first module that resolves +// successfully, or the error that resulted from the last attempted module resolution. +async function resolveImportSpecifiers({ + importer, + importSpecifierList, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot +}) { + let lastResolveError; + + for (let i = 0; i < importSpecifierList.length; i++) { + // eslint-disable-next-line no-await-in-loop + const result = await resolveId({ + importer, + importSpecifier: importSpecifierList[i], + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot + }); + + if (result instanceof ResolveError) { + lastResolveError = result; + } else if (result) { + return result; + } + } + + if (lastResolveError) { + // only log the last failed resolve error + warn(lastResolveError); + } + return null; +} + +function handleDeprecatedOptions(opts) { + const warnings = []; + + if (opts.customResolveOptions) { + const { customResolveOptions } = opts; + if (customResolveOptions.moduleDirectory) { + // eslint-disable-next-line no-param-reassign + opts.moduleDirectories = Array.isArray(customResolveOptions.moduleDirectory) + ? customResolveOptions.moduleDirectory + : [customResolveOptions.moduleDirectory]; + + warnings.push( + 'node-resolve: The `customResolveOptions.moduleDirectory` option has been deprecated. Use `moduleDirectories`, which must be an array.' + ); + } + + if (customResolveOptions.preserveSymlinks) { + throw new Error( + 'node-resolve: `customResolveOptions.preserveSymlinks` is no longer an option. We now always use the rollup `preserveSymlinks` option.' + ); + } + + [ + 'basedir', + 'package', + 'extensions', + 'includeCoreModules', + 'readFile', + 'isFile', + 'isDirectory', + 'realpath', + 'packageFilter', + 'pathFilter', + 'paths', + 'packageIterator' + ].forEach((resolveOption) => { + if (customResolveOptions[resolveOption]) { + throw new Error( + `node-resolve: \`customResolveOptions.${resolveOption}\` is no longer an option. If you need this, please open an issue.` + ); + } + }); + } + + return { warnings }; +} + +/* eslint-disable no-param-reassign, no-shadow, no-undefined */ + +const builtins = new Set(builtinList__default['default']); +const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js'; +const deepFreeze = (object) => { + Object.freeze(object); + + for (const value of Object.values(object)) { + if (typeof value === 'object' && !Object.isFrozen(value)) { + deepFreeze(value); + } + } + + return object; +}; + +const baseConditions = ['default', 'module']; +const baseConditionsEsm = [...baseConditions, 'import']; +const baseConditionsCjs = [...baseConditions, 'require']; +const defaults = { + dedupe: [], + // It's important that .mjs is listed before .js so that Rollup will interpret npm modules + // which deploy both ESM .mjs and CommonJS .js files as ESM. + extensions: ['.mjs', '.js', '.json', '.node'], + resolveOnly: [], + moduleDirectories: ['node_modules'], + ignoreSideEffectsForRoot: false +}; +const DEFAULTS = deepFreeze(deepMerge__default['default']({}, defaults)); + +function nodeResolve(opts = {}) { + const { warnings } = handleDeprecatedOptions(opts); + + const options = { ...defaults, ...opts }; + const { extensions, jail, moduleDirectories, ignoreSideEffectsForRoot } = options; + const conditionsEsm = [...baseConditionsEsm, ...(options.exportConditions || [])]; + const conditionsCjs = [...baseConditionsCjs, ...(options.exportConditions || [])]; + const packageInfoCache = new Map(); + const idToPackageInfo = new Map(); + const mainFields = getMainFields(options); + const useBrowserOverrides = mainFields.indexOf('browser') !== -1; + const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false; + const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true; + const rootDir = path.resolve(options.rootDir || process.cwd()); + let { dedupe } = options; + let rollupOptions; + + if (typeof dedupe !== 'function') { + dedupe = (importee) => + options.dedupe.includes(importee) || options.dedupe.includes(getPackageName(importee)); + } + + const resolveOnly = options.resolveOnly.map((pattern) => { + if (pattern instanceof RegExp) { + return pattern; + } + const normalized = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&'); + return new RegExp(`^${normalized}$`); + }); + + const browserMapCache = new Map(); + let preserveSymlinks; + + return { + name: 'node-resolve', + + buildStart(options) { + rollupOptions = options; + + for (const warning of warnings) { + this.warn(warning); + } + + ({ preserveSymlinks } = options); + }, + + generateBundle() { + readCachedFile.clear(); + isFileCached.clear(); + isDirCached.clear(); + }, + + async resolveId(importee, importer, opts) { + if (importee === ES6_BROWSER_EMPTY) { + return importee; + } + // ignore IDs with null character, these belong to other plugins + if (/\0/.test(importee)) return null; + + if (/\0/.test(importer)) { + importer = undefined; + } + + // strip query params from import + const [importPath, params] = importee.split('?'); + const importSuffix = `${params ? `?${params}` : ''}`; + importee = importPath; + + const baseDir = !importer || dedupe(importee) ? rootDir : path.dirname(importer); + + // https://github.com/defunctzombie/package-browser-field-spec + const browser = browserMapCache.get(importer); + if (useBrowserOverrides && browser) { + const resolvedImportee = path.resolve(baseDir, importee); + if (browser[importee] === false || browser[resolvedImportee] === false) { + return ES6_BROWSER_EMPTY; + } + const browserImportee = + browser[importee] || + browser[resolvedImportee] || + browser[`${resolvedImportee}.js`] || + browser[`${resolvedImportee}.json`]; + if (browserImportee) { + importee = browserImportee; + } + } + + const parts = importee.split(/[/\\]/); + let id = parts.shift(); + let isRelativeImport = false; + + if (id[0] === '@' && parts.length > 0) { + // scoped packages + id += `/${parts.shift()}`; + } else if (id[0] === '.') { + // an import relative to the parent dir of the importer + id = path.resolve(baseDir, importee); + isRelativeImport = true; + } + + if ( + !isRelativeImport && + resolveOnly.length && + !resolveOnly.some((pattern) => pattern.test(id)) + ) { + if (normalizeInput(rollupOptions.input).includes(importee)) { + return null; + } + return false; + } + + const importSpecifierList = []; + + if (importer === undefined && !importee[0].match(/^\.?\.?\//)) { + // For module graph roots (i.e. when importer is undefined), we + // need to handle 'path fragments` like `foo/bar` that are commonly + // found in rollup config files. If importee doesn't look like a + // relative or absolute path, we make it relative and attempt to + // resolve it. If we don't find anything, we try resolving it as we + // got it. + importSpecifierList.push(`./${importee}`); + } + + const importeeIsBuiltin = builtins.has(importee); + + if (importeeIsBuiltin) { + // The `resolve` library will not resolve packages with the same + // name as a node built-in module. If we're resolving something + // that's a builtin, and we don't prefer to find built-ins, we + // first try to look up a local module with that name. If we don't + // find anything, we resolve the builtin which just returns back + // the built-in's name. + importSpecifierList.push(`${importee}/`); + } + + // TypeScript files may import '.js' to refer to either '.ts' or '.tsx' + if (importer && importee.endsWith('.js')) { + for (const ext of ['.ts', '.tsx']) { + if (importer.endsWith(ext) && extensions.includes(ext)) { + importSpecifierList.push(importee.replace(/.js$/, ext)); + } + } + } + + importSpecifierList.push(importee); + + const warn = (...args) => this.warn(...args); + const isRequire = + opts && opts.custom && opts.custom['node-resolve'] && opts.custom['node-resolve'].isRequire; + const exportConditions = isRequire ? conditionsCjs : conditionsEsm; + + const resolvedWithoutBuiltins = await resolveImportSpecifiers({ + importer, + importSpecifierList, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot + }); + + const resolved = + importeeIsBuiltin && preferBuiltins + ? { + packageInfo: undefined, + hasModuleSideEffects: () => null, + hasPackageEntry: true, + packageBrowserField: false + } + : resolvedWithoutBuiltins; + if (!resolved) { + return null; + } + + const { packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = resolved; + let { location } = resolved; + if (packageBrowserField) { + if (Object.prototype.hasOwnProperty.call(packageBrowserField, location)) { + if (!packageBrowserField[location]) { + browserMapCache.set(location, packageBrowserField); + return ES6_BROWSER_EMPTY; + } + location = packageBrowserField[location]; + } + browserMapCache.set(location, packageBrowserField); + } + + if (hasPackageEntry && !preserveSymlinks) { + const fileExists = await exists(location); + if (fileExists) { + location = await realpath(location); + } + } + + idToPackageInfo.set(location, packageInfo); + + if (hasPackageEntry) { + if (importeeIsBuiltin && preferBuiltins) { + if (!isPreferBuiltinsSet && resolvedWithoutBuiltins && resolved !== importee) { + this.warn( + `preferring built-in module '${importee}' over local alternative at '${resolvedWithoutBuiltins.location}', pass 'preferBuiltins: false' to disable this behavior or 'preferBuiltins: true' to disable this warning` + ); + } + return false; + } else if (jail && location.indexOf(path.normalize(jail.trim(path.sep))) !== 0) { + return null; + } + } + + if (options.modulesOnly && (await exists(location))) { + const code = await readFile(location, 'utf-8'); + if (isModule__default['default'](code)) { + return { + id: `${location}${importSuffix}`, + moduleSideEffects: hasModuleSideEffects(location) + }; + } + return null; + } + const result = { + id: `${location}${importSuffix}`, + moduleSideEffects: hasModuleSideEffects(location) + }; + return result; + }, + + load(importee) { + if (importee === ES6_BROWSER_EMPTY) { + return 'export default {};'; + } + return null; + }, + + getPackageInfoForId(id) { + return idToPackageInfo.get(id); + } + }; +} + +exports.DEFAULTS = DEFAULTS; +exports.default = nodeResolve; +exports.nodeResolve = nodeResolve; Index: frontend/node_modules/@rollup/plugin-node-resolve/dist/es/index.js =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/dist/es/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/dist/es/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1075 @@ +import path, { dirname, resolve, extname, normalize, sep } from 'path'; +import builtinList from 'builtin-modules'; +import deepMerge from 'deepmerge'; +import isModule from 'is-module'; +import fs, { realpathSync } from 'fs'; +import { promisify } from 'util'; +import { pathToFileURL, fileURLToPath } from 'url'; +import resolve$1 from 'resolve'; +import { createFilter } from '@rollup/pluginutils'; + +const access = promisify(fs.access); +const readFile = promisify(fs.readFile); +const realpath = promisify(fs.realpath); +const stat = promisify(fs.stat); +async function exists(filePath) { + try { + await access(filePath); + return true; + } catch { + return false; + } +} + +const onError = (error) => { + if (error.code === 'ENOENT') { + return false; + } + throw error; +}; + +const makeCache = (fn) => { + const cache = new Map(); + const wrapped = async (param, done) => { + if (cache.has(param) === false) { + cache.set( + param, + fn(param).catch((err) => { + cache.delete(param); + throw err; + }) + ); + } + + try { + const result = cache.get(param); + const value = await result; + return done(null, value); + } catch (error) { + return done(error); + } + }; + + wrapped.clear = () => cache.clear(); + + return wrapped; +}; + +const isDirCached = makeCache(async (file) => { + try { + const stats = await stat(file); + return stats.isDirectory(); + } catch (error) { + return onError(error); + } +}); + +const isFileCached = makeCache(async (file) => { + try { + const stats = await stat(file); + return stats.isFile(); + } catch (error) { + return onError(error); + } +}); + +const readCachedFile = makeCache(readFile); + +// returns the imported package name for bare module imports +function getPackageName(id) { + if (id.startsWith('.') || id.startsWith('/')) { + return null; + } + + const split = id.split('/'); + + // @my-scope/my-package/foo.js -> @my-scope/my-package + // @my-scope/my-package -> @my-scope/my-package + if (split[0][0] === '@') { + return `${split[0]}/${split[1]}`; + } + + // my-package/foo.js -> my-package + // my-package -> my-package + return split[0]; +} + +function getMainFields(options) { + let mainFields; + if (options.mainFields) { + ({ mainFields } = options); + } else { + mainFields = ['module', 'main']; + } + if (options.browser && mainFields.indexOf('browser') === -1) { + return ['browser'].concat(mainFields); + } + if (!mainFields.length) { + throw new Error('Please ensure at least one `mainFields` value is specified'); + } + return mainFields; +} + +function getPackageInfo(options) { + const { + cache, + extensions, + pkg, + mainFields, + preserveSymlinks, + useBrowserOverrides, + rootDir, + ignoreSideEffectsForRoot + } = options; + let { pkgPath } = options; + + if (cache.has(pkgPath)) { + return cache.get(pkgPath); + } + + // browserify/resolve doesn't realpath paths returned in its packageFilter callback + if (!preserveSymlinks) { + pkgPath = realpathSync(pkgPath); + } + + const pkgRoot = dirname(pkgPath); + + const packageInfo = { + // copy as we are about to munge the `main` field of `pkg`. + packageJson: { ...pkg }, + + // path to package.json file + packageJsonPath: pkgPath, + + // directory containing the package.json + root: pkgRoot, + + // which main field was used during resolution of this module (main, module, or browser) + resolvedMainField: 'main', + + // whether the browser map was used to resolve the entry point to this module + browserMappedMain: false, + + // the entry point of the module with respect to the selected main field and any + // relevant browser mappings. + resolvedEntryPoint: '' + }; + + let overriddenMain = false; + for (let i = 0; i < mainFields.length; i++) { + const field = mainFields[i]; + if (typeof pkg[field] === 'string') { + pkg.main = pkg[field]; + packageInfo.resolvedMainField = field; + overriddenMain = true; + break; + } + } + + const internalPackageInfo = { + cachedPkg: pkg, + hasModuleSideEffects: () => null, + hasPackageEntry: overriddenMain !== false || mainFields.indexOf('main') !== -1, + packageBrowserField: + useBrowserOverrides && + typeof pkg.browser === 'object' && + Object.keys(pkg.browser).reduce((browser, key) => { + let resolved = pkg.browser[key]; + if (resolved && resolved[0] === '.') { + resolved = resolve(pkgRoot, resolved); + } + /* eslint-disable no-param-reassign */ + browser[key] = resolved; + if (key[0] === '.') { + const absoluteKey = resolve(pkgRoot, key); + browser[absoluteKey] = resolved; + if (!extname(key)) { + extensions.reduce((subBrowser, ext) => { + subBrowser[absoluteKey + ext] = subBrowser[key]; + return subBrowser; + }, browser); + } + } + return browser; + }, {}), + packageInfo + }; + + const browserMap = internalPackageInfo.packageBrowserField; + if ( + useBrowserOverrides && + typeof pkg.browser === 'object' && + // eslint-disable-next-line no-prototype-builtins + browserMap.hasOwnProperty(pkg.main) + ) { + packageInfo.resolvedEntryPoint = browserMap[pkg.main]; + packageInfo.browserMappedMain = true; + } else { + // index.node is technically a valid default entrypoint as well... + packageInfo.resolvedEntryPoint = resolve(pkgRoot, pkg.main || 'index.js'); + packageInfo.browserMappedMain = false; + } + + if (!ignoreSideEffectsForRoot || rootDir !== pkgRoot) { + const packageSideEffects = pkg.sideEffects; + if (typeof packageSideEffects === 'boolean') { + internalPackageInfo.hasModuleSideEffects = () => packageSideEffects; + } else if (Array.isArray(packageSideEffects)) { + internalPackageInfo.hasModuleSideEffects = createFilter(packageSideEffects, null, { + resolve: pkgRoot + }); + } + } + + cache.set(pkgPath, internalPackageInfo); + return internalPackageInfo; +} + +function normalizeInput(input) { + if (Array.isArray(input)) { + return input; + } else if (typeof input === 'object') { + return Object.values(input); + } + + // otherwise it's a string + return [input]; +} + +/* eslint-disable no-await-in-loop */ + +const fileExists = promisify(fs.exists); + +function isModuleDir(current, moduleDirs) { + return moduleDirs.some((dir) => current.endsWith(dir)); +} + +async function findPackageJson(base, moduleDirs) { + const { root } = path.parse(base); + let current = base; + + while (current !== root && !isModuleDir(current, moduleDirs)) { + const pkgJsonPath = path.join(current, 'package.json'); + if (await fileExists(pkgJsonPath)) { + const pkgJsonString = fs.readFileSync(pkgJsonPath, 'utf-8'); + return { pkgJson: JSON.parse(pkgJsonString), pkgPath: current, pkgJsonPath }; + } + current = path.resolve(current, '..'); + } + return null; +} + +function isUrl(str) { + try { + return !!new URL(str); + } catch (_) { + return false; + } +} + +function isConditions(exports) { + return typeof exports === 'object' && Object.keys(exports).every((k) => !k.startsWith('.')); +} + +function isMappings(exports) { + return typeof exports === 'object' && !isConditions(exports); +} + +function isMixedExports(exports) { + const keys = Object.keys(exports); + return keys.some((k) => k.startsWith('.')) && keys.some((k) => !k.startsWith('.')); +} + +function createBaseErrorMsg(importSpecifier, importer) { + return `Could not resolve import "${importSpecifier}" in ${importer}`; +} + +function createErrorMsg(context, reason, internal) { + const { importSpecifier, importer, pkgJsonPath } = context; + const base = createBaseErrorMsg(importSpecifier, importer); + const field = internal ? 'imports' : 'exports'; + return `${base} using ${field} defined in ${pkgJsonPath}.${reason ? ` ${reason}` : ''}`; +} + +class ResolveError extends Error {} + +class InvalidConfigurationError extends ResolveError { + constructor(context, reason) { + super(createErrorMsg(context, `Invalid "exports" field. ${reason}`)); + } +} + +class InvalidModuleSpecifierError extends ResolveError { + constructor(context, internal) { + super(createErrorMsg(context, internal)); + } +} + +class InvalidPackageTargetError extends ResolveError { + constructor(context, reason) { + super(createErrorMsg(context, reason)); + } +} + +/* eslint-disable no-await-in-loop, no-undefined */ + +function includesInvalidSegments(pathSegments, moduleDirs) { + return pathSegments + .split('/') + .slice(1) + .some((t) => ['.', '..', ...moduleDirs].includes(t)); +} + +async function resolvePackageTarget(context, { target, subpath, pattern, internal }) { + if (typeof target === 'string') { + if (!pattern && subpath.length > 0 && !target.endsWith('/')) { + throw new InvalidModuleSpecifierError(context); + } + + if (!target.startsWith('./')) { + if (internal && !['/', '../'].some((p) => target.startsWith(p)) && !isUrl(target)) { + // this is a bare package import, remap it and resolve it using regular node resolve + if (pattern) { + const result = await context.resolveId( + target.replace(/\*/g, subpath), + context.pkgURL.href + ); + return result ? pathToFileURL(result.location) : null; + } + + const result = await context.resolveId(`${target}${subpath}`, context.pkgURL.href); + return result ? pathToFileURL(result.location) : null; + } + throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`); + } + + if (includesInvalidSegments(target, context.moduleDirs)) { + throw new InvalidPackageTargetError(context, `Invalid mapping: "${target}".`); + } + + const resolvedTarget = new URL(target, context.pkgURL); + if (!resolvedTarget.href.startsWith(context.pkgURL.href)) { + throw new InvalidPackageTargetError( + context, + `Resolved to ${resolvedTarget.href} which is outside package ${context.pkgURL.href}` + ); + } + + if (includesInvalidSegments(subpath, context.moduleDirs)) { + throw new InvalidModuleSpecifierError(context); + } + + if (pattern) { + return resolvedTarget.href.replace(/\*/g, subpath); + } + return new URL(subpath, resolvedTarget).href; + } + + if (Array.isArray(target)) { + let lastError; + for (const item of target) { + try { + const resolved = await resolvePackageTarget(context, { + target: item, + subpath, + pattern, + internal + }); + + // return if defined or null, but not undefined + if (resolved !== undefined) { + return resolved; + } + } catch (error) { + if (!(error instanceof InvalidPackageTargetError)) { + throw error; + } else { + lastError = error; + } + } + } + + if (lastError) { + throw lastError; + } + return null; + } + + if (target && typeof target === 'object') { + for (const [key, value] of Object.entries(target)) { + if (key === 'default' || context.conditions.includes(key)) { + const resolved = await resolvePackageTarget(context, { + target: value, + subpath, + pattern, + internal + }); + + // return if defined or null, but not undefined + if (resolved !== undefined) { + return resolved; + } + } + } + return undefined; + } + + if (target === null) { + return null; + } + + throw new InvalidPackageTargetError(context, `Invalid exports field.`); +} + +/* eslint-disable no-await-in-loop */ + +async function resolvePackageImportsExports(context, { matchKey, matchObj, internal }) { + if (!matchKey.endsWith('*') && matchKey in matchObj) { + const target = matchObj[matchKey]; + const resolved = await resolvePackageTarget(context, { target, subpath: '', internal }); + return resolved; + } + + const expansionKeys = Object.keys(matchObj) + .filter((k) => k.endsWith('/') || k.endsWith('*')) + .sort((a, b) => b.length - a.length); + + for (const expansionKey of expansionKeys) { + const prefix = expansionKey.substring(0, expansionKey.length - 1); + + if (expansionKey.endsWith('*') && matchKey.startsWith(prefix)) { + const target = matchObj[expansionKey]; + const subpath = matchKey.substring(expansionKey.length - 1); + const resolved = await resolvePackageTarget(context, { + target, + subpath, + pattern: true, + internal + }); + return resolved; + } + + if (matchKey.startsWith(expansionKey)) { + const target = matchObj[expansionKey]; + const subpath = matchKey.substring(expansionKey.length); + + const resolved = await resolvePackageTarget(context, { target, subpath, internal }); + return resolved; + } + } + + throw new InvalidModuleSpecifierError(context, internal); +} + +async function resolvePackageExports(context, subpath, exports) { + if (isMixedExports(exports)) { + throw new InvalidConfigurationError( + context, + 'All keys must either start with ./, or without one.' + ); + } + + if (subpath === '.') { + let mainExport; + // If exports is a String or Array, or an Object containing no keys starting with ".", then + if (typeof exports === 'string' || Array.isArray(exports) || isConditions(exports)) { + mainExport = exports; + } else if (isMappings(exports)) { + mainExport = exports['.']; + } + + if (mainExport) { + const resolved = await resolvePackageTarget(context, { target: mainExport, subpath: '' }); + if (resolved) { + return resolved; + } + } + } else if (isMappings(exports)) { + const resolvedMatch = await resolvePackageImportsExports(context, { + matchKey: subpath, + matchObj: exports + }); + + if (resolvedMatch) { + return resolvedMatch; + } + } + + throw new InvalidModuleSpecifierError(context); +} + +async function resolvePackageImports({ + importSpecifier, + importer, + moduleDirs, + conditions, + resolveId +}) { + const result = await findPackageJson(importer, moduleDirs); + if (!result) { + throw new Error(createBaseErrorMsg('. Could not find a parent package.json.')); + } + + const { pkgPath, pkgJsonPath, pkgJson } = result; + const pkgURL = pathToFileURL(`${pkgPath}/`); + const context = { + importer, + importSpecifier, + moduleDirs, + pkgURL, + pkgJsonPath, + conditions, + resolveId + }; + + const { imports } = pkgJson; + if (!imports) { + throw new InvalidModuleSpecifierError(context, true); + } + + if (importSpecifier === '#' || importSpecifier.startsWith('#/')) { + throw new InvalidModuleSpecifierError(context, 'Invalid import specifier.'); + } + + return resolvePackageImportsExports(context, { + matchKey: importSpecifier, + matchObj: imports, + internal: true + }); +} + +const resolveImportPath = promisify(resolve$1); +const readFile$1 = promisify(fs.readFile); + +async function getPackageJson(importer, pkgName, resolveOptions, moduleDirectories) { + if (importer) { + const selfPackageJsonResult = await findPackageJson(importer, moduleDirectories); + if (selfPackageJsonResult && selfPackageJsonResult.pkgJson.name === pkgName) { + // the referenced package name is the current package + return selfPackageJsonResult; + } + } + + try { + const pkgJsonPath = await resolveImportPath(`${pkgName}/package.json`, resolveOptions); + const pkgJson = JSON.parse(await readFile$1(pkgJsonPath, 'utf-8')); + return { pkgJsonPath, pkgJson }; + } catch (_) { + return null; + } +} + +async function resolveId({ + importer, + importSpecifier, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot +}) { + let hasModuleSideEffects = () => null; + let hasPackageEntry = true; + let packageBrowserField = false; + let packageInfo; + + const filter = (pkg, pkgPath) => { + const info = getPackageInfo({ + cache: packageInfoCache, + extensions, + pkg, + pkgPath, + mainFields, + preserveSymlinks, + useBrowserOverrides, + rootDir, + ignoreSideEffectsForRoot + }); + + ({ packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = info); + + return info.cachedPkg; + }; + + const resolveOptions = { + basedir: baseDir, + readFile: readCachedFile, + isFile: isFileCached, + isDirectory: isDirCached, + extensions, + includeCoreModules: false, + moduleDirectory: moduleDirectories, + preserveSymlinks, + packageFilter: filter + }; + + let location; + + const pkgName = getPackageName(importSpecifier); + if (importSpecifier.startsWith('#')) { + // this is a package internal import, resolve using package imports field + const resolveResult = await resolvePackageImports({ + importSpecifier, + importer, + moduleDirs: moduleDirectories, + conditions: exportConditions, + resolveId(id, parent) { + return resolveId({ + importSpecifier: id, + importer: parent, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories + }); + } + }); + location = fileURLToPath(resolveResult); + } else if (pkgName) { + // it's a bare import, find the package.json and resolve using package exports if available + const result = await getPackageJson(importer, pkgName, resolveOptions, moduleDirectories); + + if (result && result.pkgJson.exports) { + const { pkgJson, pkgJsonPath } = result; + try { + const subpath = + pkgName === importSpecifier ? '.' : `.${importSpecifier.substring(pkgName.length)}`; + const pkgDr = pkgJsonPath.replace('package.json', ''); + const pkgURL = pathToFileURL(pkgDr); + + const context = { + importer, + importSpecifier, + moduleDirs: moduleDirectories, + pkgURL, + pkgJsonPath, + conditions: exportConditions + }; + const resolvedPackageExport = await resolvePackageExports( + context, + subpath, + pkgJson.exports + ); + location = fileURLToPath(resolvedPackageExport); + } catch (error) { + if (error instanceof ResolveError) { + return error; + } + throw error; + } + } + } + + if (!location) { + // package has no imports or exports, use classic node resolve + try { + location = await resolveImportPath(importSpecifier, resolveOptions); + } catch (error) { + if (error.code !== 'MODULE_NOT_FOUND') { + throw error; + } + return null; + } + } + + if (!preserveSymlinks) { + if (await exists(location)) { + location = await realpath(location); + } + } + + return { + location, + hasModuleSideEffects, + hasPackageEntry, + packageBrowserField, + packageInfo + }; +} + +// Resolve module specifiers in order. Promise resolves to the first module that resolves +// successfully, or the error that resulted from the last attempted module resolution. +async function resolveImportSpecifiers({ + importer, + importSpecifierList, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot +}) { + let lastResolveError; + + for (let i = 0; i < importSpecifierList.length; i++) { + // eslint-disable-next-line no-await-in-loop + const result = await resolveId({ + importer, + importSpecifier: importSpecifierList[i], + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot + }); + + if (result instanceof ResolveError) { + lastResolveError = result; + } else if (result) { + return result; + } + } + + if (lastResolveError) { + // only log the last failed resolve error + warn(lastResolveError); + } + return null; +} + +function handleDeprecatedOptions(opts) { + const warnings = []; + + if (opts.customResolveOptions) { + const { customResolveOptions } = opts; + if (customResolveOptions.moduleDirectory) { + // eslint-disable-next-line no-param-reassign + opts.moduleDirectories = Array.isArray(customResolveOptions.moduleDirectory) + ? customResolveOptions.moduleDirectory + : [customResolveOptions.moduleDirectory]; + + warnings.push( + 'node-resolve: The `customResolveOptions.moduleDirectory` option has been deprecated. Use `moduleDirectories`, which must be an array.' + ); + } + + if (customResolveOptions.preserveSymlinks) { + throw new Error( + 'node-resolve: `customResolveOptions.preserveSymlinks` is no longer an option. We now always use the rollup `preserveSymlinks` option.' + ); + } + + [ + 'basedir', + 'package', + 'extensions', + 'includeCoreModules', + 'readFile', + 'isFile', + 'isDirectory', + 'realpath', + 'packageFilter', + 'pathFilter', + 'paths', + 'packageIterator' + ].forEach((resolveOption) => { + if (customResolveOptions[resolveOption]) { + throw new Error( + `node-resolve: \`customResolveOptions.${resolveOption}\` is no longer an option. If you need this, please open an issue.` + ); + } + }); + } + + return { warnings }; +} + +/* eslint-disable no-param-reassign, no-shadow, no-undefined */ + +const builtins = new Set(builtinList); +const ES6_BROWSER_EMPTY = '\0node-resolve:empty.js'; +const deepFreeze = (object) => { + Object.freeze(object); + + for (const value of Object.values(object)) { + if (typeof value === 'object' && !Object.isFrozen(value)) { + deepFreeze(value); + } + } + + return object; +}; + +const baseConditions = ['default', 'module']; +const baseConditionsEsm = [...baseConditions, 'import']; +const baseConditionsCjs = [...baseConditions, 'require']; +const defaults = { + dedupe: [], + // It's important that .mjs is listed before .js so that Rollup will interpret npm modules + // which deploy both ESM .mjs and CommonJS .js files as ESM. + extensions: ['.mjs', '.js', '.json', '.node'], + resolveOnly: [], + moduleDirectories: ['node_modules'], + ignoreSideEffectsForRoot: false +}; +const DEFAULTS = deepFreeze(deepMerge({}, defaults)); + +function nodeResolve(opts = {}) { + const { warnings } = handleDeprecatedOptions(opts); + + const options = { ...defaults, ...opts }; + const { extensions, jail, moduleDirectories, ignoreSideEffectsForRoot } = options; + const conditionsEsm = [...baseConditionsEsm, ...(options.exportConditions || [])]; + const conditionsCjs = [...baseConditionsCjs, ...(options.exportConditions || [])]; + const packageInfoCache = new Map(); + const idToPackageInfo = new Map(); + const mainFields = getMainFields(options); + const useBrowserOverrides = mainFields.indexOf('browser') !== -1; + const isPreferBuiltinsSet = options.preferBuiltins === true || options.preferBuiltins === false; + const preferBuiltins = isPreferBuiltinsSet ? options.preferBuiltins : true; + const rootDir = resolve(options.rootDir || process.cwd()); + let { dedupe } = options; + let rollupOptions; + + if (typeof dedupe !== 'function') { + dedupe = (importee) => + options.dedupe.includes(importee) || options.dedupe.includes(getPackageName(importee)); + } + + const resolveOnly = options.resolveOnly.map((pattern) => { + if (pattern instanceof RegExp) { + return pattern; + } + const normalized = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&'); + return new RegExp(`^${normalized}$`); + }); + + const browserMapCache = new Map(); + let preserveSymlinks; + + return { + name: 'node-resolve', + + buildStart(options) { + rollupOptions = options; + + for (const warning of warnings) { + this.warn(warning); + } + + ({ preserveSymlinks } = options); + }, + + generateBundle() { + readCachedFile.clear(); + isFileCached.clear(); + isDirCached.clear(); + }, + + async resolveId(importee, importer, opts) { + if (importee === ES6_BROWSER_EMPTY) { + return importee; + } + // ignore IDs with null character, these belong to other plugins + if (/\0/.test(importee)) return null; + + if (/\0/.test(importer)) { + importer = undefined; + } + + // strip query params from import + const [importPath, params] = importee.split('?'); + const importSuffix = `${params ? `?${params}` : ''}`; + importee = importPath; + + const baseDir = !importer || dedupe(importee) ? rootDir : dirname(importer); + + // https://github.com/defunctzombie/package-browser-field-spec + const browser = browserMapCache.get(importer); + if (useBrowserOverrides && browser) { + const resolvedImportee = resolve(baseDir, importee); + if (browser[importee] === false || browser[resolvedImportee] === false) { + return ES6_BROWSER_EMPTY; + } + const browserImportee = + browser[importee] || + browser[resolvedImportee] || + browser[`${resolvedImportee}.js`] || + browser[`${resolvedImportee}.json`]; + if (browserImportee) { + importee = browserImportee; + } + } + + const parts = importee.split(/[/\\]/); + let id = parts.shift(); + let isRelativeImport = false; + + if (id[0] === '@' && parts.length > 0) { + // scoped packages + id += `/${parts.shift()}`; + } else if (id[0] === '.') { + // an import relative to the parent dir of the importer + id = resolve(baseDir, importee); + isRelativeImport = true; + } + + if ( + !isRelativeImport && + resolveOnly.length && + !resolveOnly.some((pattern) => pattern.test(id)) + ) { + if (normalizeInput(rollupOptions.input).includes(importee)) { + return null; + } + return false; + } + + const importSpecifierList = []; + + if (importer === undefined && !importee[0].match(/^\.?\.?\//)) { + // For module graph roots (i.e. when importer is undefined), we + // need to handle 'path fragments` like `foo/bar` that are commonly + // found in rollup config files. If importee doesn't look like a + // relative or absolute path, we make it relative and attempt to + // resolve it. If we don't find anything, we try resolving it as we + // got it. + importSpecifierList.push(`./${importee}`); + } + + const importeeIsBuiltin = builtins.has(importee); + + if (importeeIsBuiltin) { + // The `resolve` library will not resolve packages with the same + // name as a node built-in module. If we're resolving something + // that's a builtin, and we don't prefer to find built-ins, we + // first try to look up a local module with that name. If we don't + // find anything, we resolve the builtin which just returns back + // the built-in's name. + importSpecifierList.push(`${importee}/`); + } + + // TypeScript files may import '.js' to refer to either '.ts' or '.tsx' + if (importer && importee.endsWith('.js')) { + for (const ext of ['.ts', '.tsx']) { + if (importer.endsWith(ext) && extensions.includes(ext)) { + importSpecifierList.push(importee.replace(/.js$/, ext)); + } + } + } + + importSpecifierList.push(importee); + + const warn = (...args) => this.warn(...args); + const isRequire = + opts && opts.custom && opts.custom['node-resolve'] && opts.custom['node-resolve'].isRequire; + const exportConditions = isRequire ? conditionsCjs : conditionsEsm; + + const resolvedWithoutBuiltins = await resolveImportSpecifiers({ + importer, + importSpecifierList, + exportConditions, + warn, + packageInfoCache, + extensions, + mainFields, + preserveSymlinks, + useBrowserOverrides, + baseDir, + moduleDirectories, + rootDir, + ignoreSideEffectsForRoot + }); + + const resolved = + importeeIsBuiltin && preferBuiltins + ? { + packageInfo: undefined, + hasModuleSideEffects: () => null, + hasPackageEntry: true, + packageBrowserField: false + } + : resolvedWithoutBuiltins; + if (!resolved) { + return null; + } + + const { packageInfo, hasModuleSideEffects, hasPackageEntry, packageBrowserField } = resolved; + let { location } = resolved; + if (packageBrowserField) { + if (Object.prototype.hasOwnProperty.call(packageBrowserField, location)) { + if (!packageBrowserField[location]) { + browserMapCache.set(location, packageBrowserField); + return ES6_BROWSER_EMPTY; + } + location = packageBrowserField[location]; + } + browserMapCache.set(location, packageBrowserField); + } + + if (hasPackageEntry && !preserveSymlinks) { + const fileExists = await exists(location); + if (fileExists) { + location = await realpath(location); + } + } + + idToPackageInfo.set(location, packageInfo); + + if (hasPackageEntry) { + if (importeeIsBuiltin && preferBuiltins) { + if (!isPreferBuiltinsSet && resolvedWithoutBuiltins && resolved !== importee) { + this.warn( + `preferring built-in module '${importee}' over local alternative at '${resolvedWithoutBuiltins.location}', pass 'preferBuiltins: false' to disable this behavior or 'preferBuiltins: true' to disable this warning` + ); + } + return false; + } else if (jail && location.indexOf(normalize(jail.trim(sep))) !== 0) { + return null; + } + } + + if (options.modulesOnly && (await exists(location))) { + const code = await readFile(location, 'utf-8'); + if (isModule(code)) { + return { + id: `${location}${importSuffix}`, + moduleSideEffects: hasModuleSideEffects(location) + }; + } + return null; + } + const result = { + id: `${location}${importSuffix}`, + moduleSideEffects: hasModuleSideEffects(location) + }; + return result; + }, + + load(importee) { + if (importee === ES6_BROWSER_EMPTY) { + return 'export default {};'; + } + return null; + }, + + getPackageInfoForId(id) { + return idToPackageInfo.get(id); + } + }; +} + +export default nodeResolve; +export { DEFAULTS, nodeResolve }; Index: frontend/node_modules/@rollup/plugin-node-resolve/dist/es/package.json =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/dist/es/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/dist/es/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"type":"module"} Index: frontend/node_modules/@rollup/plugin-node-resolve/package.json =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,87 @@ +{ + "name": "@rollup/plugin-node-resolve", + "version": "11.2.1", + "publishConfig": { + "access": "public" + }, + "description": "Locate and bundle third-party dependencies in node_modules", + "license": "MIT", + "repository": "rollup/plugins", + "author": "Rich Harris ", + "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", + "type": "commonjs", + "exports": { + "require": "./dist/cjs/index.js", + "import": "./dist/es/index.js" + }, + "engines": { + "node": ">= 10.0.0" + }, + "scripts": { + "build": "rollup -c", + "ci:coverage": "nyc pnpm run test && nyc report --reporter=text-lcov > coverage.lcov", + "ci:lint": "pnpm run build && pnpm run lint", + "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}", + "ci:test": "pnpm run test -- --verbose && pnpm run test:ts", + "lint": "pnpm run lint:js && pnpm run lint:docs && pnpm run lint:package", + "lint:docs": "prettier --single-quote --arrow-parens avoid --trailing-comma none --write README.md", + "lint:js": "eslint --fix --cache src test types --ext .js,.ts", + "lint:package": "prettier --write package.json --plugin=prettier-plugin-package", + "prebuild": "del-cli dist", + "prepare": "pnpm run build", + "prepublishOnly": "pnpm run lint && pnpm run test && pnpm run test:ts", + "pretest": "pnpm run build", + "test": "ava", + "test:ts": "tsc types/index.d.ts test/types.ts --noEmit" + }, + "files": [ + "dist", + "types", + "README.md", + "LICENSE" + ], + "keywords": [ + "rollup", + "plugin", + "es2015", + "npm", + "modules" + ], + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + }, + "dependencies": { + "@rollup/pluginutils": "^3.1.0", + "@types/resolve": "1.17.1", + "builtin-modules": "^3.1.0", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.19.0" + }, + "devDependencies": { + "@babel/core": "^7.10.5", + "@babel/plugin-transform-typescript": "^7.10.5", + "@rollup/plugin-babel": "^5.1.0", + "@rollup/plugin-commonjs": "^16.0.0", + "@rollup/plugin-json": "^4.1.0", + "es5-ext": "^0.10.53", + "rollup": "^2.23.0", + "source-map": "^0.7.3", + "string-capitalize": "^1.0.1" + }, + "types": "types/index.d.ts", + "ava": { + "babel": { + "compileEnhancements": false + }, + "files": [ + "!**/fixtures/**", + "!**/helpers/**", + "!**/recipes/**", + "!**/types.ts" + ] + } +} Index: frontend/node_modules/@rollup/plugin-node-resolve/types/index.d.ts =================================================================== --- frontend/node_modules/@rollup/plugin-node-resolve/types/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@rollup/plugin-node-resolve/types/index.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,98 @@ +import { Plugin } from 'rollup'; + +export const DEFAULTS: { + customResolveOptions: {}; + dedupe: []; + extensions: ['.mjs', '.js', '.json', '.node']; + resolveOnly: []; +}; + +export interface RollupNodeResolveOptions { + /** + * Additional conditions of the package.json exports field to match when resolving modules. + * By default, this plugin looks for the `'default', 'module', 'import']` conditions when resolving imports. + * + * When using `@rollup/plugin-commonjs` v16 or higher, this plugin will use the + * `['default', 'module', 'import']` conditions when resolving require statements. + * + * Setting this option will add extra conditions on top of the default conditions. + * See https://nodejs.org/api/packages.html#packages_conditional_exports for more information. + */ + exportConditions?: string[]; + + /** + * If `true`, instructs the plugin to use the `"browser"` property in `package.json` + * files to specify alternative files to load for bundling. This is useful when + * bundling for a browser environment. Alternatively, a value of `'browser'` can be + * added to the `mainFields` option. If `false`, any `"browser"` properties in + * package files will be ignored. This option takes precedence over `mainFields`. + * @default false + */ + browser?: boolean; + + /** + * One or more directories in which to recursively look for modules. + * @default ['node_modules'] + */ + moduleDirectories?: string[]; + + /** + * An `Array` of modules names, which instructs the plugin to force resolving for the + * specified modules to the root `node_modules`. Helps to prevent bundling the same + * package multiple times if package is imported from dependencies. + */ + dedupe?: string[] | ((importee: string) => boolean); + + /** + * Specifies the extensions of files that the plugin will operate on. + * @default [ '.mjs', '.js', '.json', '.node' ] + */ + extensions?: readonly string[]; + + /** + * Locks the module search within specified path (e.g. chroot). Modules defined + * outside this path will be marked as external. + * @default '/' + */ + jail?: string; + + /** + * Specifies the properties to scan within a `package.json`, used to determine the + * bundle entry point. + * @default ['module', 'main'] + */ + mainFields?: readonly string[]; + + /** + * If `true`, inspect resolved files to assert that they are ES2015 modules. + * @default false + */ + modulesOnly?: boolean; + + /** + * If `true`, the plugin will prefer built-in modules (e.g. `fs`, `path`). If `false`, + * the plugin will look for locally installed modules of the same name. + * @default true + */ + preferBuiltins?: boolean; + + /** + * An `Array` which instructs the plugin to limit module resolution to those whose + * names match patterns in the array. + * @default [] + */ + resolveOnly?: ReadonlyArray | null; + + /** + * Specifies the root directory from which to resolve modules. Typically used when + * resolving entry-point imports, and when resolving deduplicated modules. + * @default process.cwd() + */ + rootDir?: string; +} + +/** + * Locate modules using the Node resolution algorithm, for using third party modules in node_modules + */ +export function nodeResolve(options?: RollupNodeResolveOptions): Plugin; +export default nodeResolve;