initial commit

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

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

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

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function matches(pattern, importee) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(importee);
+    }
+    if (importee.length < pattern.length) {
+        return false;
+    }
+    if (importee === pattern) {
+        return true;
+    }
+    // eslint-disable-next-line prefer-template
+    return importee.startsWith(pattern + '/');
+}
+function getEntries({ entries, customResolver }) {
+    if (!entries) {
+        return [];
+    }
+    const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+    if (Array.isArray(entries)) {
+        return entries.map((entry) => {
+            return {
+                find: entry.find,
+                replacement: entry.replacement,
+                resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+            };
+        });
+    }
+    return Object.entries(entries).map(([key, value]) => {
+        return { find: key, replacement: value, resolverFunction: resolverFunctionFromOptions };
+    });
+}
+function getHookFunction(hook) {
+    if (typeof hook === 'function') {
+        return hook;
+    }
+    if (hook && 'handler' in hook && typeof hook.handler === 'function') {
+        return hook.handler;
+    }
+    return null;
+}
+function resolveCustomResolver(customResolver) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
+    if (customResolver) {
+        return getHookFunction(customResolver.resolveId);
+    }
+    return null;
+}
+function alias(options = {}) {
+    const entries = getEntries(options);
+    if (entries.length === 0) {
+        return {
+            name: 'alias',
+            resolveId: () => null
+        };
+    }
+    return {
+        name: 'alias',
+        async buildStart(inputOptions) {
+            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => { var _a; return customResolver && ((_a = getHookFunction(customResolver.buildStart)) === null || _a === void 0 ? void 0 : _a.call(this, inputOptions)); }));
+        },
+        resolveId(importee, importer, resolveOptions) {
+            if (!importer) {
+                return null;
+            }
+            // First match is supposed to be the correct one
+            const matchedEntry = entries.find((entry) => matches(entry.find, importee));
+            if (!matchedEntry) {
+                return null;
+            }
+            const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+            if (matchedEntry.resolverFunction) {
+                return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+            }
+            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => resolved || { id: updatedId });
+        }
+    };
+}
+
+exports.default = alias;
+module.exports = Object.assign(exports.default, exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,82 @@
+function matches(pattern, importee) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(importee);
+    }
+    if (importee.length < pattern.length) {
+        return false;
+    }
+    if (importee === pattern) {
+        return true;
+    }
+    // eslint-disable-next-line prefer-template
+    return importee.startsWith(pattern + '/');
+}
+function getEntries({ entries, customResolver }) {
+    if (!entries) {
+        return [];
+    }
+    const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+    if (Array.isArray(entries)) {
+        return entries.map((entry) => {
+            return {
+                find: entry.find,
+                replacement: entry.replacement,
+                resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+            };
+        });
+    }
+    return Object.entries(entries).map(([key, value]) => {
+        return { find: key, replacement: value, resolverFunction: resolverFunctionFromOptions };
+    });
+}
+function getHookFunction(hook) {
+    if (typeof hook === 'function') {
+        return hook;
+    }
+    if (hook && 'handler' in hook && typeof hook.handler === 'function') {
+        return hook.handler;
+    }
+    return null;
+}
+function resolveCustomResolver(customResolver) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
+    if (customResolver) {
+        return getHookFunction(customResolver.resolveId);
+    }
+    return null;
+}
+function alias(options = {}) {
+    const entries = getEntries(options);
+    if (entries.length === 0) {
+        return {
+            name: 'alias',
+            resolveId: () => null
+        };
+    }
+    return {
+        name: 'alias',
+        async buildStart(inputOptions) {
+            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => { var _a; return customResolver && ((_a = getHookFunction(customResolver.buildStart)) === null || _a === void 0 ? void 0 : _a.call(this, inputOptions)); }));
+        },
+        resolveId(importee, importer, resolveOptions) {
+            if (!importer) {
+                return null;
+            }
+            // First match is supposed to be the correct one
+            const matchedEntry = entries.find((entry) => matches(entry.find, importee));
+            if (!matchedEntry) {
+                return null;
+            }
+            const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+            if (matchedEntry.resolverFunction) {
+                return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+            }
+            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => resolved || { id: updatedId });
+        }
+    };
+}
+
+export { alias as default };
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,81 @@
+{
+  "name": "@rollup/plugin-alias",
+  "version": "4.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Define and resolve aliases for bundle dependencies",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/alias"
+  },
+  "author": "Johannes Stein",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/alias#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "import": "./dist/es/index.js",
+    "types": "./types/index.d.ts",
+    "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",
+    "test:ts": "tsc --noEmit"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "resolve",
+    "alias"
+  ],
+  "peerDependencies": {
+    "rollup": "^1.20.0||^2.0.0||^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "slash": "^4.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@rollup/plugin-typescript": "^9.0.1",
+    "del-cli": "^5.0.0",
+    "rollup": "^3.2.3",
+    "typescript": "^4.8.3"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "files": [
+      "!**/fixtures/**",
+      "!**/output/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  }
+}

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

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