pax_global_header00006660000000000000000000000064144421026000014503gustar00rootroot0000000000000052 comment=a998c7d218b7a9ec2461fc4fddd1ad5dd7687485 enhanced-resolve-5.15.0/000077500000000000000000000000001444210260000150155ustar00rootroot00000000000000enhanced-resolve-5.15.0/.cspell.json000066400000000000000000000011271444210260000172510ustar00rootroot00000000000000{ "version": "0.2", "words": [ "abcxyz", "addrs", "anotherhashishere", "arcanis", "Builtins", "complexm", "endregion", "entrypoints", "filesystems", "hashishere", "jsons", "Kopeykin", "Koppers", "MaĆ«l", "memfs", "mergeable", "Nison", "opensource", "pjson", "pnpapi", "sokra", "subpaths", "tapable", "undescribed", "unreviewed", "vankop", "wpck", "zapp", "zipp", "zippi", "zizizi", "codecov" ], "ignorePaths": ["package.json", "yarn.lock", "coverage", "*.log"] } enhanced-resolve-5.15.0/.editorconfig000066400000000000000000000003701444210260000174720ustar00rootroot00000000000000root = true [*] indent_style = tab indent_size = 2 charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true max_line_length = 80 [*.{yml,yaml,json}] indent_style = space indent_size = 2 [*.md] trim_trailing_whitespace = false enhanced-resolve-5.15.0/.eslintignore000066400000000000000000000000221444210260000175120ustar00rootroot00000000000000test/fixtures/**/*enhanced-resolve-5.15.0/.eslintrc.js000066400000000000000000000040401444210260000172520ustar00rootroot00000000000000module.exports = { root: true, plugins: ["prettier", "node", "jsdoc"], extends: [ "eslint:recommended", "plugin:node/recommended", "plugin:prettier/recommended" ], env: { node: true, es6: true }, parserOptions: { ecmaVersion: 2018 }, rules: { "prettier/prettier": "error", "no-template-curly-in-string": "error", "no-caller": "error", "no-control-regex": "off", yoda: "error", eqeqeq: "error", "eol-last": "error", "no-extra-bind": "warn", "no-process-exit": "warn", "no-use-before-define": "off", "no-unused-vars": ["error", { args: "none", ignoreRestSiblings: true }], "no-loop-func": "warn", "node/no-missing-require": "error", "jsdoc/check-indentation": "error", "jsdoc/check-param-names": "error", "jsdoc/check-property-names": "error", "jsdoc/check-tag-names": "error", "jsdoc/require-hyphen-before-param-description": ["error", "never"], "jsdoc/require-param-description": "error", "jsdoc/require-param-name": "error", "jsdoc/require-param-type": "error", "jsdoc/require-param": "error", "jsdoc/require-property": "error", "jsdoc/require-property-name": "error", "jsdoc/require-property-type": "error", "jsdoc/require-returns-description": "error", "jsdoc/require-returns-type": "error", "jsdoc/require-returns": "error" }, settings: { jsdoc: { mode: "typescript", // supported tags https://github.com/microsoft/TypeScript-wiki/blob/master/JSDoc-support-in-JavaScript.md tagNamePreference: { ...["implements", "const", "memberof", "readonly", "yields"].reduce( (acc, tag) => { acc[tag] = { message: `@${tag} currently not supported in Typescript` }; return acc; }, {} ), extends: "extends", return: "returns", constructor: "constructor", prop: "property", arg: "param", augments: "extends", description: false, desc: false, inheritdoc: false, class: "constructor" }, overrideReplacesDocs: false } }, overrides: [ { files: ["test/**/*.js"], env: { jest: true } } ] }; enhanced-resolve-5.15.0/.github/000077500000000000000000000000001444210260000163555ustar00rootroot00000000000000enhanced-resolve-5.15.0/.github/workflows/000077500000000000000000000000001444210260000204125ustar00rootroot00000000000000enhanced-resolve-5.15.0/.github/workflows/test.yml000066400000000000000000000024371444210260000221220ustar00rootroot00000000000000name: Test on: push: branches: [main] pull_request: branches: [main] permissions: contents: read # to fetch code (actions/checkout) jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Use Node.js uses: actions/setup-node@v3 with: node-version: 16.x cache: yarn - run: yarn --frozen-lockfile - run: yarn lint test: strategy: fail-fast: false matrix: os: [ubuntu-latest, windows-latest, macos-latest] node-version: [10.x, 12.x, 14.x, 16.x, 18.x, 20.x] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v3 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v3 with: node-version: ${{ matrix.node-version }} cache: yarn - name: Install dependencies run: | yarn upgrade typescript@^4 --ignore-engines yarn --frozen-lockfile if: matrix.node-version == '10.x' - name: Install dependencies run: yarn --frozen-lockfile if: matrix.node-version != '10.x' - name: Run tests with coverage run: npm run test:coverage -- --ci - if: ${{ matrix.os != 'windows-latest' }} uses: codecov/codecov-action@v3 enhanced-resolve-5.15.0/.gitignore000066400000000000000000000001421444210260000170020ustar00rootroot00000000000000/node_modules /coverage /.nyc_output *.log .eslintcache .idea .vscode .DS_Store package-lock.json enhanced-resolve-5.15.0/.husky/000077500000000000000000000000001444210260000162365ustar00rootroot00000000000000enhanced-resolve-5.15.0/.husky/.gitignore000066400000000000000000000000021444210260000202160ustar00rootroot00000000000000_ enhanced-resolve-5.15.0/.husky/pre-commit000077500000000000000000000000721444210260000202370ustar00rootroot00000000000000#!/bin/sh . "$(dirname "$0")/_/husky.sh" npx lint-staged enhanced-resolve-5.15.0/.prettierignore000066400000000000000000000000441444210260000200560ustar00rootroot00000000000000package.json test/**/*.* !test/*.js enhanced-resolve-5.15.0/.prettierrc.js000066400000000000000000000004421444210260000176140ustar00rootroot00000000000000module.exports = { printWidth: 80, useTabs: true, tabWidth: 2, trailingComma: "none", arrowParens: "avoid", overrides: [ { files: "*.json", options: { parser: "json", useTabs: false } }, { files: "*.ts", options: { parser: "typescript" } } ] }; enhanced-resolve-5.15.0/.travis.yml000066400000000000000000000002351444210260000171260ustar00rootroot00000000000000sudo: false language: node_js node_js: - "14" - "12" - "10" script: npm run travis after_success: - bash <(curl -s https://codecov.io/bash) -X gcov enhanced-resolve-5.15.0/LICENSE000066400000000000000000000020571444210260000160260ustar00rootroot00000000000000Copyright JS Foundation and other 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. enhanced-resolve-5.15.0/README.md000066400000000000000000000254311444210260000163010ustar00rootroot00000000000000# enhanced-resolve [![npm][npm]][npm-url] [![Build Status][build-status]][build-status-url] [![codecov][codecov-badge]][codecov-url] [![Install Size][size]][size-url] [![GitHub Discussions][discussion]][discussion-url] Offers an async require.resolve function. It's highly configurable. ## Features - plugin system - provide a custom filesystem - sync and async node.js filesystems included ## Getting Started ### Install ```sh # npm npm install enhanced-resolve # or Yarn yarn add enhanced-resolve ``` ### Resolve There is a Node.js API which allows to resolve requests according to the Node.js resolving rules. Sync and async APIs are offered. A `create` method allows to create a custom resolve function. ```js const resolve = require("enhanced-resolve"); resolve("/some/path/to/folder", "module/dir", (err, result) => { result; // === "/some/path/node_modules/module/dir/index.js" }); resolve.sync("/some/path/to/folder", "../../dir"); // === "/some/path/dir/index.js" const myResolve = resolve.create({ // or resolve.create.sync extensions: [".ts", ".js"] // see more options below }); myResolve("/some/path/to/folder", "ts-module", (err, result) => { result; // === "/some/node_modules/ts-module/index.ts" }); ``` ### Creating a Resolver The easiest way to create a resolver is to use the `createResolver` function on `ResolveFactory`, along with one of the supplied File System implementations. ```js const fs = require("fs"); const { CachedInputFileSystem, ResolverFactory } = require("enhanced-resolve"); // create a resolver const myResolver = ResolverFactory.createResolver({ // Typical usage will consume the `fs` + `CachedInputFileSystem`, which wraps Node.js `fs` to add caching. fileSystem: new CachedInputFileSystem(fs, 4000), extensions: [".js", ".json"] /* any other resolver options here. Options/defaults can be seen below */ }); // resolve a file with the new resolver const context = {}; const lookupStartPath = "/Users/webpack/some/root/dir"; const request = "./path/to-look-up.js"; const resolveContext = {}; myResolver.resolve(context, lookupStartPath, request, resolveContext, ( err /*Error*/, filepath /*string*/ ) => { // Do something with the path }); ``` #### Resolver Options | Field | Default | Description | |------------------|-----------------------------| --------------------------------------------------------------------------------------------------------------------------------------------------------- | | alias | [] | A list of module alias configurations or an object which maps key to value | | aliasFields | [] | A list of alias fields in description files | | extensionAlias | {} | An object which maps extension to extension aliases | | cachePredicate | function() { return true }; | A function which decides whether a request should be cached or not. An object is passed to the function with `path` and `request` properties. | | cacheWithContext | true | If unsafe cache is enabled, includes `request.context` in the cache key | | conditionNames | [] | A list of exports field condition names | | descriptionFiles | ["package.json"] | A list of description files to read from | | enforceExtension | false | Enforce that a extension from extensions must be used | | exportsFields | ["exports"] | A list of exports fields in description files | | extensions | [".js", ".json", ".node"] | A list of extensions which should be tried for files | | fallback | [] | Same as `alias`, but only used if default resolving fails | | fileSystem | | The file system which should be used | | fullySpecified | false | Request passed to resolve is already fully specified and extensions or main files are not resolved for it (they are still resolved for internal requests) | | mainFields | ["main"] | A list of main fields in description files | | mainFiles | ["index"] | A list of main files in directories | | modules | ["node_modules"] | A list of directories to resolve modules from, can be absolute path or folder name | | plugins | [] | A list of additional resolve plugins which should be applied | | resolver | undefined | A prepared Resolver to which the plugins are attached | | resolveToContext | false | Resolve to a context instead of a file | | preferRelative | false | Prefer to resolve module requests as relative request and fallback to resolving as module | | preferAbsolute | false | Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots | | restrictions | [] | A list of resolve restrictions | | roots | [] | A list of root paths | | symlinks | true | Whether to resolve symlinks to their symlinked location | | unsafeCache | false | Use this cache object to unsafely cache the successful requests | ## Plugins Similar to `webpack`, the core of `enhanced-resolve` functionality is implemented as individual plugins that are executed using [`tapable`](https://github.com/webpack/tapable). These plugins can extend the functionality of the library, adding other ways for files/contexts to be resolved. A plugin should be a `class` (or its ES5 equivalent) with an `apply` method. The `apply` method will receive a `resolver` instance, that can be used to hook in to the event system. ### Plugin Boilerplate ```js class MyResolverPlugin { constructor(source, target) { this.source = source; this.target = target; } apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("MyResolverPlugin", (request, resolveContext, callback) => { // Any logic you need to create a new `request` can go here resolver.doResolve(target, request, null, resolveContext, callback); }); } } ``` Plugins are executed in a pipeline, and register which event they should be executed before/after. In the example above, `source` is the name of the event that starts the pipeline, and `target` is what event this plugin should fire, which is what continues the execution of the pipeline. For an example of how these different plugin events create a chain, see `lib/ResolverFactory.js`, in the `//// pipeline ////` section. ## Escaping It's allowed to escape `#` as `\0#` to avoid parsing it as fragment. enhanced-resolve will try to resolve requests containing `#` as path and as fragment, so it will automatically figure out if `./some#thing` means `.../some.js#thing` or `.../some#thing.js`. When a `#` is resolved as path it will be escaped in the result. Here: `.../some\0#thing.js`. ## Tests ```javascript yarn test ``` ## Passing options from webpack If you are using `webpack`, and you want to pass custom options to `enhanced-resolve`, the options are passed from the `resolve` key of your webpack configuration e.g.: ``` resolve: { extensions: ['.js', '.jsx'], modules: [path.resolve(__dirname, 'src'), 'node_modules'], plugins: [new DirectoryNamedWebpackPlugin()] ... }, ``` ## License Copyright (c) 2012-2019 JS Foundation and other contributors MIT (http://www.opensource.org/licenses/mit-license.php) [npm]: https://img.shields.io/npm/v/enhanced-resolve.svg [npm-url]: https://www.npmjs.com/package/enhanced-resolve [build-status]: https://github.com/webpack/enhanced-resolve/actions/workflows/test.yml/badge.svg?branch=master [build-status-url]: https://github.com/webpack/enhanced-resolve/actions [codecov-badge]: https://codecov.io/gh/webpack/enhanced-resolve/branch/main/graph/badge.svg?token=6B6NxtsZc3 [codecov-url]: https://codecov.io/gh/webpack/enhanced-resolve [size]: https://packagephobia.com/badge?p=enhanced-resolve [size-url]: https://packagephobia.com/result?p=enhanced-resolve [discussion]: https://img.shields.io/github/discussions/webpack/webpack [discussion-url]: https://github.com/webpack/webpack/discussions enhanced-resolve-5.15.0/jest.config.js000066400000000000000000000001131444210260000175570ustar00rootroot00000000000000module.exports = { moduleFileExtensions: ["js", "mjs", "cjs", "ts"] }; enhanced-resolve-5.15.0/lib/000077500000000000000000000000001444210260000155635ustar00rootroot00000000000000enhanced-resolve-5.15.0/lib/AliasFieldPlugin.js000066400000000000000000000060201444210260000212730ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const DescriptionFileUtils = require("./DescriptionFileUtils"); const getInnerRequest = require("./getInnerRequest"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonPrimitive} JsonPrimitive */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class AliasFieldPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | Array} field field * @param {string | ResolveStepHook} target target */ constructor(source, field, target) { this.source = source; this.field = field; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => { if (!request.descriptionFileData) return callback(); const innerRequest = getInnerRequest(resolver, request); if (!innerRequest) return callback(); const fieldData = DescriptionFileUtils.getField( request.descriptionFileData, this.field ); if (fieldData === null || typeof fieldData !== "object") { if (resolveContext.log) resolveContext.log( "Field '" + this.field + "' doesn't contain a valid alias configuration" ); return callback(); } /** @type {JsonPrimitive | undefined} */ const data = Object.prototype.hasOwnProperty.call( fieldData, innerRequest ) ? /** @type {{[Key in string]: JsonPrimitive}} */ (fieldData)[ innerRequest ] : innerRequest.startsWith("./") ? /** @type {{[Key in string]: JsonPrimitive}} */ (fieldData)[ innerRequest.slice(2) ] : undefined; if (data === innerRequest) return callback(); if (data === undefined) return callback(); if (data === false) { /** @type {ResolveRequest} */ const ignoreObj = { ...request, path: false }; if (typeof resolveContext.yield === "function") { resolveContext.yield(ignoreObj); return callback(null, null); } return callback(null, ignoreObj); } /** @type {ResolveRequest} */ const obj = { ...request, path: /** @type {string} */ (request.descriptionFileRoot), request: /** @type {string} */ (data), fullySpecified: false }; resolver.doResolve( target, obj, "aliased from description file " + request.descriptionFilePath + " with mapping '" + innerRequest + "' to '" + /** @type {string} */ (data) + "'", resolveContext, (err, result) => { if (err) return callback(err); // Don't allow other aliasing or raw request if (result === undefined) return callback(null, null); callback(null, result); } ); }); } }; enhanced-resolve-5.15.0/lib/AliasPlugin.js000066400000000000000000000107601444210260000203350ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const forEachBail = require("./forEachBail"); const { PathType, getType } = require("./util/path"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {string | Array | false} Alias */ /** @typedef {{alias: Alias, name: string, onlyModule?: boolean}} AliasOption */ module.exports = class AliasPlugin { /** * @param {string | ResolveStepHook} source source * @param {AliasOption | Array} options options * @param {string | ResolveStepHook} target target */ constructor(source, options, target) { this.source = source; this.options = Array.isArray(options) ? options : [options]; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); /** * @param {string} maybeAbsolutePath path * @returns {null|string} absolute path with slash ending */ const getAbsolutePathWithSlashEnding = maybeAbsolutePath => { const type = getType(maybeAbsolutePath); if (type === PathType.AbsolutePosix || type === PathType.AbsoluteWin) { return resolver.join(maybeAbsolutePath, "_").slice(0, -1); } return null; }; /** * @param {string} path path * @param {string} maybeSubPath sub path * @returns {boolean} true, if path is sub path */ const isSubPath = (path, maybeSubPath) => { const absolutePath = getAbsolutePathWithSlashEnding(maybeSubPath); if (!absolutePath) return false; return path.startsWith(absolutePath); }; resolver .getHook(this.source) .tapAsync("AliasPlugin", (request, resolveContext, callback) => { const innerRequest = request.request || request.path; if (!innerRequest) return callback(); forEachBail( this.options, (item, callback) => { /** @type {boolean} */ let shouldStop = false; if ( innerRequest === item.name || (!item.onlyModule && (request.request ? innerRequest.startsWith(`${item.name}/`) : isSubPath(innerRequest, item.name))) ) { /** @type {string} */ const remainingRequest = innerRequest.slice(item.name.length); /** * @param {Alias} alias alias * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @returns {void} */ const resolveWithAlias = (alias, callback) => { if (alias === false) { /** @type {ResolveRequest} */ const ignoreObj = { ...request, path: false }; if (typeof resolveContext.yield === "function") { resolveContext.yield(ignoreObj); return callback(null, null); } return callback(null, ignoreObj); } if ( innerRequest !== alias && !innerRequest.startsWith(alias + "/") ) { shouldStop = true; const newRequestStr = alias + remainingRequest; /** @type {ResolveRequest} */ const obj = { ...request, request: newRequestStr, fullySpecified: false }; return resolver.doResolve( target, obj, "aliased with mapping '" + item.name + "': '" + alias + "' to '" + newRequestStr + "'", resolveContext, (err, result) => { if (err) return callback(err); if (result) return callback(null, result); return callback(); } ); } return callback(); }; /** * @param {null|Error} [err] error * @param {null|ResolveRequest} [result] result * @returns {void} */ const stoppingCallback = (err, result) => { if (err) return callback(err); if (result) return callback(null, result); // Don't allow other aliasing or raw request if (shouldStop) return callback(null, null); return callback(); }; if (Array.isArray(item.alias)) { return forEachBail( item.alias, resolveWithAlias, stoppingCallback ); } else { return resolveWithAlias(item.alias, stoppingCallback); } } return callback(); }, callback ); }); } }; enhanced-resolve-5.15.0/lib/AppendPlugin.js000066400000000000000000000022571444210260000205150ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class AppendPlugin { /** * @param {string | ResolveStepHook} source source * @param {string} appending appending * @param {string | ResolveStepHook} target target */ constructor(source, appending, target) { this.source = source; this.appending = appending; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("AppendPlugin", (request, resolveContext, callback) => { /** @type {ResolveRequest} */ const obj = { ...request, path: request.path + this.appending, relativePath: request.relativePath && request.relativePath + this.appending }; resolver.doResolve( target, obj, this.appending, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/CachedInputFileSystem.js000066400000000000000000000360161444210260000223230ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const nextTick = require("process").nextTick; /** @typedef {import("./Resolver").FileSystem} FileSystem */ /** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ /** @typedef {any} BaseFileSystem */ /** * @template T * @typedef {import("./Resolver").FileSystemCallback} FileSystemCallback */ /** * @param {string} path path * @returns {string} dirname */ const dirname = path => { let idx = path.length - 1; while (idx >= 0) { const c = path.charCodeAt(idx); // slash or backslash if (c === 47 || c === 92) break; idx--; } if (idx < 0) return ""; return path.slice(0, idx); }; /** * @template T * @param {FileSystemCallback[]} callbacks callbacks * @param {Error | undefined} err error * @param {T} result result */ const runCallbacks = (callbacks, err, result) => { if (callbacks.length === 1) { callbacks[0](err, result); callbacks.length = 0; return; } let error; for (const callback of callbacks) { try { callback(err, result); } catch (e) { if (!error) error = e; } } callbacks.length = 0; if (error) throw error; }; class OperationMergerBackend { /** * @param {function} provider async method in filesystem * @param {function} syncProvider sync method in filesystem * @param {BaseFileSystem} providerContext call context for the provider methods */ constructor(provider, syncProvider, providerContext) { this._provider = provider; this._syncProvider = syncProvider; this._providerContext = providerContext; this._activeAsyncOperations = new Map(); this.provide = this._provider ? /** * @param {string} path path * @param {any} options options * @param {function} callback callback * @returns {any} result */ (path, options, callback) => { if (typeof options === "function") { callback = options; options = undefined; } if (options) { return this._provider.call( this._providerContext, path, options, callback ); } if (typeof path !== "string") { callback(new TypeError("path must be a string")); return; } let callbacks = this._activeAsyncOperations.get(path); if (callbacks) { callbacks.push(callback); return; } this._activeAsyncOperations.set(path, (callbacks = [callback])); provider( path, /** * @param {Error} err error * @param {any} result result */ (err, result) => { this._activeAsyncOperations.delete(path); runCallbacks(callbacks, err, result); } ); } : null; this.provideSync = this._syncProvider ? /** * @param {string} path path * @param {any} options options * @returns {any} result */ (path, options) => { return this._syncProvider.call(this._providerContext, path, options); } : null; } purge() {} purgeParent() {} } /* IDLE: insert data: goto SYNC SYNC: before provide: run ticks event loop tick: goto ASYNC_ACTIVE ASYNC: timeout: run tick, goto ASYNC_PASSIVE ASYNC_PASSIVE: before provide: run ticks IDLE --[insert data]--> SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE ^ | +---------[insert data]-------+ */ const STORAGE_MODE_IDLE = 0; const STORAGE_MODE_SYNC = 1; const STORAGE_MODE_ASYNC = 2; class CacheBackend { /** * @param {number} duration max cache duration of items * @param {function} provider async method * @param {function} syncProvider sync method * @param {BaseFileSystem} providerContext call context for the provider methods */ constructor(duration, provider, syncProvider, providerContext) { this._duration = duration; this._provider = provider; this._syncProvider = syncProvider; this._providerContext = providerContext; /** @type {Map[]>} */ this._activeAsyncOperations = new Map(); /** @type {Map }>} */ this._data = new Map(); /** @type {Set[]} */ this._levels = []; for (let i = 0; i < 10; i++) this._levels.push(new Set()); for (let i = 5000; i < duration; i += 500) this._levels.push(new Set()); this._currentLevel = 0; this._tickInterval = Math.floor(duration / this._levels.length); /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */ this._mode = STORAGE_MODE_IDLE; /** @type {NodeJS.Timeout | undefined} */ this._timeout = undefined; /** @type {number | undefined} */ this._nextDecay = undefined; // @ts-ignore this.provide = provider ? this.provide.bind(this) : null; // @ts-ignore this.provideSync = syncProvider ? this.provideSync.bind(this) : null; } /** * @param {string} path path * @param {any} options options * @param {FileSystemCallback} callback callback * @returns {void} */ provide(path, options, callback) { if (typeof options === "function") { callback = options; options = undefined; } if (typeof path !== "string") { callback(new TypeError("path must be a string")); return; } if (options) { return this._provider.call( this._providerContext, path, options, callback ); } // When in sync mode we can move to async mode if (this._mode === STORAGE_MODE_SYNC) { this._enterAsyncMode(); } // Check in cache let cacheEntry = this._data.get(path); if (cacheEntry !== undefined) { if (cacheEntry.err) return nextTick(callback, cacheEntry.err); return nextTick(callback, null, cacheEntry.result); } // Check if there is already the same operation running let callbacks = this._activeAsyncOperations.get(path); if (callbacks !== undefined) { callbacks.push(callback); return; } this._activeAsyncOperations.set(path, (callbacks = [callback])); // Run the operation this._provider.call( this._providerContext, path, /** * @param {Error} [err] error * @param {any} [result] result */ (err, result) => { this._activeAsyncOperations.delete(path); this._storeResult(path, err, result); // Enter async mode if not yet done this._enterAsyncMode(); runCallbacks( /** @type {FileSystemCallback[]} */ (callbacks), err, result ); } ); } /** * @param {string} path path * @param {any} options options * @returns {any} result */ provideSync(path, options) { if (typeof path !== "string") { throw new TypeError("path must be a string"); } if (options) { return this._syncProvider.call(this._providerContext, path, options); } // In sync mode we may have to decay some cache items if (this._mode === STORAGE_MODE_SYNC) { this._runDecays(); } // Check in cache let cacheEntry = this._data.get(path); if (cacheEntry !== undefined) { if (cacheEntry.err) throw cacheEntry.err; return cacheEntry.result; } // Get all active async operations // This sync operation will also complete them const callbacks = this._activeAsyncOperations.get(path); this._activeAsyncOperations.delete(path); // Run the operation // When in idle mode, we will enter sync mode let result; try { result = this._syncProvider.call(this._providerContext, path); } catch (err) { this._storeResult(path, /** @type {Error} */ (err), undefined); this._enterSyncModeWhenIdle(); if (callbacks) { runCallbacks(callbacks, /** @type {Error} */ (err), undefined); } throw err; } this._storeResult(path, undefined, result); this._enterSyncModeWhenIdle(); if (callbacks) { runCallbacks(callbacks, undefined, result); } return result; } /** * @param {string|string[]|Set} [what] what to purge */ purge(what) { if (!what) { if (this._mode !== STORAGE_MODE_IDLE) { this._data.clear(); for (const level of this._levels) { level.clear(); } this._enterIdleMode(); } } else if (typeof what === "string") { for (let [key, data] of this._data) { if (key.startsWith(what)) { this._data.delete(key); data.level.delete(key); } } if (this._data.size === 0) { this._enterIdleMode(); } } else { for (let [key, data] of this._data) { for (const item of what) { if (key.startsWith(item)) { this._data.delete(key); data.level.delete(key); break; } } } if (this._data.size === 0) { this._enterIdleMode(); } } } /** * @param {string|string[]|Set} [what] what to purge */ purgeParent(what) { if (!what) { this.purge(); } else if (typeof what === "string") { this.purge(dirname(what)); } else { const set = new Set(); for (const item of what) { set.add(dirname(item)); } this.purge(set); } } /** * @param {string} path path * @param {undefined | Error} err error * @param {any} result result */ _storeResult(path, err, result) { if (this._data.has(path)) return; const level = this._levels[this._currentLevel]; this._data.set(path, { err, result, level }); level.add(path); } _decayLevel() { const nextLevel = (this._currentLevel + 1) % this._levels.length; const decay = this._levels[nextLevel]; this._currentLevel = nextLevel; for (let item of decay) { this._data.delete(item); } decay.clear(); if (this._data.size === 0) { this._enterIdleMode(); } else { /** @type {number} */ (this._nextDecay) += this._tickInterval; } } _runDecays() { while ( /** @type {number} */ (this._nextDecay) <= Date.now() && this._mode !== STORAGE_MODE_IDLE ) { this._decayLevel(); } } _enterAsyncMode() { let timeout = 0; switch (this._mode) { case STORAGE_MODE_ASYNC: return; case STORAGE_MODE_IDLE: this._nextDecay = Date.now() + this._tickInterval; timeout = this._tickInterval; break; case STORAGE_MODE_SYNC: this._runDecays(); // _runDecays may change the mode if ( /** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC}*/ (this._mode) === STORAGE_MODE_IDLE ) return; timeout = Math.max( 0, /** @type {number} */ (this._nextDecay) - Date.now() ); break; } this._mode = STORAGE_MODE_ASYNC; const ref = setTimeout(() => { this._mode = STORAGE_MODE_SYNC; this._runDecays(); }, timeout); if (ref.unref) ref.unref(); this._timeout = ref; } _enterSyncModeWhenIdle() { if (this._mode === STORAGE_MODE_IDLE) { this._mode = STORAGE_MODE_SYNC; this._nextDecay = Date.now() + this._tickInterval; } } _enterIdleMode() { this._mode = STORAGE_MODE_IDLE; this._nextDecay = undefined; if (this._timeout) clearTimeout(this._timeout); } } /** * @template {function} Provider * @template {function} AsyncProvider * @template FileSystem * @param {number} duration duration in ms files are cached * @param {Provider} provider provider * @param {AsyncProvider} syncProvider sync provider * @param {FileSystem} providerContext provider context * @returns {OperationMergerBackend | CacheBackend} backend */ const createBackend = (duration, provider, syncProvider, providerContext) => { if (duration > 0) { return new CacheBackend(duration, provider, syncProvider, providerContext); } return new OperationMergerBackend(provider, syncProvider, providerContext); }; module.exports = class CachedInputFileSystem { /** * @param {BaseFileSystem} fileSystem file system * @param {number} duration duration in ms files are cached */ constructor(fileSystem, duration) { this.fileSystem = fileSystem; this._lstatBackend = createBackend( duration, this.fileSystem.lstat, this.fileSystem.lstatSync, this.fileSystem ); const lstat = this._lstatBackend.provide; this.lstat = /** @type {FileSystem["lstat"]} */ (lstat); const lstatSync = this._lstatBackend.provideSync; this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync); this._statBackend = createBackend( duration, this.fileSystem.stat, this.fileSystem.statSync, this.fileSystem ); const stat = this._statBackend.provide; this.stat = /** @type {FileSystem["stat"]} */ (stat); const statSync = this._statBackend.provideSync; this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync); this._readdirBackend = createBackend( duration, this.fileSystem.readdir, this.fileSystem.readdirSync, this.fileSystem ); const readdir = this._readdirBackend.provide; this.readdir = /** @type {FileSystem["readdir"]} */ (readdir); const readdirSync = this._readdirBackend.provideSync; this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ ( readdirSync ); this._readFileBackend = createBackend( duration, this.fileSystem.readFile, this.fileSystem.readFileSync, this.fileSystem ); const readFile = this._readFileBackend.provide; this.readFile = /** @type {FileSystem["readFile"]} */ (readFile); const readFileSync = this._readFileBackend.provideSync; this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ ( readFileSync ); this._readJsonBackend = createBackend( duration, // prettier-ignore this.fileSystem.readJson || (this.readFile && ( /** * @param {string} path path * @param {FileSystemCallback} callback */ (path, callback) => { this.readFile(path, (err, buffer) => { if (err) return callback(err); if (!buffer || buffer.length === 0) return callback(new Error("No file content")); let data; try { data = JSON.parse(buffer.toString("utf-8")); } catch (e) { return callback(/** @type {Error} */ (e)); } callback(null, data); }); }) ), // prettier-ignore this.fileSystem.readJsonSync || (this.readFileSync && ( /** * @param {string} path path * @returns {any} result */ (path) => { const buffer = this.readFileSync(path); const data = JSON.parse(buffer.toString("utf-8")); return data; } )), this.fileSystem ); const readJson = this._readJsonBackend.provide; this.readJson = /** @type {FileSystem["readJson"]} */ (readJson); const readJsonSync = this._readJsonBackend.provideSync; this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ ( readJsonSync ); this._readlinkBackend = createBackend( duration, this.fileSystem.readlink, this.fileSystem.readlinkSync, this.fileSystem ); const readlink = this._readlinkBackend.provide; this.readlink = /** @type {FileSystem["readlink"]} */ (readlink); const readlinkSync = this._readlinkBackend.provideSync; this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ ( readlinkSync ); } /** * @param {string|string[]|Set} [what] what to purge */ purge(what) { this._statBackend.purge(what); this._lstatBackend.purge(what); this._readdirBackend.purgeParent(what); this._readFileBackend.purge(what); this._readlinkBackend.purge(what); this._readJsonBackend.purge(what); } }; enhanced-resolve-5.15.0/lib/CloneBasenamePlugin.js000066400000000000000000000025371444210260000220030ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const basename = require("./getPaths").basename; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class CloneBasenamePlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => { const requestPath = /** @type {string} */ (request.path); const filename = /** @type {string} */ (basename(requestPath)); const filePath = resolver.join(requestPath, filename); /** @type {ResolveRequest} */ const obj = { ...request, path: filePath, relativePath: request.relativePath && resolver.join(request.relativePath, filename) }; resolver.doResolve( target, obj, "using path: " + filePath, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/ConditionalPlugin.js000066400000000000000000000032731444210260000215500ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class ConditionalPlugin { /** * @param {string | ResolveStepHook} source source * @param {Partial} test compare object * @param {string | null} message log message * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches * @param {string | ResolveStepHook} target target */ constructor(source, test, message, allowAlternatives, target) { this.source = source; this.test = test; this.message = message; this.allowAlternatives = allowAlternatives; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); const { test, message, allowAlternatives } = this; const keys = /** @type {(keyof ResolveRequest)[]} */ (Object.keys(test)); resolver .getHook(this.source) .tapAsync("ConditionalPlugin", (request, resolveContext, callback) => { for (const prop of keys) { if (request[prop] !== test[prop]) return callback(); } resolver.doResolve( target, request, message, resolveContext, allowAlternatives ? callback : (err, result) => { if (err) return callback(err); // Don't allow other alternatives if (result === undefined) return callback(null, null); callback(null, result); } ); }); } }; enhanced-resolve-5.15.0/lib/DescriptionFilePlugin.js000066400000000000000000000052111444210260000223620ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const DescriptionFileUtils = require("./DescriptionFileUtils"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class DescriptionFilePlugin { /** * @param {string | ResolveStepHook} source source * @param {string[]} filenames filenames * @param {boolean} pathIsFile pathIsFile * @param {string | ResolveStepHook} target target */ constructor(source, filenames, pathIsFile, target) { this.source = source; this.filenames = filenames; this.pathIsFile = pathIsFile; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync( "DescriptionFilePlugin", (request, resolveContext, callback) => { const path = request.path; if (!path) return callback(); const directory = this.pathIsFile ? DescriptionFileUtils.cdUp(path) : path; if (!directory) return callback(); DescriptionFileUtils.loadDescriptionFile( resolver, directory, this.filenames, request.descriptionFilePath ? { path: request.descriptionFilePath, content: request.descriptionFileData, directory: /** @type {string} */ (request.descriptionFileRoot) } : undefined, resolveContext, (err, result) => { if (err) return callback(err); if (!result) { if (resolveContext.log) resolveContext.log( `No description file found in ${directory} or above` ); return callback(); } const relativePath = "." + path.slice(result.directory.length).replace(/\\/g, "/"); /** @type {ResolveRequest} */ const obj = { ...request, descriptionFilePath: result.path, descriptionFileData: result.content, descriptionFileRoot: result.directory, relativePath: relativePath }; resolver.doResolve( target, obj, "using description file: " + result.path + " (relative path: " + relativePath + ")", resolveContext, (err, result) => { if (err) return callback(err); // Don't allow other processing if (result === undefined) return callback(null, null); callback(null, result); } ); } ); } ); } }; enhanced-resolve-5.15.0/lib/DescriptionFileUtils.js000066400000000000000000000122061444210260000222260ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const forEachBail = require("./forEachBail"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonObject} JsonObject */ /** @typedef {import("./Resolver").JsonValue} JsonValue */ /** @typedef {import("./Resolver").ResolveContext} ResolveContext */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** * @typedef {Object} DescriptionFileInfo * @property {JsonObject=} content * @property {string} path * @property {string} directory */ /** * @callback ErrorFirstCallback * @param {Error|null=} error * @param {DescriptionFileInfo=} result */ /** * @typedef {Object} Result * @property {string} path path to description file * @property {string} directory directory of description file * @property {JsonObject} content content of description file */ /** * @param {Resolver} resolver resolver * @param {string} directory directory * @param {string[]} filenames filenames * @param {DescriptionFileInfo|undefined} oldInfo oldInfo * @param {ResolveContext} resolveContext resolveContext * @param {ErrorFirstCallback} callback callback */ function loadDescriptionFile( resolver, directory, filenames, oldInfo, resolveContext, callback ) { (function findDescriptionFile() { if (oldInfo && oldInfo.directory === directory) { // We already have info for this directory and can reuse it return callback(null, oldInfo); } forEachBail( filenames, /** * @param {string} filename filename * @param {(err?: null|Error, result?: null|Result) => void} callback callback * @returns {void} */ (filename, callback) => { const descriptionFilePath = resolver.join(directory, filename); if (resolver.fileSystem.readJson) { resolver.fileSystem.readJson(descriptionFilePath, (err, content) => { if (err) { if (typeof err.code !== "undefined") { if (resolveContext.missingDependencies) { resolveContext.missingDependencies.add(descriptionFilePath); } return callback(); } if (resolveContext.fileDependencies) { resolveContext.fileDependencies.add(descriptionFilePath); } return onJson(err); } if (resolveContext.fileDependencies) { resolveContext.fileDependencies.add(descriptionFilePath); } onJson(null, /** @type {JsonObject} */ (content)); }); } else { resolver.fileSystem.readFile(descriptionFilePath, (err, content) => { if (err) { if (resolveContext.missingDependencies) { resolveContext.missingDependencies.add(descriptionFilePath); } return callback(); } if (resolveContext.fileDependencies) { resolveContext.fileDependencies.add(descriptionFilePath); } /** @type {JsonObject | undefined} */ let json; if (content) { try { json = JSON.parse(content.toString()); } catch (/** @type {unknown} */ e) { return onJson(/** @type {Error} */ (e)); } } else { return onJson(new Error("No content in file")); } onJson(null, json); }); } /** * @param {null|Error} [err] error * @param {JsonObject} [content] content * @returns {void} */ function onJson(err, content) { if (err) { if (resolveContext.log) resolveContext.log( descriptionFilePath + " (directory description file): " + err ); else err.message = descriptionFilePath + " (directory description file): " + err; return callback(err); } callback(null, { content: /** @type {JsonObject} */ (content), directory, path: descriptionFilePath }); } }, /** * @param {null|Error} [err] error * @param {null|Result} [result] result * @returns {void} */ (err, result) => { if (err) return callback(err); if (result) { return callback(null, result); } else { const dir = cdUp(directory); if (!dir) { return callback(); } else { directory = dir; return findDescriptionFile(); } } } ); })(); } /** * @param {JsonObject} content content * @param {string|string[]} field field * @returns {JsonValue | undefined} field data */ function getField(content, field) { if (!content) return undefined; if (Array.isArray(field)) { /** @type {JsonValue} */ let current = content; for (let j = 0; j < field.length; j++) { if (current === null || typeof current !== "object") { current = null; break; } current = /** @type {JsonObject} */ (current)[field[j]]; } return current; } else { return content[field]; } } /** * @param {string} directory directory * @returns {string|null} parent directory or null */ function cdUp(directory) { if (directory === "/") return null; const i = directory.lastIndexOf("/"), j = directory.lastIndexOf("\\"); const p = i < 0 ? j : j < 0 ? i : i < j ? j : i; if (p < 0) return null; return directory.slice(0, p || 1); } exports.loadDescriptionFile = loadDescriptionFile; exports.getField = getField; exports.cdUp = cdUp; enhanced-resolve-5.15.0/lib/DirectoryExistsPlugin.js000066400000000000000000000032411444210260000224440ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class DirectoryExistsPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync( "DirectoryExistsPlugin", (request, resolveContext, callback) => { const fs = resolver.fileSystem; const directory = request.path; if (!directory) return callback(); fs.stat(directory, (err, stat) => { if (err || !stat) { if (resolveContext.missingDependencies) resolveContext.missingDependencies.add(directory); if (resolveContext.log) resolveContext.log(directory + " doesn't exist"); return callback(); } if (!stat.isDirectory()) { if (resolveContext.missingDependencies) resolveContext.missingDependencies.add(directory); if (resolveContext.log) resolveContext.log(directory + " is not a directory"); return callback(); } if (resolveContext.fileDependencies) resolveContext.fileDependencies.add(directory); resolver.doResolve( target, request, `existing directory ${directory}`, resolveContext, callback ); }); } ); } }; enhanced-resolve-5.15.0/lib/ExportsFieldPlugin.js000066400000000000000000000116571444210260000217220ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; const path = require("path"); const DescriptionFileUtils = require("./DescriptionFileUtils"); const forEachBail = require("./forEachBail"); const { processExportsField } = require("./util/entrypoints"); const { parseIdentifier } = require("./util/identifier"); const { checkImportsExportsFieldTarget } = require("./util/path"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonObject} JsonObject */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {import("./util/entrypoints").ExportsField} ExportsField */ /** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */ module.exports = class ExportsFieldPlugin { /** * @param {string | ResolveStepHook} source source * @param {Set} conditionNames condition names * @param {string | string[]} fieldNamePath name path * @param {string | ResolveStepHook} target target */ constructor(source, conditionNames, fieldNamePath, target) { this.source = source; this.target = target; this.conditionNames = conditionNames; this.fieldName = fieldNamePath; /** @type {WeakMap} */ this.fieldProcessorCache = new WeakMap(); } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => { // When there is no description file, abort if (!request.descriptionFilePath) return callback(); if ( // When the description file is inherited from parent, abort // (There is no description file inside of this package) request.relativePath !== "." || request.request === undefined ) return callback(); const remainingRequest = request.query || request.fragment ? (request.request === "." ? "./" : request.request) + request.query + request.fragment : request.request; const exportsField = /** @type {ExportsField|null|undefined} */ ( DescriptionFileUtils.getField( /** @type {JsonObject} */ (request.descriptionFileData), this.fieldName ) ); if (!exportsField) return callback(); if (request.directory) { return callback( new Error( `Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)` ) ); } /** @type {string[]} */ let paths; try { // We attach the cache to the description file instead of the exportsField value // because we use a WeakMap and the exportsField could be a string too. // Description file is always an object when exports field can be accessed. let fieldProcessor = this.fieldProcessorCache.get( /** @type {JsonObject} */ (request.descriptionFileData) ); if (fieldProcessor === undefined) { fieldProcessor = processExportsField(exportsField); this.fieldProcessorCache.set( /** @type {JsonObject} */ (request.descriptionFileData), fieldProcessor ); } paths = fieldProcessor(remainingRequest, this.conditionNames); } catch (/** @type {unknown} */ err) { if (resolveContext.log) { resolveContext.log( `Exports field in ${request.descriptionFilePath} can't be processed: ${err}` ); } return callback(/** @type {Error} */ (err)); } if (paths.length === 0) { return callback( new Error( `Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})` ) ); } forEachBail( paths, /** * @param {string} p path * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @returns {void} */ (p, callback) => { const parsedIdentifier = parseIdentifier(p); if (!parsedIdentifier) return callback(); const [relativePath, query, fragment] = parsedIdentifier; const error = checkImportsExportsFieldTarget(relativePath); if (error) { return callback(error); } /** @type {ResolveRequest} */ const obj = { ...request, request: undefined, path: path.join( /** @type {string} */ (request.descriptionFileRoot), relativePath ), relativePath, query, fragment }; resolver.doResolve( target, obj, "using exports field: " + p, resolveContext, callback ); }, /** * @param {null|Error} [err] error * @param {null|ResolveRequest} [result] result * @returns {void} */ (err, result) => callback(err, result || null) ); }); } }; enhanced-resolve-5.15.0/lib/ExtensionAliasPlugin.js000066400000000000000000000057631444210260000222410ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; const forEachBail = require("./forEachBail"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {{ alias: string|string[], extension: string }} ExtensionAliasOption */ module.exports = class ExtensionAliasPlugin { /** * @param {string | ResolveStepHook} source source * @param {ExtensionAliasOption} options options * @param {string | ResolveStepHook} target target */ constructor(source, options, target) { this.source = source; this.options = options; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); const { extension, alias } = this.options; resolver .getHook(this.source) .tapAsync("ExtensionAliasPlugin", (request, resolveContext, callback) => { const requestPath = request.request; if (!requestPath || !requestPath.endsWith(extension)) return callback(); const isAliasString = typeof alias === "string"; /** * @param {string} alias extension alias * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @param {number} [index] index * @returns {void} */ const resolve = (alias, callback, index) => { const newRequest = `${requestPath.slice( 0, -extension.length )}${alias}`; return resolver.doResolve( target, { ...request, request: newRequest, fullySpecified: true }, `aliased from extension alias with mapping '${extension}' to '${alias}'`, resolveContext, (err, result) => { // Throw error if we are on the last alias (for multiple aliases) and it failed, always throw if we are not an array or we have only one alias if (!isAliasString && index) { if (index !== this.options.alias.length) { if (resolveContext.log) { resolveContext.log( `Failed to alias from extension alias with mapping '${extension}' to '${alias}' for '${newRequest}': ${err}` ); } return callback(null, result); } return callback(err, result); } else { callback(err, result); } } ); }; /** * @param {null|Error} [err] error * @param {null|ResolveRequest} [result] result * @returns {void} */ const stoppingCallback = (err, result) => { if (err) return callback(err); if (result) return callback(null, result); // Don't allow other aliasing or raw request return callback(null, null); }; if (isAliasString) { resolve(alias, stoppingCallback); } else if (alias.length > 1) { forEachBail(alias, resolve, stoppingCallback); } else { resolve(alias[0], stoppingCallback); } }); } }; enhanced-resolve-5.15.0/lib/FileExistsPlugin.js000066400000000000000000000030421444210260000213560ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class FileExistsPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); const fs = resolver.fileSystem; resolver .getHook(this.source) .tapAsync("FileExistsPlugin", (request, resolveContext, callback) => { const file = request.path; if (!file) return callback(); fs.stat(file, (err, stat) => { if (err || !stat) { if (resolveContext.missingDependencies) resolveContext.missingDependencies.add(file); if (resolveContext.log) resolveContext.log(file + " doesn't exist"); return callback(); } if (!stat.isFile()) { if (resolveContext.missingDependencies) resolveContext.missingDependencies.add(file); if (resolveContext.log) resolveContext.log(file + " is not a file"); return callback(); } if (resolveContext.fileDependencies) resolveContext.fileDependencies.add(file); resolver.doResolve( target, request, "existing file: " + file, resolveContext, callback ); }); }); } }; enhanced-resolve-5.15.0/lib/ImportsFieldPlugin.js000066400000000000000000000127031444210260000217040ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; const path = require("path"); const DescriptionFileUtils = require("./DescriptionFileUtils"); const forEachBail = require("./forEachBail"); const { processImportsField } = require("./util/entrypoints"); const { parseIdentifier } = require("./util/identifier"); const { checkImportsExportsFieldTarget } = require("./util/path"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonObject} JsonObject */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */ /** @typedef {import("./util/entrypoints").ImportsField} ImportsField */ const dotCode = ".".charCodeAt(0); module.exports = class ImportsFieldPlugin { /** * @param {string | ResolveStepHook} source source * @param {Set} conditionNames condition names * @param {string | string[]} fieldNamePath name path * @param {string | ResolveStepHook} targetFile target file * @param {string | ResolveStepHook} targetPackage target package */ constructor( source, conditionNames, fieldNamePath, targetFile, targetPackage ) { this.source = source; this.targetFile = targetFile; this.targetPackage = targetPackage; this.conditionNames = conditionNames; this.fieldName = fieldNamePath; /** @type {WeakMap} */ this.fieldProcessorCache = new WeakMap(); } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const targetFile = resolver.ensureHook(this.targetFile); const targetPackage = resolver.ensureHook(this.targetPackage); resolver .getHook(this.source) .tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => { // When there is no description file, abort if (!request.descriptionFilePath || request.request === undefined) { return callback(); } const remainingRequest = request.request + request.query + request.fragment; const importsField = /** @type {ImportsField|null|undefined} */ ( DescriptionFileUtils.getField( /** @type {JsonObject} */ (request.descriptionFileData), this.fieldName ) ); if (!importsField) return callback(); if (request.directory) { return callback( new Error( `Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)` ) ); } /** @type {string[]} */ let paths; try { // We attach the cache to the description file instead of the importsField value // because we use a WeakMap and the importsField could be a string too. // Description file is always an object when exports field can be accessed. let fieldProcessor = this.fieldProcessorCache.get( /** @type {JsonObject} */ (request.descriptionFileData) ); if (fieldProcessor === undefined) { fieldProcessor = processImportsField(importsField); this.fieldProcessorCache.set( /** @type {JsonObject} */ (request.descriptionFileData), fieldProcessor ); } paths = fieldProcessor(remainingRequest, this.conditionNames); } catch (/** @type {unknown} */ err) { if (resolveContext.log) { resolveContext.log( `Imports field in ${request.descriptionFilePath} can't be processed: ${err}` ); } return callback(/** @type {Error} */ (err)); } if (paths.length === 0) { return callback( new Error( `Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})` ) ); } forEachBail( paths, /** * @param {string} p path * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @returns {void} */ (p, callback) => { const parsedIdentifier = parseIdentifier(p); if (!parsedIdentifier) return callback(); const [path_, query, fragment] = parsedIdentifier; const error = checkImportsExportsFieldTarget(path_); if (error) { return callback(error); } switch (path_.charCodeAt(0)) { // should be relative case dotCode: { /** @type {ResolveRequest} */ const obj = { ...request, request: undefined, path: path.join( /** @type {string} */ (request.descriptionFileRoot), path_ ), relativePath: path_, query, fragment }; resolver.doResolve( targetFile, obj, "using imports field: " + p, resolveContext, callback ); break; } // package resolving default: { /** @type {ResolveRequest} */ const obj = { ...request, request: path_, relativePath: path_, fullySpecified: true, query, fragment }; resolver.doResolve( targetPackage, obj, "using imports field: " + p, resolveContext, callback ); } } }, /** * @param {null|Error} [err] error * @param {null|ResolveRequest} [result] result * @returns {void} */ (err, result) => callback(err, result || null) ); }); } }; enhanced-resolve-5.15.0/lib/JoinRequestPartPlugin.js000066400000000000000000000035771444210260000224130ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ const namespaceStartCharCode = "@".charCodeAt(0); module.exports = class JoinRequestPartPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync( "JoinRequestPartPlugin", (request, resolveContext, callback) => { const req = request.request || ""; let i = req.indexOf("/", 3); if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) { i = req.indexOf("/", i + 1); } /** @type {string} */ let moduleName; /** @type {string} */ let remainingRequest; /** @type {boolean} */ let fullySpecified; if (i < 0) { moduleName = req; remainingRequest = "."; fullySpecified = false; } else { moduleName = req.slice(0, i); remainingRequest = "." + req.slice(i); fullySpecified = /** @type {boolean} */ (request.fullySpecified); } /** @type {ResolveRequest} */ const obj = { ...request, path: resolver.join( /** @type {string} */ (request.path), moduleName ), relativePath: request.relativePath && resolver.join(request.relativePath, moduleName), request: remainingRequest, fullySpecified }; resolver.doResolve(target, obj, null, resolveContext, callback); } ); } }; enhanced-resolve-5.15.0/lib/JoinRequestPlugin.js000066400000000000000000000023731444210260000215550ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class JoinRequestPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => { const requestPath = /** @type {string} */ (request.path); const requestRequest = /** @type {string} */ (request.request); /** @type {ResolveRequest} */ const obj = { ...request, path: resolver.join(requestPath, requestRequest), relativePath: request.relativePath && resolver.join(request.relativePath, requestRequest), request: undefined }; resolver.doResolve(target, obj, null, resolveContext, callback); }); } }; enhanced-resolve-5.15.0/lib/LogInfoPlugin.js000066400000000000000000000030061444210260000206340ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class LogInfoPlugin { /** * @param {string | ResolveStepHook} source source */ constructor(source) { this.source = source; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const source = this.source; resolver .getHook(this.source) .tapAsync("LogInfoPlugin", (request, resolveContext, callback) => { if (!resolveContext.log) return callback(); const log = resolveContext.log; const prefix = "[" + source + "] "; if (request.path) log(prefix + "Resolving in directory: " + request.path); if (request.request) log(prefix + "Resolving request: " + request.request); if (request.module) log(prefix + "Request is an module request."); if (request.directory) log(prefix + "Request is a directory request."); if (request.query) log(prefix + "Resolving request query: " + request.query); if (request.fragment) log(prefix + "Resolving request fragment: " + request.fragment); if (request.descriptionFilePath) log( prefix + "Has description data from " + request.descriptionFilePath ); if (request.relativePath) log( prefix + "Relative path from description file is: " + request.relativePath ); callback(); }); } }; enhanced-resolve-5.15.0/lib/MainFieldPlugin.js000066400000000000000000000046551444210260000211420ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const path = require("path"); const DescriptionFileUtils = require("./DescriptionFileUtils"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonObject} JsonObject */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {{name: string|Array, forceRelative: boolean}} MainFieldOptions */ const alreadyTriedMainField = Symbol("alreadyTriedMainField"); module.exports = class MainFieldPlugin { /** * @param {string | ResolveStepHook} source source * @param {MainFieldOptions} options options * @param {string | ResolveStepHook} target target */ constructor(source, options, target) { this.source = source; this.options = options; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("MainFieldPlugin", (request, resolveContext, callback) => { if ( request.path !== request.descriptionFileRoot || /** @type {ResolveRequest & { [alreadyTriedMainField]?: string }} */ (request)[alreadyTriedMainField] === request.descriptionFilePath || !request.descriptionFilePath ) return callback(); const filename = path.basename(request.descriptionFilePath); let mainModule = /** @type {string|null|undefined} */ ( DescriptionFileUtils.getField( /** @type {JsonObject} */ (request.descriptionFileData), this.options.name ) ); if ( !mainModule || typeof mainModule !== "string" || mainModule === "." || mainModule === "./" ) { return callback(); } if (this.options.forceRelative && !/^\.\.?\//.test(mainModule)) mainModule = "./" + mainModule; /** @type {ResolveRequest & { [alreadyTriedMainField]?: string }} */ const obj = { ...request, request: mainModule, module: false, directory: mainModule.endsWith("/"), [alreadyTriedMainField]: request.descriptionFilePath }; return resolver.doResolve( target, obj, "use " + mainModule + " from " + this.options.name + " in " + filename, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/ModulesInHierachicDirectoriesPlugin.js000066400000000000000000000003271444210260000251760ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; // TODO remove in next major module.exports = require("./ModulesInHierarchicalDirectoriesPlugin"); enhanced-resolve-5.15.0/lib/ModulesInHierarchicalDirectoriesPlugin.js000066400000000000000000000045701444210260000257010ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const forEachBail = require("./forEachBail"); const getPaths = require("./getPaths"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class ModulesInHierarchicalDirectoriesPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | Array} directories directories * @param {string | ResolveStepHook} target target */ constructor(source, directories, target) { this.source = source; this.directories = /** @type {Array} */ ([]).concat(directories); this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync( "ModulesInHierarchicalDirectoriesPlugin", (request, resolveContext, callback) => { const fs = resolver.fileSystem; const addrs = getPaths(/** @type {string} */ (request.path)) .paths.map(p => { return this.directories.map(d => resolver.join(p, d)); }) .reduce((array, p) => { array.push.apply(array, p); return array; }, []); forEachBail( addrs, /** * @param {string} addr addr * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @returns {void} */ (addr, callback) => { fs.stat(addr, (err, stat) => { if (!err && stat && stat.isDirectory()) { /** @type {ResolveRequest} */ const obj = { ...request, path: addr, request: "./" + request.request, module: false }; const message = "looking for modules in " + addr; return resolver.doResolve( target, obj, message, resolveContext, callback ); } if (resolveContext.log) resolveContext.log( addr + " doesn't exist or is not a directory" ); if (resolveContext.missingDependencies) resolveContext.missingDependencies.add(addr); return callback(); }); }, callback ); } ); } }; enhanced-resolve-5.15.0/lib/ModulesInRootPlugin.js000066400000000000000000000022111444210260000220370ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class ModulesInRootPlugin { /** * @param {string | ResolveStepHook} source source * @param {string} path path * @param {string | ResolveStepHook} target target */ constructor(source, path, target) { this.source = source; this.path = path; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => { /** @type {ResolveRequest} */ const obj = { ...request, path: this.path, request: "./" + request.request, module: false }; resolver.doResolve( target, obj, "looking for modules in " + this.path, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/NextPlugin.js000066400000000000000000000014431444210260000202200ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class NextPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("NextPlugin", (request, resolveContext, callback) => { resolver.doResolve(target, request, null, resolveContext, callback); }); } }; enhanced-resolve-5.15.0/lib/ParsePlugin.js000066400000000000000000000044101444210260000203510ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class ParsePlugin { /** * @param {string | ResolveStepHook} source source * @param {Partial} requestOptions request options * @param {string | ResolveStepHook} target target */ constructor(source, requestOptions, target) { this.source = source; this.requestOptions = requestOptions; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("ParsePlugin", (request, resolveContext, callback) => { const parsed = resolver.parse(/** @type {string} */ (request.request)); /** @type {ResolveRequest} */ const obj = { ...request, ...parsed, ...this.requestOptions }; if (request.query && !parsed.query) { obj.query = request.query; } if (request.fragment && !parsed.fragment) { obj.fragment = request.fragment; } if (parsed && resolveContext.log) { if (parsed.module) resolveContext.log("Parsed request is a module"); if (parsed.directory) resolveContext.log("Parsed request is a directory"); } // There is an edge-case where a request with # can be a path or a fragment -> try both if (obj.request && !obj.query && obj.fragment) { const directory = obj.fragment.endsWith("/"); /** @type {ResolveRequest} */ const alternative = { ...obj, directory, request: obj.request + (obj.directory ? "/" : "") + (directory ? obj.fragment.slice(0, -1) : obj.fragment), fragment: "" }; resolver.doResolve( target, alternative, null, resolveContext, (err, result) => { if (err) return callback(err); if (result) return callback(null, result); resolver.doResolve(target, obj, null, resolveContext, callback); } ); return; } resolver.doResolve(target, obj, null, resolveContext, callback); }); } }; enhanced-resolve-5.15.0/lib/PnpPlugin.js000066400000000000000000000062301444210260000200360ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author MaĆ«l Nison @arcanis */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** * @typedef {Object} PnpApiImpl * @property {function(string, string, object): string} resolveToUnqualified */ module.exports = class PnpPlugin { /** * @param {string | ResolveStepHook} source source * @param {PnpApiImpl} pnpApi pnpApi * @param {string | ResolveStepHook} target target */ constructor(source, pnpApi, target) { this.source = source; this.pnpApi = pnpApi; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { /** @type {ResolveStepHook} */ const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("PnpPlugin", (request, resolveContext, callback) => { const req = request.request; if (!req) return callback(); // The trailing slash indicates to PnP that this value is a folder rather than a file const issuer = `${request.path}/`; const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req); if (!packageMatch) return callback(); const packageName = packageMatch[0]; const innerRequest = `.${req.slice(packageName.length)}`; /** @type {string|undefined} */ let resolution; /** @type {string|undefined} */ let apiResolution; try { resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, { considerBuiltins: false }); if (resolveContext.fileDependencies) { apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, { considerBuiltins: false }); } } catch (/** @type {unknown} */ error) { if ( /** @type {Error & { code: string }} */ (error).code === "MODULE_NOT_FOUND" && /** @type {Error & { pnpCode: string }} */ (error).pnpCode === "UNDECLARED_DEPENDENCY" ) { // This is not a PnP managed dependency. // Try to continue resolving with our alternatives if (resolveContext.log) { resolveContext.log(`request is not managed by the pnpapi`); for (const line of /** @type {Error} */ (error).message .split("\n") .filter(Boolean)) resolveContext.log(` ${line}`); } return callback(); } return callback(/** @type {Error} */ (error)); } if (resolution === packageName) return callback(); if (apiResolution && resolveContext.fileDependencies) { resolveContext.fileDependencies.add(apiResolution); } /** @type {ResolveRequest} */ const obj = { ...request, path: resolution, request: innerRequest, ignoreSymlinks: true, fullySpecified: request.fullySpecified && innerRequest !== "." }; resolver.doResolve( target, obj, `resolved by pnp to ${resolution}`, resolveContext, (err, result) => { if (err) return callback(err); if (result) return callback(null, result); // Skip alternatives return callback(null, null); } ); }); } }; enhanced-resolve-5.15.0/lib/Resolver.js000066400000000000000000000405551444210260000177330ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = require("tapable"); const createInnerContext = require("./createInnerContext"); const { parseIdentifier } = require("./util/identifier"); const { normalize, cachedJoin: join, getType, PathType } = require("./util/path"); /** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */ /** @typedef {Error & {details?: string}} ErrorWithDetail */ /** @typedef {(err: ErrorWithDetail|null, res?: string|false, req?: ResolveRequest) => void} ResolveCallback */ /** * @typedef {Object} FileSystemStats * @property {function(): boolean} isDirectory * @property {function(): boolean} isFile */ /** * @typedef {Object} FileSystemDirent * @property {Buffer | string} name * @property {function(): boolean} isDirectory * @property {function(): boolean} isFile */ /** * @typedef {Object} PossibleFileSystemError * @property {string=} code * @property {number=} errno * @property {string=} path * @property {string=} syscall */ /** * @template T * @callback FileSystemCallback * @param {PossibleFileSystemError & Error | null | undefined} err * @param {T=} result */ /** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | import("fs").Dirent[]=): void} DirentArrayCallback */ /** * @typedef {Object} ReaddirOptions * @property {BufferEncoding | null | 'buffer'} [encoding] * @property {boolean | undefined} [withFileTypes=false] */ /** * @typedef {Object} FileSystem * @property {(function(string, FileSystemCallback): void) & function(string, object, FileSystemCallback): void} readFile * @property {function(string, (ReaddirOptions | BufferEncoding | null | undefined | 'buffer' | DirentArrayCallback)=, DirentArrayCallback=): void} readdir * @property {((function(string, FileSystemCallback): void) & function(string, object, FileSystemCallback): void)=} readJson * @property {(function(string, FileSystemCallback): void) & function(string, object, FileSystemCallback): void} readlink * @property {(function(string, FileSystemCallback): void) & function(string, object, FileSystemCallback): void=} lstat * @property {(function(string, FileSystemCallback): void) & function(string, object, FileSystemCallback): void} stat */ /** * @typedef {Object} SyncFileSystem * @property {function(string, object=): Buffer | string} readFileSync * @property {function(string, object=): (Buffer | string)[] | FileSystemDirent[]} readdirSync * @property {(function(string, object=): object)=} readJsonSync * @property {function(string, object=): Buffer | string} readlinkSync * @property {function(string, object=): FileSystemStats=} lstatSync * @property {function(string, object=): FileSystemStats} statSync */ /** * @typedef {Object} ParsedIdentifier * @property {string} request * @property {string} query * @property {string} fragment * @property {boolean} directory * @property {boolean} module * @property {boolean} file * @property {boolean} internal */ /** @typedef {string | number | boolean | null} JsonPrimitive */ /** @typedef {JsonValue[]} JsonArray */ /** @typedef {JsonPrimitive | JsonObject | JsonArray} JsonValue */ /** @typedef {{[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined}} JsonObject */ /** * @typedef {Object} BaseResolveRequest * @property {string | false} path * @property {object=} context * @property {string=} descriptionFilePath * @property {string=} descriptionFileRoot * @property {JsonObject=} descriptionFileData * @property {string=} relativePath * @property {boolean=} ignoreSymlinks * @property {boolean=} fullySpecified * @property {string=} __innerRequest * @property {string=} __innerRequest_request * @property {string=} __innerRequest_relativePath */ /** @typedef {BaseResolveRequest & Partial} ResolveRequest */ /** * String with special formatting * @typedef {string} StackEntry */ /** * @template T * @typedef {{ add: (item: T) => void }} WriteOnlySet */ /** @typedef {(function (ResolveRequest): void)} ResolveContextYield */ /** * Resolve context * @typedef {Object} ResolveContext * @property {WriteOnlySet=} contextDependencies * @property {WriteOnlySet=} fileDependencies files that was found on file system * @property {WriteOnlySet=} missingDependencies dependencies that was not found on file system * @property {Set=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`, * @property {(function(string): void)=} log log function * @property {ResolveContextYield=} yield yield result, if provided plugins can return several results */ /** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */ /** * @typedef {Object} KnownHooks * @property {SyncHook<[ResolveStepHook, ResolveRequest], void>} resolveStep * @property {SyncHook<[ResolveRequest, Error]>} noResolve * @property {ResolveStepHook} resolve * @property {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} result */ /** * @typedef {{[key: string]: ResolveStepHook}} EnsuredHooks */ /** * @param {string} str input string * @returns {string} in camel case */ function toCamelCase(str) { return str.replace(/-([a-z])/g, str => str.slice(1).toUpperCase()); } class Resolver { /** * @param {ResolveStepHook} hook hook * @param {ResolveRequest} request request * @returns {StackEntry} stack entry */ static createStackEntry(hook, request) { return ( hook.name + ": (" + request.path + ") " + (request.request || "") + (request.query || "") + (request.fragment || "") + (request.directory ? " directory" : "") + (request.module ? " module" : "") ); } /** * @param {FileSystem} fileSystem a filesystem * @param {ResolveOptions} options options */ constructor(fileSystem, options) { this.fileSystem = fileSystem; this.options = options; /** @type {KnownHooks} */ this.hooks = { resolveStep: new SyncHook(["hook", "request"], "resolveStep"), noResolve: new SyncHook(["request", "error"], "noResolve"), resolve: new AsyncSeriesBailHook( ["request", "resolveContext"], "resolve" ), result: new AsyncSeriesHook(["result", "resolveContext"], "result") }; } /** * @param {string | ResolveStepHook} name hook name or hook itself * @returns {ResolveStepHook} the hook */ ensureHook(name) { if (typeof name !== "string") { return name; } name = toCamelCase(name); if (/^before/.test(name)) { return /** @type {ResolveStepHook} */ ( this.ensureHook(name[6].toLowerCase() + name.slice(7)).withOptions({ stage: -10 }) ); } if (/^after/.test(name)) { return /** @type {ResolveStepHook} */ ( this.ensureHook(name[5].toLowerCase() + name.slice(6)).withOptions({ stage: 10 }) ); } /** @type {ResolveStepHook} */ const hook = /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; if (!hook) { /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name] = new AsyncSeriesBailHook( ["request", "resolveContext"], name ); return /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; } return hook; } /** * @param {string | ResolveStepHook} name hook name or hook itself * @returns {ResolveStepHook} the hook */ getHook(name) { if (typeof name !== "string") { return name; } name = toCamelCase(name); if (/^before/.test(name)) { return /** @type {ResolveStepHook} */ ( this.getHook(name[6].toLowerCase() + name.slice(7)).withOptions({ stage: -10 }) ); } if (/^after/.test(name)) { return /** @type {ResolveStepHook} */ ( this.getHook(name[5].toLowerCase() + name.slice(6)).withOptions({ stage: 10 }) ); } /** @type {ResolveStepHook} */ const hook = /** @type {KnownHooks & EnsuredHooks} */ (this.hooks)[name]; if (!hook) { throw new Error(`Hook ${name} doesn't exist`); } return hook; } /** * @param {object} context context information object * @param {string} path context path * @param {string} request request string * @returns {string | false} result */ resolveSync(context, path, request) { /** @type {Error | null | undefined} */ let err = undefined; /** @type {string | false | undefined} */ let result = undefined; let sync = false; this.resolve(context, path, request, {}, (e, r) => { err = e; result = r; sync = true; }); if (!sync) { throw new Error( "Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!" ); } if (err) throw err; if (result === undefined) throw new Error("No result"); return result; } /** * @param {object} context context information object * @param {string} path context path * @param {string} request request string * @param {ResolveContext} resolveContext resolve context * @param {ResolveCallback} callback callback function * @returns {void} */ resolve(context, path, request, resolveContext, callback) { if (!context || typeof context !== "object") return callback(new Error("context argument is not an object")); if (typeof path !== "string") return callback(new Error("path argument is not a string")); if (typeof request !== "string") return callback(new Error("request argument is not a string")); if (!resolveContext) return callback(new Error("resolveContext argument is not set")); /** @type {ResolveRequest} */ const obj = { context: context, path: path, request: request }; /** @type {ResolveContextYield | undefined} */ let yield_; let yieldCalled = false; /** @type {ResolveContextYield | undefined} */ let finishYield; if (typeof resolveContext.yield === "function") { const old = resolveContext.yield; /** * @param {ResolveRequest} obj object */ yield_ = obj => { old(obj); yieldCalled = true; }; /** * @param {ResolveRequest} result result * @returns {void} */ finishYield = result => { if (result) { /** @type {ResolveContextYield} */ (yield_)(result); } callback(null); }; } const message = `resolve '${request}' in '${path}'`; /** * @param {ResolveRequest} result result * @returns {void} */ const finishResolved = result => { return callback( null, result.path === false ? false : `${result.path.replace(/#/g, "\0#")}${ result.query ? result.query.replace(/#/g, "\0#") : "" }${result.fragment || ""}`, result ); }; /** * @param {string[]} log logs * @returns {void} */ const finishWithoutResolve = log => { /** * @type {ErrorWithDetail} */ const error = new Error("Can't " + message); error.details = log.join("\n"); this.hooks.noResolve.call(obj, error); return callback(error); }; if (resolveContext.log) { // We need log anyway to capture it in case of an error const parentLog = resolveContext.log; /** @type {string[]} */ const log = []; return this.doResolve( this.hooks.resolve, obj, message, { log: msg => { parentLog(msg); log.push(msg); }, yield: yield_, fileDependencies: resolveContext.fileDependencies, contextDependencies: resolveContext.contextDependencies, missingDependencies: resolveContext.missingDependencies, stack: resolveContext.stack }, (err, result) => { if (err) return callback(err); if (yieldCalled || (result && yield_)) { return /** @type {ResolveContextYield} */ (finishYield)( /** @type {ResolveRequest} */ (result) ); } if (result) return finishResolved(result); return finishWithoutResolve(log); } ); } else { // Try to resolve assuming there is no error // We don't log stuff in this case return this.doResolve( this.hooks.resolve, obj, message, { log: undefined, yield: yield_, fileDependencies: resolveContext.fileDependencies, contextDependencies: resolveContext.contextDependencies, missingDependencies: resolveContext.missingDependencies, stack: resolveContext.stack }, (err, result) => { if (err) return callback(err); if (yieldCalled || (result && yield_)) { return /** @type {ResolveContextYield} */ (finishYield)( /** @type {ResolveRequest} */ (result) ); } if (result) return finishResolved(result); // log is missing for the error details // so we redo the resolving for the log info // this is more expensive to the success case // is assumed by default /** @type {string[]} */ const log = []; return this.doResolve( this.hooks.resolve, obj, message, { log: msg => log.push(msg), yield: yield_, stack: resolveContext.stack }, (err, result) => { if (err) return callback(err); // In a case that there is a race condition and yield will be called if (yieldCalled || (result && yield_)) { return /** @type {ResolveContextYield} */ (finishYield)( /** @type {ResolveRequest} */ (result) ); } return finishWithoutResolve(log); } ); } ); } } /** * @param {ResolveStepHook} hook hook * @param {ResolveRequest} request request * @param {null|string} message string * @param {ResolveContext} resolveContext resolver context * @param {(err?: null|Error, result?: ResolveRequest) => void} callback callback * @returns {void} */ doResolve(hook, request, message, resolveContext, callback) { const stackEntry = Resolver.createStackEntry(hook, request); /** @type {Set | undefined} */ let newStack; if (resolveContext.stack) { newStack = new Set(resolveContext.stack); if (resolveContext.stack.has(stackEntry)) { /** * Prevent recursion * @type {Error & {recursion?: boolean}} */ const recursionError = new Error( "Recursion in resolving\nStack:\n " + Array.from(newStack).join("\n ") ); recursionError.recursion = true; if (resolveContext.log) resolveContext.log("abort resolving because of recursion"); return callback(recursionError); } newStack.add(stackEntry); } else { newStack = new Set([stackEntry]); } this.hooks.resolveStep.call(hook, request); if (hook.isUsed()) { const innerContext = createInnerContext( { log: resolveContext.log, yield: resolveContext.yield, fileDependencies: resolveContext.fileDependencies, contextDependencies: resolveContext.contextDependencies, missingDependencies: resolveContext.missingDependencies, stack: newStack }, message ); return hook.callAsync(request, innerContext, (err, result) => { if (err) return callback(err); if (result) return callback(null, result); callback(); }); } else { callback(); } } /** * @param {string} identifier identifier * @returns {ParsedIdentifier} parsed identifier */ parse(identifier) { const part = { request: "", query: "", fragment: "", module: false, directory: false, file: false, internal: false }; const parsedIdentifier = parseIdentifier(identifier); if (!parsedIdentifier) return part; [part.request, part.query, part.fragment] = parsedIdentifier; if (part.request.length > 0) { part.internal = this.isPrivate(identifier); part.module = this.isModule(part.request); part.directory = this.isDirectory(part.request); if (part.directory) { part.request = part.request.slice(0, -1); } } return part; } /** * @param {string} path path * @returns {boolean} true, if the path is a module */ isModule(path) { return getType(path) === PathType.Normal; } /** * @param {string} path path * @returns {boolean} true, if the path is private */ isPrivate(path) { return getType(path) === PathType.Internal; } /** * @param {string} path a path * @returns {boolean} true, if the path is a directory path */ isDirectory(path) { return path.endsWith("/"); } /** * @param {string} path path * @param {string} request request * @returns {string} joined path */ join(path, request) { return join(path, request); } /** * @param {string} path path * @returns {string} normalized path */ normalize(path) { return normalize(path); } } module.exports = Resolver; enhanced-resolve-5.15.0/lib/ResolverFactory.js000066400000000000000000000507511444210260000212620ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const versions = require("process").versions; const Resolver = require("./Resolver"); const { getType, PathType } = require("./util/path"); const SyncAsyncFileSystemDecorator = require("./SyncAsyncFileSystemDecorator"); const AliasFieldPlugin = require("./AliasFieldPlugin"); const AliasPlugin = require("./AliasPlugin"); const AppendPlugin = require("./AppendPlugin"); const ConditionalPlugin = require("./ConditionalPlugin"); const DescriptionFilePlugin = require("./DescriptionFilePlugin"); const DirectoryExistsPlugin = require("./DirectoryExistsPlugin"); const ExportsFieldPlugin = require("./ExportsFieldPlugin"); const ExtensionAliasPlugin = require("./ExtensionAliasPlugin"); const FileExistsPlugin = require("./FileExistsPlugin"); const ImportsFieldPlugin = require("./ImportsFieldPlugin"); const JoinRequestPartPlugin = require("./JoinRequestPartPlugin"); const JoinRequestPlugin = require("./JoinRequestPlugin"); const MainFieldPlugin = require("./MainFieldPlugin"); const ModulesInHierarchicalDirectoriesPlugin = require("./ModulesInHierarchicalDirectoriesPlugin"); const ModulesInRootPlugin = require("./ModulesInRootPlugin"); const NextPlugin = require("./NextPlugin"); const ParsePlugin = require("./ParsePlugin"); const PnpPlugin = require("./PnpPlugin"); const RestrictionsPlugin = require("./RestrictionsPlugin"); const ResultPlugin = require("./ResultPlugin"); const RootsPlugin = require("./RootsPlugin"); const SelfReferencePlugin = require("./SelfReferencePlugin"); const SymlinkPlugin = require("./SymlinkPlugin"); const TryNextPlugin = require("./TryNextPlugin"); const UnsafeCachePlugin = require("./UnsafeCachePlugin"); const UseFilePlugin = require("./UseFilePlugin"); /** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */ /** @typedef {import("./ExtensionAliasPlugin").ExtensionAliasOption} ExtensionAliasOption */ /** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */ /** @typedef {import("./Resolver").EnsuredHooks} EnsuredHooks */ /** @typedef {import("./Resolver").FileSystem} FileSystem */ /** @typedef {import("./Resolver").KnownHooks} KnownHooks */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ /** @typedef {string|string[]|false} AliasOptionNewRequest */ /** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */ /** @typedef {{[k: string]: string|string[] }} ExtensionAliasOptions */ /** @typedef {false | 0 | "" | null | undefined} Falsy */ /** @typedef {{apply: function(Resolver): void} | (function(this: Resolver, Resolver): void) | Falsy} Plugin */ /** * @typedef {Object} UserResolveOptions * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option * @property {ExtensionAliasOptions=} extensionAlias An object which maps extension to extension aliases * @property {(string | string[])[]=} aliasFields A list of alias fields in description files * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties. * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key. * @property {string[]=} descriptionFiles A list of description files to read from * @property {string[]=} conditionNames A list of exports field condition names. * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used * @property {(string | string[])[]=} exportsFields A list of exports fields in description files * @property {(string | string[])[]=} importsFields A list of imports fields in description files * @property {string[]=} extensions A list of extensions which should be tried for files * @property {FileSystem} fileSystem The file system which should be used * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests * @property {boolean=} symlinks Resolve symlinks to their symlinked location * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files * @property {string[]=} mainFiles A list of main files in directories * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto" * @property {string[]=} roots A list of root paths * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it * @property {boolean=} resolveToContext Resolve to a context instead of a file * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions * @property {boolean=} useSyncFileSystemCalls Use only the sync constraints of the file system calls * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots */ /** * @typedef {Object} ResolveOptions * @property {AliasOptionEntry[]} alias * @property {AliasOptionEntry[]} fallback * @property {Set} aliasFields * @property {ExtensionAliasOption[]} extensionAlias * @property {(function(ResolveRequest): boolean)} cachePredicate * @property {boolean} cacheWithContext * @property {Set} conditionNames A list of exports field condition names. * @property {string[]} descriptionFiles * @property {boolean} enforceExtension * @property {Set} exportsFields * @property {Set} importsFields * @property {Set} extensions * @property {FileSystem} fileSystem * @property {object | false} unsafeCache * @property {boolean} symlinks * @property {Resolver=} resolver * @property {Array} modules * @property {{name: string[], forceRelative: boolean}[]} mainFields * @property {Set} mainFiles * @property {Plugin[]} plugins * @property {PnpApi | null} pnpApi * @property {Set} roots * @property {boolean} fullySpecified * @property {boolean} resolveToContext * @property {Set} restrictions * @property {boolean} preferRelative * @property {boolean} preferAbsolute */ /** * @param {PnpApi | null=} option option * @returns {PnpApi | null} processed option */ function processPnpApiOption(option) { if ( option === undefined && /** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp ) { // @ts-ignore return require("pnpapi"); // eslint-disable-line node/no-missing-require } return option || null; } /** * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias * @returns {AliasOptionEntry[]} normalized aliases */ function normalizeAlias(alias) { return typeof alias === "object" && !Array.isArray(alias) && alias !== null ? Object.keys(alias).map(key => { /** @type {AliasOptionEntry} */ const obj = { name: key, onlyModule: false, alias: alias[key] }; if (/\$$/.test(key)) { obj.onlyModule = true; obj.name = key.slice(0, -1); } return obj; }) : /** @type {Array} */ (alias) || []; } /** * @param {UserResolveOptions} options input options * @returns {ResolveOptions} output options */ function createOptions(options) { const mainFieldsSet = new Set(options.mainFields || ["main"]); /** @type {ResolveOptions["mainFields"]} */ const mainFields = []; for (const item of mainFieldsSet) { if (typeof item === "string") { mainFields.push({ name: [item], forceRelative: true }); } else if (Array.isArray(item)) { mainFields.push({ name: item, forceRelative: true }); } else { mainFields.push({ name: Array.isArray(item.name) ? item.name : [item.name], forceRelative: item.forceRelative }); } } return { alias: normalizeAlias(options.alias), fallback: normalizeAlias(options.fallback), aliasFields: new Set(options.aliasFields), cachePredicate: options.cachePredicate || function () { return true; }, cacheWithContext: typeof options.cacheWithContext !== "undefined" ? options.cacheWithContext : true, exportsFields: new Set(options.exportsFields || ["exports"]), importsFields: new Set(options.importsFields || ["imports"]), conditionNames: new Set(options.conditionNames), descriptionFiles: Array.from( new Set(options.descriptionFiles || ["package.json"]) ), enforceExtension: options.enforceExtension === undefined ? options.extensions && options.extensions.includes("") ? true : false : options.enforceExtension, extensions: new Set(options.extensions || [".js", ".json", ".node"]), extensionAlias: options.extensionAlias ? Object.keys(options.extensionAlias).map(k => ({ extension: k, alias: /** @type {ExtensionAliasOptions} */ (options.extensionAlias)[ k ] })) : [], fileSystem: options.useSyncFileSystemCalls ? new SyncAsyncFileSystemDecorator( /** @type {SyncFileSystem} */ ( /** @type {unknown} */ (options.fileSystem) ) ) : options.fileSystem, unsafeCache: options.unsafeCache && typeof options.unsafeCache !== "object" ? {} : options.unsafeCache || false, symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true, resolver: options.resolver, modules: mergeFilteredToArray( Array.isArray(options.modules) ? options.modules : options.modules ? [options.modules] : ["node_modules"], item => { const type = getType(item); return type === PathType.Normal || type === PathType.Relative; } ), mainFields, mainFiles: new Set(options.mainFiles || ["index"]), plugins: options.plugins || [], pnpApi: processPnpApiOption(options.pnpApi), roots: new Set(options.roots || undefined), fullySpecified: options.fullySpecified || false, resolveToContext: options.resolveToContext || false, preferRelative: options.preferRelative || false, preferAbsolute: options.preferAbsolute || false, restrictions: new Set(options.restrictions) }; } /** * @param {UserResolveOptions} options resolve options * @returns {Resolver} created resolver */ exports.createResolver = function (options) { const normalizedOptions = createOptions(options); const { alias, fallback, aliasFields, cachePredicate, cacheWithContext, conditionNames, descriptionFiles, enforceExtension, exportsFields, extensionAlias, importsFields, extensions, fileSystem, fullySpecified, mainFields, mainFiles, modules, plugins: userPlugins, pnpApi, resolveToContext, preferRelative, preferAbsolute, symlinks, unsafeCache, resolver: customResolver, restrictions, roots } = normalizedOptions; const plugins = userPlugins.slice(); const resolver = customResolver ? customResolver : new Resolver(fileSystem, normalizedOptions); //// pipeline //// resolver.ensureHook("resolve"); resolver.ensureHook("internalResolve"); resolver.ensureHook("newInternalResolve"); resolver.ensureHook("parsedResolve"); resolver.ensureHook("describedResolve"); resolver.ensureHook("rawResolve"); resolver.ensureHook("normalResolve"); resolver.ensureHook("internal"); resolver.ensureHook("rawModule"); resolver.ensureHook("module"); resolver.ensureHook("resolveAsModule"); resolver.ensureHook("undescribedResolveInPackage"); resolver.ensureHook("resolveInPackage"); resolver.ensureHook("resolveInExistingDirectory"); resolver.ensureHook("relative"); resolver.ensureHook("describedRelative"); resolver.ensureHook("directory"); resolver.ensureHook("undescribedExistingDirectory"); resolver.ensureHook("existingDirectory"); resolver.ensureHook("undescribedRawFile"); resolver.ensureHook("rawFile"); resolver.ensureHook("file"); resolver.ensureHook("finalFile"); resolver.ensureHook("existingFile"); resolver.ensureHook("resolved"); // TODO remove in next major // cspell:word Interal // Backward-compat // @ts-ignore resolver.hooks.newInteralResolve = resolver.hooks.newInternalResolve; // resolve for (const { source, resolveOptions } of [ { source: "resolve", resolveOptions: { fullySpecified } }, { source: "internal-resolve", resolveOptions: { fullySpecified: false } } ]) { if (unsafeCache) { plugins.push( new UnsafeCachePlugin( source, cachePredicate, /** @type {import("./UnsafeCachePlugin").Cache} */ (unsafeCache), cacheWithContext, `new-${source}` ) ); plugins.push( new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve") ); } else { plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve")); } } // parsed-resolve plugins.push( new DescriptionFilePlugin( "parsed-resolve", descriptionFiles, false, "described-resolve" ) ); plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve")); // described-resolve plugins.push(new NextPlugin("described-resolve", "raw-resolve")); if (fallback.length > 0) { plugins.push( new AliasPlugin("described-resolve", fallback, "internal-resolve") ); } // raw-resolve if (alias.length > 0) { plugins.push(new AliasPlugin("raw-resolve", alias, "internal-resolve")); } aliasFields.forEach(item => { plugins.push(new AliasFieldPlugin("raw-resolve", item, "internal-resolve")); }); extensionAlias.forEach(item => plugins.push( new ExtensionAliasPlugin("raw-resolve", item, "normal-resolve") ) ); plugins.push(new NextPlugin("raw-resolve", "normal-resolve")); // normal-resolve if (preferRelative) { plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); } plugins.push( new ConditionalPlugin( "after-normal-resolve", { module: true }, "resolve as module", false, "raw-module" ) ); plugins.push( new ConditionalPlugin( "after-normal-resolve", { internal: true }, "resolve as internal import", false, "internal" ) ); if (preferAbsolute) { plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); } if (roots.size > 0) { plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative")); } if (!preferRelative && !preferAbsolute) { plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative")); } // internal importsFields.forEach(importsField => { plugins.push( new ImportsFieldPlugin( "internal", conditionNames, importsField, "relative", "internal-resolve" ) ); }); // raw-module exportsFields.forEach(exportsField => { plugins.push( new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module") ); }); modules.forEach(item => { if (Array.isArray(item)) { if (item.includes("node_modules") && pnpApi) { plugins.push( new ModulesInHierarchicalDirectoriesPlugin( "raw-module", item.filter(i => i !== "node_modules"), "module" ) ); plugins.push( new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package") ); } else { plugins.push( new ModulesInHierarchicalDirectoriesPlugin( "raw-module", item, "module" ) ); } } else { plugins.push(new ModulesInRootPlugin("raw-module", item, "module")); } }); // module plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module")); // resolve-as-module if (!resolveToContext) { plugins.push( new ConditionalPlugin( "resolve-as-module", { directory: false, request: "." }, "single file module", true, "undescribed-raw-file" ) ); } plugins.push( new DirectoryExistsPlugin( "resolve-as-module", "undescribed-resolve-in-package" ) ); // undescribed-resolve-in-package plugins.push( new DescriptionFilePlugin( "undescribed-resolve-in-package", descriptionFiles, false, "resolve-in-package" ) ); plugins.push( new NextPlugin("after-undescribed-resolve-in-package", "resolve-in-package") ); // resolve-in-package exportsFields.forEach(exportsField => { plugins.push( new ExportsFieldPlugin( "resolve-in-package", conditionNames, exportsField, "relative" ) ); }); plugins.push( new NextPlugin("resolve-in-package", "resolve-in-existing-directory") ); // resolve-in-existing-directory plugins.push( new JoinRequestPlugin("resolve-in-existing-directory", "relative") ); // relative plugins.push( new DescriptionFilePlugin( "relative", descriptionFiles, true, "described-relative" ) ); plugins.push(new NextPlugin("after-relative", "described-relative")); // described-relative if (resolveToContext) { plugins.push(new NextPlugin("described-relative", "directory")); } else { plugins.push( new ConditionalPlugin( "described-relative", { directory: false }, null, true, "raw-file" ) ); plugins.push( new ConditionalPlugin( "described-relative", { fullySpecified: false }, "as directory", true, "directory" ) ); } // directory plugins.push( new DirectoryExistsPlugin("directory", "undescribed-existing-directory") ); if (resolveToContext) { // undescribed-existing-directory plugins.push(new NextPlugin("undescribed-existing-directory", "resolved")); } else { // undescribed-existing-directory plugins.push( new DescriptionFilePlugin( "undescribed-existing-directory", descriptionFiles, false, "existing-directory" ) ); mainFiles.forEach(item => { plugins.push( new UseFilePlugin( "undescribed-existing-directory", item, "undescribed-raw-file" ) ); }); // described-existing-directory mainFields.forEach(item => { plugins.push( new MainFieldPlugin( "existing-directory", item, "resolve-in-existing-directory" ) ); }); mainFiles.forEach(item => { plugins.push( new UseFilePlugin("existing-directory", item, "undescribed-raw-file") ); }); // undescribed-raw-file plugins.push( new DescriptionFilePlugin( "undescribed-raw-file", descriptionFiles, true, "raw-file" ) ); plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file")); // raw-file plugins.push( new ConditionalPlugin( "raw-file", { fullySpecified: true }, null, false, "file" ) ); if (!enforceExtension) { plugins.push(new TryNextPlugin("raw-file", "no extension", "file")); } extensions.forEach(item => { plugins.push(new AppendPlugin("raw-file", item, "file")); }); // file if (alias.length > 0) plugins.push(new AliasPlugin("file", alias, "internal-resolve")); aliasFields.forEach(item => { plugins.push(new AliasFieldPlugin("file", item, "internal-resolve")); }); plugins.push(new NextPlugin("file", "final-file")); // final-file plugins.push(new FileExistsPlugin("final-file", "existing-file")); // existing-file if (symlinks) plugins.push(new SymlinkPlugin("existing-file", "existing-file")); plugins.push(new NextPlugin("existing-file", "resolved")); } const resolved = /** @type {KnownHooks & EnsuredHooks} */ (resolver.hooks).resolved; // resolved if (restrictions.size > 0) { plugins.push(new RestrictionsPlugin(resolved, restrictions)); } plugins.push(new ResultPlugin(resolved)); //// RESOLVER //// for (const plugin of plugins) { if (typeof plugin === "function") { /** @type {function(this: Resolver, Resolver): void} */ (plugin).call(resolver, resolver); } else if (plugin) { plugin.apply(resolver); } } return resolver; }; /** * Merging filtered elements * @param {string[]} array source array * @param {function(string): boolean} filter predicate * @returns {Array} merge result */ function mergeFilteredToArray(array, filter) { /** @type {Array} */ const result = []; const set = new Set(array); for (const item of set) { if (filter(item)) { const lastElement = result.length > 0 ? result[result.length - 1] : undefined; if (Array.isArray(lastElement)) { lastElement.push(item); } else { result.push([item]); } } else { result.push(item); } } return result; } enhanced-resolve-5.15.0/lib/RestrictionsPlugin.js000066400000000000000000000034271444210260000217760ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ const slashCode = "/".charCodeAt(0); const backslashCode = "\\".charCodeAt(0); /** * @param {string} path path * @param {string} parent parent path * @returns {boolean} true, if path is inside of parent */ const isInside = (path, parent) => { if (!path.startsWith(parent)) return false; if (path.length === parent.length) return true; const charCode = path.charCodeAt(parent.length); return charCode === slashCode || charCode === backslashCode; }; module.exports = class RestrictionsPlugin { /** * @param {string | ResolveStepHook} source source * @param {Set} restrictions restrictions */ constructor(source, restrictions) { this.source = source; this.restrictions = restrictions; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { resolver .getHook(this.source) .tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => { if (typeof request.path === "string") { const path = request.path; for (const rule of this.restrictions) { if (typeof rule === "string") { if (!isInside(path, rule)) { if (resolveContext.log) { resolveContext.log( `${path} is not inside of the restriction ${rule}` ); } return callback(null, null); } } else if (!rule.test(path)) { if (resolveContext.log) { resolveContext.log( `${path} doesn't match the restriction ${rule}` ); } return callback(null, null); } } } callback(); }); } }; enhanced-resolve-5.15.0/lib/ResultPlugin.js000066400000000000000000000017131444210260000205600ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class ResultPlugin { /** * @param {ResolveStepHook} source source */ constructor(source) { this.source = source; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { this.source.tapAsync( "ResultPlugin", (request, resolverContext, callback) => { const obj = { ...request }; if (resolverContext.log) resolverContext.log("reporting result " + obj.path); resolver.hooks.result.callAsync(obj, resolverContext, err => { if (err) return callback(err); if (typeof resolverContext.yield === "function") { resolverContext.yield(obj); callback(null, null); } else { callback(null, obj); } }); } ); } }; enhanced-resolve-5.15.0/lib/RootsPlugin.js000066400000000000000000000031661444210260000204140ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; const forEachBail = require("./forEachBail"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ class RootsPlugin { /** * @param {string | ResolveStepHook} source source hook * @param {Set} roots roots * @param {string | ResolveStepHook} target target hook */ constructor(source, roots, target) { this.roots = Array.from(roots); this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("RootsPlugin", (request, resolveContext, callback) => { const req = request.request; if (!req) return callback(); if (!req.startsWith("/")) return callback(); forEachBail( this.roots, /** * @param {string} root root * @param {(err?: null|Error, result?: null|ResolveRequest) => void} callback callback * @returns {void} */ (root, callback) => { const path = resolver.join(root, req.slice(1)); /** @type {ResolveRequest} */ const obj = { ...request, path, relativePath: request.relativePath && path }; resolver.doResolve( target, obj, `root path ${root}`, resolveContext, callback ); }, callback ); }); } } module.exports = RootsPlugin; enhanced-resolve-5.15.0/lib/SelfReferencePlugin.js000066400000000000000000000042311444210260000220100ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const DescriptionFileUtils = require("./DescriptionFileUtils"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").JsonObject} JsonObject */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ const slashCode = "/".charCodeAt(0); module.exports = class SelfReferencePlugin { /** * @param {string | ResolveStepHook} source source * @param {string | string[]} fieldNamePath name path * @param {string | ResolveStepHook} target target */ constructor(source, fieldNamePath, target) { this.source = source; this.target = target; this.fieldName = fieldNamePath; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => { if (!request.descriptionFilePath) return callback(); const req = request.request; if (!req) return callback(); // Feature is only enabled when an exports field is present const exportsField = DescriptionFileUtils.getField( /** @type {JsonObject} */ (request.descriptionFileData), this.fieldName ); if (!exportsField) return callback(); const name = DescriptionFileUtils.getField( /** @type {JsonObject} */ (request.descriptionFileData), "name" ); if (typeof name !== "string") return callback(); if ( req.startsWith(name) && (req.length === name.length || req.charCodeAt(name.length) === slashCode) ) { const remainingRequest = `.${req.slice(name.length)}`; /** @type {ResolveRequest} */ const obj = { ...request, request: remainingRequest, path: /** @type {string} */ (request.descriptionFileRoot), relativePath: "." }; resolver.doResolve( target, obj, "self reference", resolveContext, callback ); } else { return callback(); } }); } }; enhanced-resolve-5.15.0/lib/SymlinkPlugin.js000066400000000000000000000052521444210260000207320ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const forEachBail = require("./forEachBail"); const getPaths = require("./getPaths"); const { getType, PathType } = require("./util/path"); /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class SymlinkPlugin { /** * @param {string | ResolveStepHook} source source * @param {string | ResolveStepHook} target target */ constructor(source, target) { this.source = source; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); const fs = resolver.fileSystem; resolver .getHook(this.source) .tapAsync("SymlinkPlugin", (request, resolveContext, callback) => { if (request.ignoreSymlinks) return callback(); const pathsResult = getPaths(/** @type {string} */ (request.path)); const pathSegments = pathsResult.segments; const paths = pathsResult.paths; let containsSymlink = false; let idx = -1; forEachBail( paths, /** * @param {string} path path * @param {(err?: null|Error, result?: null|number) => void} callback callback * @returns {void} */ (path, callback) => { idx++; if (resolveContext.fileDependencies) resolveContext.fileDependencies.add(path); fs.readlink(path, (err, result) => { if (!err && result) { pathSegments[idx] = /** @type {string} */ (result); containsSymlink = true; // Shortcut when absolute symlink found const resultType = getType(result.toString()); if ( resultType === PathType.AbsoluteWin || resultType === PathType.AbsolutePosix ) { return callback(null, idx); } } callback(); }); }, /** * @param {null|Error} [err] error * @param {null|number} [idx] result * @returns {void} */ (err, idx) => { if (!containsSymlink) return callback(); const resultSegments = typeof idx === "number" ? pathSegments.slice(0, idx + 1) : pathSegments.slice(); const result = resultSegments.reduceRight((a, b) => { return resolver.join(a, b); }); /** @type {ResolveRequest} */ const obj = { ...request, path: result }; resolver.doResolve( target, obj, "resolved symlink to " + result, resolveContext, callback ); } ); }); } }; enhanced-resolve-5.15.0/lib/SyncAsyncFileSystemDecorator.js000066400000000000000000000054551444210260000237140ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver").FileSystem} FileSystem */ /** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */ /** * @param {SyncFileSystem} fs file system implementation * @constructor */ function SyncAsyncFileSystemDecorator(fs) { this.fs = fs; /** @type {FileSystem["lstat"] | undefined} */ this.lstat = undefined; /** @type {SyncFileSystem["lstatSync"] | undefined} */ this.lstatSync = undefined; const lstatSync = fs.lstatSync; if (lstatSync) { this.lstat = (arg, options, callback) => { let result; try { result = lstatSync.call(fs, arg); } catch (e) { // @ts-ignore return (callback || options)(e); } // @ts-ignore (callback || options)(null, result); }; this.lstatSync = (arg, options) => lstatSync.call(fs, arg, options); } // @ts-ignore this.stat = (arg, options, callback) => { let result; try { result = callback ? fs.statSync(arg, options) : fs.statSync(arg); } catch (e) { return (callback || options)(e); } (callback || options)(null, result); }; /** @type {SyncFileSystem["statSync"]} */ this.statSync = (arg, options) => fs.statSync(arg, options); // @ts-ignore this.readdir = (arg, options, callback) => { let result; try { result = fs.readdirSync(arg); } catch (e) { return (callback || options)(e); } (callback || options)(null, result); }; /** @type {SyncFileSystem["readdirSync"]} */ this.readdirSync = (arg, options) => fs.readdirSync(arg, options); // @ts-ignore this.readFile = (arg, options, callback) => { let result; try { result = fs.readFileSync(arg); } catch (e) { return (callback || options)(e); } (callback || options)(null, result); }; /** @type {SyncFileSystem["readFileSync"]} */ this.readFileSync = (arg, options) => fs.readFileSync(arg, options); // @ts-ignore this.readlink = (arg, options, callback) => { let result; try { result = fs.readlinkSync(arg); } catch (e) { return (callback || options)(e); } (callback || options)(null, result); }; /** @type {SyncFileSystem["readlinkSync"]} */ this.readlinkSync = (arg, options) => fs.readlinkSync(arg, options); /** @type {FileSystem["readJson"] | undefined} */ this.readJson = undefined; /** @type {SyncFileSystem["readJsonSync"] | undefined} */ this.readJsonSync = undefined; const readJsonSync = fs.readJsonSync; if (readJsonSync) { this.readJson = (arg, options, callback) => { let result; try { result = readJsonSync.call(fs, arg); } catch (e) { // @ts-ignore return (callback || options)(e); } (callback || options)(null, result); }; this.readJsonSync = (arg, options) => readJsonSync.call(fs, arg, options); } } module.exports = SyncAsyncFileSystemDecorator; enhanced-resolve-5.15.0/lib/TryNextPlugin.js000066400000000000000000000016271444210260000207230ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class TryNextPlugin { /** * @param {string | ResolveStepHook} source source * @param {string} message message * @param {string | ResolveStepHook} target target */ constructor(source, message, target) { this.source = source; this.message = message; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("TryNextPlugin", (request, resolveContext, callback) => { resolver.doResolve( target, request, this.message, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/UnsafeCachePlugin.js000066400000000000000000000062351444210260000214530ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ /** @typedef {import("./Resolver").ResolveContextYield} ResolveContextYield */ /** @typedef {{[k: string]: ResolveRequest | ResolveRequest[] | undefined}} Cache */ /** * @param {string} type type of cache * @param {ResolveRequest} request request * @param {boolean} withContext cache with context? * @returns {string} cache id */ function getCacheId(type, request, withContext) { return JSON.stringify({ type, context: withContext ? request.context : "", path: request.path, query: request.query, fragment: request.fragment, request: request.request }); } module.exports = class UnsafeCachePlugin { /** * @param {string | ResolveStepHook} source source * @param {function(ResolveRequest): boolean} filterPredicate filterPredicate * @param {Cache} cache cache * @param {boolean} withContext withContext * @param {string | ResolveStepHook} target target */ constructor(source, filterPredicate, cache, withContext, target) { this.source = source; this.filterPredicate = filterPredicate; this.withContext = withContext; this.cache = cache; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => { if (!this.filterPredicate(request)) return callback(); const isYield = typeof resolveContext.yield === "function"; const cacheId = getCacheId( isYield ? "yield" : "default", request, this.withContext ); const cacheEntry = this.cache[cacheId]; if (cacheEntry) { if (isYield) { const yield_ = /** @type {Function} */ (resolveContext.yield); if (Array.isArray(cacheEntry)) { for (const result of cacheEntry) yield_(result); } else { yield_(cacheEntry); } return callback(null, null); } return callback(null, /** @type {ResolveRequest} */ (cacheEntry)); } /** @type {ResolveContextYield|undefined} */ let yieldFn; /** @type {ResolveContextYield|undefined} */ let yield_; /** @type {ResolveRequest[]} */ const yieldResult = []; if (isYield) { yieldFn = resolveContext.yield; yield_ = result => { yieldResult.push(result); }; } resolver.doResolve( target, request, null, yield_ ? { ...resolveContext, yield: yield_ } : resolveContext, (err, result) => { if (err) return callback(err); if (isYield) { if (result) yieldResult.push(result); for (const result of yieldResult) { /** @type {ResolveContextYield} */ (yieldFn)(result); } this.cache[cacheId] = yieldResult; return callback(null, null); } if (result) return callback(null, (this.cache[cacheId] = result)); callback(); } ); }); } }; enhanced-resolve-5.15.0/lib/UseFilePlugin.js000066400000000000000000000024371444210260000206420ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */ module.exports = class UseFilePlugin { /** * @param {string | ResolveStepHook} source source * @param {string} filename filename * @param {string | ResolveStepHook} target target */ constructor(source, filename, target) { this.source = source; this.filename = filename; this.target = target; } /** * @param {Resolver} resolver the resolver * @returns {void} */ apply(resolver) { const target = resolver.ensureHook(this.target); resolver .getHook(this.source) .tapAsync("UseFilePlugin", (request, resolveContext, callback) => { const filePath = resolver.join( /** @type {string} */ (request.path), this.filename ); /** @type {ResolveRequest} */ const obj = { ...request, path: filePath, relativePath: request.relativePath && resolver.join(request.relativePath, this.filename) }; resolver.doResolve( target, obj, "using path: " + filePath, resolveContext, callback ); }); } }; enhanced-resolve-5.15.0/lib/createInnerContext.js000066400000000000000000000020571444210260000217310ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver").ResolveContext} ResolveContext */ /** * @param {ResolveContext} options options for inner context * @param {null|string} message message to log * @returns {ResolveContext} inner context */ module.exports = function createInnerContext(options, message) { let messageReported = false; let innerLog = undefined; if (options.log) { if (message) { /** * @param {string} msg message */ innerLog = msg => { if (!messageReported) { /** @type {(function(string): void)} */ (options.log)(message); messageReported = true; } /** @type {(function(string): void)} */ (options.log)(" " + msg); }; } else { innerLog = options.log; } } return { log: innerLog, yield: options.yield, fileDependencies: options.fileDependencies, contextDependencies: options.contextDependencies, missingDependencies: options.missingDependencies, stack: options.stack }; }; enhanced-resolve-5.15.0/lib/forEachBail.js000066400000000000000000000021361444210260000202620ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** * @template T * @template Z * @callback Iterator * @param {T} item item * @param {(err?: null|Error, result?: null|Z) => void} callback callback * @param {number} i index * @returns {void} */ /** * @template T * @template Z * @param {T[]} array array * @param {Iterator} iterator iterator * @param {(err?: null|Error, result?: null|Z) => void} callback callback after all items are iterated * @returns {void} */ module.exports = function forEachBail(array, iterator, callback) { if (array.length === 0) return callback(); let i = 0; const next = () => { /** @type {boolean|undefined} */ let loop = undefined; iterator( array[i++], (err, result) => { if (err || result !== undefined || i >= array.length) { return callback(err, result); } if (loop === false) while (next()); loop = true; }, i ); if (!loop) loop = false; return loop; }; while (next()); }; enhanced-resolve-5.15.0/lib/getInnerRequest.js000066400000000000000000000021421444210260000212440ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** * @param {Resolver} resolver resolver * @param {ResolveRequest} request string * @returns {string} inner request */ module.exports = function getInnerRequest(resolver, request) { if ( typeof request.__innerRequest === "string" && request.__innerRequest_request === request.request && request.__innerRequest_relativePath === request.relativePath ) return request.__innerRequest; /** @type {string|undefined} */ let innerRequest; if (request.request) { innerRequest = request.request; if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) { innerRequest = resolver.join(request.relativePath, innerRequest); } } else { innerRequest = request.relativePath; } request.__innerRequest_request = request.request; request.__innerRequest_relativePath = request.relativePath; return (request.__innerRequest = /** @type {string} */ (innerRequest)); }; enhanced-resolve-5.15.0/lib/getPaths.js000066400000000000000000000021771444210260000177070ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; /** * @param {string} path path * @returns {{paths: string[], segments: string[]}}} paths and segments */ module.exports = function getPaths(path) { if (path === "/") return { paths: ["/"], segments: [""] }; const parts = path.split(/(.*?[\\/]+)/); const paths = [path]; const segments = [parts[parts.length - 1]]; let part = parts[parts.length - 1]; path = path.substring(0, path.length - part.length - 1); for (let i = parts.length - 2; i > 2; i -= 2) { paths.push(path); part = parts[i]; path = path.substring(0, path.length - part.length) || "/"; segments.push(part.slice(0, -1)); } part = parts[1]; segments.push(part); paths.push(part); return { paths: paths, segments: segments }; }; /** * @param {string} path path * @returns {string|null} basename or null */ module.exports.basename = function basename(path) { const i = path.lastIndexOf("/"), j = path.lastIndexOf("\\"); const p = i < 0 ? j : j < 0 ? i : i < j ? j : i; if (p < 0) return null; const s = path.slice(p + 1); return s; }; enhanced-resolve-5.15.0/lib/index.js000066400000000000000000000132141444210260000172310ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const fs = require("graceful-fs"); const CachedInputFileSystem = require("./CachedInputFileSystem"); const ResolverFactory = require("./ResolverFactory"); /** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */ /** @typedef {import("./Resolver")} Resolver */ /** @typedef {import("./Resolver").FileSystem} FileSystem */ /** @typedef {import("./Resolver").ResolveCallback} ResolveCallback */ /** @typedef {import("./Resolver").ResolveContext} ResolveContext */ /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */ /** @typedef {import("./ResolverFactory").Plugin} Plugin */ /** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */ /** @typedef {{ * (context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void; * (context: object, path: string, request: string, callback: ResolveCallback): void; * (path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void; * (path: string, request: string, callback: ResolveCallback): void; * }} ResolveFunctionAsync */ /** @typedef {{ * (context: object, path: string, request: string): string|false; * (path: string, request: string): string|false; * }} ResolveFunction */ const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const nodeContext = { environments: ["node+es3+es5+process+native"] }; const asyncResolver = ResolverFactory.createResolver({ conditionNames: ["node"], extensions: [".js", ".json", ".node"], fileSystem: nodeFileSystem }); /** * @type {ResolveFunctionAsync} */ const resolve = /** * @param {object|string} context * @param {string} path * @param {string|ResolveContext|ResolveCallback} request * @param {ResolveContext|ResolveCallback=} resolveContext * @param {ResolveCallback=} callback */ (context, path, request, resolveContext, callback) => { if (typeof context === "string") { callback = /** @type {ResolveCallback} */ (resolveContext); resolveContext = /** @type {ResolveContext} */ (request); request = path; path = context; context = nodeContext; } if (typeof callback !== "function") { callback = /** @type {ResolveCallback} */ (resolveContext); } asyncResolver.resolve( context, path, /** @type {string} */ (request), /** @type {ResolveContext} */ (resolveContext), /** @type {ResolveCallback} */ (callback) ); }; const syncResolver = ResolverFactory.createResolver({ conditionNames: ["node"], extensions: [".js", ".json", ".node"], useSyncFileSystemCalls: true, fileSystem: nodeFileSystem }); /** * @type {ResolveFunction} */ const resolveSync = /** * @param {object|string} context * @param {string} path * @param {string=} request */ (context, path, request) => { if (typeof context === "string") { request = path; path = context; context = nodeContext; } return syncResolver.resolveSync( context, path, /** @type {string} */ (request) ); }; /** @typedef {Omit & Partial>} ResolveOptionsOptionalFS */ /** * @param {ResolveOptionsOptionalFS} options Resolver options * @returns {ResolveFunctionAsync} Resolver function */ function create(options) { const resolver = ResolverFactory.createResolver({ fileSystem: nodeFileSystem, ...options }); /** * @param {object|string} context Custom context * @param {string} path Base path * @param {string|ResolveContext|ResolveCallback} request String to resolve * @param {ResolveContext|ResolveCallback=} resolveContext Resolve context * @param {ResolveCallback=} callback Result callback */ return function (context, path, request, resolveContext, callback) { if (typeof context === "string") { callback = /** @type {ResolveCallback} */ (resolveContext); resolveContext = /** @type {ResolveContext} */ (request); request = path; path = context; context = nodeContext; } if (typeof callback !== "function") { callback = /** @type {ResolveCallback} */ (resolveContext); } resolver.resolve( context, path, /** @type {string} */ (request), /** @type {ResolveContext} */ (resolveContext), callback ); }; } /** * @param {ResolveOptionsOptionalFS} options Resolver options * @returns {ResolveFunction} Resolver function */ function createSync(options) { const resolver = ResolverFactory.createResolver({ useSyncFileSystemCalls: true, fileSystem: nodeFileSystem, ...options }); /** * @param {object|string} context custom context * @param {string} path base path * @param {string=} request request to resolve * @returns {string|false} Resolved path or false */ return function (context, path, request) { if (typeof context === "string") { request = path; path = context; context = nodeContext; } return resolver.resolveSync(context, path, /** @type {string} */ (request)); }; } /** * @template A * @template B * @param {A} obj input a * @param {B} exports input b * @returns {A & B} merged */ const mergeExports = (obj, exports) => { const descriptors = Object.getOwnPropertyDescriptors(exports); Object.defineProperties(obj, descriptors); return /** @type {A & B} */ (Object.freeze(obj)); }; module.exports = mergeExports(resolve, { get sync() { return resolveSync; }, create: mergeExports(create, { get sync() { return createSync; } }), ResolverFactory, CachedInputFileSystem, get CloneBasenamePlugin() { return require("./CloneBasenamePlugin"); }, get LogInfoPlugin() { return require("./LogInfoPlugin"); }, get forEachBail() { return require("./forEachBail"); } }); enhanced-resolve-5.15.0/lib/util/000077500000000000000000000000001444210260000165405ustar00rootroot00000000000000enhanced-resolve-5.15.0/lib/util/entrypoints.js000066400000000000000000000354041444210260000215020ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; /** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */ /** @typedef {{[k: string]: MappingValue}} ConditionalMapping */ /** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */ /** @typedef {Record|ConditionalMapping|DirectMapping} ExportsField */ /** @typedef {Record} ImportsField */ /** * Processing exports/imports field * @callback FieldProcessor * @param {string} request request * @param {Set} conditionNames condition names * @returns {string[]} resolved paths */ /* Example exports field: { ".": "./main.js", "./feature": { "browser": "./feature-browser.js", "default": "./feature.js" } } Terminology: Enhanced-resolve name keys ("." and "./feature") as exports field keys. If value is string or string[], mapping is called as a direct mapping and value called as a direct export. If value is key-value object, mapping is called as a conditional mapping and value called as a conditional export. Key in conditional mapping is called condition name. Conditional mapping nested in another conditional mapping is called nested mapping. ---------- Example imports field: { "#a": "./main.js", "#moment": { "browser": "./moment/index.js", "default": "moment" }, "#moment/": { "browser": "./moment/", "default": "moment/" } } Terminology: Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys. If value is string or string[], mapping is called as a direct mapping and value called as a direct export. If value is key-value object, mapping is called as a conditional mapping and value called as a conditional export. Key in conditional mapping is called condition name. Conditional mapping nested in another conditional mapping is called nested mapping. */ const slashCode = "/".charCodeAt(0); const dotCode = ".".charCodeAt(0); const hashCode = "#".charCodeAt(0); const patternRegEx = /\*/g; /** * @param {ExportsField} exportsField the exports field * @returns {FieldProcessor} process callback */ module.exports.processExportsField = function processExportsField( exportsField ) { return createFieldProcessor( buildExportsField(exportsField), request => (request.length === 0 ? "." : "./" + request), assertExportsFieldRequest, assertExportTarget ); }; /** * @param {ImportsField} importsField the exports field * @returns {FieldProcessor} process callback */ module.exports.processImportsField = function processImportsField( importsField ) { return createFieldProcessor( buildImportsField(importsField), request => "#" + request, assertImportsFieldRequest, assertImportTarget ); }; /** * @param {ExportsField | ImportsField} field root * @param {(s: string) => string} normalizeRequest Normalize request, for `imports` field it adds `#`, for `exports` field it adds `.` or `./` * @param {(s: string) => string} assertRequest assertRequest * @param {(s: string, f: boolean) => void} assertTarget assertTarget * @returns {FieldProcessor} field processor */ function createFieldProcessor( field, normalizeRequest, assertRequest, assertTarget ) { return function fieldProcessor(request, conditionNames) { request = assertRequest(request); const match = findMatch(normalizeRequest(request), field); if (match === null) return []; const [mapping, remainingRequest, isSubpathMapping, isPattern] = match; /** @type {DirectMapping|null} */ let direct = null; if (isConditionalMapping(mapping)) { direct = conditionalMapping( /** @type {ConditionalMapping} */ (mapping), conditionNames ); // matching not found if (direct === null) return []; } else { direct = /** @type {DirectMapping} */ (mapping); } return directMapping( remainingRequest, isPattern, isSubpathMapping, direct, conditionNames, assertTarget ); }; } /** * @param {string} request request * @returns {string} updated request */ function assertExportsFieldRequest(request) { if (request.charCodeAt(0) !== dotCode) { throw new Error('Request should be relative path and start with "."'); } if (request.length === 1) return ""; if (request.charCodeAt(1) !== slashCode) { throw new Error('Request should be relative path and start with "./"'); } if (request.charCodeAt(request.length - 1) === slashCode) { throw new Error("Only requesting file allowed"); } return request.slice(2); } /** * @param {string} request request * @returns {string} updated request */ function assertImportsFieldRequest(request) { if (request.charCodeAt(0) !== hashCode) { throw new Error('Request should start with "#"'); } if (request.length === 1) { throw new Error("Request should have at least 2 characters"); } if (request.charCodeAt(1) === slashCode) { throw new Error('Request should not start with "#/"'); } if (request.charCodeAt(request.length - 1) === slashCode) { throw new Error("Only requesting file allowed"); } return request.slice(1); } /** * @param {string} exp export target * @param {boolean} expectFolder is folder expected */ function assertExportTarget(exp, expectFolder) { if ( exp.charCodeAt(0) === slashCode || (exp.charCodeAt(0) === dotCode && exp.charCodeAt(1) !== slashCode) ) { throw new Error( `Export should be relative path and start with "./", got ${JSON.stringify( exp )}.` ); } const isFolder = exp.charCodeAt(exp.length - 1) === slashCode; if (isFolder !== expectFolder) { throw new Error( expectFolder ? `Expecting folder to folder mapping. ${JSON.stringify( exp )} should end with "/"` : `Expecting file to file mapping. ${JSON.stringify( exp )} should not end with "/"` ); } } /** * @param {string} imp import target * @param {boolean} expectFolder is folder expected */ function assertImportTarget(imp, expectFolder) { const isFolder = imp.charCodeAt(imp.length - 1) === slashCode; if (isFolder !== expectFolder) { throw new Error( expectFolder ? `Expecting folder to folder mapping. ${JSON.stringify( imp )} should end with "/"` : `Expecting file to file mapping. ${JSON.stringify( imp )} should not end with "/"` ); } } /** * @param {string} a first string * @param {string} b second string * @returns {number} compare result */ function patternKeyCompare(a, b) { const aPatternIndex = a.indexOf("*"); const bPatternIndex = b.indexOf("*"); const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; if (baseLenA > baseLenB) return -1; if (baseLenB > baseLenA) return 1; if (aPatternIndex === -1) return 1; if (bPatternIndex === -1) return -1; if (a.length > b.length) return -1; if (b.length > a.length) return 1; return 0; } /** * Trying to match request to field * @param {string} request request * @param {ExportsField | ImportsField} field exports or import field * @returns {[MappingValue, string, boolean, boolean]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings */ function findMatch(request, field) { if ( Object.prototype.hasOwnProperty.call(field, request) && !request.includes("*") && !request.endsWith("/") ) { const target = /** @type {{[k: string]: MappingValue}} */ (field)[request]; return [target, "", false, false]; } /** @type {string} */ let bestMatch = ""; /** @type {string|undefined} */ let bestMatchSubpath; const keys = Object.getOwnPropertyNames(field); for (let i = 0; i < keys.length; i++) { const key = keys[i]; const patternIndex = key.indexOf("*"); if (patternIndex !== -1 && request.startsWith(key.slice(0, patternIndex))) { const patternTrailer = key.slice(patternIndex + 1); if ( request.length >= key.length && request.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex ) { bestMatch = key; bestMatchSubpath = request.slice( patternIndex, request.length - patternTrailer.length ); } } // For legacy `./foo/` else if ( key[key.length - 1] === "/" && request.startsWith(key) && patternKeyCompare(bestMatch, key) === 1 ) { bestMatch = key; bestMatchSubpath = request.slice(key.length); } } if (bestMatch === "") return null; const target = /** @type {{[k: string]: MappingValue}} */ (field)[bestMatch]; const isSubpathMapping = bestMatch.endsWith("/"); const isPattern = bestMatch.includes("*"); return [ target, /** @type {string} */ (bestMatchSubpath), isSubpathMapping, isPattern ]; } /** * @param {ConditionalMapping|DirectMapping|null} mapping mapping * @returns {boolean} is conditional mapping */ function isConditionalMapping(mapping) { return ( mapping !== null && typeof mapping === "object" && !Array.isArray(mapping) ); } /** * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings * @param {boolean} isPattern true, if mapping is a pattern (contains "*") * @param {boolean} isSubpathMapping true, for subpath mappings * @param {DirectMapping|null} mappingTarget direct export * @param {Set} conditionNames condition names * @param {(d: string, f: boolean) => void} assert asserting direct value * @returns {string[]} mapping result */ function directMapping( remainingRequest, isPattern, isSubpathMapping, mappingTarget, conditionNames, assert ) { if (mappingTarget === null) return []; if (typeof mappingTarget === "string") { return [ targetMapping( remainingRequest, isPattern, isSubpathMapping, mappingTarget, assert ) ]; } /** @type {string[]} */ const targets = []; for (const exp of mappingTarget) { if (typeof exp === "string") { targets.push( targetMapping( remainingRequest, isPattern, isSubpathMapping, exp, assert ) ); continue; } const mapping = conditionalMapping(exp, conditionNames); if (!mapping) continue; const innerExports = directMapping( remainingRequest, isPattern, isSubpathMapping, mapping, conditionNames, assert ); for (const innerExport of innerExports) { targets.push(innerExport); } } return targets; } /** * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings * @param {boolean} isPattern true, if mapping is a pattern (contains "*") * @param {boolean} isSubpathMapping true, for subpath mappings * @param {string} mappingTarget direct export * @param {(d: string, f: boolean) => void} assert asserting direct value * @returns {string} mapping result */ function targetMapping( remainingRequest, isPattern, isSubpathMapping, mappingTarget, assert ) { if (remainingRequest === undefined) { assert(mappingTarget, false); return mappingTarget; } if (isSubpathMapping) { assert(mappingTarget, true); return mappingTarget + remainingRequest; } assert(mappingTarget, false); let result = mappingTarget; if (isPattern) { result = result.replace( patternRegEx, remainingRequest.replace(/\$/g, "$$") ); } return result; } /** * @param {ConditionalMapping} conditionalMapping_ conditional mapping * @param {Set} conditionNames condition names * @returns {DirectMapping|null} direct mapping if found */ function conditionalMapping(conditionalMapping_, conditionNames) { /** @type {[ConditionalMapping, string[], number][]} */ let lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]]; loop: while (lookup.length > 0) { const [mapping, conditions, j] = lookup[lookup.length - 1]; const last = conditions.length - 1; for (let i = j; i < conditions.length; i++) { const condition = conditions[i]; // assert default. Could be last only if (i !== last) { if (condition === "default") { throw new Error("Default condition should be last one"); } } else if (condition === "default") { const innerMapping = mapping[condition]; // is nested if (isConditionalMapping(innerMapping)) { const conditionalMapping = /** @type {ConditionalMapping} */ ( innerMapping ); lookup[lookup.length - 1][2] = i + 1; lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]); continue loop; } return /** @type {DirectMapping} */ (innerMapping); } if (conditionNames.has(condition)) { const innerMapping = mapping[condition]; // is nested if (isConditionalMapping(innerMapping)) { const conditionalMapping = /** @type {ConditionalMapping} */ ( innerMapping ); lookup[lookup.length - 1][2] = i + 1; lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]); continue loop; } return /** @type {DirectMapping} */ (innerMapping); } } lookup.pop(); } return null; } /** * @param {ExportsField} field exports field * @returns {ExportsField} normalized exports field */ function buildExportsField(field) { // handle syntax sugar, if exports field is direct mapping for "." if (typeof field === "string" || Array.isArray(field)) { return { ".": field }; } const keys = Object.keys(field); for (let i = 0; i < keys.length; i++) { const key = keys[i]; if (key.charCodeAt(0) !== dotCode) { // handle syntax sugar, if exports field is conditional mapping for "." if (i === 0) { while (i < keys.length) { const charCode = keys[i].charCodeAt(0); if (charCode === dotCode || charCode === slashCode) { throw new Error( `Exports field key should be relative path and start with "." (key: ${JSON.stringify( key )})` ); } i++; } return { ".": field }; } throw new Error( `Exports field key should be relative path and start with "." (key: ${JSON.stringify( key )})` ); } if (key.length === 1) { continue; } if (key.charCodeAt(1) !== slashCode) { throw new Error( `Exports field key should be relative path and start with "./" (key: ${JSON.stringify( key )})` ); } } return field; } /** * @param {ImportsField} field imports field * @returns {ImportsField} normalized imports field */ function buildImportsField(field) { const keys = Object.keys(field); for (let i = 0; i < keys.length; i++) { const key = keys[i]; if (key.charCodeAt(0) !== hashCode) { throw new Error( `Imports field key should start with "#" (key: ${JSON.stringify(key)})` ); } if (key.length === 1) { throw new Error( `Imports field key should have at least 2 characters (key: ${JSON.stringify( key )})` ); } if (key.charCodeAt(1) === slashCode) { throw new Error( `Imports field key should not start with "#/" (key: ${JSON.stringify( key )})` ); } } return field; } enhanced-resolve-5.15.0/lib/util/identifier.js000066400000000000000000000011471444210260000212230ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Ivan Kopeykin @vankop */ "use strict"; const PATH_QUERY_FRAGMENT_REGEXP = /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/; /** * @param {string} identifier identifier * @returns {[string, string, string]|null} parsed identifier */ function parseIdentifier(identifier) { const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier); if (!match) return null; return [ match[1].replace(/\0(.)/g, "$1"), match[2] ? match[2].replace(/\0(.)/g, "$1") : "", match[3] || "" ]; } module.exports.parseIdentifier = parseIdentifier; enhanced-resolve-5.15.0/lib/util/path.js000066400000000000000000000122671444210260000200420ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; const path = require("path"); const CHAR_HASH = "#".charCodeAt(0); const CHAR_SLASH = "/".charCodeAt(0); const CHAR_BACKSLASH = "\\".charCodeAt(0); const CHAR_A = "A".charCodeAt(0); const CHAR_Z = "Z".charCodeAt(0); const CHAR_LOWER_A = "a".charCodeAt(0); const CHAR_LOWER_Z = "z".charCodeAt(0); const CHAR_DOT = ".".charCodeAt(0); const CHAR_COLON = ":".charCodeAt(0); const posixNormalize = path.posix.normalize; const winNormalize = path.win32.normalize; /** * @enum {number} */ const PathType = Object.freeze({ Empty: 0, Normal: 1, Relative: 2, AbsoluteWin: 3, AbsolutePosix: 4, Internal: 5 }); exports.PathType = PathType; /** * @param {string} p a path * @returns {PathType} type of path */ const getType = p => { switch (p.length) { case 0: return PathType.Empty; case 1: { const c0 = p.charCodeAt(0); switch (c0) { case CHAR_DOT: return PathType.Relative; case CHAR_SLASH: return PathType.AbsolutePosix; case CHAR_HASH: return PathType.Internal; } return PathType.Normal; } case 2: { const c0 = p.charCodeAt(0); switch (c0) { case CHAR_DOT: { const c1 = p.charCodeAt(1); switch (c1) { case CHAR_DOT: case CHAR_SLASH: return PathType.Relative; } return PathType.Normal; } case CHAR_SLASH: return PathType.AbsolutePosix; case CHAR_HASH: return PathType.Internal; } const c1 = p.charCodeAt(1); if (c1 === CHAR_COLON) { if ( (c0 >= CHAR_A && c0 <= CHAR_Z) || (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z) ) { return PathType.AbsoluteWin; } } return PathType.Normal; } } const c0 = p.charCodeAt(0); switch (c0) { case CHAR_DOT: { const c1 = p.charCodeAt(1); switch (c1) { case CHAR_SLASH: return PathType.Relative; case CHAR_DOT: { const c2 = p.charCodeAt(2); if (c2 === CHAR_SLASH) return PathType.Relative; return PathType.Normal; } } return PathType.Normal; } case CHAR_SLASH: return PathType.AbsolutePosix; case CHAR_HASH: return PathType.Internal; } const c1 = p.charCodeAt(1); if (c1 === CHAR_COLON) { const c2 = p.charCodeAt(2); if ( (c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) && ((c0 >= CHAR_A && c0 <= CHAR_Z) || (c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)) ) { return PathType.AbsoluteWin; } } return PathType.Normal; }; exports.getType = getType; /** * @param {string} p a path * @returns {string} the normalized path */ const normalize = p => { switch (getType(p)) { case PathType.Empty: return p; case PathType.AbsoluteWin: return winNormalize(p); case PathType.Relative: { const r = posixNormalize(p); return getType(r) === PathType.Relative ? r : `./${r}`; } } return posixNormalize(p); }; exports.normalize = normalize; /** * @param {string} rootPath the root path * @param {string | undefined} request the request path * @returns {string} the joined path */ const join = (rootPath, request) => { if (!request) return normalize(rootPath); const requestType = getType(request); switch (requestType) { case PathType.AbsolutePosix: return posixNormalize(request); case PathType.AbsoluteWin: return winNormalize(request); } switch (getType(rootPath)) { case PathType.Normal: case PathType.Relative: case PathType.AbsolutePosix: return posixNormalize(`${rootPath}/${request}`); case PathType.AbsoluteWin: return winNormalize(`${rootPath}\\${request}`); } switch (requestType) { case PathType.Empty: return rootPath; case PathType.Relative: { const r = posixNormalize(rootPath); return getType(r) === PathType.Relative ? r : `./${r}`; } } return posixNormalize(rootPath); }; exports.join = join; /** @type {Map>} */ const joinCache = new Map(); /** * @param {string} rootPath the root path * @param {string} request the request path * @returns {string} the joined path */ const cachedJoin = (rootPath, request) => { /** @type {string | undefined} */ let cacheEntry; let cache = joinCache.get(rootPath); if (cache === undefined) { joinCache.set(rootPath, (cache = new Map())); } else { cacheEntry = cache.get(request); if (cacheEntry !== undefined) return cacheEntry; } cacheEntry = join(rootPath, request); cache.set(request, cacheEntry); return cacheEntry; }; exports.cachedJoin = cachedJoin; /** * @param {string} relativePath relative path * @returns {undefined|Error} nothing or an error */ const checkImportsExportsFieldTarget = relativePath => { let lastNonSlashIndex = 0; let slashIndex = relativePath.indexOf("/", 1); let cd = 0; while (slashIndex !== -1) { const folder = relativePath.slice(lastNonSlashIndex, slashIndex); switch (folder) { case "..": { cd--; if (cd < 0) return new Error( `Trying to access out of package scope. Requesting ${relativePath}` ); break; } case ".": break; default: cd++; break; } lastNonSlashIndex = slashIndex + 1; slashIndex = relativePath.indexOf("/", lastNonSlashIndex); } }; exports.checkImportsExportsFieldTarget = checkImportsExportsFieldTarget; enhanced-resolve-5.15.0/lib/util/process-browser.js000066400000000000000000000006041444210260000222350ustar00rootroot00000000000000/* MIT License http://www.opensource.org/licenses/mit-license.php Author Tobias Koppers @sokra */ "use strict"; module.exports = { /** * @type {Record} */ versions: {}, /** * @param {function} fn function */ nextTick(fn) { const args = Array.prototype.slice.call(arguments, 1); Promise.resolve().then(function () { fn.apply(null, args); }); } }; enhanced-resolve-5.15.0/open-bot.yaml000066400000000000000000000076631444210260000174400ustar00rootroot00000000000000bot: "webpack-bot" rules: # Add ci-ok, ci-not-ok labels depending on travis status # comment to point the user to the results # comment in case of success - filters: open: true pull_request: mergeable: true status_1: context: "continuous-integration/travis-ci/pr" ensure_1: value: "{{status_1.state}}" equals: "success" actions: label: add: "PR: CI-ok" remove: "PR: CI-not-ok" comment: identifier: "ci-result" message: |- Thank you for your pull request! The most important CI builds succeeded, we’ll review the pull request soon. - filters: open: true pull_request: mergeable: true status_1: context: "continuous-integration/travis-ci/pr" any: ensure_1: value: "{{status_1.state}}" equals: "failure" actions: label: add: "PR: CI-not-ok" remove: "PR: CI-ok" # add conflict label to pull requests with conflict # on conflict all result labels are removed - filters: open: true pull_request: mergeable: false actions: label: add: "PR: conflict" remove: - "PR: tests-needed" - "PR: CI-ok" - "PR: CI-not-ok" - filters: open: true pull_request: mergeable: true actions: label: remove: "PR: conflict" # add unreviewed, reviewed, review-outdated labels # comment to ping reviewer # comment on new PR - filters: open: true in_order: commit: true review: state: APPROVED|CHANGES_REQUESTED ensure: value: "{{review.state}}" equals: APPROVED actions: label: add: "PR: reviewed-approved" remove: - "PR: review-outdated" - "PR: unreviewed" - "PR: reviewed" - filters: open: true in_order: commit: true review: state: APPROVED|CHANGES_REQUESTED ensure: value: "{{review.state}}" equals: CHANGES_REQUESTED actions: label: add: "PR: reviewed-changes-requested" remove: - "PR: review-outdated" - "PR: unreviewed" - "PR: reviewed" - filters: open: true in_order: review: state: APPROVED|CHANGES_REQUESTED commit: true not: label: "review-outdated" ensure: value: "{{commit.author.login}}" notEquals: "{{review.user.login}}" actions: label: add: "PR: review-outdated" remove: - "PR: reviewed-approved" - "PR: reviewed-changes-requested" - "PR: unreviewed" - "PR: reviewed" comment: identifier: "review-outdated" message: |- @{{commit.author.login}} Thanks for your update. I labeled the Pull Request so reviewers will review it again. @{{review.user.login}} Please review the new changes. - filters: open: true commit: true not: review: state: APPROVED|CHANGES_REQUESTED actions: label: "PR: unreviewed" # add non-main label to pull request to other branch - filters: pull_request: base_ref: "^(?!main)" actions: label: "PR: non-main" # add small label to small pull requests - filters: open: true pull_request: additions: "<= 10" deletions: "<= 10" changed_files: "<= 2" actions: label: "PR: small" # Move issue task - filters: open: true comment: "\\s*@webpack-bot\\s+move\\s+(?:to\\s+)?([a-z0-9_\\-\\.]+/[a-z0-9_\\-\\.]+)\\s*([\\s\\S]*)$" not: comment_1: matching: "moved\\-by\\-bot" author: "." permission: user: "{{comment.actor.login}}" actions: new_issue: target: "{{{comment_match.[1]}}}" body: |- {{{issue.body}}} --- This issue was moved from {{owner}}/{{repo}}#{{issue.number}} by @{{comment.actor.login}}. Original issue was by @{{issue.user.login}}. {{{comment_match.[2]}}} comment: identifier: moved-by-bot message: |- I've moved it to {{comment_match.[1]}}. close: true enhanced-resolve-5.15.0/package.json000066400000000000000000000050411444210260000173030ustar00rootroot00000000000000{ "name": "enhanced-resolve", "version": "5.15.0", "author": "Tobias Koppers @sokra", "description": "Offers a async require.resolve function. It's highly configurable.", "files": [ "lib", "types.d.ts", "LICENSE" ], "browser": { "pnpapi": false, "process": "./lib/util/process-browser.js" }, "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" }, "license": "MIT", "devDependencies": { "@types/graceful-fs": "^4.1.6", "@types/jest": "^27.5.1", "@types/node": "^14.11.1", "cspell": "4.2.8", "eslint": "^7.9.0", "eslint-config-prettier": "^6.11.0", "eslint-plugin-jsdoc": "^30.5.1", "eslint-plugin-node": "^11.1.0", "eslint-plugin-prettier": "^3.1.4", "husky": "^6.0.0", "jest": "^27.5.1", "lint-staged": "^10.4.0", "memfs": "^3.2.0", "prettier": "^2.1.2", "tooling": "webpack/tooling#v1.14.0", "typescript": "^5.0.4" }, "engines": { "node": ">=10.13.0" }, "main": "lib/index.js", "types": "types.d.ts", "homepage": "http://github.com/webpack/enhanced-resolve", "scripts": { "lint": "yarn run code-lint && yarn run type-lint && yarn typings-test && yarn run special-lint && yarn run spelling", "fix": "yarn run code-lint-fix && yarn run special-lint-fix", "code-lint": "eslint --cache lib test", "code-lint-fix": "eslint --cache lib test --fix", "type-lint": "tsc", "typings-test": "tsc -p tsconfig.types.test.json", "type-report": "rimraf coverage && yarn cover:types && yarn cover:report && open-cli coverage/lcov-report/index.html", "special-lint": "node node_modules/tooling/lockfile-lint && node node_modules/tooling/inherit-types && node node_modules/tooling/format-file-header && node node_modules/tooling/generate-types", "special-lint-fix": "node node_modules/tooling/inherit-types --write && node node_modules/tooling/format-file-header --write && node node_modules/tooling/generate-types --write", "pretty": "prettier --loglevel warn --write \"lib/**/*.{js,json}\" \"test/*.js\"", "pretest": "yarn lint", "spelling": "cspell \"**\"", "test:only": "jest", "test:watch": "yarn test:only -- --watch", "test:coverage": "yarn test:only -- --collectCoverageFrom=\"lib/**/*.js\" --coverage", "test": "yarn test:coverage", "precover": "yarn lint", "prepare": "husky install" }, "lint-staged": { "*": "cspell --no-must-find-files", "*.js": "eslint --cache" }, "repository": { "type": "git", "url": "git://github.com/webpack/enhanced-resolve.git" } } enhanced-resolve-5.15.0/test/000077500000000000000000000000001444210260000157745ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/CachedInputFileSystem.test.js000066400000000000000000000201501444210260000235020ustar00rootroot00000000000000const { CachedInputFileSystem } = require("../"); describe("CachedInputFileSystem OperationMergerBackend ('stat' and 'statSync')", () => { let fs; beforeEach(() => { fs = new CachedInputFileSystem( { stat: function (path, options, callback) { if (!callback) { callback = options; options = undefined; } setTimeout( () => callback(null, { path, options }), 100 ); }, statSync: function (path, options) { return { path, options }; } }, 0 ); }); afterEach(() => { fs.purge(); }); it("should join accesses", function (done) { fs.stat("a", function (err, result) { expect(result).toBeDefined(); result.a = true; }); fs.stat("a", function (err, result) { expect(result).toBeDefined(); expect(result.a).toBeDefined(); done(); }); }); it("should not join accesses with options", function (done) { fs.stat("a", function (err, result) { expect(result).toBeDefined(); result.a = true; expect(result.path).toEqual("a"); expect(result.options).toBeUndefined(); }); fs.stat("a", { options: true }, function (err, result) { expect(result).toBeDefined(); expect(result.a).toBeUndefined(); expect(result.path).toEqual("a"); expect(result.options).toMatchObject({ options: true }); done(); }); }); it("should not cache accesses", function (done) { fs.stat("a", function (err, result) { result.a = true; fs.stat("a", function (err, result) { expect(result.a).toBeUndefined(); done(); }); }); }); it("should not cache sync accesses", () => { const result = fs.statSync("a"); result.a = true; const result2 = fs.statSync("a"); expect(result2.a).toBeUndefined(); }); }); describe("CachedInputFileSystem OperationMergerBackend ('lstat' and 'lstatSync')", () => { let fs; beforeEach(() => { fs = new CachedInputFileSystem( { lstat: function (path, options, callback) { if (!callback) { callback = options; options = undefined; } setTimeout( () => callback(null, { path, options }), 100 ); }, lstatSync: function (path, options) { return { path, options }; } }, 0 ); }); afterEach(() => { fs.purge(); }); it("should join accesses", function (done) { fs.lstat("a", function (err, result) { expect(result).toBeDefined(); result.a = true; }); fs.lstat("a", function (err, result) { expect(result).toBeDefined(); expect(result.a).toBeDefined(); done(); }); }); it("should not join accesses with options", function (done) { fs.lstat("a", function (err, result) { expect(result).toBeDefined(); result.a = true; expect(result).toBeDefined(); expect(result.path).toEqual("a"); expect(result.options).toBeUndefined(); }); fs.lstat("a", { options: true }, function (err, result) { expect(result).toBeDefined(); expect(result.a).toBeUndefined(); expect(result.path).toEqual("a"); expect(result.options).toMatchObject({ options: true }); done(); }); }); it("should not cache accesses", function (done) { fs.lstat("a", function (err, result) { result.a = true; fs.lstat("a", function (err, result) { expect(result.a).toBeUndefined(); done(); }); }); }); it("should not cache sync accesses", () => { const result = fs.lstatSync("a"); result.a = true; const result2 = fs.lstatSync("a"); expect(result2.a).toBeUndefined(); }); }); describe("CachedInputFileSystem CacheBackend", () => { let fs; beforeEach(() => { let counter = 0; fs = new CachedInputFileSystem( { stat: function (path, options, callback) { if (!callback) { callback = options; options = undefined; } setTimeout( callback.bind(null, null, { path, options }), 100 ); }, statSync: function (path, options) { return { path, options }; }, readdir: function (path, callback) { callback(null, [`${counter++}`]); } }, 1000 ); }); afterEach(() => { fs.purge(); }); it("should join accesses", function (done) { fs.stat("a", function (err, result) { result.a = true; }); fs.stat("a", function (err, result) { expect(result.a).toBeDefined(); done(); }); }); it("should not call callback twice when combining sync and async calls", function (done) { let called = false; fs.stat("a", function (err, result) { if (called) return done(new Error("callback was called twice")); called = true; expect(result).toBeDefined(); result.a = true; done(); }); const syncResult = fs.statSync("a"); expect(syncResult).toBeDefined(); expect(syncResult.a).toBeDefined(); }); it("should not join accesses with options", function (done) { fs.stat("a", function (err, result) { result.a = true; expect(result.path).toEqual("a"); expect(result.options).toBeUndefined(); }); fs.stat("a", { options: true }, function (err, result) { expect(result.a).toBeUndefined(); expect(result.path).toEqual("a"); expect(result.options).toMatchObject({ options: true }); done(); }); }); it("should cache accesses", function (done) { fs.stat("a", function (err, result) { result.a = true; var sync = true; fs.stat("a", function (err, result) { expect(result.a).toBeDefined(); expect(sync).toEqual(true); setTimeout(() => { fs.stat("a", function (err, result) { expect(result.a).toBeUndefined(); result.b = true; var sync2 = true; fs.stat("a", function (err, result) { expect(result.b).toBeDefined(); expect(result.a).toBeUndefined(); expect(sync2).toEqual(true); done(); }); setTimeout(() => { sync2 = false; }, 50); }); }, 1100); }); setTimeout(() => { sync = false; }, 50); }); }); it("should cache sync accesses", () => { const result = fs.statSync("a"); result.a = true; const result2 = fs.statSync("a"); expect(result2.a).toBeDefined(); const result3 = fs.statSync("a", { options: true }); expect(result3.a).toBeUndefined(); expect(result3.options).toMatchObject({ options: true }); }); it("should recover after passive periods", function (done) { fs.stat("a", function (err, result) { result.a = true; setTimeout(() => { fs.stat("a", function (err, result) { expect(result.a).toBeDefined(); setTimeout(() => { fs.stat("a", function (err, result) { expect(result.a).toBeUndefined(); result.b = true; setTimeout(() => { fs.stat("a", function (err, result) { expect(result.b).toBeDefined(); expect(result.a).toBeUndefined(); done(); }); }, 500); }); }, 600); }); }, 500); }); }); it("should restart after timeout", function (done) { fs.stat("a", function (err, result) { result.a = true; setTimeout(() => { fs.stat("a", function (err, result) { expect(result.a).toBeUndefined(); result.b = true; setTimeout(() => { fs.stat("a", function (err, result) { expect(result.b).toBeDefined(); expect(result.a).toBeUndefined(); done(); }); }, 50); }); }, 1100); }); }); it("should cache undefined value", function (done) { fs.stat(undefined, function (err, result) { fs.purge("a"); fs.purge(); done(); }); }); it("should purge readdir correctly", function (done) { fs.readdir("/test/path", (err, r) => { expect(r[0]).toEqual("0"); fs.purge(["/test/path/sub/path"]); fs.readdir("/test/path", (err, r) => { expect(r[0]).toEqual("0"); fs.purge(["/test/path/sub"]); fs.readdir("/test/path", (err, r) => { expect(r[0]).toEqual("1"); fs.purge(["/test/path"]); fs.readdir("/test/path", (err, r) => { expect(r[0]).toEqual("2"); done(); }); }); }); }); }); it("should not stack overflow when resolving in an async loop", done => { let i = 10000; const next = () => { fs.stat(__dirname, (err, result) => { if (i-- > 0) { next(); } else { done(); } }); }; next(); }); }); enhanced-resolve-5.15.0/test/SyncAsyncFileSystemDecorator.test.js000066400000000000000000000021521444210260000250720ustar00rootroot00000000000000"use strict"; const fs = require("fs"); const path = require("path"); const SyncAsyncFileSystemDecorator = require("../lib/SyncAsyncFileSystemDecorator"); describe("SyncAsyncFileSystemDecorator stat", function () { it("should use options when they're provided", function (done) { const decoratedFs = new SyncAsyncFileSystemDecorator(fs); decoratedFs.stat( path.join(__dirname, "fixtures", "decorated-fs", "exists.js"), { bigint: true }, function (error, result) { expect(error).toBeNull(); expect(result).toHaveProperty("size"); expect(result).toHaveProperty("birthtime"); expect(typeof result.size).toEqual("bigint"); done(); } ); }); it("should work correctly when no options provided", function (done) { const decoratedFs = new SyncAsyncFileSystemDecorator(fs); decoratedFs.stat( path.join(__dirname, "fixtures", "decorated-fs", "exists.js"), function (error, result) { expect(error).toBeNull(); expect(result).toHaveProperty("size"); expect(result).toHaveProperty("birthtime"); expect(typeof result.size).toEqual("number"); done(); } ); }); }); enhanced-resolve-5.15.0/test/__snapshots__/000077500000000000000000000000001444210260000206125ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/__snapshots__/alias.test.js.snap000066400000000000000000000022711444210260000241610ustar00rootroot00000000000000// Jest Snapshot v1, https://goo.gl/fbAQLP exports[`alias should log the correct info 1`] = ` Array [ "resolve 'aliasA/dir' in '/'", " Parsed request is a module", " No description file found in / or above", " aliased with mapping 'aliasA': 'a' to 'a/dir'", " Parsed request is a module", " No description file found in / or above", " resolve as module", " looking for modules in /", " existing directory /a", " No description file found in /a or above", " No description file found in /a or above", " no extension", " /a/dir is not a file", " .js", " /a/dir.js doesn't exist", " .json", " /a/dir.json doesn't exist", " .node", " /a/dir.node doesn't exist", " as directory", " existing directory /a/dir", " No description file found in /a/dir or above", " using path: /a/dir/index", " No description file found in /a/dir or above", " no extension", " existing file: /a/dir/index", " reporting result /a/dir/index", ] `; enhanced-resolve-5.15.0/test/__snapshots__/exportsField.test.js.snap000066400000000000000000000021571444210260000255430ustar00rootroot00000000000000// Jest Snapshot v1, https://goo.gl/fbAQLP exports[`ExportsFieldPlugin should log the correct info 1`] = ` Array [ "resolve 'exports-field/dist/browser.js' in '...'", " Parsed request is a module", " using description file: .../package.json (relative path: .)", " resolve as module", " looking for modules in .../node_modules", " existing directory .../node_modules/exports-field", " using description file: .../node_modules/exports-field/package.json (relative path: .)", " using exports field: ./lib/lib2/browser.js", " using description file: .../node_modules/exports-field/package.json (relative path: ./lib/lib2/browser.js)", " .../node_modules/exports-field/lib/lib2/browser.js doesn't exist", " using exports field: ./lib/browser.js", " using description file: .../node_modules/exports-field/package.json (relative path: ./lib/browser.js)", " existing file: .../node_modules/exports-field/lib/browser.js", " reporting result .../node_modules/exports-field/lib/browser.js", ] `; enhanced-resolve-5.15.0/test/__snapshots__/fallback.test.js.snap000066400000000000000000000024301444210260000246240ustar00rootroot00000000000000// Jest Snapshot v1, https://goo.gl/fbAQLP exports[`fallback should log the correct info 1`] = ` Array [ "resolve 'aliasA/dir' in '/'", " Parsed request is a module", " No description file found in / or above", " resolve as module", " looking for modules in /", " /aliasA doesn't exist", " aliased with mapping 'aliasA': 'a' to 'a/dir'", " Parsed request is a module", " No description file found in / or above", " resolve as module", " looking for modules in /", " existing directory /a", " No description file found in /a or above", " No description file found in /a or above", " no extension", " /a/dir is not a file", " .js", " /a/dir.js doesn't exist", " .json", " /a/dir.json doesn't exist", " .node", " /a/dir.node doesn't exist", " as directory", " existing directory /a/dir", " No description file found in /a/dir or above", " using path: /a/dir/index", " No description file found in /a/dir or above", " no extension", " existing file: /a/dir/index", " reporting result /a/dir/index", ] `; enhanced-resolve-5.15.0/test/__snapshots__/importsField.test.js.snap000066400000000000000000000030451444210260000255310ustar00rootroot00000000000000// Jest Snapshot v1, https://goo.gl/fbAQLP exports[`ImportsFieldPlugin should log the correct info 1`] = ` Array [ "resolve '#a/dist/index.js' in '...'", " using description file: .../package.json (relative path: .)", " resolve as internal import", " using imports field: a/dist/index.js", " Parsed request is a module", " using description file: .../package.json (relative path: .)", " resolve as module", " looking for modules in .../node_modules", " existing directory .../node_modules/a", " using description file: .../node_modules/a/package.json (relative path: .)", " using exports field: ./lib/lib2/index.js", " using description file: .../node_modules/a/package.json (relative path: ./lib/lib2/index.js)", " no extension", " .../node_modules/a/lib/lib2/index.js doesn't exist", " .js", " .../node_modules/a/lib/lib2/index.js.js doesn't exist", " as directory", " .../node_modules/a/lib/lib2/index.js doesn't exist", " using exports field: ./lib/index.js", " using description file: .../node_modules/a/package.json (relative path: ./lib/index.js)", " no extension", " existing file: .../node_modules/a/lib/index.js", " reporting result .../node_modules/a/lib/index.js", ] `; enhanced-resolve-5.15.0/test/__snapshots__/restrictions.test.js.snap000066400000000000000000000066051444210260000256250ustar00rootroot00000000000000// Jest Snapshot v1, https://goo.gl/fbAQLP exports[`restrictions should try to find alternative #3 1`] = ` Array [ "resolve 'pck2' in '.../test/fixtures/restrictions'", " Parsed request is a module", " using description file: .../package.json (relative path: ./test/fixtures/restrictions)", " resolve as module", " looking for modules in .../test/fixtures/restrictions/node_modules", " single file module", " using description file: .../package.json (relative path: ./test/fixtures/restrictions/node_modules/pck2)", " no extension", " .../test/fixtures/restrictions/node_modules/pck2 is not a file", " .js", " .../test/fixtures/restrictions/node_modules/pck2.js doesn't exist", " existing directory .../test/fixtures/restrictions/node_modules/pck2", " using description file: .../test/fixtures/restrictions/node_modules/pck2/package.json (relative path: .)", " using description file: .../package.json (relative path: ./test/fixtures/restrictions/node_modules/pck2)", " no extension", " .../test/fixtures/restrictions/node_modules/pck2 is not a file", " .js", " .../test/fixtures/restrictions/node_modules/pck2.js doesn't exist", " as directory", " existing directory .../test/fixtures/restrictions/node_modules/pck2", " using description file: .../test/fixtures/restrictions/node_modules/pck2/package.json (relative path: .)", " use ../../../c.js from main in package.json", " using description file: .../package.json (relative path: ./test/fixtures/c.js)", " no extension", " existing file: .../test/fixtures/c.js", " .../test/fixtures/c.js is not inside of the restriction .../test/fixtures/restrictions", " .js", " .../test/fixtures/c.js.js doesn't exist", " as directory", " .../test/fixtures/c.js is not a directory", " use ./module.js from module in package.json", " using description file: .../test/fixtures/restrictions/node_modules/pck2/package.json (relative path: ./module.js)", " no extension", " existing file: .../test/fixtures/restrictions/node_modules/pck2/module.js", " .../test/fixtures/restrictions/node_modules/pck2/module.js doesn't match the restriction //.(sass|scss|css)$/", " .js", " .../test/fixtures/restrictions/node_modules/pck2/module.js.js doesn't exist", " as directory", " .../test/fixtures/restrictions/node_modules/pck2/module.js is not a directory", " use ./index.css from style in package.json", " using description file: .../test/fixtures/restrictions/node_modules/pck2/package.json (relative path: ./index.css)", " no extension", " existing file: .../test/fixtures/restrictions/node_modules/pck2/index.css", " reporting result .../test/fixtures/restrictions/node_modules/pck2/index.css", ] `; enhanced-resolve-5.15.0/test/alias.test.js000066400000000000000000000115641444210260000204100ustar00rootroot00000000000000const path = require("path"); const { Volume } = require("memfs"); const { ResolverFactory } = require("../"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); const fs = require("fs"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); describe("alias", () => { let resolver; beforeEach(() => { const fileSystem = Volume.fromJSON( { "/a/index": "", "/a/dir/index": "", "/recursive/index": "", "/recursive/dir/index": "", "/b/index": "", "/b/dir/index": "", "/c/index": "", "/c/dir/index": "", "/d/index.js": "", "/d/dir/.empty": "", "/e/index": "", "/e/anotherDir/index": "", "/e/dir/file": "" }, "/" ); resolver = ResolverFactory.createResolver({ alias: { aliasA: "a", b$: "a/index", c$: "/a/index", multiAlias: ["b", "c", "d", "e", "a"], recursive: "recursive/dir", "/d/dir": "/c/dir", "/d/index.js": "/c/index", // alias configuration should work "#": "/c/dir", "@": "/c/dir", ignored: false }, modules: "/", useSyncFileSystemCalls: true, //@ts-ignore fileSystem: fileSystem }); }); it("should resolve a not aliased module", () => { expect(resolver.resolveSync({}, "/", "a")).toEqual("/a/index"); expect(resolver.resolveSync({}, "/", "a/index")).toEqual("/a/index"); expect(resolver.resolveSync({}, "/", "a/dir")).toEqual("/a/dir/index"); expect(resolver.resolveSync({}, "/", "a/dir/index")).toEqual( "/a/dir/index" ); }); it("should resolve an aliased module", () => { expect(resolver.resolveSync({}, "/", "aliasA")).toEqual("/a/index"); expect(resolver.resolveSync({}, "/", "aliasA/index")).toEqual("/a/index"); expect(resolver.resolveSync({}, "/", "aliasA/dir")).toEqual("/a/dir/index"); expect(resolver.resolveSync({}, "/", "aliasA/dir/index")).toEqual( "/a/dir/index" ); }); it('should resolve "#" alias', () => { expect(resolver.resolveSync({}, "/", "#")).toEqual("/c/dir/index"); expect(resolver.resolveSync({}, "/", "#/index")).toEqual("/c/dir/index"); }); it('should resolve "@" alias', () => { expect(resolver.resolveSync({}, "/", "@")).toEqual("/c/dir/index"); expect(resolver.resolveSync({}, "/", "@/index")).toEqual("/c/dir/index"); }); it("should resolve an ignore module", () => { expect(resolver.resolveSync({}, "/", "ignored")).toEqual(false); }); it("should resolve a recursive aliased module", () => { expect(resolver.resolveSync({}, "/", "recursive")).toEqual( "/recursive/dir/index" ); expect(resolver.resolveSync({}, "/", "recursive/index")).toEqual( "/recursive/dir/index" ); expect(resolver.resolveSync({}, "/", "recursive/dir")).toEqual( "/recursive/dir/index" ); expect(resolver.resolveSync({}, "/", "recursive/dir/index")).toEqual( "/recursive/dir/index" ); }); it("should resolve a file aliased module", () => { expect(resolver.resolveSync({}, "/", "b")).toEqual("/a/index"); expect(resolver.resolveSync({}, "/", "c")).toEqual("/a/index"); }); it("should resolve a file aliased module with a query", () => { expect(resolver.resolveSync({}, "/", "b?query")).toEqual("/a/index?query"); expect(resolver.resolveSync({}, "/", "c?query")).toEqual("/a/index?query"); }); it("should resolve a path in a file aliased module", () => { expect(resolver.resolveSync({}, "/", "b/index")).toEqual("/b/index"); expect(resolver.resolveSync({}, "/", "b/dir")).toEqual("/b/dir/index"); expect(resolver.resolveSync({}, "/", "b/dir/index")).toEqual( "/b/dir/index" ); expect(resolver.resolveSync({}, "/", "c/index")).toEqual("/c/index"); expect(resolver.resolveSync({}, "/", "c/dir")).toEqual("/c/dir/index"); expect(resolver.resolveSync({}, "/", "c/dir/index")).toEqual( "/c/dir/index" ); }); it("should resolve a file aliased file", () => { expect(resolver.resolveSync({}, "/", "d")).toEqual("/c/index"); expect(resolver.resolveSync({}, "/", "d/dir/index")).toEqual( "/c/dir/index" ); }); it("should resolve a file in multiple aliased dirs", () => { expect(resolver.resolveSync({}, "/", "multiAlias/dir/file")).toEqual( "/e/dir/file" ); expect(resolver.resolveSync({}, "/", "multiAlias/anotherDir")).toEqual( "/e/anotherDir/index" ); }); it("should log the correct info", done => { const log = []; resolver.resolve( {}, "/", "aliasA/dir", { log: v => log.push(v) }, (err, result) => { if (err) return done(err); expect(result).toEqual("/a/dir/index"); expect(log).toMatchSnapshot(); done(); } ); }); it("should work with absolute paths", done => { const resolver = ResolverFactory.createResolver({ alias: { [path.resolve(__dirname, "fixtures", "foo")]: false }, modules: path.resolve(__dirname, "fixtures"), fileSystem: nodeFileSystem }); resolver.resolve({}, __dirname, "foo/index", {}, (err, result) => { if (err) done(err); expect(result).toEqual(false); done(); }); }); }); enhanced-resolve-5.15.0/test/browserField.test.js000066400000000000000000000047631444210260000217510ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { ResolverFactory } = require("../"); const browserModule = path.join(__dirname, "fixtures", "browser-module"); function p() { return path.join.apply( path, [browserModule].concat(Array.prototype.slice.call(arguments)) ); } describe("browserField", () => { let resolver; beforeEach(() => { resolver = ResolverFactory.createResolver({ aliasFields: [ "browser", ["innerBrowser1", "field2", "browser"], // not presented ["innerBrowser1", "field", "browser"], ["innerBrowser2", "browser"] ], useSyncFileSystemCalls: true, fileSystem: fs }); }); it("should ignore", function (done) { resolver.resolve({}, p(), "./lib/ignore", {}, function (err, result) { if (err) throw err; expect(result).toEqual(false); done(); }); }); it("should ignore", () => { expect(resolver.resolveSync({}, p(), "./lib/ignore")).toEqual(false); expect(resolver.resolveSync({}, p(), "./lib/ignore.js")).toEqual(false); expect(resolver.resolveSync({}, p("lib"), "./ignore")).toEqual(false); expect(resolver.resolveSync({}, p("lib"), "./ignore.js")).toEqual(false); }); it("should replace a file", () => { expect(resolver.resolveSync({}, p(), "./lib/replaced")).toEqual( p("lib", "browser.js") ); expect(resolver.resolveSync({}, p(), "./lib/replaced.js")).toEqual( p("lib", "browser.js") ); expect(resolver.resolveSync({}, p("lib"), "./replaced")).toEqual( p("lib", "browser.js") ); expect(resolver.resolveSync({}, p("lib"), "./replaced.js")).toEqual( p("lib", "browser.js") ); }); it("should replace a module with a file", () => { expect(resolver.resolveSync({}, p(), "module-a")).toEqual( p("browser", "module-a.js") ); expect(resolver.resolveSync({}, p("lib"), "module-a")).toEqual( p("browser", "module-a.js") ); }); it("should replace a module with a module", () => { expect(resolver.resolveSync({}, p(), "module-b")).toEqual( p("node_modules", "module-c.js") ); expect(resolver.resolveSync({}, p("lib"), "module-b")).toEqual( p("node_modules", "module-c.js") ); }); it("should resolve in nested property", () => { expect(resolver.resolveSync({}, p(), "./lib/main1.js")).toEqual( p("lib", "main.js") ); expect(resolver.resolveSync({}, p(), "./lib/main2.js")).toEqual( p("lib", "browser.js") ); }); it("should check only alias field properties", () => { expect(resolver.resolveSync({}, p(), "./toString")).toEqual( p("lib", "toString.js") ); }); }); enhanced-resolve-5.15.0/test/dependencies.test.js000066400000000000000000000051621444210260000217420ustar00rootroot00000000000000const { Volume } = require("memfs"); const resolve = require("../"); describe("dependencies", function () { let resolver; beforeEach(function () { const fileSystem = Volume.fromJSON( { "/a/b/node_modules/some-module/index.js": "", "/a/node_modules/module/package.json": JSON.stringify({ main: "entry.js" }), "/a/node_modules/module/file.js": JSON.stringify({ main: "entry.js" }), "/modules/other-module/file.js": "" }, "/" ); resolver = resolve.create({ extensions: [".json", ".js"], modules: ["/modules", "node_modules"], // @ts-ignore fileSystem: fileSystem }); }); const testCases = [ { name: "middle module request", context: "/a/b/c", request: "module/file", result: "/a/node_modules/module/file.js", fileDependencies: [ // found package.json "/a/node_modules/module/package.json", // symlink checks "/a/node_modules/module/file.js", "/a/node_modules/module", "/a/node_modules", "/a", "/" ], missingDependencies: [ // missing package.jsons "/a/b/c/package.json", "/a/b/package.json", "/a/package.json", "/package.json", // missing modules directories "/a/b/c/node_modules", // missing single file modules "/modules/module", "/a/b/node_modules/module", // missing files with alterative extensions "/a/node_modules/module/file", "/a/node_modules/module/file.json" ] }, { name: "fast found module request", context: "/a/b/c", request: "other-module/file.js", result: "/modules/other-module/file.js", fileDependencies: [ // symlink checks "/modules/other-module/file.js", "/modules/other-module", "/modules", "/" ], missingDependencies: [ // missing package.jsons "/a/b/c/package.json", "/a/b/package.json", "/a/package.json", "/package.json", "/modules/other-module/package.json", "/modules/package.json" ] } ]; for (const testCase of testCases) { // eslint-disable-next-line no-loop-func it(`should report correct dependencies for ${testCase.name}`, done => { const fileDependencies = new Set(); const missingDependencies = new Set(); resolver( testCase.context, testCase.request, { fileDependencies, missingDependencies }, (err, result) => { if (err) return done(err); expect(result).toEqual(testCase.result); expect(Array.from(fileDependencies).sort()).toEqual( testCase.fileDependencies.sort() ); expect(Array.from(missingDependencies).sort()).toEqual( testCase.missingDependencies.sort() ); done(); } ); }); } }); enhanced-resolve-5.15.0/test/exportsField.test.js000066400000000000000000001643461444210260000217760ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { processExportsField } = require("../lib/util/entrypoints"); const ResolverFactory = require("../lib/ResolverFactory"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); /** @typedef {import("../lib/util/entrypoints").ExportsField} ExportsField */ const fixture = path.resolve(__dirname, "fixtures", "exports-field"); const fixture2 = path.resolve(__dirname, "fixtures", "exports-field2"); const fixture3 = path.resolve(__dirname, "fixtures", "exports-field3"); const fixture4 = path.resolve(__dirname, "fixtures", "exports-field-error"); describe("Process exports field", function exportsField() { /** @type {Array<{name: string, expect: string[]|Error, suite: [ExportsField, string, string[]]}>} */ const testCases = [ //#region Samples { name: "sample #1", expect: ["./dist/test/file.js", "./src/test/file.js"], suite: [ { "./foo/": { import: ["./dist/", "./src/"], webpack: "./wp/" }, ".": "./main.js" }, "./foo/test/file.js", ["import", "webpack"] ] }, { name: "sample #1 (wildcard)", expect: ["./dist/test/file.js", "./src/test/file.js"], suite: [ { "./foo/*": { import: ["./dist/*", "./src/*"], webpack: "./wp/*" }, ".": "./main.js" }, "./foo/test/file.js", ["import", "webpack"] ] }, { name: "sample #2", expect: ["./data/timezones/pdt.mjs"], suite: [ { "./timezones/": "./data/timezones/" }, "./timezones/pdt.mjs", [] ] }, { name: "sample #2 (wildcard)", expect: ["./data/timezones/pdt.mjs"], suite: [ { "./timezones/*": "./data/timezones/*" }, "./timezones/pdt.mjs", [] ] }, { name: "sample #3", // mapping works like concatenating strings not file paths expect: ["./data/timezones/timezones/pdt.mjs"], suite: [ { "./": "./data/timezones/" }, "./timezones/pdt.mjs", [] ] }, { name: "sample #3 (wildcard)", // mapping works like concatenating strings not file paths expect: ["./data/timezones/timezones/pdt.mjs"], suite: [ { "./*": "./data/timezones/*.mjs" }, "./timezones/pdt", [] ] }, { name: "sample #4", expect: [], suite: [ { "./lib/": { browser: ["./browser/"] }, "./dist/index.js": { node: "./index.js" } }, "./dist/index.js", ["browser"] ] }, { name: "sample #4 (wildcard)", expect: [], suite: [ { "./lib/*": { browser: ["./browser/*"] }, "./dist/index.js": { node: "./index.js" } }, "./dist/index.js", ["browser"] ] }, { name: "sample #5", expect: ["./browser/index.js"], // default condition used suite: [ { "./lib/": { browser: ["./browser/"] }, "./dist/index.js": { node: "./index.js", default: "./browser/index.js" } }, "./dist/index.js", ["browser"] ] }, { name: "sample #5 (wildcard)", expect: ["./browser/index.js"], // default condition used suite: [ { "./lib/*": { browser: ["./browser/*"] }, "./dist/index.js": { node: "./index.js", default: "./browser/index.js" } }, "./dist/index.js", ["browser"] ] }, { name: "sample #6", expect: [], suite: [ { "./dist/a": "./dist/index.js" }, "./dist/aaa", [] ] }, { name: "sample #7", expect: [], suite: [ { "./dist/a/a/": "./dist/index.js" }, "./dist/a/a", [] ] }, { name: "sample #7 (wildcard)", expect: [], suite: [ { "./dist/a/a/*": "./dist/index.js" }, "./dist/a/a", [] ] }, { name: "sample #8", expect: [], suite: [ { ".": "./index.js" }, "./timezones/pdt.mjs", [] ] }, { name: "sample #9", expect: ["./main.js"], suite: [ { "./index.js": "./main.js" }, "./index.js", [] ] }, { name: "sample #10", expect: ["./ok.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./#foo", [] ] }, { name: "sample #11", expect: ["./ok.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./bar#foo", [] ] }, { name: "sample #12", expect: ["./ok.js#abc"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./#zapp/ok.js#abc", [] ] }, { name: "sample #12", expect: ["./ok.js#abc"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./#zapp/ok.js#abc", [] ] }, { name: "sample #13", expect: ["./ok.js?abc"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./#zapp/ok.js?abc", [] ] }, { name: "sample #14", expect: ["./šŸŽ‰.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./#zapp/šŸŽ‰.js", [] ] }, { name: "sample #15", expect: ["./%F0%9F%8E%89.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, // "šŸŽ‰" percent encoded "./#zapp/%F0%9F%8E%89.js", [] ] }, { name: "sample #16", expect: ["./ok.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./šŸŽ‰", [] ] }, { name: "sample #17", expect: ["./other.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./%F0%9F%8E%89", [] ] }, { name: "sample #18", expect: ["./ok.js"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./module", [] ] }, { name: "sample #19", expect: [], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./module#foo", [] ] }, { name: "sample #20", expect: [], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./zzz*" }, "./module?foo", [] ] }, { name: "sample #21", expect: ["./zizizi"], suite: [ { "./#foo": "./ok.js", "./module": "./ok.js", "./šŸŽ‰": "./ok.js", "./%F0%9F%8E%89": "./other.js", "./bar#foo": "./ok.js", "./#zapp/": "./", "./#zipp*": "./z*z*z*" }, "./#zippi", [] ] }, { name: "sample #22", expect: ["./d?e?f"], suite: [ { "./a?b?c/": "./" }, "./a?b?c/d?e?f", [] ] }, //#endregion //#region Direct mapping { name: "Direct mapping #1", expect: ["./dist/index.js"], suite: [ { ".": "./dist/index.js" }, ".", [] ] }, { name: "Direct mapping #2", expect: [], suite: [ { "./": "./", "./*": "./*", "./dist/index.js": "./dist/index.js" }, ".", [] ] }, { name: "Direct mapping #3", expect: ["./dist/a.js"], // direct mapping is more prioritize suite: [ { "./dist/": "./dist/", "./dist/*": "./dist/*", "./dist*": "./dist*", "./dist/index.js": "./dist/a.js" }, "./dist/index.js", [] ] }, { name: "Direct mapping #4", expect: ["./index.js"], // direct mapping is more prioritize suite: [ { "./": { browser: ["./browser/"] }, "./*": { browser: ["./browser/*"] }, "./dist/index.js": { browser: "./index.js" } }, "./dist/index.js", ["browser"] ] }, { name: "Direct mapping #5", // direct mapping is more prioritize, // so there is no match expect: [], suite: [ { "./": { browser: ["./browser/"] }, "./*": { browser: ["./browser/*"] }, "./dist/index.js": { node: "./node.js" } }, "./dist/index.js", ["browser"] ] }, { name: "Direct mapping #6", expect: ["./index.js"], suite: [ { ".": { browser: "./index.js", node: "./src/node/index.js", default: "./src/index.js" } }, ".", ["browser"] ] }, { name: "Direct mapping #7", expect: new Error(), // Default is first one suite: [ { ".": { default: "./src/index.js", browser: "./index.js", node: "./src/node/index.js" } }, ".", ["browser"] ] }, { name: "Direct mapping #8", expect: ["./src/index.js"], suite: [ { ".": { browser: "./index.js", node: "./src/node/index.js", default: "./src/index.js" } }, ".", [] ] }, { name: "Direct mapping #9", expect: ["./index"], // it is fine, file may not have extension suite: [ { ".": "./index" }, ".", [] ] }, { name: "Direct mapping #10", expect: ["./index.js"], suite: [ { "./index": "./index.js" }, "./index", [] ] }, { name: "Direct mapping #11", expect: ["./foo.js"], suite: [ { "./": "./", "./*": "./*", "./dist/index.js": "./dist/index.js" }, "./foo.js", [] ] }, { name: "Direct mapping #12", expect: ["./foo/bar/baz.js"], suite: [ { "./": "./", "./*": "./*", "./dist/index.js": "./dist/index.js" }, "./foo/bar/baz.js", [] ] }, { name: "Direct mapping #13", expect: ["./foo/bar/baz.js"], suite: [ { "./": "./", "./dist/index.js": "./dist/index.js" }, "./foo/bar/baz.js", [] ] }, { name: "Direct mapping #14", expect: ["./foo/bar/baz.js"], suite: [ { "./*": "./*", "./dist/index.js": "./dist/index.js" }, "./foo/bar/baz.js", [] ] }, //#endregion //#region Direct and conditional mapping { name: "Direct and conditional mapping #1", expect: [], suite: [ { ".": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, ".", [] ] }, { name: "Direct and conditional mapping #2", expect: ["./import.mjs"], suite: [ { ".": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, ".", ["import"] ] }, { name: "Direct and conditional mapping #3", expect: ["./require.js", "./import.mjs"], suite: [ { ".": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, ".", ["import", "require"] ] }, { name: "Direct and conditional mapping #4", expect: ["./require.js", "./import.mjs", "./import.js"], suite: [ { ".": [ { browser: "./browser.js" }, { require: ["./require.js"] }, { import: ["./import.mjs", "./import.js"] } ] }, ".", ["import", "require"] ] }, //#endregion //#region When mapping to a folder root, both the left and right sides must end in slashes { name: "mapping to a folder root #1", expect: [], suite: [ { "./timezones": "./data/timezones/" }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #2", expect: new Error(), // incorrect export field suite: [ { "./timezones/": "./data/timezones" }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #3", expect: ["./data/timezones/pdt/index.mjs"], suite: [ { "./timezones/pdt/": "./data/timezones/pdt/" }, "./timezones/pdt/index.mjs", [] ] }, { name: "mapping to a folder root #3 (wildcard)", expect: ["./data/timezones/pdt/index.mjs"], suite: [ { "./timezones/pdt/*": "./data/timezones/pdt/*" }, "./timezones/pdt/index.mjs", [] ] }, { name: "mapping to a folder root #4", expect: ["./timezones/pdt.mjs"], suite: [ { "./": "./timezones/" }, "./pdt.mjs", [] ] }, { name: "mapping to a folder root #4 (wildcard)", expect: ["./timezones/pdt.mjs"], suite: [ { "./*": "./timezones/*" }, "./pdt.mjs", [] ] }, { name: "mapping to a folder root #5", expect: ["./timezones/pdt.mjs"], suite: [ { "./": "./" }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #5 (wildcard)", expect: ["./timezones/pdt.mjs"], suite: [ { "./*": "./*" }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #6", expect: new Error(), // not a folder mapping suite: [ { "./": "." }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #6 (wildcard)", expect: new Error(), // not a valid mapping suite: [ { "./*": "." }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #7", expect: [], // incorrect export field, but value did not processed suite: [ { ".": "./" }, "./timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #7 (wildcard)", expect: [], // incorrect export field, but value did not processed suite: [ { ".": "./*" }, "./timezones/pdt.mjs", [] ] }, //#endregion //#region The longest matching path prefix is prioritized { name: "the longest matching path prefix is prioritized #1", // it does not work same as conditional mapping, // so there is no match for ./dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "./": "./", "./dist/": "./lib/" }, "./dist/index.mjs", [] ] }, { name: "the longest matching path prefix is prioritized #1 (wildcard)", // it does not work same as conditional mapping, // so there is no match for ./dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "./*": "./*", "./dist/*": "./lib/*" }, "./dist/index.mjs", [] ] }, { name: "the longest matching path prefix is prioritized #2", expect: ["./dist/utils/index.js"], suite: [ { "./dist/utils/": "./dist/utils/", "./dist/": "./lib/" }, "./dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #2 (wildcard)", expect: ["./dist/utils/index.js"], suite: [ { "./dist/utils/*": "./dist/utils/*", "./dist/*": "./lib/*" }, "./dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #3", // direct mapping is prioritize // it does not work same as conditional mapping, // so there is no match for ./dist/utils/index.mjs expect: ["./dist/utils/index.js"], suite: [ { "./dist/utils/index.js": "./dist/utils/index.js", "./dist/utils/": "./dist/utils/index.mjs", "./dist/": "./lib/" }, "./dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #3 (wildcard)", // direct mapping is prioritize // it does not work same as conditional mapping, // so there is no match for ./dist/utils/index.mjs expect: ["./dist/utils/index.js"], suite: [ { "./dist/utils/index.js": "./dist/utils/index.js", "./dist/utils/*": "./dist/utils/index.mjs", "./dist/*": "./lib/*" }, "./dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #4", // it does not work same as conditional mapping, // even if right side is a conditional mapping, // so there is no match for ./browser/dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "./": { browser: "./browser/" }, "./dist/": "./lib/" }, "./dist/index.mjs", ["browser"] ] }, { name: "the longest matching path prefix is prioritized #4 (wildcard)", // it does not work same as conditional mapping, // even if right side is a conditional mapping, // so there is no match for ./browser/dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "./*": { browser: "./browser/*" }, "./dist/*": "./lib/*" }, "./dist/index.mjs", ["browser"] ] }, //#endregion //#region Conditional mapping folder { name: "conditional mapping folder #1", expect: ["lodash/index.js", "./utils/index.js"], suite: [ { "./utils/": { browser: ["lodash/", "./utils/"], node: ["./utils-node/"] } }, "./utils/index.js", ["browser"] ] }, { name: "conditional mapping folder #1 (wildcard)", expect: ["lodash/index.js", "./utils/index.js"], suite: [ { "./utils/*": { browser: ["lodash/*", "./utils/*"], node: ["./utils-node/*"] } }, "./utils/index.js", ["browser"] ] }, { name: "conditional mapping folder #2", expect: [], // no condition names suite: [ { "./utils/": { webpack: "./wpk/", browser: ["lodash/", "./utils/"], node: ["./node/"] } }, "./utils/index.mjs", [] ] }, { name: "conditional mapping folder #2 (wildcard)", expect: [], // no condition names suite: [ { "./utils/*": { webpack: "./wpk/*", browser: ["lodash/*", "./utils/*"], node: ["./node/*"] } }, "./utils/index.mjs", [] ] }, { name: "conditional mapping folder #3", expect: ["./wpk/index.mjs"], suite: [ { "./utils/": { webpack: "./wpk/", browser: ["lodash/", "./utils/"], node: ["./utils/"] } }, "./utils/index.mjs", ["browser", "webpack"] ] }, { name: "conditional mapping folder #3 (wildcard)", expect: ["./wpk/index.mjs"], suite: [ { "./utils/*": { webpack: "./wpk/*", browser: ["lodash/*", "./utils/*"], node: ["./utils/*"] } }, "./utils/index.mjs", ["browser", "webpack"] ] }, //#endregion //#region Incorrect exports field definition { name: "incorrect exports field #1", expect: new Error(), suite: [ { "/utils/": "./a/" }, "./utils/index.mjs", [] ] }, { name: "incorrect exports field #2", expect: new Error(), suite: [ { "./utils/": "/a/" }, "./utils/index.mjs", [] ] }, { name: "incorrect exports field #3", expect: new Error(), suite: [ { "/utils/": { browser: "./a/", default: "./b/" } }, "./utils/index.mjs", ["browser"] ] }, { name: "incorrect exports field #4", expect: new Error(), suite: [ { "./utils/": { browser: "/a/", default: "/b/" } }, "./utils/index.mjs", ["browser"] ] }, { name: "incorrect exports field #4 (wildcard)", expect: new Error(), suite: [ { "./utils/*": { browser: "/a/", default: "/b/" } }, "./utils/index.mjs", ["browser"] ] }, { name: "incorrect exports field #5", expect: [], suite: [ { "./utils/index": "./a/index.js" }, "./utils/index.mjs", [] ] }, { name: "incorrect exports field #6", expect: [], suite: [ { "./utils/index.mjs": "./a/index.js" }, "./utils/index", [] ] }, { name: "incorrect exports field #7", expect: [], suite: [ { "./utils/index": { browser: "./a/index.js", default: "./b/index.js" } }, "./utils/index.mjs", ["browser"] ] }, { name: "incorrect exports field #8", expect: [], suite: [ { "./utils/index.mjs": { browser: "./a/index.js", default: "./b/index.js" } }, "./utils/index", ["browser"] ] }, //#endregion //#region Incorrect request { name: "incorrect request #1", expect: new Error(), suite: [ { "./utils/": "./a/" }, "/utils/index.mjs", [] ] }, { name: "incorrect request #2", expect: new Error(), suite: [ { "./utils/": { browser: "./a/", default: "./b/" } }, "/utils/index.mjs", ["browser"] ] }, { name: "incorrect request #3", expect: new Error(), suite: [ { "./utils/": { browser: "./a/", default: "./b/" } }, "../utils/index.mjs", ["browser"] ] }, { name: "incorrect request #4", expect: new Error(), suite: [ { "./utils/": { browser: "./a/", default: "./b/" } }, "/utils/index.mjs/", ["browser"] ] }, //#endregion //#region Directory exports targets may not backtrack above the package base { name: "backtracking package base #1", expect: ["./dist/index"], // we don't handle backtracking here suite: [ { "./../../utils/": "./dist/" }, "./../../utils/index", [] ] }, { name: "backtracking package base #1 (wildcard)", expect: ["./dist/index"], // we don't handle backtracking here suite: [ { "./../../utils/*": "./dist/*" }, "./../../utils/index", [] ] }, { name: "backtracking package base #2", expect: new Error(), suite: [ { "../../utils/": "./dist/" }, "../../utils/index", [] ] }, { name: "backtracking package base #2 (wildcard)", expect: new Error(), suite: [ { "../../utils/*": "./dist/*" }, "../../utils/index", [] ] }, { name: "backtracking package base #3", expect: new Error(), suite: [ { "./utils/": "../src/" }, "./utils/index", [] ] }, { name: "backtracking package base #3 (wildcard)", expect: new Error(), suite: [ { "./utils/*": "../src/*" }, "./utils/index", [] ] }, { name: "backtracking package base #4", expect: ["./../src/index"], // we don't handle backtracking here suite: [ { "./utils/": "./../src/" }, "./utils/index", [] ] }, { name: "backtracking package base #4 (wildcard)", expect: ["./../src/index"], // we don't handle backtracking here suite: [ { "./utils/*": "./../src/*" }, "./utils/index", [] ] }, { name: "backtracking package base #5", // fits package base depth expect: ["./src/../index.js"], suite: [ { "./utils/index": "./src/../index.js" }, "./utils/index", [] ] }, { name: "backtracking package base #6", // fits package base depth, // but matching works as string concatenation not file paths expect: [], suite: [ { "./utils/../utils/index": "./src/../index.js" }, "./utils/index", [] ] }, { name: "backtracking package base #7", // enhanced-resolve don't know is this same package or not expect: new Error(), suite: [ { "./utils/": { browser: "../this/" } }, "./utils/index", ["browser"] ] }, { name: "backtracking package base #7", // enhanced-resolve don't know is this same package or not expect: new Error(), suite: [ { "./utils/*": { browser: "../this/*" } }, "./utils/index", ["browser"] ] }, { name: "backtracking package base #8", expect: ["./utils/../index"], suite: [ { "./utils/": { browser: "./utils/../" } }, "./utils/index", ["browser"] ] }, { name: "backtracking package base #8 (wildcard)", expect: ["./utils/../index"], suite: [ { "./utils/*": { browser: "./utils/../*" } }, "./utils/index", ["browser"] ] }, { name: "backtracking package base #9", expect: ["./dist/index"], suite: [ { "./": "./src/../../", "./dist/": "./dist/" }, "./dist/index", ["browser"] ] }, { name: "backtracking package base #9 (wildcard)", expect: ["./dist/index"], suite: [ { "./*": "./src/../../*", "./dist/*": "./dist/*" }, "./dist/index", ["browser"] ] }, //#endregion //#region Directory exports subpaths may not backtrack above the target folder { name: "backtracking target folder #1", expect: ["./dist/timezone/../../index"], suite: [ { "./utils/": "./dist/" }, "./utils/timezone/../../index", [] ] }, { name: "backtracking target folder #1 (wildcard)", expect: ["./dist/timezone/../../index"], suite: [ { "./utils/*": "./dist/*" }, "./utils/timezone/../../index", [] ] }, { name: "backtracking target folder #2", expect: ["./dist/timezone/../index"], suite: [ { "./utils/": "./dist/" }, "./utils/timezone/../index", [] ] }, { name: "backtracking target folder #2 (wildcard)", expect: ["./dist/timezone/../index"], suite: [ { "./utils/*": "./dist/*" }, "./utils/timezone/../index", [] ] }, { name: "backtracking target folder #3", expect: ["./dist/target/../../index"], suite: [ { "./utils/": "./dist/target/" }, "./utils/../../index", [] ] }, { name: "backtracking target folder #3 (wildcard)", expect: ["./dist/target/../../index"], suite: [ { "./utils/*": "./dist/target/*" }, "./utils/../../index", [] ] }, //#endregion //#region Exports targets cannot map into a nested node_modules path { name: "nested node_modules path #1", expect: ["./node_modules/lodash/dist/index.js"], // we don't handle node_modules here suite: [ { "./utils/": { browser: "./node_modules/" } }, "./utils/lodash/dist/index.js", ["browser"] ] }, { name: "nested node_modules path #1 (wildcard)", expect: ["./node_modules/lodash/dist/index.js"], // we don't handle node_modules here suite: [ { "./utils/*": { browser: "./node_modules/*" } }, "./utils/lodash/dist/index.js", ["browser"] ] }, { name: "nested node_modules path #2", expect: ["./utils/../node_modules/lodash/dist/index.js"], suite: [ { "./utils/": "./utils/../node_modules/" }, "./utils/lodash/dist/index.js", [] ] }, { name: "nested node_modules path #2 (wildcard)", expect: ["./utils/../node_modules/lodash/dist/index.js"], suite: [ { "./utils/*": "./utils/../node_modules/*" }, "./utils/lodash/dist/index.js", [] ] }, //#endregion //#region Nested mapping { name: "nested mapping #1", expect: [], suite: [ { "./utils/": { browser: { webpack: "./", default: { node: "./node/" } } } }, "./utils/index.js", ["browser"] ] }, { name: "nested mapping #1 (wildcard)", expect: [], suite: [ { "./utils/*": { browser: { webpack: "./*", default: { node: "./node/*" } } } }, "./utils/index.js", ["browser"] ] }, { name: "nested mapping #2", expect: ["./index.js", "./node/index.js"], suite: [ { "./utils/": { browser: { webpack: ["./", "./node/"], default: { node: "./node/" } } } }, "./utils/index.js", ["browser", "webpack"] ] }, { name: "nested mapping #2 (wildcard)", expect: ["./index.js", "./node/index.js"], suite: [ { "./utils/*": { browser: { webpack: ["./*", "./node/*"], default: { node: "./node/*" } } } }, "./utils/index.js", ["browser", "webpack"] ] }, { name: "nested mapping #3", expect: [], // no browser condition name suite: [ { "./utils/": { browser: { webpack: ["./", "./node/"], default: { node: "./node/" } } } }, "./utils/index.js", ["webpack"] ] }, { name: "nested mapping #3 (wildcard)", expect: [], // no browser condition name suite: [ { "./utils/*": { browser: { webpack: ["./*", "./node/*"], default: { node: "./node/*" } } } }, "./utils/index.js", ["webpack"] ] }, { name: "nested mapping #4", expect: ["./node/index.js"], suite: [ { "./utils/": { browser: { webpack: ["./", "./node/"], default: { node: "./node/" } } } }, "./utils/index.js", ["node", "browser"] ] }, { name: "nested mapping #4 (wildcard)", expect: ["./node/index.js"], suite: [ { "./utils/*": { browser: { webpack: ["./*", "./node/*"], default: { node: "./node/*" } } } }, "./utils/index.js", ["node", "browser"] ] }, { name: "nested mapping #5", expect: [], suite: [ { "./utils/": { browser: { webpack: ["./", "./node/"], default: { node: { webpack: ["./wpck/"] } } } } }, "./utils/index.js", ["browser", "node"] ] }, { name: "nested mapping #5 (wildcard)", expect: [], suite: [ { "./utils/*": { browser: { webpack: ["./*", "./node/*"], default: { node: { webpack: ["./wpck/*"] } } } } }, "./utils/index.js", ["browser", "node"] ] }, { name: "nested mapping #6", expect: ["./index.js", "./node/index.js"], suite: [ { "./utils/": { browser: { webpack: ["./", "./node/"], default: { node: { webpack: ["./wpck/"] } } } } }, "./utils/index.js", ["browser", "node", "webpack"] ] }, { name: "nested mapping #6 (wildcard)", expect: ["./index.js", "./node/index.js"], suite: [ { "./utils/*": { browser: { webpack: ["./*", "./node/*"], default: { node: { webpack: ["./wpck/*"] } } } } }, "./utils/index.js", ["browser", "node", "webpack"] ] }, { name: "nested mapping #7", expect: ["./y.js"], suite: [ { "./a.js": { abc: { def: "./x.js" }, ghi: "./y.js" } }, "./a.js", ["abc", "ghi"] ] }, { name: "nested mapping #8", expect: [], suite: [ { "./a.js": { abc: { def: "./x.js", default: [] }, ghi: "./y.js" } }, "./a.js", ["abc", "ghi"] ] }, //#endregion //#region Syntax sugar { name: "syntax sugar #1", expect: ["./main.js"], suite: ["./main.js", ".", []] }, { name: "syntax sugar #2", expect: [], suite: ["./main.js", "./lib.js", []] }, { name: "syntax sugar #3", expect: ["./a.js", "./b.js"], suite: [["./a.js", "./b.js"], ".", []] }, { name: "syntax sugar #4", expect: [], suite: [["./a.js", "./b.js"], "./lib.js", []] }, { name: "syntax sugar #5", expect: ["./index.js"], suite: [ { browser: { default: "./index.js" } }, ".", ["browser"] ] }, { name: "syntax sugar #6", expect: [], suite: [ { browser: { default: "./index.js" } }, "./lib.js", ["browser"] ] }, { name: "syntax sugar #7", expect: new Error(), suite: [ { "./node": "./node.js", browser: { default: "./index.js" } }, ".", ["browser"] ] }, { name: "syntax sugar #8", expect: new Error(), suite: [ { browser: { default: "./index.js" }, "./node": "./node.js" }, ".", ["browser"] ] }, //#endregion //#region Wildcards { name: "wildcard longest #1", expect: ["./abc/d"], suite: [ { "./ab*": "./ab/*", "./abc*": "./abc/*", "./a*": "./a/*" }, "./abcd", ["browser"] ] }, { name: "wildcard longest #2", expect: ["./abc/d/e"], suite: [ { "./ab*": "./ab/*", "./abc*": "./abc/*", "./a*": "./a/*" }, "./abcd/e", ["browser"] ] }, { name: "wildcard longest #3", expect: ["./abc/d"], suite: [ { "./x/ab*": "./ab/*", "./x/abc*": "./abc/*", "./x/a*": "./a/*" }, "./x/abcd", ["browser"] ] }, { name: "wildcard longest #4", expect: ["./abc/d/e"], suite: [ { "./x/ab*": "./ab/*", "./x/abc*": "./abc/*", "./x/a*": "./a/*" }, "./x/abcd/e", ["browser"] ] }, //#endregion { name: "path tree edge case #1", expect: ["./A/b/d.js"], suite: [ { "./a/": "./A/", "./a/b/c": "./c.js" }, "./a/b/d.js", [] ] }, { name: "path tree edge case #1 (wildcard)", expect: ["./A/b/d.js"], suite: [ { "./a/*": "./A/*", "./a/b/c": "./c.js" }, "./a/b/d.js", [] ] }, { name: "path tree edge case #2", expect: ["./A/c.js"], suite: [ { "./a/": "./A/", "./a/b": "./b.js" }, "./a/c.js", [] ] }, { name: "path tree edge case #2 (wildcard)", expect: ["./A/c.js"], suite: [ { "./a/*": "./A/*", "./a/b": "./b.js" }, "./a/c.js", [] ] }, { name: "path tree edge case #3", expect: ["./A/b/d/c.js"], suite: [ { "./a/": "./A/", "./a/b/c/d": "./c.js" }, "./a/b/d/c.js", [] ] }, { name: "path tree edge case #3 (wildcard)", expect: ["./A/b/d/c.js"], suite: [ { "./a/*": "./A/*", "./a/b/c/d": "./c.js" }, "./a/b/d/c.js", [] ] }, { name: "wildcard pattern #1", expect: ["./A/b.js"], suite: [ { "./a/*.js": "./A/*.js" }, "./a/b.js", [] ] }, { name: "wildcard pattern #2", expect: ["./A/b/c.js"], suite: [ { "./a/*.js": "./A/*.js" }, "./a/b/c.js", [] ] }, { name: "wildcard pattern #3", expect: ["./A/b/c.js"], suite: [ { "./a/*/c.js": "./A/*/c.js" }, "./a/b/c.js", [] ] }, { name: "wildcard pattern #4", expect: ["./A/b/b.js"], suite: [ { "./a/*/c.js": "./A/*/*.js" }, "./a/b/c.js", [] ] }, { name: "wildcard pattern #5", expect: ["./browser/index.js"], suite: [ { "./lib/*": { browser: ["./browser/*"] }, "./dist/*.js": { node: "./*.js", default: "./browser/*.js" } }, "./dist/index.js", ["browser"] ] }, { name: "wildcard pattern #5", expect: ["./browser/index.js"], suite: [ { "./lib/*": { browser: ["./browser/*"] }, "./dist/*.js": { node: "./*.js", default: "./browser/*.js" } }, "./lib/index.js", ["browser"] ] }, { name: "wildcard pattern #6", expect: ["./browser/foo/bar.js"], suite: [ { "./lib/*/bar.js": { browser: ["./browser/*/bar.js"] }, "./dist/*/bar.js": { node: "./*.js", default: "./browser/*.js" } }, "./lib/foo/bar.js", ["browser"] ] }, { name: "wildcard pattern #6", expect: ["./browser/foo.js"], suite: [ { "./lib/*/bar.js": { browser: ["./browser/*/bar.js"] }, "./dist/*/bar.js": { node: "./*.js", default: "./browser/*.js" } }, "./dist/foo/bar.js", ["browser"] ] }, { name: "wildcard pattern #7", expect: ["./browser/foo/default.js"], suite: [ { "./lib/*/bar.js": { browser: ["./browser/*/bar.js"] }, "./dist/*/bar.js": { node: "./*.js", default: "./browser/*/default.js" } }, "./dist/foo/bar.js", ["default"] ] }, { name: "wildcard pattern #8", expect: ["./A/b/b/b.js"], suite: [ { "./a/*/c.js": "./A/*/*/*.js" }, "./a/b/c.js", [] ] }, { name: "wildcard pattern #9", expect: ["./A/b/b/b.js", "./B/b/b/b.js"], suite: [ { "./a/*/c.js": ["./A/*/*/*.js", "./B/*/*/*.js"] }, "./a/b/c.js", [] ] }, { name: "wildcard pattern #10", expect: ["./A/b/b/b.js"], suite: [ { "./a/foo-*/c.js": "./A/*/*/*.js" }, "./a/foo-b/c.js", [] ] }, { name: "wildcard pattern #11", expect: ["./A/b/b/b.js"], suite: [ { "./a/*-foo/c.js": "./A/*/*/*.js" }, "./a/b-foo/c.js", [] ] }, { name: "wildcard pattern #12", expect: ["./A/b/b/b.js"], suite: [ { "./a/foo-*-foo/c.js": "./A/*/*/*.js" }, "./a/foo-b-foo/c.js", [] ] }, { name: "wildcard pattern #13", expect: ["./A/b/c/d.js"], suite: [ { "./a/foo-*-foo/c.js": "./A/b/c/d.js" }, "./a/foo-b-foo/c.js", [] ] }, { name: "wildcard pattern #13", expect: ["./A/b/c/*.js"], suite: [ { "./a/foo-foo/c.js": "./A/b/c/*.js" }, "./a/foo-foo/c.js", [] ] } ]; testCases.forEach(testCase => { it(testCase.name, () => { if (testCase.expect instanceof Error) { expect(() => { processExportsField(testCase.suite[0])( testCase.suite[1], new Set(testCase.suite[2]) ); }).toThrowError(); } else { expect( processExportsField(testCase.suite[0])( testCase.suite[1], new Set(testCase.suite[2]) ) ).toEqual(testCase.expect); } }); }); }); describe("ExportsFieldPlugin", () => { const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack"] }); const commonjsResolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, conditionNames: ["webpack"] }); it("resolve root using exports field, not a main field", done => { resolver.resolve({}, fixture, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/exports-field/x.js") ); done(); }); }); it("resolve using exports field, not a browser field #1", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], conditionNames: ["webpack"], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve( {}, fixture, "exports-field/dist/main.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/exports-field/lib/lib2/main.js") ); done(); } ); }); it("resolve using exports field and a browser alias field #2", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], extensions: [".js"], fileSystem: nodeFileSystem, conditionNames: ["node"] }); resolver.resolve( {}, fixture2, "exports-field/dist/main.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture2, "node_modules/exports-field/lib/browser.js") ); done(); } ); }); it("throw error if extension not provided", done => { resolver.resolve( {}, fixture2, "exports-field/dist/main", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Can't resolve/); done(); } ); }); it("throw error if extension not provided", done => { resolver.resolve( {}, fixture2, "exports-field/dist/main", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Can't resolve/); done(); } ); }); it("should resolve extension without fullySpecified", done => { commonjsResolver.resolve( {}, fixture2, "exports-field/dist/main", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture2, "node_modules/exports-field/lib/lib2/main.js") ); done(); } ); }); it("resolver should respect condition names", done => { resolver.resolve( {}, fixture, "exports-field/dist/main.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/exports-field/lib/lib2/main.js") ); done(); } ); }); it("resolver should respect fallback", done => { resolver.resolve( {}, fixture2, "exports-field/dist/browser.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture2, "node_modules/exports-field/lib/browser.js") ); done(); } ); }); it("resolver should respect query parameters #1", done => { resolver.resolve( {}, fixture2, "exports-field/dist/browser.js?foo", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve( fixture2, "node_modules/exports-field/lib/browser.js?foo" ) ); done(); } ); }); it("resolver should respect query parameters #2. Direct matching", done => { resolver.resolve({}, fixture2, "exports-field?foo", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Package path \.\/\?foo is not exported/); done(); }); }); it("resolver should respect fragment parameters #1", done => { resolver.resolve( {}, fixture2, "exports-field/dist/browser.js#foo", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve( fixture2, "node_modules/exports-field/lib/browser.js#foo" ) ); done(); } ); }); it("resolver should respect fragment parameters #2. Direct matching", done => { resolver.resolve({}, fixture2, "exports-field#foo", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Package path \.\/#foo is not exported/); done(); }); }); it("relative path should work, if relative path as request is used", done => { resolver.resolve( {}, fixture, "./node_modules/exports-field/lib/main.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/exports-field/lib/main.js") ); done(); } ); }); it("relative path should not work with exports field", done => { resolver.resolve( {}, fixture, "./node_modules/exports-field/dist/main.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Can't resolve/); done(); } ); }); it("backtracking should not work for request", done => { resolver.resolve( {}, fixture, "exports-field/dist/../../../a.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/out of package scope/); done(); } ); }); it("backtracking should not work for exports field target", done => { resolver.resolve( {}, fixture, "exports-field/dist/a.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/out of package scope/); done(); } ); }); it("self-resolving root", done => { resolver.resolve({}, fixture, "@exports-field/core", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "./a.js")); done(); }); }); it("not exported error", done => { resolver.resolve( {}, fixture, "exports-field/anything/else", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/not exported from package/); done(); } ); }); it("field name path #1", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], exportsFields: [["exportsField", "exports"]], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve({}, fixture3, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture3, "node_modules/exports-field/main.js") ); done(); }); }); it("field name path #2", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], exportsFields: [["exportsField", "exports"], "exports"], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve({}, fixture3, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture3, "node_modules/exports-field/main.js") ); done(); }); }); it("field name path #3", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], exportsFields: ["exports", ["exportsField", "exports"]], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve({}, fixture3, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture3, "node_modules/exports-field/main.js") ); done(); }); }); it("field name path #4", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], exportsFields: [["exports"]], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve({}, fixture2, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture2, "node_modules/exports-field/index.js") ); done(); }); }); it("field name path #5", done => { const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], exportsFields: ["ex", ["exportsField", "exports"]], extensions: [".js"], fileSystem: nodeFileSystem }); resolver.resolve({}, fixture3, "exports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture3, "node_modules/exports-field/index") ); done(); }); }); it("request ending with slash #1", done => { resolver.resolve({}, fixture, "exports-field/", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Resolving to directories is not possible/); done(); }); }); it("request ending with slash #2", done => { resolver.resolve({}, fixture, "exports-field/dist/", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Resolving to directories is not possible/); done(); }); }); it("request ending with slash #3", done => { resolver.resolve({}, fixture, "exports-field/lib/", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Resolving to directories is not possible/); done(); }); }); it("should throw error if target is invalid", done => { resolver.resolve({}, fixture4, "exports-field", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Trying to access out of package scope/); done(); }); }); it("throw error if exports field is invalid", done => { resolver.resolve( {}, fixture, "invalid-exports-field", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/should be relative path/); expect(err.message).toMatch(/umd/); done(); } ); }); it("should log the correct info", done => { const log = []; resolver.resolve( {}, fixture, "exports-field/dist/browser.js", { log: v => log.push(v) }, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/exports-field/lib/browser.js") ); expect( log.map(line => line.replace(fixture, "...").replace(/\\/g, "/")) ).toMatchSnapshot(); done(); } ); }); it("should resolve with wildcard pattern #1", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/features/f.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/features/f.js") ); done(); }); }); it("should resolve with wildcard pattern #2", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/features/y/y.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/features/y/y.js") ); done(); }); }); it("should resolve with wildcard pattern #2", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/features/y/y.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/features/y/y.js") ); done(); }); }); it("should resolve with wildcard pattern #3", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve( {}, fixture, "m/features-no-ext/y/y.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/features/y/y.js") ); done(); } ); }); it("should resolve with wildcard pattern #4", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/middle/nested/f.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/middle/nested/f.js") ); done(); }); }); it("should resolve with wildcard pattern #5", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve( {}, fixture, "m/middle-1/nested/f.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/middle-1/nested/f.js") ); done(); } ); }); it("should resolve with wildcard pattern #6", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve( {}, fixture, "m/middle-2/nested/f.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/middle-2/nested/f.js") ); done(); } ); }); it("should resolve with wildcard pattern #7", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/middle-3/nested/f", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve( fixture, "./node_modules/m/src/middle-3/nested/f/nested/f.js" ) ); done(); }); }); it("should resolve with wildcard pattern #8", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/middle-4/f/nested", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/middle-4/f/f.js") ); done(); }); }); it("should resolve with wildcard pattern #9", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve({}, fixture, "m/middle-5/f$/$", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/m/src/middle-5/f$/$.js") ); done(); }); }); it("should throw error if target is 'null'", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/" ); resolver.resolve( {}, fixture, "m/features/internal/file.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch( /Package path \.\/features\/internal\/file\.js is not exported/ ); done(); } ); }); it("should resolve with the `extensionAlias` option", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], extensionAlias: { ".js": [".ts", ".js"] }, fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack", "default"] }); const fixture = path.resolve( __dirname, "./fixtures/exports-field-and-extension-alias/" ); resolver.resolve({}, fixture, "@org/pkg/string.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/@org/pkg/dist/string.js") ); done(); }); }); it("should resolve with the `extensionAlias` option #2", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], extensionAlias: { ".js": [".ts", ".js"] }, fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack", "default"] }); const fixture = path.resolve( __dirname, "./fixtures/exports-field-and-extension-alias/" ); resolver.resolve({}, fixture, "pkg/string.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/pkg/dist/string.js") ); done(); }); }); it("should resolve with the `extensionAlias` option #3", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], extensionAlias: { ".js": [".foo", ".baz", ".baz", ".ts", ".js"] }, fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack", "default"] }); const fixture = path.resolve( __dirname, "./fixtures/exports-field-and-extension-alias/" ); resolver.resolve({}, fixture, "pkg/string.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/pkg/dist/string.js") ); done(); }); }); it("should throw error with the `extensionAlias` option", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], extensionAlias: { ".js": [".ts"] }, fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack", "default"] }); const fixture = path.resolve( __dirname, "./fixtures/exports-field-and-extension-alias/" ); resolver.resolve({}, fixture, "pkg/string.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch( /Package path \.\/string\.ts is not exported/ ); done(); }); }); it("should throw error with the `extensionAlias` option #2", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], extensionAlias: { ".js": ".ts" }, fileSystem: nodeFileSystem, fullySpecified: true, conditionNames: ["webpack", "default"] }); const fixture = path.resolve( __dirname, "./fixtures/exports-field-and-extension-alias/" ); resolver.resolve({}, fixture, "pkg/string.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch( /Package path \.\/string\.ts is not exported/ ); done(); }); }); }); enhanced-resolve-5.15.0/test/extension-alias.test.js000066400000000000000000000050671444210260000224230ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); const ResolverFactory = require("../lib/ResolverFactory"); /** @typedef {import("../lib/util/entrypoints").ImportsField} ImportsField */ describe("extension-alias", () => { const fixture = path.resolve(__dirname, "fixtures", "extension-alias"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFiles: ["index.js"], extensionAlias: { ".js": [".ts", ".js"], ".mjs": ".mts" } }); it("should alias fully specified file", done => { resolver.resolve({}, fixture, "./index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "index.ts")); done(); }); }); it("should alias fully specified file when there are two alternatives", done => { resolver.resolve({}, fixture, "./dir/index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "dir", "index.ts")); done(); }); }); it("should also allow the second alternative", done => { resolver.resolve({}, fixture, "./dir2/index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "dir2", "index.js")); done(); }); }); it("should support alias option without an array", done => { resolver.resolve({}, fixture, "./dir2/index.mjs", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "dir2", "index.mts")); done(); }); }); it("should not allow to fallback to the original extension or add extensions", done => { resolver.resolve({}, fixture, "./index.mjs", {}, (err, result) => { expect(err).toBeInstanceOf(Error); done(); }); }); describe("should not apply extension alias to extensions or mainFiles field", () => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFiles: ["index.js"], extensionAlias: { ".js": [] } }); it("directory", done => { resolver.resolve({}, fixture, "./dir2", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "dir2", "index.js")); done(); }); }); it("file", done => { resolver.resolve({}, fixture, "./dir2/index", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "dir2", "index.js")); done(); }); }); }); }); enhanced-resolve-5.15.0/test/extensions.test.js000066400000000000000000000065771444210260000215260ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { ResolverFactory, CachedInputFileSystem } = require("../"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ extensions: [".ts", ".js"], fileSystem: nodeFileSystem }); const resolver2 = ResolverFactory.createResolver({ extensions: [".ts", "", ".js"], fileSystem: nodeFileSystem }); const resolver3 = ResolverFactory.createResolver({ extensions: [".ts", "", ".js"], enforceExtension: false, fileSystem: nodeFileSystem }); const fixture = path.resolve(__dirname, "fixtures", "extensions"); describe("extensions", function () { it("should resolve according to order of provided extensions", function (done) { resolver.resolve({}, fixture, "./foo", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "foo.ts")); done(); }); }); it("should resolve according to order of provided extensions (dir index)", function (done) { resolver.resolve({}, fixture, "./dir", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "dir/index.ts")); done(); }); }); it("should resolve according to main field in module root", function (done) { resolver.resolve({}, fixture, ".", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "index.js")); done(); }); }); it("should resolve single file module before directory", function (done) { resolver.resolve({}, fixture, "module", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "node_modules/module.js")); done(); }); }); it("should resolve trailing slash directory before single file", function (done) { resolver.resolve({}, fixture, "module/", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/module/index.ts") ); done(); }); }); it("should not resolve to file when request has a trailing slash (relative)", function (done) { resolver.resolve({}, fixture, "./foo.js/", {}, (err, result) => { if (!err) return done(new Error("No error")); expect(err).toBeInstanceOf(Error); done(); }); }); it("should not resolve to file when request has a trailing slash (module)", function (done) { resolver.resolve({}, fixture, "module.js/", {}, (err, result) => { if (!err) return done(new Error("No error")); expect(err).toBeInstanceOf(Error); done(); }); }); it("should default enforceExtension to true when extensions includes an empty string", function (done) { const missingDependencies = new Set(); resolver2.resolve({}, fixture, "./foo", { missingDependencies }, () => { expect(missingDependencies).not.toContain(path.resolve(fixture, "foo")); done(); }); }); it("should respect enforceExtension when extensions includes an empty string", function (done) { const missingDependencies = new Set(); resolver3.resolve({}, fixture, "./foo", { missingDependencies }, () => { expect(missingDependencies).toContain(path.resolve(fixture, "foo")); done(); }); }); }); enhanced-resolve-5.15.0/test/fallback.test.js000066400000000000000000000070571444210260000210600ustar00rootroot00000000000000const { Volume } = require("memfs"); const { ResolverFactory } = require("../"); describe("fallback", function () { let resolver; beforeEach(function () { const fileSystem = Volume.fromJSON( { "/a/index": "", "/a/dir/index": "", "/recursive/index": "", "/recursive/dir/index": "", "/recursive/dir/file": "", "/recursive/dir/dir/index": "", "/b/index": "", "/b/dir/index": "", "/c/index": "", "/c/dir/index": "", "/d/index.js": "", "/d/dir/.empty": "", "/e/index": "", "/e/anotherDir/index": "", "/e/dir/file": "" }, "/" ); resolver = ResolverFactory.createResolver({ fallback: { aliasA: "a", b$: "a/index", c$: "/a/index", multiAlias: ["b", "c", "d", "e", "a"], recursive: "recursive/dir", "/d/dir": "/c/dir", "/d/index.js": "/c/index", ignored: false }, modules: "/", useSyncFileSystemCalls: true, //@ts-ignore fileSystem: fileSystem }); }); it("should resolve a not aliased module", function () { expect(resolver.resolveSync({}, "/", "a")).toBe("/a/index"); expect(resolver.resolveSync({}, "/", "a/index")).toBe("/a/index"); expect(resolver.resolveSync({}, "/", "a/dir")).toBe("/a/dir/index"); expect(resolver.resolveSync({}, "/", "a/dir/index")).toBe("/a/dir/index"); }); it("should resolve an fallback module", function () { expect(resolver.resolveSync({}, "/", "aliasA")).toBe("/a/index"); expect(resolver.resolveSync({}, "/", "aliasA/index")).toBe("/a/index"); expect(resolver.resolveSync({}, "/", "aliasA/dir")).toBe("/a/dir/index"); expect(resolver.resolveSync({}, "/", "aliasA/dir/index")).toBe( "/a/dir/index" ); }); it("should resolve an ignore module", () => { expect(resolver.resolveSync({}, "/", "ignored")).toBe(false); }); it("should resolve a recursive aliased module", function () { expect(resolver.resolveSync({}, "/", "recursive")).toBe("/recursive/index"); expect(resolver.resolveSync({}, "/", "recursive/index")).toBe( "/recursive/index" ); expect(resolver.resolveSync({}, "/", "recursive/dir")).toBe( "/recursive/dir/index" ); expect(resolver.resolveSync({}, "/", "recursive/dir/index")).toBe( "/recursive/dir/index" ); expect(resolver.resolveSync({}, "/", "recursive/file")).toBe( "/recursive/dir/file" ); }); it("should resolve a file aliased module with a query", function () { expect(resolver.resolveSync({}, "/", "b?query")).toBe("/b/index?query"); expect(resolver.resolveSync({}, "/", "c?query")).toBe("/c/index?query"); }); it("should resolve a path in a file aliased module", function () { expect(resolver.resolveSync({}, "/", "b/index")).toBe("/b/index"); expect(resolver.resolveSync({}, "/", "b/dir")).toBe("/b/dir/index"); expect(resolver.resolveSync({}, "/", "b/dir/index")).toBe("/b/dir/index"); expect(resolver.resolveSync({}, "/", "c/index")).toBe("/c/index"); expect(resolver.resolveSync({}, "/", "c/dir")).toBe("/c/dir/index"); expect(resolver.resolveSync({}, "/", "c/dir/index")).toBe("/c/dir/index"); }); it("should resolve a file in multiple aliased dirs", function () { expect(resolver.resolveSync({}, "/", "multiAlias/dir/file")).toBe( "/e/dir/file" ); expect(resolver.resolveSync({}, "/", "multiAlias/anotherDir")).toBe( "/e/anotherDir/index" ); }); it("should log the correct info", done => { const log = []; resolver.resolve( {}, "/", "aliasA/dir", { log: v => log.push(v) }, (err, result) => { if (err) return done(err); expect(result).toBe("/a/dir/index"); expect(log).toMatchSnapshot(); done(); } ); }); }); enhanced-resolve-5.15.0/test/fixtures/000077500000000000000000000000001444210260000176455ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/a.js000066400000000000000000000000701444210260000204200ustar00rootroot00000000000000module.exports = function a() { return "This is a"; }; enhanced-resolve-5.15.0/test/fixtures/abc.txt000066400000000000000000000000031444210260000211240ustar00rootroot00000000000000abcenhanced-resolve-5.15.0/test/fixtures/b.js000066400000000000000000000000701444210260000204210ustar00rootroot00000000000000module.exports = function b() { return "This is b"; }; enhanced-resolve-5.15.0/test/fixtures/browser-module/000077500000000000000000000000001444210260000226135ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/browser/000077500000000000000000000000001444210260000242765ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/browser/module-a.js000066400000000000000000000000001444210260000263250ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/000077500000000000000000000000001444210260000233615ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/browser.js000066400000000000000000000000001444210260000253700ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/ignore.js000066400000000000000000000000001444210260000251700ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/main.js000066400000000000000000000000001444210260000246310ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/replaced.js000066400000000000000000000000001444210260000254640ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/lib/toString.js000066400000000000000000000000001444210260000255160ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/node_modules/000077500000000000000000000000001444210260000252705ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/node_modules/module-a.js000066400000000000000000000000001444210260000273170ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/node_modules/module-b.js000066400000000000000000000000001444210260000273200ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/node_modules/module-c.js000066400000000000000000000000001444210260000273210ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/browser-module/package.json000066400000000000000000000006531444210260000251050ustar00rootroot00000000000000{ "browser": { "./lib/ignore.js": false, "./lib/replaced.js": "./lib/browser", "module-a": "./browser/module-a.js", "module-b": "module-c", "./toString": "./lib/toString.js", ".": false }, "innerBrowser1": { "field": { "browser": { "./lib/main1.js": "./lib/main.js" } } }, "innerBrowser2": { "browser": { "./lib/main2.js": "./lib/replaced.js" } } } enhanced-resolve-5.15.0/test/fixtures/c.js000066400000000000000000000001111444210260000204160ustar00rootroot00000000000000module.exports = function b() { require("./a"); return "This is c"; }; enhanced-resolve-5.15.0/test/fixtures/complex.js000066400000000000000000000006161444210260000216550ustar00rootroot00000000000000var complex1 = require("./lib/complex1"); require.ensure(["./lib/complex1", "complexm/step2"], function(require) { require("./lib/complex1"); var a = function() {}; require.ensure(["complexm/step1"], function(require) { require("./lib/complex1"); var s1 = require("complexm/step1"); var s2 = require("complexm/step2"); console.log(s1); console.log(s2); }); }); console.log(complex1); enhanced-resolve-5.15.0/test/fixtures/decorated-fs/000077500000000000000000000000001444210260000222055ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/decorated-fs/exists.js000066400000000000000000000000001444210260000240500ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/dirOrFile.js000066400000000000000000000000311444210260000220540ustar00rootroot00000000000000module.exports = "file"; enhanced-resolve-5.15.0/test/fixtures/dirOrFile/000077500000000000000000000000001444210260000215245ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/dirOrFile/index.js000066400000000000000000000000301444210260000231620ustar00rootroot00000000000000module.exports = "dir"; enhanced-resolve-5.15.0/test/fixtures/directory-default/000077500000000000000000000000001444210260000232735ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/directory-default/directory-default.js000066400000000000000000000000001444210260000272450ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/000077500000000000000000000000001444210260000262735ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/000077500000000000000000000000001444210260000307505ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/000077500000000000000000000000001444210260000316375ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/pkg/000077500000000000000000000000001444210260000324205ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/pkg/dist/000077500000000000000000000000001444210260000333635ustar00rootroot00000000000000string.js000066400000000000000000000000311444210260000351420ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/pkg/distexport default "string"; string.test.d.ts000066400000000000000000000000131444210260000363540ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/pkg/distexport {}; package.json000066400000000000000000000002021444210260000346210ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/@org/pkg{ "name": "@org/pkg", "exports": { "./*.js": { "types": "./dist/*.d.ts", "default": "./dist/*.js" } } } enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/pkg/000077500000000000000000000000001444210260000315315ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/pkg/dist/000077500000000000000000000000001444210260000324745ustar00rootroot00000000000000string.js000066400000000000000000000000311444210260000342530ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/pkg/distexport default "string"; string.test.d.ts000066400000000000000000000000131444210260000354650ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/pkg/distexport {}; package.json000066400000000000000000000002111444210260000337320ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-and-extension-alias/node_modules/pkg{ "name": "@raviqqe/hidash", "exports": { "./*.js": { "types": "./dist/*.d.ts", "default": "./dist/*.js" } } } enhanced-resolve-5.15.0/test/fixtures/exports-field-error/000077500000000000000000000000001444210260000235615ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-error/node_modules/000077500000000000000000000000001444210260000262365ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-error/node_modules/exports-field/000077500000000000000000000000001444210260000310235ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-error/node_modules/exports-field/package.json000066400000000000000000000001611444210260000333070ustar00rootroot00000000000000{ "name": "exports-field", "version": "1.0.0", "exports": { ".": "./a/../b/../../pack1/index.js" } } enhanced-resolve-5.15.0/test/fixtures/exports-field-error/node_modules/pack1/000077500000000000000000000000001444210260000272355ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field-error/node_modules/pack1/index.js000066400000000000000000000000001444210260000306700ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/000077500000000000000000000000001444210260000224325ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/a.js000066400000000000000000000000241444210260000232040ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/000077500000000000000000000000001444210260000251075ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/000077500000000000000000000000001444210260000276745ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/000077500000000000000000000000001444210260000304425ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/browser.js000066400000000000000000000000241444210260000324570ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/index.js000066400000000000000000000000001444210260000320750ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/lib2/000077500000000000000000000000001444210260000312725ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/lib2/main.js000066400000000000000000000000241444210260000325500ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/lib/main.js000066400000000000000000000000241444210260000317200ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/main.js000066400000000000000000000000241444210260000311520ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/package.json000066400000000000000000000005601444210260000321630ustar00rootroot00000000000000{ "name": "exports-field", "version": "1.0.0", "main": "./main.js", "browser": { "./lib/main.js": "./lib/browser.js", "./dist/main.js": "./lib/browser.js" }, "exports": { ".": "./x.js", "./dist/": { "webpack": ["./lib/lib2/", "./lib/"], "node": "./lib/", "default": "./lib/" }, "./dist/a.js": "./../../a.js" } } enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/exports-field/x.js000066400000000000000000000000241444210260000304750ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/invalid-exports-field/000077500000000000000000000000001444210260000313205ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/invalid-exports-field/index.js000066400000000000000000000000001444210260000327530ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/invalid-exports-field/package.json000066400000000000000000000003621444210260000336070ustar00rootroot00000000000000{ "name": "exports-field", "version": "1.0.0", "main": "./main.js", "browser": { "./lib/main.js": "./lib/browser.js", "./dist/main.js": "./lib/browser.js" }, "exports": { ".": "./index.js", "umd": "./umd.js" } } enhanced-resolve-5.15.0/test/fixtures/exports-field/node_modules/invalid-exports-field/umd.js000066400000000000000000000000001444210260000324310ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field/package.json000066400000000000000000000001211444210260000247120ustar00rootroot00000000000000{ "name": "@exports-field/core", "version": "1.0.0", "exports": "./a.js" } enhanced-resolve-5.15.0/test/fixtures/exports-field2/000077500000000000000000000000001444210260000225145ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/000077500000000000000000000000001444210260000251715ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/000077500000000000000000000000001444210260000277565ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/index.js000066400000000000000000000000241444210260000314170ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/lib/000077500000000000000000000000001444210260000305245ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/lib/browser.js000066400000000000000000000000241444210260000325410ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/lib/lib2/000077500000000000000000000000001444210260000313545ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/lib/lib2/main.js000066400000000000000000000000241444210260000326320ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/lib/main.js000066400000000000000000000000241444210260000320020ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/main.js000066400000000000000000000000241444210260000312340ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field2/node_modules/exports-field/package.json000066400000000000000000000005211444210260000322420ustar00rootroot00000000000000{ "name": "exports-field", "version": "1.0.0", "main": "./main.js", "browser": { "./lib/main.js": "./lib/browser.js", "./dist/main.js": "./lib/browser.js" }, "exports": { ".": "./index.js", "./dist/": { "webpack": ["./lib/lib2/", "./lib/"], "node": "./lib/", "default": "./lib/" } } } enhanced-resolve-5.15.0/test/fixtures/exports-field3/000077500000000000000000000000001444210260000225155ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field3/node_modules/000077500000000000000000000000001444210260000251725ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field3/node_modules/exports-field/000077500000000000000000000000001444210260000277575ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field3/node_modules/exports-field/index000066400000000000000000000000001444210260000307770ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/exports-field3/node_modules/exports-field/main.js000066400000000000000000000000241444210260000312350ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/exports-field3/node_modules/exports-field/package.json000066400000000000000000000001451444210260000322450ustar00rootroot00000000000000{ "name": "exports-field", "exportsField": { "exports": "./main.js" }, "ex": "./index" } enhanced-resolve-5.15.0/test/fixtures/extension-alias/000077500000000000000000000000001444210260000227505ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir/000077500000000000000000000000001444210260000235265ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir/index.js000066400000000000000000000000001444210260000251610ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir/index.ts000066400000000000000000000000001444210260000251730ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir2/000077500000000000000000000000001444210260000236105ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir2/index.js000066400000000000000000000000001444210260000252430ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/dir2/index.mts000066400000000000000000000000001444210260000254320ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/index.js000066400000000000000000000000001444210260000244030ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/index.mjs000066400000000000000000000000001444210260000245600ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/index.mts.js000066400000000000000000000000001444210260000252050ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extension-alias/index.ts000066400000000000000000000000001444210260000244150ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/000077500000000000000000000000001444210260000220445ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/dir/000077500000000000000000000000001444210260000226225ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/dir/index.js000066400000000000000000000000001444210260000242550ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/dir/index.ts000066400000000000000000000000001444210260000242670ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/foo.js000066400000000000000000000000001444210260000231530ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/foo.ts000066400000000000000000000000001444210260000231650ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/index.js000066400000000000000000000000001444210260000234770ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/index.ts000066400000000000000000000000001444210260000235110ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/node_modules/000077500000000000000000000000001444210260000245215ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/node_modules/module.js000066400000000000000000000000001444210260000263320ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/node_modules/module/000077500000000000000000000000001444210260000260065ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/node_modules/module/index.ts000066400000000000000000000000001444210260000274530ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/extensions/package.json000066400000000000000000000000331444210260000243260ustar00rootroot00000000000000{ "main": "./index.js" } enhanced-resolve-5.15.0/test/fixtures/file.load1000066400000000000000000000000001444210260000214740ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/file.load2000066400000000000000000000000001444210260000214750ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/foo/000077500000000000000000000000001444210260000204305ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/foo/index.js000066400000000000000000000000001444210260000220630ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/foo/package.json000066400000000000000000000000521444210260000227130ustar00rootroot00000000000000{ "name": "foo", "version": "1.0.0" } enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/000077500000000000000000000000001444210260000246335ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/000077500000000000000000000000001444210260000273105ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/000077500000000000000000000000001444210260000275445ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/package.json000066400000000000000000000010331444210260000320270ustar00rootroot00000000000000{ "name": "m", "exports": { "./features-no-ext/*": "./src/features/*", "./features/*.js": "./src/features/*.js", "./features/internal/*": null, "./middle/nested/f.js": "./src/middle/nested/f.js", "./middle-1/nested/*.js": "./src/middle-1/nested/*.js", "./middle-2/*/f.js": "./src/middle-2/*/f.js", "./middle-3/*": "./src/middle-3/*/*.js", "./middle-4/*/nested": "./src/middle-4/*/*.js", "./middle-5/*/$": "./src/middle-5/*/$.js" }, "imports": { "#internal/*.js": "./src/internal/*.js" } } enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/000077500000000000000000000000001444210260000303335ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/000077500000000000000000000000001444210260000321515ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/f.js000066400000000000000000000000001444210260000327220ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/internal/000077500000000000000000000000001444210260000337655ustar00rootroot00000000000000file.js000066400000000000000000000000001444210260000351510ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/internalenhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/y/000077500000000000000000000000001444210260000324215ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/features/y/y.js000066400000000000000000000000001444210260000332150ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/internal/000077500000000000000000000000001444210260000321475ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/internal/i.js000066400000000000000000000000001444210260000327230ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-1/000077500000000000000000000000001444210260000317275ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-1/f.js000066400000000000000000000000001444210260000325000ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-1/nested/000077500000000000000000000000001444210260000332115ustar00rootroot00000000000000f.js000066400000000000000000000000001444210260000337030ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-1/nestedenhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-2/000077500000000000000000000000001444210260000317305ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-2/nested/000077500000000000000000000000001444210260000332125ustar00rootroot00000000000000f.js000066400000000000000000000000461444210260000337160ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-2/nestedmodule.exports = { nested: "nested" } enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-3/000077500000000000000000000000001444210260000317315ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-3/nested/000077500000000000000000000000001444210260000332135ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-3/nested/f/000077500000000000000000000000001444210260000334405ustar00rootroot00000000000000nested/000077500000000000000000000000001444210260000346435ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-3/nested/ff.js000066400000000000000000000000001444210260000354140ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-3/nested/f/nestedenhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-4/000077500000000000000000000000001444210260000317325ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-4/f/000077500000000000000000000000001444210260000321575ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-4/f/f.js000066400000000000000000000000001444210260000327300ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-5/000077500000000000000000000000001444210260000317335ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-5/f$/000077500000000000000000000000001444210260000322245ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-5/f$/$.js000066400000000000000000000000001444210260000326730ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-5/f/000077500000000000000000000000001444210260000321605ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle-5/f/$.js000066400000000000000000000000001444210260000326270ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle/000077500000000000000000000000001444210260000315715ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle/f.js000066400000000000000000000000001444210260000323420ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle/nested/000077500000000000000000000000001444210260000330535ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-exports-wildcard/node_modules/m/src/middle/nested/f.js000066400000000000000000000000001444210260000336240ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/000077500000000000000000000000001444210260000224235ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/a.js000066400000000000000000000000241444210260000231750ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/b.js000066400000000000000000000000001444210260000231700ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/dir/000077500000000000000000000000001444210260000232015ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/dir/b.js000066400000000000000000000000001444210260000237460ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/000077500000000000000000000000001444210260000251005ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/000077500000000000000000000000001444210260000253205ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/000077500000000000000000000000001444210260000260665ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/browser.js000066400000000000000000000000241444210260000301030ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/index.js000066400000000000000000000000001444210260000275210ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/lib2/000077500000000000000000000000001444210260000267165ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/lib2/main.js000066400000000000000000000000241444210260000301740ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/lib/main.js000066400000000000000000000000241444210260000273440ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/main.js000066400000000000000000000000241444210260000265760ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/package.json000066400000000000000000000005441444210260000276110ustar00rootroot00000000000000{ "name": "a", "version": "1.0.0", "main": "./main.js", "browser": { "./lib/main.js": "./lib/browser.js", "./dist/main.js": "./lib/browser.js" }, "exports": { ".": "./x.js", "./dist/": { "webpack": ["./lib/lib2/", "./lib/"], "node": "./lib/", "default": "./lib/" }, "./dist/a.js": "./../../a.js" } } enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/a/x.js000066400000000000000000000000241444210260000261210ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/c/000077500000000000000000000000001444210260000253225ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/node_modules/c/index.js000066400000000000000000000000001444210260000267550ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/imports-field/package.json000066400000000000000000000004041444210260000247070ustar00rootroot00000000000000{ "name": "imports-field", "version": "1.0.0", "exports": "./a.js", "imports": { "#imports-field": "./b.js", "#b": "../b.js", "#ccc/": "c/", "#c": "c", "#a/": "a/" }, "other": { "imports": { "#b": "./a.js" } } } enhanced-resolve-5.15.0/test/fixtures/incorrect-package/000077500000000000000000000000001444210260000232265ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack1/000077500000000000000000000000001444210260000242255ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack1/a.js000066400000000000000000000000001444210260000247710ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack1/package.json000066400000000000000000000000261444210260000265110ustar00rootroot00000000000000{ "main": "./a.js", enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack2/000077500000000000000000000000001444210260000242265ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack2/a.js000066400000000000000000000000001444210260000247720ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/incorrect-package/pack2/package.json000066400000000000000000000000001444210260000265020ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/000077500000000000000000000000001444210260000213075ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/package.json000066400000000000000000000000261444210260000235730ustar00rootroot00000000000000{ "private": true } enhanced-resolve-5.15.0/test/fixtures/issue-238/src/000077500000000000000000000000001444210260000220765ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/src/a/000077500000000000000000000000001444210260000223165ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/src/a/config.js000066400000000000000000000000001444210260000241070ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/src/common/000077500000000000000000000000001444210260000233665ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/src/common/config/000077500000000000000000000000001444210260000246335ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/issue-238/src/common/config/myObjectFile.js000066400000000000000000000000001444210260000275330ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/lib/000077500000000000000000000000001444210260000204135ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/lib/complex1.js000066400000000000000000000000411444210260000224740ustar00rootroot00000000000000module.exports = "lib complex1"; enhanced-resolve-5.15.0/test/fixtures/main-field-self/000077500000000000000000000000001444210260000226015ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/main-field-self/index.js000066400000000000000000000000001444210260000242340ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/main-field-self/package.json000066400000000000000000000000231444210260000250620ustar00rootroot00000000000000{ "main": "./" } enhanced-resolve-5.15.0/test/fixtures/main-field-self2/000077500000000000000000000000001444210260000226635ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/main-field-self2/index.js000066400000000000000000000000001444210260000243160ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/main-field-self2/package.json000066400000000000000000000000221444210260000251430ustar00rootroot00000000000000{ "main": "." } enhanced-resolve-5.15.0/test/fixtures/main1.js000066400000000000000000000002241444210260000212060ustar00rootroot00000000000000var a = require("./a"); if (x) { for (var i = 0; i < 100; i++) { while (true) require("./b"); do { i++; } while (require("m1/a")()); } } enhanced-resolve-5.15.0/test/fixtures/main2.js000066400000000000000000000003051444210260000212070ustar00rootroot00000000000000var a = require("./a"); with (x) { switch (a) { case 1: require("./b"); default: require.ensure(["m1/a"], function() { var a = require("m1/a"), b = require("m1/b"); }); } } enhanced-resolve-5.15.0/test/fixtures/main3.js000066400000000000000000000001271444210260000212120ustar00rootroot00000000000000var a = require("./a"); require.ensure([], function(require) { require("./c.js"); }); enhanced-resolve-5.15.0/test/fixtures/multiple_modules/000077500000000000000000000000001444210260000232305ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/multiple_modules/node_modules/000077500000000000000000000000001444210260000257055ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/multiple_modules/node_modules/m1/000077500000000000000000000000001444210260000262225ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/multiple_modules/node_modules/m1/a.js000066400000000000000000000001021444210260000267710ustar00rootroot00000000000000module.exports = function a() { return "This is nested m1/a"; }; enhanced-resolve-5.15.0/test/fixtures/no#fragment/000077500000000000000000000000001444210260000220505ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/no#fragment/#/000077500000000000000000000000001444210260000221725ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/no#fragment/#/#.js000066400000000000000000000000001444210260000226400ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/no.js000066400000000000000000000000001444210260000206050ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/000077500000000000000000000000001444210260000223225ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/000077500000000000000000000000001444210260000241465ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/node_modules/000077500000000000000000000000001444210260000266235ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/node_modules/m1/000077500000000000000000000000001444210260000271405ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/node_modules/m1/a.js000066400000000000000000000000451444210260000277150ustar00rootroot00000000000000module.exports = "the correct a.js"; enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/node_modules/m1/index.js000066400000000000000000000000561444210260000306060ustar00rootroot00000000000000module.exports = " :) " + require("m2/b.js"); enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/step1.js000066400000000000000000000000621444210260000255360ustar00rootroot00000000000000module.exports = require("m1/a") + require("m1"); enhanced-resolve-5.15.0/test/fixtures/node_modules/complexm/step2.js000066400000000000000000000000321444210260000255340ustar00rootroot00000000000000module.exports = "Step2"; enhanced-resolve-5.15.0/test/fixtures/node_modules/invalidPackageJson/000077500000000000000000000000001444210260000260565ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/invalidPackageJson/package.json000066400000000000000000000000001444210260000303320ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/m1/000077500000000000000000000000001444210260000226375ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/m1/a.js000066400000000000000000000000731444210260000234150ustar00rootroot00000000000000module.exports = function a() { return "This is m1/a"; }; enhanced-resolve-5.15.0/test/fixtures/node_modules/m1/b.js000066400000000000000000000000731444210260000234160ustar00rootroot00000000000000module.exports = function a() { return "This is m1/b"; }; enhanced-resolve-5.15.0/test/fixtures/node_modules/m2/000077500000000000000000000000001444210260000226405ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/m2/b.js000066400000000000000000000000411444210260000234120ustar00rootroot00000000000000module.exports = "This is m2/b"; enhanced-resolve-5.15.0/test/fixtures/node_modules/recursive-module/000077500000000000000000000000001444210260000256145ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/recursive-module/file.js000066400000000000000000000000001444210260000270570ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/node_modules/recursive-module/index.js000066400000000000000000000000001444210260000272470ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp-a/000077500000000000000000000000001444210260000206605ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp-a/m2/000077500000000000000000000000001444210260000211765ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp-a/m2/a.js000066400000000000000000000001021444210260000217450ustar00rootroot00000000000000module.exports = function a() { return "This is nested m1/a"; }; enhanced-resolve-5.15.0/test/fixtures/pnp/000077500000000000000000000000001444210260000204425ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/000077500000000000000000000000001444210260000212235ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/dir/000077500000000000000000000000001444210260000220015ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/dir/index.js000066400000000000000000000000001444210260000234340ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/index.js000066400000000000000000000000001444210260000226560ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/main.js000066400000000000000000000000001444210260000224730ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/package-alias/000077500000000000000000000000001444210260000237055ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/package-alias/browser.js000066400000000000000000000000001444210260000257140ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/package-alias/index.js000066400000000000000000000000001444210260000253400ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/package.json000066400000000000000000000002101444210260000235020ustar00rootroot00000000000000{ "main": "main.js", "browser": { "./package-alias/index.js": "./package-alias/browser.js", "module": "pkg/dir/index" } } enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/typescript/000077500000000000000000000000001444210260000234315ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg/typescript/index.ts000066400000000000000000000000001444210260000250760ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg3/000077500000000000000000000000001444210260000213065ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/pnp/pkg3/a.js000066400000000000000000000000241444210260000220600ustar00rootroot00000000000000module.exports = 1; enhanced-resolve-5.15.0/test/fixtures/pnp/pkg3/package.json000066400000000000000000000001651444210260000235760ustar00rootroot00000000000000{ "name": "@exports-field/core", "version": "1.0.0", "exports": { ".": "./a.js", "./x": "./a.js" } } enhanced-resolve-5.15.0/test/fixtures/prefer-pnp/000077500000000000000000000000001444210260000217235ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/prefer-pnp/alternative-modules/000077500000000000000000000000001444210260000257075ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/prefer-pnp/alternative-modules/m1/000077500000000000000000000000001444210260000262245ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/prefer-pnp/alternative-modules/m1/b.js000066400000000000000000000000001444210260000267710ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/000077500000000000000000000000001444210260000223755ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/000077500000000000000000000000001444210260000250525ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck1/000077500000000000000000000000001444210260000257105ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck1/index.css000066400000000000000000000000001444210260000275170ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck1/index.js000066400000000000000000000000001444210260000273430ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck1/package.json000066400000000000000000000000311444210260000301700ustar00rootroot00000000000000{ "main": "index.js" } enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck2/000077500000000000000000000000001444210260000257115ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck2/index.css000066400000000000000000000000001444210260000275200ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck2/module.js000066400000000000000000000000001444210260000275220ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/restrictions/node_modules/pck2/package.json000066400000000000000000000001171444210260000301760ustar00rootroot00000000000000{ "main": "../../../c.js", "module": "module.js", "style": "index.css" } enhanced-resolve-5.15.0/test/fixtures/scoped/000077500000000000000000000000001444210260000211225ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/000077500000000000000000000000001444210260000235775ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/000077500000000000000000000000001444210260000250105ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack1/000077500000000000000000000000001444210260000260075ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack1/main.js000066400000000000000000000000001444210260000272570ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack1/package.json000066400000000000000000000000651444210260000302760ustar00rootroot00000000000000{ "browser": { "./index.js": "./main.js" } } enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack2/000077500000000000000000000000001444210260000260105ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack2/lib/000077500000000000000000000000001444210260000265565ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack2/lib/index.js000066400000000000000000000000001444210260000302110ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack2/main.js000066400000000000000000000000001444210260000272600ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/scoped/node_modules/@scope/pack2/package.json000066400000000000000000000000321444210260000302710ustar00rootroot00000000000000{ "main": "./main.js" } enhanced-resolve-5.15.0/test/fixtures/shortcutdir.js/000077500000000000000000000000001444210260000226325ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/shortcutdir.js/a.js000066400000000000000000000000001444210260000233760ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/000077500000000000000000000000001444210260000207535ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/000077500000000000000000000000001444210260000211735ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo-2/000077500000000000000000000000001444210260000221155ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo-2/b000066400000000000000000000000001444210260000222470ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo-2/c000066400000000000000000000000001444210260000222500ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo/000077500000000000000000000000001444210260000217565ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo/a000066400000000000000000000000001444210260000221070ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/a/foo/b000066400000000000000000000000001444210260000221100ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/b/000077500000000000000000000000001444210260000211745ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/b/foo/000077500000000000000000000000001444210260000217575ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/b/foo/a000066400000000000000000000000001444210260000221100ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/c/000077500000000000000000000000001444210260000211755ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/c/foo/000077500000000000000000000000001444210260000217605ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/c/foo/a000066400000000000000000000000001444210260000221110ustar00rootroot00000000000000enhanced-resolve-5.15.0/test/fixtures/yield/c/foo/package.json000066400000000000000000000001171444210260000242450ustar00rootroot00000000000000{ "name": "foo", "version": "1.0.0", "browser": { "./a": false } } enhanced-resolve-5.15.0/test/forEachBail.test.js000066400000000000000000000026331444210260000214530ustar00rootroot00000000000000const { forEachBail } = require("../"); describe("forEachBail", () => { it("should iterate correctly", done => { const log = []; forEachBail( [0, 1, 2, 3, 4, 5, 6], (value, callback) => { log.push(value); if (value % 4 === 0) return callback(null, undefined); if (value % 2 === 0) return callback(); if (value === 5) return callback(null, { path: "test" }); process.nextTick(callback); }, (err, result) => { if (err) return done(err); if (!result) return done(new Error("Should have result")); expect(result).toEqual({ path: "test" }); expect(log).toEqual([0, 1, 2, 3, 4, 5]); done(); } ); }); it("should handle empty array", done => { forEachBail( [], () => { done(new Error("Should not be called")); }, (err, result) => { expect(err).toBeUndefined(); expect(result).toBeUndefined(); done(); } ); }); it("should sync finish with undefined", done => { forEachBail( [2, 3, 4, 5, 6], (value, callback) => { return callback(); }, (err, result) => { expect(err).toBeUndefined(); expect(result).toBeUndefined(); done(); } ); }); it("should async finish with undefined", done => { forEachBail( [2, 3, 4, 5, 6], (value, callback) => { process.nextTick(callback); }, (err, result) => { expect(err).toBeUndefined(); expect(result).toBeUndefined(); done(); } ); }); }); enhanced-resolve-5.15.0/test/fullSpecified.test.js000066400000000000000000000070141444210260000220700ustar00rootroot00000000000000const { Volume } = require("memfs"); const { ResolverFactory } = require("../"); describe("fullSpecified", function () { const fileSystem = Volume.fromJSON( { "/a/node_modules/package1/index.js": "", "/a/node_modules/package1/file.js": "", "/a/node_modules/package2/package.json": JSON.stringify({ main: "a" }), "/a/node_modules/package2/a.js": "", "/a/node_modules/package3/package.json": JSON.stringify({ main: "dir" }), "/a/node_modules/package3/dir/index.js": "", "/a/node_modules/package4/package.json": JSON.stringify({ browser: { "./a.js": "./b" } }), "/a/node_modules/package4/a.js": "", "/a/node_modules/package4/b.js": "", "/a/abc.js": "", "/a/dir/index.js": "", "/a/index.js": "" }, "/" ); const resolver = ResolverFactory.createResolver({ alias: { alias1: "/a/abc", alias2: "/a/" }, aliasFields: ["browser"], fullySpecified: true, useSyncFileSystemCalls: true, // @ts-ignore fileSystem: fileSystem }); const contextResolver = ResolverFactory.createResolver({ alias: { alias1: "/a/abc", alias2: "/a/" }, aliasFields: ["browser"], fullySpecified: true, resolveToContext: true, useSyncFileSystemCalls: true, // @ts-ignore fileSystem: fileSystem }); const failingResolves = { "no extensions": "./abc", "no extensions (absolute)": "/a/abc", "no extensions in packages": "package1/file", "no directories": ".", "no directories 2": "./", "no directories in packages": "package3/dir", "no extensions in packages 2": "package3/a" }; const pkg = "/a/node_modules/package"; const successfulResolves = { "fully relative": ["./abc.js", "/a/abc.js"], "fully absolute": ["/a/abc.js", "/a/abc.js"], "fully relative in package": ["package1/file.js", `${pkg}1/file.js`], "extensions in mainFiles": ["package1", `${pkg}1/index.js`], "extensions in mainFields": ["package2", `${pkg}2/a.js`], "extensions in alias": ["alias1", `/a/abc.js`], "directories in alias": ["alias2", `/a/index.js`], "directories in packages": ["package3", `${pkg}3/dir/index.js`], "extensions in aliasFields": ["package4/a.js", `${pkg}4/b.js`] }; for (const key of Object.keys(failingResolves)) { const request = failingResolves[key]; it(`should fail resolving ${key}`, () => { expect(() => { resolver.resolveSync({}, "/a", request); }).toThrowError(); }); } for (const key of Object.keys(successfulResolves)) { const [request, expected] = successfulResolves[key]; it(`should resolve ${key} successfully`, () => { try { expect(resolver.resolveSync({}, "/a", request)).toEqual(expected); } catch (e) { e.message += `\n${e.details}`; throw e; } }); } const successfulContextResolves = { "current folder": [".", "/a"], "current folder 2": ["./", "/a"], "relative directory": ["./dir", "/a/dir"], "relative directory 2": ["./dir/", "/a/dir"], "relative directory with query and fragment": [ "./dir?123#456", "/a/dir?123#456" ], "relative directory with query and fragment 2": [ "./dir/?123#456", "/a/dir?123#456" ], "absolute directory": ["/a/dir", "/a/dir"], "directory in package": ["package3/dir", `${pkg}3/dir`] }; for (const key of Object.keys(successfulContextResolves)) { const [request, expected] = successfulContextResolves[key]; it(`should resolve ${key} successfully to an context`, () => { try { expect(contextResolver.resolveSync({}, "/a", request)).toEqual( expected ); } catch (e) { e.message += `\n${e.details}`; throw e; } }); } }); enhanced-resolve-5.15.0/test/getPaths.test.js000066400000000000000000000012141444210260000210650ustar00rootroot00000000000000const getPaths = require("../lib/getPaths"); /** * @type {[string,{paths: string[], segments: string[]}][]} */ const cases = [ ["/a", { paths: ["/a", "/"], segments: ["a", "/"] }], ["/a/", { paths: ["/a/", "/a", "/"], segments: ["", "a", "/"] }], ["/a/b", { paths: ["/a/b", "/a", "/"], segments: ["b", "a", "/"] }], [ "/a/b/", { paths: ["/a/b/", "/a/b", "/a", "/"], segments: ["", "b", "a", "/"] } ], ["/", { paths: ["/"], segments: [""] }] ]; cases.forEach(case_ => { it(case_[0], () => { const { paths, segments } = getPaths(case_[0]); expect(paths).toEqual(case_[1].paths); expect(segments).toEqual(case_[1].segments); }); }); enhanced-resolve-5.15.0/test/identifier.test.js000066400000000000000000000033461444210260000214400ustar00rootroot00000000000000const { parseIdentifier } = require("../lib/util/identifier"); /** * @typedef {{input: string, expected: [string, string, string]}} TestSuite */ /** * @param {TestSuite[]} suites suites */ function run(suites) { suites.forEach(({ input, expected }) => { it(input, () => { const parsed = parseIdentifier(input); if (!parsed) throw new Error("should not be null"); expect(parsed).toEqual(expected); }); }); } describe("parse identifier. edge cases", () => { /** @type {TestSuite[]} */ const tests = [ { input: "path/#", expected: ["path/", "", "#"] }, { input: "path/as/?", expected: ["path/as/", "?", ""] }, { input: "path/#/?", expected: ["path/", "", "#/?"] }, { input: "path/#repo#hash", expected: ["path/", "", "#repo#hash"] }, { input: "path/#r#hash", expected: ["path/", "", "#r#hash"] }, { input: "path/#repo/#repo2#hash", expected: ["path/", "", "#repo/#repo2#hash"] }, { input: "path/#r/#r#hash", expected: ["path/", "", "#r/#r#hash"] }, { input: "path/#/not/a/hash?not-a-query", expected: ["path/", "", "#/not/a/hash?not-a-query"] } ]; run(tests); }); describe("parse identifier. Windows-like paths", () => { /** @type {TestSuite[]} */ const tests = [ { input: "path\\#", expected: ["path\\", "", "#"] }, { input: "C:path\\as\\?", expected: ["C:path\\as\\", "?", ""] }, { input: "path\\#\\?", expected: ["path\\", "", "#\\?"] }, { input: "path\\#repo#hash", expected: ["path\\", "", "#repo#hash"] }, { input: "path\\#r#hash", expected: ["path\\", "", "#r#hash"] }, { input: "path\\#/not/a/hash?not-a-query", expected: ["path\\", "", "#/not/a/hash?not-a-query"] } ]; run(tests); }); enhanced-resolve-5.15.0/test/importsField.test.js000066400000000000000000000610561444210260000217610ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { processImportsField } = require("../lib/util/entrypoints"); const ResolverFactory = require("../lib/ResolverFactory"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); /** @typedef {import("../lib/util/entrypoints").ImportsField} ImportsField */ const fixture = path.resolve(__dirname, "fixtures", "imports-field"); describe("Process imports field", function exportsField() { /** @type {Array<{name: string, expect: string[]|Error, suite: [ImportsField, string, string[]]}>} */ const testCases = [ //#region Samples { name: "sample #1", expect: ["./dist/test/file.js", "./src/test/file.js"], suite: [ { "#abc/": { import: ["./dist/", "./src/"], webpack: "./wp/" }, "#abc": "./main.js" }, "#abc/test/file.js", ["import", "webpack"] ] }, { name: "sample #2", expect: ["./data/timezones/pdt.mjs"], suite: [ { "#1/timezones/": "./data/timezones/" }, "#1/timezones/pdt.mjs", [] ] }, { name: "sample #3", // mapping works like concatenating strings not file paths expect: ["./data/timezones/timezones/pdt.mjs"], suite: [ { "#aaa/": "./data/timezones/", "#a/": "./data/timezones/" }, "#a/timezones/pdt.mjs", [] ] }, { name: "sample #4", expect: [], suite: [ { "#a/lib/": { browser: ["./browser/"] }, "#a/dist/index.js": { node: "./index.js" } }, "#a/dist/index.js", ["browser"] ] }, { name: "sample #5", expect: ["./browser/index.js"], // default condition used suite: [ { "#a/lib/": { browser: ["./browser/"] }, "#a/dist/index.js": { node: "./index.js", default: "./browser/index.js" } }, "#a/dist/index.js", ["browser"] ] }, { name: "sample #6", expect: [], suite: [ { "#a/dist/a": "./dist/index.js" }, "#a/dist/aaa", [] ] }, { name: "sample #7", expect: [], suite: [ { "#a/a/a/": "./dist/index.js" }, "#a/a/a", [] ] }, { name: "sample #8", expect: [], suite: [ { "#a": "./index.js" }, "#a/timezones/pdt.mjs", [] ] }, { name: "sample #9", expect: ["./main.js"], suite: [ { "#a/index.js": "./main.js" }, "#a/index.js", [] ] }, { name: "sample #10", expect: ["./ok.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/#foo", [] ] }, { name: "sample #11", expect: ["./ok.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/bar#foo", [] ] }, { name: "sample #12", expect: ["./ok.js#abc"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/#zapp/ok.js#abc", [] ] }, { name: "sample #13", expect: ["./ok.js?abc"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/#zapp/ok.js?abc", [] ] }, { name: "sample #14", expect: ["./šŸŽ‰.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/#zapp/šŸŽ‰.js", [] ] }, { name: "sample #15", expect: ["./%F0%9F%8E%89.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, // "šŸŽ‰" percent encoded "#a/#zapp/%F0%9F%8E%89.js", [] ] }, { name: "sample #16", expect: ["./ok.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/šŸŽ‰", [] ] }, { name: "sample #17", expect: ["./other.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/%F0%9F%8E%89", [] ] }, { name: "sample #18", expect: ["./ok.js"], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/module", [] ] }, { name: "sample #19", expect: [], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/module#foo", [] ] }, { name: "sample #20", expect: [], suite: [ { "#a/#foo": "./ok.js", "#a/module": "./ok.js", "#a/šŸŽ‰": "./ok.js", "#a/%F0%9F%8E%89": "./other.js", "#a/bar#foo": "./ok.js", "#a/#zapp/": "./" }, "#a/module?foo", [] ] }, { name: "sample #21", expect: ["./d?e?f"], suite: [ { "#a/a?b?c/": "./" }, "#a/a?b?c/d?e?f", [] ] }, { name: "sample #22", expect: ["/user/a/index"], suite: [ { "#a/": "/user/a/" }, "#a/index", [] ] }, { name: "path tree edge case #1", expect: ["./A/b/d.js"], suite: [ { "#a/": "./A/", "#a/b/c": "./c.js" }, "#a/b/d.js", [] ] }, { name: "path tree edge case #2", expect: ["./A/c.js"], suite: [ { "#a/": "./A/", "#a/b": "./b.js" }, "#a/c.js", [] ] }, { name: "path tree edge case #3", expect: ["./A/b/c/d.js"], suite: [ { "#a/": "./A/", "#a/b/c/d": "./c.js" }, "#a/b/c/d.js", [] ] }, //#endregion //#region Direct mapping { name: "Direct mapping #1", expect: ["./dist/index.js"], suite: [ { "#a": "./dist/index.js" }, "#a", [] ] }, { name: "Direct mapping #2", expect: [], suite: [ { "#a/": "./" }, "#a", [] ] }, { name: "Direct mapping #3", expect: ["./dist/a.js"], // direct mapping is more prioritize suite: [ { "#a/": "./dist/", "#a/index.js": "./dist/a.js" }, "#a/index.js", [] ] }, { name: "Direct mapping #4", expect: ["./index.js"], // direct mapping is more prioritize suite: [ { "#a/": { browser: ["./browser/"] }, "#a/index.js": { browser: "./index.js" } }, "#a/index.js", ["browser"] ] }, { name: "Direct mapping #5", // direct mapping is more prioritize, // so there is no match expect: [], suite: [ { "#a/": { browser: ["./browser/"] }, "#a/index.js": { node: "./node.js" } }, "#a/index.js", ["browser"] ] }, { name: "Direct mapping #6", expect: ["./index.js"], suite: [ { "#a": { browser: "./index.js", node: "./src/node/index.js", default: "./src/index.js" } }, "#a", ["browser"] ] }, { name: "Direct mapping #7", expect: new Error(), // Default is first one suite: [ { "#a": { default: "./src/index.js", browser: "./index.js", node: "./src/node/index.js" } }, "#a", ["browser"] ] }, { name: "Direct mapping #8", expect: ["./src/index.js"], suite: [ { "#a": { browser: "./index.js", node: "./src/node/index.js", default: "./src/index.js" } }, "#a", [] ] }, { name: "Direct mapping #9", expect: ["./index"], // it is fine, file may not have extension suite: [ { "#a": "./index" }, "#a", [] ] }, { name: "Direct mapping #10", expect: ["./index.js"], suite: [ { "#a/index": "./index.js" }, "#a/index", [] ] }, { name: "Direct mapping #11", expect: ["b"], suite: [ { "#a": "b" }, "#a", [] ] }, { name: "Direct mapping #12", expect: ["b/index"], suite: [ { "#a/": "b/" }, "#a/index", [] ] }, { name: "Direct mapping #13", expect: ["b#anotherhashishere"], suite: [ { "#a?q=a#hashishere": "b#anotherhashishere" }, "#a?q=a#hashishere", [] ] }, //#endregion //#region Direct and conditional mapping { name: "Direct and conditional mapping #1", expect: [], suite: [ { "#a": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, "#a", [] ] }, { name: "Direct and conditional mapping #2", expect: ["./import.mjs"], suite: [ { "#a": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, "#a", ["import"] ] }, { name: "Direct and conditional mapping #3", expect: ["./require.js", "./import.mjs"], suite: [ { "#a": [ { browser: "./browser.js" }, { require: "./require.js" }, { import: "./import.mjs" } ] }, "#a", ["import", "require"] ] }, { name: "Direct and conditional mapping #4", expect: ["./require.js", "./import.mjs", "#b/import.js"], suite: [ { "#a": [ { browser: "./browser.js" }, { require: ["./require.js"] }, { import: ["./import.mjs", "#b/import.js"] } ] }, "#a", ["import", "require"] ] }, //#endregion //#region When mapping to a folder root, both the left and right sides must end in slashes { name: "mapping to a folder root #1", expect: [], suite: [ { "#timezones": "./data/timezones/" }, "#timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #2", expect: new Error(), // incorrect export field suite: [ { "#timezones/": "./data/timezones" }, "#timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #3", expect: ["./data/timezones/pdt/index.mjs"], suite: [ { "#timezones/pdt/": "./data/timezones/pdt/" }, "#timezones/pdt/index.mjs", [] ] }, { name: "mapping to a folder root #4", expect: ["./timezones/pdt.mjs"], suite: [ { "#a/": "./timezones/" }, "#a/pdt.mjs", [] ] }, { name: "mapping to a folder root #5", expect: ["./timezones/pdt.mjs"], suite: [ { "#a/": "./" }, "#a/timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #6", expect: new Error(), // not a folder mapping suite: [ { "#a/": "." }, "#a/timezones/pdt.mjs", [] ] }, { name: "mapping to a folder root #7", expect: [], // incorrect export field, but value did not processed suite: [ { "#a": "./" }, "#a/timezones/pdt.mjs", [] ] }, //#endregion //#region The longest matching path prefix is prioritized { name: "the longest matching path prefix is prioritized #1", // it does not work same as conditional mapping, // so there is no match for ./dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "#a/": "./", "#a/dist/": "./lib/" }, "#a/dist/index.mjs", [] ] }, { name: "the longest matching path prefix is prioritized #2", expect: ["./dist/utils/index.js"], suite: [ { "#a/dist/utils/": "./dist/utils/", "#a/dist/": "./lib/" }, "#a/dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #3", // direct mapping is prioritize // it does not work same as conditional mapping, // so there is no match for ./dist/utils/index.mjs expect: ["./dist/utils/index.js"], suite: [ { "#a/dist/utils/index.js": "./dist/utils/index.js", "#a/dist/utils/": "./dist/utils/index.mjs", "#a/dist/": "./lib/" }, "#a/dist/utils/index.js", [] ] }, { name: "the longest matching path prefix is prioritized #4", // it does not work same as conditional mapping, // even if right side is a conditional mapping, // so there is no match for ./browser/dist/index.mjs expect: ["./lib/index.mjs"], suite: [ { "#a/": { browser: "./browser/" }, "#a/dist/": "./lib/" }, "#a/dist/index.mjs", ["browser"] ] }, //#endregion //#region Conditional mapping folder { name: "conditional mapping folder #1", expect: ["lodash/index.js", "./utils/index.js"], suite: [ { "#a/": { browser: ["lodash/", "./utils/"], node: ["./utils-node/"] } }, "#a/index.js", ["browser"] ] }, { name: "conditional mapping folder #2", expect: [], // no condition names suite: [ { "#a/": { webpack: "./wpk/", browser: ["lodash/", "./utils/"], node: ["./node/"] } }, "#a/index.mjs", [] ] }, { name: "conditional mapping folder #3", expect: ["./wpk/index.mjs"], suite: [ { "#a/": { webpack: "./wpk/", browser: ["lodash/", "./utils/"], node: ["./utils/"] } }, "#a/index.mjs", ["browser", "webpack"] ] }, //#endregion //#region Incorrect imports field definition { name: "incorrect exports field #1", expect: new Error(), suite: [ { "/utils/": "./a/" }, "#a/index.mjs", [] ] }, { name: "incorrect exports field #2", expect: new Error(), suite: [ { "/utils/": { browser: "./a/", default: "./b/" } }, "#a/index.mjs", ["browser"] ] }, { name: "incorrect exports field #3", expect: [], suite: [ { "#a/index": "./a/index.js" }, "#a/index.mjs", [] ] }, { name: "incorrect exports field #4", expect: [], suite: [ { "#a/index.mjs": "./a/index.js" }, "#a/index", [] ] }, { name: "incorrect exports field #5", expect: [], suite: [ { "#a/index": { browser: "./a/index.js", default: "./b/index.js" } }, "#a/index.mjs", ["browser"] ] }, { name: "incorrect exports field #6", expect: [], suite: [ { "#a/index.mjs": { browser: "./a/index.js", default: "./b/index.js" } }, "#a/index", ["browser"] ] }, //#endregion //#region Incorrect request { name: "incorrect request #1", expect: new Error(), suite: [ { "#a/": "./a/" }, "/utils/index.mjs", [] ] }, { name: "incorrect request #2", expect: new Error(), suite: [ { "#a/": { browser: "./a/", default: "./b/" } }, "./utils/index.mjs", ["browser"] ] }, { name: "incorrect request #3", expect: new Error(), suite: [ { "#a/": { browser: "./a/", default: "./b/" } }, "#", ["browser"] ] }, { name: "incorrect request #4", expect: new Error(), suite: [ { "#a/": { browser: "./a/", default: "./b/" } }, "#/", ["browser"] ] }, { name: "incorrect request #5", expect: new Error(), suite: [ { "#a/": { browser: "./a/", default: "./b/" } }, "#a/", ["browser"] ] }, //#endregion //#region Directory imports targets may backtrack above the package base { name: "backtracking package base #1", expect: ["./dist/index"], // we don't handle backtracking here suite: [ { "#a/../../utils/": "./dist/" }, "#a/../../utils/index", [] ] }, { name: "backtracking package base #2", expect: ["./dist/../../utils/index"], suite: [ { "#a/": "./dist/" }, "#a/../../utils/index", [] ] }, { name: "backtracking package base #3", expect: ["../src/index"], suite: [ { "#a/": "../src/" }, "#a/index", [] ] }, { name: "backtracking package base #4", expect: ["./utils/../../../index"], suite: [ { "#a/": { browser: "./utils/../../../" } }, "#a/index", ["browser"] ] }, //#endregion //#region Imports targets cannot map into a nested node_modules path { name: "nested node_modules path #1", expect: ["moment/node_modules/lodash/dist/index.js"], // we don't handle node_modules here suite: [ { "#a/": { browser: "moment/node_modules/" } }, "#a/lodash/dist/index.js", ["browser"] ] }, { name: "nested node_modules path #2", expect: ["../node_modules/lodash/dist/index.js"], suite: [ { "#a/": "../node_modules/" }, "#a/lodash/dist/index.js", [] ] }, //#endregion //#region Nested mapping { name: "nested mapping #1", expect: [], suite: [ { "#a/": { browser: { webpack: "./", default: { node: "./node/" } } } }, "#a/index.js", ["browser"] ] }, { name: "nested mapping #2", expect: ["./index.js", "./node/index.js"], suite: [ { "#a/": { browser: { webpack: ["./", "./node/"], default: { node: "./node/" } } } }, "#a/index.js", ["browser", "webpack"] ] }, { name: "nested mapping #3", expect: [], // no browser condition name suite: [ { "#a/": { browser: { webpack: ["./", "./node/"], default: { node: "./node/" } } } }, "#a/index.js", ["webpack"] ] }, { name: "nested mapping #4", expect: ["moment/node/index.js"], suite: [ { "#a/": { browser: { webpack: ["./", "./node/"], default: { node: "moment/node/" } } } }, "#a/index.js", ["node", "browser"] ] }, { name: "nested mapping #5", expect: [], suite: [ { "#a/": { browser: { webpack: ["./", "./node/"], default: { node: { webpack: ["./wpck/"] } } } } }, "#a/index.js", ["browser", "node"] ] }, { name: "nested mapping #6", expect: ["./index.js", "./node/index.js"], suite: [ { "#a/": { browser: { webpack: ["./", "./node/"], default: { node: { webpack: ["./wpck/"] } } } } }, "#a/index.js", ["browser", "node", "webpack"] ] }, { name: "nested mapping #7", expect: ["./y.js"], suite: [ { "#a": { abc: { def: "./x.js" }, ghi: "./y.js" } }, "#a", ["abc", "ghi"] ] }, { name: "nested mapping #8", expect: [], suite: [ { "#a": { abc: { def: "./x.js", default: [] }, ghi: "./y.js" } }, "#a", ["abc", "ghi"] ] } //#endregion ]; testCases.forEach(testCase => { it(testCase.name, () => { if (testCase.expect instanceof Error) { expect(() => processImportsField(testCase.suite[0])( testCase.suite[1], new Set(testCase.suite[2]) ) ).toThrowError(); } else { expect( processImportsField(testCase.suite[0])( testCase.suite[1], new Set(testCase.suite[2]) ) ).toEqual(testCase.expect); } }); }); }); describe("ImportsFieldPlugin", () => { const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFiles: ["index.js"], conditionNames: ["webpack"] }); it("should resolve using imports field instead of self-referencing", done => { resolver.resolve({}, fixture, "#imports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "b.js")); done(); }); }); it("should resolve using imports field instead of self-referencing for a subpath", done => { resolver.resolve( {}, path.resolve(fixture, "dir"), "#imports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "b.js")); done(); } ); }); it("should disallow resolve out of package scope", done => { resolver.resolve({}, fixture, "#b", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/Trying to access out of package scope/); done(); }); }); it("field name #1", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFiles: ["index.js"], importsFields: [["imports"]], conditionNames: ["webpack"] }); resolver.resolve({}, fixture, "#imports-field", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "b.js")); done(); }); }); it("field name #2", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFiles: ["index.js"], importsFields: [["other", "imports"], "imports"], conditionNames: ["webpack"] }); resolver.resolve({}, fixture, "#b", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "a.js")); done(); }); }); it("should resolve package #1", done => { resolver.resolve({}, fixture, "#a/dist/main.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/a/lib/lib2/main.js") ); done(); }); }); it("should resolve package #2", done => { resolver.resolve({}, fixture, "#a", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); expect(err.message).toMatch(/is not imported from package/); done(); }); }); it("should resolve package #3", done => { resolver.resolve({}, fixture, "#ccc/index.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "node_modules/c/index.js")); done(); }); }); it("should resolve package #4", done => { resolver.resolve({}, fixture, "#c", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "node_modules/c/index.js")); done(); }); }); it("should resolve absolute path as an imports field target", done => { const tmpdirPrefix = path.join(fixture, "node_modules/absolute-tmp-"); fs.mkdtemp(tmpdirPrefix, (err, dir) => { if (err) done(err); const pjson = path.resolve(dir, "./package.json"); const file = path.resolve(dir, "./index"); fs.writeFileSync(file, ""); fs.writeFileSync(pjson, JSON.stringify({ imports: { "#a": file } })); resolver.resolve({}, dir, "#a", {}, (err, result) => { fs.unlinkSync(file); fs.unlinkSync(pjson); fs.rmdirSync(dir); if (err) return done(err); if (!result) return done(new Error("No result")); console.log(result); expect(result).toEqual(file); done(); }); }); }); it("should log the correct info", done => { const log = []; resolver.resolve( {}, fixture, "#a/dist/index.js", { log: v => log.push(v) }, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.join(fixture, "node_modules/a/lib/index.js") ); expect( log.map(line => line.replace(fixture, "...").replace(/\\/g, "/")) ).toMatchSnapshot(); done(); } ); }); it("should resolve with wildcard pattern", done => { const fixture = path.resolve( __dirname, "./fixtures/imports-exports-wildcard/node_modules/m/" ); resolver.resolve({}, fixture, "#internal/i.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixture, "./src/internal/i.js")); done(); }); }); }); enhanced-resolve-5.15.0/test/incorrect-description-file.test.js000066400000000000000000000033001444210260000245320ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { CachedInputFileSystem, ResolverFactory } = require("../"); const fixtures = path.join(__dirname, "fixtures", "incorrect-package"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); function p() { return path.join.apply( path, [fixtures].concat(Array.prototype.slice.call(arguments)) ); } describe("incorrect description file", () => { const resolver = ResolverFactory.createResolver({ useSyncFileSystemCalls: true, fileSystem: nodeFileSystem }); it("should not resolve main in incorrect description file #1", done => { let called = false; const ctx = { fileDependencies: new Set(), log: () => { called = true; } }; resolver.resolve({}, p("pack1"), ".", ctx, function (err, result) { if (!err) return done(new Error("No error")); expect(err).toBeInstanceOf(Error); expect(ctx.fileDependencies.has(p("pack1", "package.json"))).toEqual( true ); expect(called).toBe(true); done(); }); }); it("should not resolve main in incorrect description file #2", done => { let called = false; const ctx = { fileDependencies: new Set(), log: () => { called = true; } }; resolver.resolve({}, p("pack2"), ".", ctx, function (err, result) { if (!err) return done(new Error("No error")); expect(ctx.fileDependencies.has(p("pack2", "package.json"))).toEqual( true ); expect(called).toBe(true); done(); }); }); it("should not resolve main in incorrect description file #3", done => { resolver.resolve({}, p("pack2"), ".", {}, function (err, result) { if (!err) return done(new Error("No error")); expect(err).toBeInstanceOf(Error); done(); }); }); }); enhanced-resolve-5.15.0/test/missing.test.js000066400000000000000000000051701444210260000207640ustar00rootroot00000000000000const path = require("path"); const resolve = require("../"); describe("missing", function () { /** * @type {Array<[string, string, Array]>} */ const testCases = [ [ path.join(__dirname, "fixtures"), "./missing-file", [ path.join(__dirname, "fixtures", "missing-file"), path.join(__dirname, "fixtures", "missing-file.js"), path.join(__dirname, "fixtures", "missing-file.node") ] ], [ path.join(__dirname, "fixtures"), "missing-module", [ path.join(__dirname, "fixtures", "node_modules", "missing-module"), path.join(__dirname, "..", "node_modules", "missing-module") ] ], [ path.join(__dirname, "fixtures"), "missing-module/missing-file", [ path.join(__dirname, "fixtures", "node_modules", "missing-module"), path.join(__dirname, "..", "node_modules", "missing-module") ] ], [ path.join(__dirname, "fixtures"), "m1/missing-file", [ path.join(__dirname, "fixtures", "node_modules", "m1", "missing-file"), path.join( __dirname, "fixtures", "node_modules", "m1", "missing-file.js" ), path.join( __dirname, "fixtures", "node_modules", "m1", "missing-file.node" ), path.join(__dirname, "..", "node_modules", "m1") ] ], [ path.join(__dirname, "fixtures"), "m1/", [ path.join(__dirname, "fixtures", "node_modules", "m1", "index"), path.join(__dirname, "fixtures", "node_modules", "m1", "index.js"), path.join(__dirname, "fixtures", "node_modules", "m1", "index.json"), path.join(__dirname, "fixtures", "node_modules", "m1", "index.node") ] ], [ path.join(__dirname, "fixtures"), "m1/a", [path.join(__dirname, "fixtures", "node_modules", "m1", "a")] ] ]; testCases.forEach(function (testCase) { it( "should tell about missing file when trying to resolve " + testCase[1], done => { const callback = function (err, filename) { expect(Array.from(missingDependencies).sort()).toEqual( expect.arrayContaining(testCase[2].sort()) ); done(); }; const missingDependencies = new Set(); resolve(testCase[0], testCase[1], { missingDependencies }, callback); } ); it( "should report error details exactly once when trying to resolve " + testCase[1], done => { const callback = function (err, filename) { if (err) { const details = err.details.split("\n"); const firstDetail = details.shift(); expect(firstDetail).toContain(testCase[1]); expect(details).not.toContain(firstDetail); } done(); }; resolve(testCase[0], testCase[1], callback); } ); }); }); enhanced-resolve-5.15.0/test/path.test.js000066400000000000000000000011751444210260000202500ustar00rootroot00000000000000const { checkImportsExportsFieldTarget } = require("../lib/util/path"); describe("checkImportsExportsFieldTarget", () => { /** * @type {string[]} */ const errorCases = [ "../a.js", "../", "./a/b/../../../c.js", "./a/b/../../../", "./../../c.js", "./../../", "./a/../b/../../c.js", "./a/../b/../../", "./././../" ]; errorCases.forEach(case_ => { it(case_, done => { const error = checkImportsExportsFieldTarget(case_); if (!error) return done("expect error"); expect(error).toBeInstanceOf(Error); expect(error.message).toMatch(/Trying to access out of package scope/); done(); }); }); }); enhanced-resolve-5.15.0/test/plugins.test.js000066400000000000000000000030751444210260000207760ustar00rootroot00000000000000"use strict"; const path = require("path"); const { ResolverFactory, CloneBasenamePlugin } = require("../"); describe("plugins", function () { it("should resolve with the CloneBasenamePlugin", done => { const resolver = ResolverFactory.createResolver({ fileSystem: require("fs"), plugins: [ new CloneBasenamePlugin( "after-existing-directory", "undescribed-raw-file" ) ] }); resolver.resolve( {}, __dirname, "./fixtures/directory-default", {}, function (err, result) { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve( __dirname, "fixtures/directory-default/directory-default.js" ) ); done(); } ); }); it("should ignore 'false'/'null'/'undefined' plugins", done => { const FailedPlugin = class { apply() { throw new Error("FailedPlugin"); } }; const falsy = false; const resolver = ResolverFactory.createResolver({ fileSystem: require("fs"), plugins: [ 0, "", false, null, undefined, falsy && new FailedPlugin(), new CloneBasenamePlugin( "after-existing-directory", "undescribed-raw-file" ) ] }); resolver.resolve( {}, __dirname, "./fixtures/directory-default", {}, function (err, result) { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve( __dirname, "fixtures/directory-default/directory-default.js" ) ); done(); } ); }); }); enhanced-resolve-5.15.0/test/pnp.test.js000066400000000000000000000161451444210260000201140ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { ResolverFactory, CachedInputFileSystem } = require("../"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const fixture = path.resolve(__dirname, "fixtures", "pnp"); let isAdmin = false; try { fs.symlinkSync("dir", path.resolve(fixture, "pkg/symlink"), "dir"); isAdmin = true; } catch (e) { // ignore } try { fs.unlinkSync(path.resolve(fixture, "pkg/symlink")); } catch (e) { isAdmin = false; // ignore } describe("pnp", () => { let pnpApi; let resolverFuzzy; let resolver; if (isAdmin) { beforeAll(() => { fs.symlinkSync("dir", path.resolve(fixture, "pkg/symlink"), "dir"); }); afterAll(() => { fs.unlinkSync(path.resolve(fixture, "pkg/symlink")); }); } beforeEach(() => { pnpApi = /** @type {any} */ ({ mocks: new Map(), resolveToUnqualified(request, issuer) { if (pnpApi.mocks.has(request)) { return pnpApi.mocks.get(request); } else { const err = /** @type {any} */ (new Error(`No way`)); err.code = "MODULE_NOT_FOUND"; err.pnpCode = "UNDECLARED_DEPENDENCY"; throw err; } } }); resolverFuzzy = ResolverFactory.createResolver({ extensions: [".ts", ".js"], aliasFields: ["browser"], fileSystem: nodeFileSystem, alias: { alias: path.resolve(fixture, "pkg") }, pnpApi, modules: ["node_modules", path.resolve(fixture, "../pnp-a")] }); resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], fileSystem: nodeFileSystem, fullySpecified: true, alias: { alias: path.resolve(fixture, "pkg") }, pnpApi, modules: [ "alternative-modules", "node_modules", path.resolve(fixture, "../pnp-a") ] }); }); it("should resolve by going through the pnp api", done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); resolver.resolve({}, __dirname, "pkg/dir/index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/dir/index.js")); done(); }); }); it("should not resolve a not fully specified request when fullySpecified is set", done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); resolver.resolve({}, __dirname, "pkg/dir/index", {}, (err, result) => { expect(err).toBeInstanceOf(Error); done(); }); }); it("should track dependency to the pnp api", done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); pnpApi.mocks.set("pnpapi", path.resolve(fixture, ".pnp.js")); const fileDependencies = new Set(); resolver.resolve( {}, __dirname, "pkg/dir/index.js", { fileDependencies }, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/dir/index.js")); expect(Array.from(fileDependencies)).toContainEqual( path.resolve(fixture, ".pnp.js") ); done(); } ); }); it("should resolve module names with package.json", done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); resolver.resolve({}, __dirname, "pkg", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/main.js")); done(); }); }); it("should resolve namespaced module names", done => { pnpApi.mocks.set("@user/pkg", path.resolve(fixture, "pkg")); resolver.resolve({}, __dirname, "@user/pkg", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/main.js")); done(); }); }); it( "should not resolve symlinks", isAdmin ? done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); resolverFuzzy.resolve( {}, __dirname, "pkg/symlink", {}, (err, result) => { if (err) return done(err); expect(result).toEqual( path.resolve(fixture, "pkg/symlink/index.js") ); done(); } ); } : undefined ); it("should properly deal with other extensions", done => { pnpApi.mocks.set("@user/pkg", path.resolve(fixture, "pkg")); resolverFuzzy.resolve( {}, __dirname, "@user/pkg/typescript", {}, (err, result) => { if (err) return done(err); expect(result).toEqual( path.resolve(fixture, "pkg/typescript/index.ts") ); done(); } ); }); it("should properly deal package.json alias", done => { pnpApi.mocks.set("pkg", path.resolve(fixture, "pkg")); resolverFuzzy.resolve( {}, __dirname, "pkg/package-alias", {}, (err, result) => { if (err) return done(err); expect(result).toEqual( path.resolve(fixture, "pkg/package-alias/browser.js") ); done(); } ); }); it("should prefer pnp resolves over normal modules", done => { pnpApi.mocks.set("m1", path.resolve(fixture, "../node_modules/m2")); resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "m1/b.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual( path.resolve(fixture, "../node_modules/m2/b.js") ); done(); } ); }); it("should prefer alternative module directories over pnp", done => { pnpApi.mocks.set("m1", path.resolve(fixture, "../node_modules/m2")); resolver.resolve( {}, path.resolve(__dirname, "fixtures/prefer-pnp"), "m1/b.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual( path.resolve( __dirname, "fixtures/prefer-pnp/alternative-modules/m1/b.js" ) ); done(); } ); }); it("should prefer alias over pnp resolves", done => { pnpApi.mocks.set("alias", path.resolve(fixture, "pkg/dir")); resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "alias/index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/index.js")); done(); } ); }); it("should prefer pnp over modules after node_modules", done => { pnpApi.mocks.set("m2", path.resolve(fixture, "pkg")); resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "m2/index.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg/index.js")); done(); } ); }); it("should fallback to alternatives when pnp resolving fails", done => { resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "m2/a.js", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "../pnp-a/m2/a.js")); done(); } ); }); it("should handle the exports field when using PnP", done => { pnpApi.mocks.set("m1", path.resolve(fixture, "pkg3")); resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "m1", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg3/a.js")); done(); } ); }); it("should handle the exports field when using PnP (with sub path)", done => { pnpApi.mocks.set("@user/m1", path.resolve(fixture, "pkg3")); resolver.resolve( {}, path.resolve(__dirname, "fixtures"), "@user/m1/x", {}, (err, result) => { if (err) return done(err); expect(result).toEqual(path.resolve(fixture, "pkg3/a.js")); done(); } ); }); }); enhanced-resolve-5.15.0/test/pr-53.test.js000066400000000000000000000006571444210260000201660ustar00rootroot00000000000000const { CachedInputFileSystem } = require("../"); describe("pr-53", () => { it("should allow to readJsonSync in CachedInputFileSystem", () => { var cfs = new CachedInputFileSystem( { readFileSync: function (path) { return JSON.stringify("abc" + path); } }, 1000 ); if (!cfs.readJsonSync) throw new Error("readJsonSync must be available"); expect(cfs.readJsonSync("xyz")).toEqual("abcxyz"); }); }); enhanced-resolve-5.15.0/test/resolve.test.js000066400000000000000000000173141444210260000207750ustar00rootroot00000000000000const path = require("path"); const resolve = require("../"); const fixtures = path.join(__dirname, "fixtures"); const asyncContextResolve = resolve.create({ extensions: [".js", ".json", ".node"], resolveToContext: true }); const syncContextResolve = resolve.create.sync({ extensions: [".js", ".json", ".node"], resolveToContext: true }); const issue238Resolve = resolve.create({ extensions: [".js", ".jsx", ".ts", ".tsx"], modules: ["src/a", "src/b", "src/common", "node_modules"] }); const preferRelativeResolve = resolve.create({ preferRelative: true }); function testResolve(name, context, moduleName, result) { describe(name, () => { it("should resolve sync correctly", () => { const filename = resolve.sync(context, moduleName); expect(filename).toBeDefined(); expect(filename).toEqual(result); }); it("should resolve async correctly", function (done) { resolve(context, moduleName, function (err, filename) { if (err) return done(err); expect(filename).toBeDefined(); expect(filename).toEqual(result); done(); }); }); }); } function testResolveContext(name, context, moduleName, result) { describe(name, () => { it("should resolve async correctly", function (done) { asyncContextResolve(context, moduleName, function (err, filename) { if (err) done(err); expect(filename).toBeDefined(); expect(filename).toEqual(result); done(); }); }); it("should resolve sync correctly", () => { const filename = syncContextResolve(context, moduleName); expect(filename).toBeDefined(); expect(filename).toEqual(result); }); }); } describe("resolve", () => { testResolve( "absolute path", fixtures, path.join(fixtures, "main1.js"), path.join(fixtures, "main1.js") ); testResolve( "file with .js", fixtures, "./main1.js", path.join(fixtures, "main1.js") ); testResolve( "file without extension", fixtures, "./main1", path.join(fixtures, "main1.js") ); testResolve( "another file with .js", fixtures, "./a.js", path.join(fixtures, "a.js") ); testResolve( "another file without extension", fixtures, "./a", path.join(fixtures, "a.js") ); testResolve( "file in module with .js", fixtures, "m1/a.js", path.join(fixtures, "node_modules", "m1", "a.js") ); testResolve( "file in module without extension", fixtures, "m1/a", path.join(fixtures, "node_modules", "m1", "a.js") ); testResolve( "another file in module without extension", fixtures, "complexm/step1", path.join(fixtures, "node_modules", "complexm", "step1.js") ); testResolve( "from submodule to file in sibling module", path.join(fixtures, "node_modules", "complexm"), "m2/b.js", path.join(fixtures, "node_modules", "m2", "b.js") ); testResolve( "from submodule to file in sibling of parent module", path.join(fixtures, "node_modules", "complexm", "web_modules", "m1"), "m2/b.js", path.join(fixtures, "node_modules", "m2", "b.js") ); testResolve( "from nested directory to overwritten file in module", path.join(fixtures, "multiple_modules"), "m1/a.js", path.join(fixtures, "multiple_modules", "node_modules", "m1", "a.js") ); testResolve( "from nested directory to not overwritten file in module", path.join(fixtures, "multiple_modules"), "m1/b.js", path.join(fixtures, "node_modules", "m1", "b.js") ); testResolve( "file with query", fixtures, "./main1.js?query", path.join(fixtures, "main1.js") + "?query" ); testResolve( "file with fragment", fixtures, "./main1.js#fragment", path.join(fixtures, "main1.js") + "#fragment" ); testResolve( "file with fragment and query", fixtures, "./main1.js#fragment?query", path.join(fixtures, "main1.js") + "#fragment?query" ); testResolve( "file with query and fragment", fixtures, "./main1.js?#fragment", path.join(fixtures, "main1.js") + "?#fragment" ); testResolve( "file in module with query", fixtures, "m1/a?query", path.join(fixtures, "node_modules", "m1", "a.js") + "?query" ); testResolve( "file in module with fragment", fixtures, "m1/a#fragment", path.join(fixtures, "node_modules", "m1", "a.js") + "#fragment" ); testResolve( "file in module with fragment and query", fixtures, "m1/a#fragment?query", path.join(fixtures, "node_modules", "m1", "a.js") + "#fragment?query" ); testResolve( "file in module with query and fragment", fixtures, "m1/a?#fragment", path.join(fixtures, "node_modules", "m1", "a.js") + "?#fragment" ); testResolveContext("context for fixtures", fixtures, "./", fixtures); testResolveContext( "context for fixtures/lib", fixtures, "./lib", path.join(fixtures, "lib") ); testResolveContext( "context for fixtures with ..", fixtures, "./lib/../../fixtures/./lib/..", fixtures ); testResolveContext( "context for fixtures with query", fixtures, "./?query", fixtures + "?query" ); testResolve( "differ between directory and file, resolve file", fixtures, "./dirOrFile", path.join(fixtures, "dirOrFile.js") ); testResolve( "differ between directory and file, resolve directory", fixtures, "./dirOrFile/", path.join(fixtures, "dirOrFile", "index.js") ); testResolve( "find node_modules outside of node_modules", path.join(fixtures, "browser-module", "node_modules"), "m1/a", path.join(fixtures, "node_modules", "m1", "a.js") ); testResolve( "don't crash on main field pointing to self", fixtures, "./main-field-self", path.join(fixtures, "main-field-self", "index.js") ); testResolve( "don't crash on main field pointing to self", fixtures, "./main-field-self2", path.join(fixtures, "main-field-self2", "index.js") ); testResolve( "handle fragment edge case (no fragment)", fixtures, "./no#fragment/#/#", path.join(fixtures, "no\0#fragment/\0#", "\0#.js") ); testResolve( "handle fragment edge case (fragment)", fixtures, "./no#fragment/#/", path.join(fixtures, "no.js") + "#fragment/#/" ); testResolve( "handle fragment escaping", fixtures, "./no\0#fragment/\0#/\0##fragment", path.join(fixtures, "no\0#fragment/\0#", "\0#.js") + "#fragment" ); it("should correctly resolve", function (done) { const issue238 = path.resolve(fixtures, "issue-238"); issue238Resolve( path.resolve(issue238, "./src/common"), "config/myObjectFile", function (err, filename) { if (err) done(err); expect(filename).toBeDefined(); expect(filename).toEqual( path.resolve(issue238, "./src/common/config/myObjectFile.js") ); done(); } ); }); it("should correctly resolve with preferRelative", function (done) { preferRelativeResolve(fixtures, "main1.js", function (err, filename) { if (err) done(err); expect(filename).toBeDefined(); expect(filename).toEqual(path.join(fixtures, "main1.js")); done(); }); }); it("should correctly resolve with preferRelative", function (done) { preferRelativeResolve(fixtures, "m1/a.js", function (err, filename) { if (err) done(err); expect(filename).toBeDefined(); expect(filename).toEqual( path.join(fixtures, "node_modules", "m1", "a.js") ); done(); }); }); it("should not crash when passing undefined as path", done => { // @ts-expect-error testing invalid arguments resolve(fixtures, undefined, err => { expect(err).toBeInstanceOf(Error); done(); }); }); it("should not crash when passing undefined as context", done => { // @ts-expect-error testing invalid arguments resolve({}, undefined, "./test/resolve.js", err => { expect(err).toBeInstanceOf(Error); done(); }); }); it("should not crash when passing undefined everywhere", done => { // @ts-expect-error testing invalid arguments resolve(undefined, undefined, undefined, undefined, err => { expect(err).toBeInstanceOf(Error); done(); }); }); }); enhanced-resolve-5.15.0/test/restrictions.test.js000066400000000000000000000055711444210260000220500ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const ResolverFactory = require("../lib/ResolverFactory"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); const fixture = path.resolve(__dirname, "fixtures", "restrictions"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); describe("restrictions", () => { it("should respect RegExp restriction", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, restrictions: [/\.(sass|scss|css)$/] }); resolver.resolve({}, fixture, "pck1", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); done(); }); }); it("should try to find alternative #1", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js", ".css"], fileSystem: nodeFileSystem, mainFiles: ["index"], restrictions: [/\.(sass|scss|css)$/] }); resolver.resolve({}, fixture, "pck1", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/pck1/index.css") ); done(); }); }); it("should respect string restriction", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, restrictions: [fixture] }); resolver.resolve({}, fixture, "pck2", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); done(); }); }); it("should try to find alternative #2", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFields: ["main", "style"], restrictions: [fixture, /\.(sass|scss|css)$/] }); resolver.resolve({}, fixture, "pck2", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/pck2/index.css") ); done(); }); }); it("should try to find alternative #3", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], fileSystem: nodeFileSystem, mainFields: ["main", "module", "style"], restrictions: [fixture, /\.(sass|scss|css)$/] }); const log = []; resolver.resolve( {}, fixture, "pck2", { log: log.push.bind(log) }, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "node_modules/pck2/index.css") ); expect( log.map(line => line .replace(path.resolve(__dirname, ".."), "...") .replace(path.resolve(__dirname, ".."), "...") .replace(/\\/g, "/") ) ).toMatchSnapshot(); done(); } ); }); }); enhanced-resolve-5.15.0/test/roots.test.js000066400000000000000000000066151444210260000204660ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const ResolverFactory = require("../lib/ResolverFactory"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); describe("roots", () => { const fixtures = path.resolve(__dirname, "fixtures"); const fileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ extensions: [".js"], alias: { foo: "/fixtures" }, roots: [__dirname, fixtures], fileSystem }); const resolverPreferAbsolute = ResolverFactory.createResolver({ extensions: [".js"], alias: { foo: "/fixtures" }, roots: [__dirname, fixtures], fileSystem, preferAbsolute: true, plugins: [ { apply(resolver) { resolver.hooks.file.tap("Test", request => { if (/test.fixtures.*test.fixtures/.test(request.path)) throw new Error("Simulate a fatal error in root path"); }); } } ] }); const contextResolver = ResolverFactory.createResolver({ roots: [__dirname], fileSystem, resolveToContext: true }); it("should respect roots option", done => { resolver.resolve({}, fixtures, "/fixtures/b.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "b.js")); done(); }); }); it("should try another root option, if it exists", done => { resolver.resolve({}, fixtures, "/b.js", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "b.js")); done(); }); }); it("should respect extension", done => { resolver.resolve({}, fixtures, "/fixtures/b", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "b.js")); done(); }); }); it("should resolve in directory", done => { resolver.resolve( {}, fixtures, "/fixtures/extensions/dir", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixtures, "extensions/dir/index.js") ); done(); } ); }); it("should respect aliases", done => { resolver.resolve({}, fixtures, "foo/b", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "b.js")); done(); }); }); it("should support roots options with resolveToContext", done => { contextResolver.resolve( {}, fixtures, "/fixtures/lib", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "lib")); done(); } ); }); it("should not work with relative path", done => { resolver.resolve({}, fixtures, "fixtures/b.js", {}, (err, result) => { if (!err) return done(new Error(`expect error, got ${result}`)); expect(err).toBeInstanceOf(Error); done(); }); }); it("should resolve an absolute path (prefer absolute)", done => { resolverPreferAbsolute.resolve( {}, fixtures, path.join(fixtures, "b.js"), {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual(path.resolve(fixtures, "b.js")); done(); } ); }); }); enhanced-resolve-5.15.0/test/scoped-packages.test.js000066400000000000000000000025141444210260000223430ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { CachedInputFileSystem, ResolverFactory } = require("../"); const fixture = path.join(__dirname, "fixtures", "scoped"); const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const resolver = ResolverFactory.createResolver({ aliasFields: ["browser"], fileSystem: nodeFileSystem }); describe("scoped-packages", () => { it("main field should work", done => { resolver.resolve({}, fixture, "@scope/pack1", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/@scope/pack1/main.js") ); done(); }); }); it("browser field should work", done => { resolver.resolve({}, fixture, "@scope/pack2", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/@scope/pack2/main.js") ); done(); }); }); it("folder request should work", done => { resolver.resolve({}, fixture, "@scope/pack2/lib", {}, (err, result) => { if (err) return done(err); if (!result) return done(new Error("No result")); expect(result).toEqual( path.resolve(fixture, "./node_modules/@scope/pack2/lib/index.js") ); done(); }); }); }); enhanced-resolve-5.15.0/test/simple.test.js000066400000000000000000000021271444210260000206030ustar00rootroot00000000000000const path = require("path"); const resolve = require("../"); describe("simple", () => { const pathsToIt = [ [__dirname, "../lib/index", "direct"], [__dirname, "..", "as directory"], [path.join(__dirname, "..", ".."), "./enhanced-resolve", "as module"], [ path.join(__dirname, "..", ".."), "./enhanced-resolve/lib/index", "in module" ] ]; pathsToIt.forEach(function (pathToIt) { it("should resolve itself " + pathToIt[2], function (done) { resolve(pathToIt[0], pathToIt[1], function (err, filename) { if (err) return done( new Error([err.message, err.stack, err.details].join("\n")) ); expect(filename).toBeDefined(); expect(typeof filename).toEqual("string"); expect(filename).toEqual(path.join(__dirname, "..", "lib", "index.js")); done(); }); }); it("should resolve itself sync " + pathToIt[2], () => { const filename = resolve.sync(pathToIt[0], pathToIt[1]); expect(filename).toBeDefined(); expect(typeof filename).toEqual("string"); expect(filename).toEqual(path.join(__dirname, "..", "lib", "index.js")); }); }); }); enhanced-resolve-5.15.0/test/symlink.test.js000066400000000000000000000144761444210260000210120ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { platform } = require("os"); const resolve = require("../"); const tempPath = path.join(__dirname, "temp"); describe("symlink", () => { let isAdmin = true; try { fs.mkdirSync(tempPath); fs.symlinkSync( path.join(__dirname, "..", "lib", "index.js"), path.join(tempPath, "test"), "file" ); fs.symlinkSync( path.join(__dirname, "..", "lib"), path.join(tempPath, "test2"), "dir" ); } catch (e) { isAdmin = false; } try { fs.unlinkSync(path.join(tempPath, "test")); } catch (e) { isAdmin = false; } try { fs.unlinkSync(path.join(tempPath, "test2")); } catch (e) { isAdmin = false; } try { fs.rmdirSync(tempPath); } catch (e) { isAdmin = false; } if (isAdmin) { // PR #150: Detect Windows and preserve current working directory. const isWindows = platform() === "win32"; const oldCWD = (isWindows && process.cwd()) || ""; beforeEach(() => { // Create some cool symlinks try { fs.mkdirSync(tempPath); fs.symlinkSync( path.join(__dirname, "..", "lib", "index.js"), path.join(tempPath, "index.js"), "file" ); fs.symlinkSync( path.join(__dirname, "..", "lib"), path.join(tempPath, "lib"), "dir" ); fs.symlinkSync( path.join(__dirname, ".."), path.join(tempPath, "this"), "dir" ); fs.symlinkSync( path.join(tempPath, "this"), path.join(tempPath, "that"), "dir" ); fs.symlinkSync( path.join("..", "..", "lib", "index.js"), path.join(tempPath, "node.relative.js"), "file" ); fs.symlinkSync( path.join(".", "node.relative.js"), path.join(tempPath, "node.relative.sym.js"), "file" ); // PR #150: Set the current working directory so that tests will fail if changes get reverted. if (isWindows) { process.chdir(path.join(tempPath, "that")); } } catch (e) { // ignore the failure } }); afterEach(() => { // PR #150: Restore the original working directory. if (isWindows) { process.chdir(oldCWD); } fs.unlinkSync(path.join(tempPath, "index.js")); fs.unlinkSync(path.join(tempPath, "node.relative.js")); fs.unlinkSync(path.join(tempPath, "node.relative.sym.js")); fs.unlinkSync(path.join(tempPath, "lib")); fs.unlinkSync(path.join(tempPath, "this")); fs.unlinkSync(path.join(tempPath, "that")); fs.rmdirSync(tempPath); }); const resolveWithoutSymlinks = resolve.create({ symlinks: false }); const resolveSyncWithoutSymlinks = resolve.create.sync({ symlinks: false }); [ [tempPath, "./index.js", "with a symlink to a file"], [tempPath, "./node.relative.js", "with a relative symlink to a file"], [ tempPath, "./node.relative.sym.js", "with a relative symlink to a symlink to a file" ], [tempPath, "./lib/index.js", "with a symlink to a directory 1"], [tempPath, "./this/lib/index.js", "with a symlink to a directory 2"], [ tempPath, "./this/test/temp/index.js", "with multiple symlinks in the path 1" ], [ tempPath, "./this/test/temp/lib/index.js", "with multiple symlinks in the path 2" ], [ tempPath, "./this/test/temp/this/lib/index.js", "with multiple symlinks in the path 3" ], [ tempPath, "./that/lib/index.js", "with a symlink to a directory 2 (chained)" ], [ tempPath, "./that/test/temp/index.js", "with multiple symlinks in the path 1 (chained)" ], [ tempPath, "./that/test/temp/lib/index.js", "with multiple symlinks in the path 2 (chained)" ], [ tempPath, "./that/test/temp/that/lib/index.js", "with multiple symlinks in the path 3 (chained)" ], [ path.join(tempPath, "lib"), "./index.js", "with symlinked directory as context 1" ], [ path.join(tempPath, "this"), "./lib/index.js", "with symlinked directory as context 2" ], [ path.join(tempPath, "this"), "./test/temp/lib/index.js", "with symlinked directory as context and in path" ], [ path.join(tempPath, "this", "lib"), "./index.js", "with symlinked directory in context path" ], [ path.join(tempPath, "this", "test"), "./temp/index.js", "with symlinked directory in context path and symlinked file" ], [ path.join(tempPath, "this", "test"), "./temp/lib/index.js", "with symlinked directory in context path and symlinked directory" ], [ path.join(tempPath, "that"), "./lib/index.js", "with symlinked directory as context 2 (chained)" ], [ path.join(tempPath, "that"), "./test/temp/lib/index.js", "with symlinked directory as context and in path (chained)" ], [ path.join(tempPath, "that", "lib"), "./index.js", "with symlinked directory in context path (chained)" ], [ path.join(tempPath, "that", "test"), "./temp/index.js", "with symlinked directory in context path and symlinked file (chained)" ], [ path.join(tempPath, "that", "test"), "./temp/lib/index.js", "with symlinked directory in context path and symlinked directory (chained)" ] ].forEach(function (pathToIt) { it("should resolve symlink to itself " + pathToIt[2], function (done) { resolve(pathToIt[0], pathToIt[1], function (err, filename) { if (err) return done(err); expect(filename).toBeDefined(); expect(typeof filename).toBe("string"); expect(filename).toEqual( path.join(__dirname, "..", "lib", "index.js") ); resolveWithoutSymlinks( pathToIt[0], pathToIt[1], function (err, filename) { if (err) return done(err); expect(typeof filename).toBe("string"); expect(filename).toEqual(path.resolve(pathToIt[0], pathToIt[1])); done(); } ); }); }); it("should resolve symlink to itself sync " + pathToIt[2], () => { let filename = resolve.sync(pathToIt[0], pathToIt[1]); expect(filename).toBeDefined(); expect(typeof filename).toBe("string"); expect(filename).toEqual(path.join(__dirname, "..", "lib", "index.js")); filename = resolveSyncWithoutSymlinks(pathToIt[0], pathToIt[1]); expect(typeof filename).toBe("string"); expect(filename).toEqual(path.resolve(pathToIt[0], pathToIt[1])); }); }); } else { it("cannot test symlinks because we have no permission to create them"); } }); enhanced-resolve-5.15.0/test/unsafe-cache.test.js000066400000000000000000000070101444210260000216300ustar00rootroot00000000000000const path = require("path"); const resolve = require("../"); describe("unsafe-cache", () => { let cache; let cachedResolve; let context; let otherContext; beforeEach(() => { context = { some: "context" }; otherContext = { someOther: "context" }; }); describe("with no other options", () => { beforeEach(() => { cache = {}; cachedResolve = resolve.create({ unsafeCache: cache }); }); it("should cache request", done => { cachedResolve( path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(Object.keys(cache)).toHaveLength(1); Object.keys(cache).forEach(function (key) { cache[key] = { path: "yep" }; }); cachedResolve( path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(result).toEqual("yep"); done(); } ); } ); }); it("should not return from cache if context does not match", done => { cachedResolve( context, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(Object.keys(cache)).toHaveLength(1); Object.keys(cache).forEach(function (key) { cache[key] = { path: "yep" }; }); cachedResolve( otherContext, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(result).not.toEqual("yep"); done(); } ); } ); }); it("should not return from cache if query does not match", done => { cachedResolve( path.join(__dirname, "fixtures"), "m2/b?query", function (err, result) { if (err) return done(err); expect(Object.keys(cache)).toHaveLength(1); Object.keys(cache).forEach(function (key) { cache[key] = { path: "yep" }; }); cachedResolve( path.join(__dirname, "fixtures"), "m2/b?query2", function (err, result) { if (err) return done(err); expect(result).not.toEqual("yep"); done(); } ); } ); }); }); describe("with cacheWithContext false", () => { beforeEach(() => { cache = {}; cachedResolve = resolve.create({ unsafeCache: cache, cacheWithContext: false }); }); it("should cache request", done => { cachedResolve( context, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(Object.keys(cache)).toHaveLength(1); Object.keys(cache).forEach(function (key) { cache[key] = { path: "yep" }; }); cachedResolve( context, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(result).toEqual("yep"); done(); } ); } ); }); it("should return from cache even if context does not match", done => { cachedResolve( context, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(Object.keys(cache)).toHaveLength(1); Object.keys(cache).forEach(function (key) { cache[key] = { path: "yep" }; }); cachedResolve( otherContext, path.join(__dirname, "fixtures"), "m2/b", function (err, result) { if (err) return done(err); expect(result).toEqual("yep"); done(); } ); } ); }); }); }); enhanced-resolve-5.15.0/test/yield.test.js000066400000000000000000000361361444210260000204270ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); const { ResolverFactory } = require("../"); const CachedInputFileSystem = require("../lib/CachedInputFileSystem"); /** @typedef {import("../lib/Resolver").ResolveContext} ResolveContext */ /** @typedef {ResolveContext & Required>} StrictResolveContext */ const nodeFileSystem = new CachedInputFileSystem(fs, 4000); const fixtures = path.resolve(__dirname, "fixtures", "yield"); const makeFixturePaths = paths => paths.map(pth => (pth ? path.join(fixtures, pth) : pth)); const contextifyDependencies = paths => Array.from(paths) .filter(pth => pth.startsWith(fixtures)) .map(pth => pth.slice(fixtures.length).split(path.sep).join("/")) .sort(); const beatifyLogs = logs => logs.map(l => { const match = /^(\s+)using description file.+(\(relative path:.+\))$/.exec( l ); if (match) return `${match[1]}using description file ${match[2]}`; while (l.includes(fixtures)) l = l.replace(fixtures, "fixtures"); return l; }); describe("should resolve all aliases", () => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], alias: { index: makeFixturePaths(["/a/foo", "/a/foo-2"]), foo: false }, aliasFields: ["browser"], fileSystem: nodeFileSystem }); const modulesResolver = ResolverFactory.createResolver({ extensions: [".js"], modules: makeFixturePaths(["a", "b"]), fileSystem: nodeFileSystem }); it("should yield all b files", done => { const paths = []; const yield_ = ({ path }) => paths.push(path); const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies }; resolver.resolve({}, fixtures, "index/b", context, (err, result) => { expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual(makeFixturePaths(["/a/foo/b", "/a/foo-2/b"])); expect(contextifyDependencies(fileDependencies)).toEqual([ "", "/a", "/a/foo", "/a/foo-2", "/a/foo-2/b", "/a/foo/b" ]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/a/foo-2/b", "/a/foo-2/b.js", "/a/foo-2/package.json", "/a/foo/b", "/a/foo/b.js", "/a/foo/package.json", "/a/package.json", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); done(); }); }); it("should yield all foo files", done => { const paths = []; const yield_ = ({ path }) => paths.push(path); const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies }; modulesResolver.resolve({}, fixtures, "foo/a", context, (err, result) => { expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual(makeFixturePaths(["/a/foo/a", "/b/foo/a"])); expect(contextifyDependencies(fileDependencies)).toEqual([ "", "/a", "/a/foo", "/a/foo/a", "/b", "/b/foo", "/b/foo/a" ]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/a/foo/a", "/a/foo/a.js", "/a/foo/package.json", "/a/package.json", "/b/foo/a", "/b/foo/a.js", "/b/foo/package.json", "/b/package.json", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); done(); }); }); it("should yield c file", done => { const paths = []; const yield_ = ({ path }) => paths.push(path); /** @type {ResolveContext} */ const context = { yield: yield_ }; resolver.resolve({}, fixtures, "index/c", context, (err, result) => { expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual(makeFixturePaths(["/a/foo-2/c"])); done(); }); }); it("should resolve false alias", done => { const paths = []; const yield_ = ({ path }) => paths.push(path); const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies }; resolver.resolve({}, fixtures, "foo", context, (err, result) => { expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual([false]); expect(contextifyDependencies(fileDependencies)).toEqual([]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/node_modules", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); done(); }); }); it("should return error if no resolve", done => { const paths = []; const yield_ = ({ path }) => paths.push(path); const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies }; resolver.resolve({}, fixtures, "index/unknown", context, (err, result) => { expect(err).not.toEqual(null); expect(err).not.toBeUndefined(); expect(result).toBeUndefined(); expect(paths).toEqual([]); expect(contextifyDependencies(fileDependencies)).toEqual([]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/a/foo-2/package.json", "/a/foo-2/unknown", "/a/foo-2/unknown.js", "/a/foo/package.json", "/a/foo/unknown", "/a/foo/unknown.js", "/a/package.json", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); done(); }); }); describe("resolve alias field", () => { it("should handle false in alias field", done => { const resolver = ResolverFactory.createResolver({ extensions: [".js"], alias: { index: makeFixturePaths(["/c/foo"]) }, aliasFields: ["browser"], fileSystem: nodeFileSystem }); let calls = 0; const paths = []; const logs = []; const yield_ = ({ path }) => { paths.push(path); }; const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies, log: l => logs.push(l) }; resolver.resolve({}, fixtures, "index/a", context, (err, result) => { calls++; expect(calls).toEqual(1); expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual([false]); expect(contextifyDependencies(fileDependencies)).toEqual([ "/c/foo/package.json" ]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/c/foo/a", "/c/foo/a.js", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); expect(beatifyLogs(logs)).toEqual([ "resolve 'index/a' in 'fixtures'", " Parsed request is a module", " using description file (relative path: ./test/fixtures/yield)", ` aliased with mapping 'index': '${["fixtures", "c", "foo"].join( path.sep )}' to '${["fixtures", "c", "foo"].join(path.sep)}/a'`, " using description file (relative path: ./test/fixtures/yield)", " using description file (relative path: ./a)", " .js", ` ${["fixtures", "c", "foo", "a.js"].join( path.sep )} doesn't exist`, " as directory", ` ${["fixtures", "c", "foo", "a"].join( path.sep )} is not a directory` ]); done(); }); }); describe("alias + alias field", () => { const createResolver = aliases => ResolverFactory.createResolver({ extensions: [".js"], alias: { index: makeFixturePaths(aliases) }, aliasFields: ["browser"], fileSystem: nodeFileSystem }); const cLog = [ ` aliased with mapping 'index': '${["fixtures", "c", "foo"].join( path.sep )}' to '${["fixtures", "c", "foo"].join(path.sep)}/a'`, " using description file (relative path: ./test/fixtures/yield)", " using description file (relative path: ./a)", " .js", ` ${["fixtures", "c", "foo", "a.js"].join( path.sep )} doesn't exist`, " as directory", ` ${["fixtures", "c", "foo", "a"].join( path.sep )} is not a directory` ]; const aLog = [ ` aliased with mapping 'index': '${["fixtures", "a", "foo"].join( path.sep )}' to '${["fixtures", "a", "foo"].join(path.sep)}/a'`, " using description file (relative path: ./test/fixtures/yield)", " using description file (relative path: ./test/fixtures/yield/a/foo/a)", " no extension", ` existing file: ${["fixtures", "a", "foo", "a"].join( path.sep )}`, ` reporting result ${["fixtures", "a", "foo", "a"].join( path.sep )}`, " .js", ` ${["fixtures", "a", "foo", "a.js"].join( path.sep )} doesn't exist`, " as directory", ` ${["fixtures", "a", "foo", "a"].join( path.sep )} is not a directory` ]; let resolver; it("default order", done => { resolver = createResolver(["/c/foo", "/a/foo"]); run( done, [false, "/a/foo/a"], [ "resolve 'index/a' in 'fixtures'", " Parsed request is a module", " using description file (relative path: ./test/fixtures/yield)", ...cLog, ...aLog ] ); }); it("reverse order", done => { resolver = createResolver(["/a/foo", "/c/foo"]); run( done, ["/a/foo/a", false], [ "resolve 'index/a' in 'fixtures'", " Parsed request is a module", " using description file (relative path: ./test/fixtures/yield)", ...aLog, ...cLog ] ); }); function run(done, expectedResult, expectedLogs) { let calls = 0; const paths = []; const logs = []; const yield_ = ({ path }) => paths.push(path); const fileDependencies = new Set(); const contextDependencies = new Set(); const missingDependencies = new Set(); /** @type {ResolveContext} */ const context = { yield: yield_, fileDependencies, contextDependencies, missingDependencies, log: l => logs.push(l) }; resolver.resolve({}, fixtures, "index/a", context, (err, result) => { calls++; expect(calls).toEqual(1); expect(err).toEqual(null); expect(result).toBeUndefined(); expect(paths).toEqual(makeFixturePaths(expectedResult)); expect(contextifyDependencies(fileDependencies)).toEqual([ "", "/a", "/a/foo", "/a/foo/a", "/c/foo/package.json" ]); expect(contextifyDependencies(missingDependencies)).toEqual([ "/a/foo/a", "/a/foo/a.js", "/a/foo/package.json", "/a/package.json", "/c/foo/a", "/c/foo/a.js", "/package.json" ]); expect(Array.from(contextDependencies).sort()).toEqual([]); expect(beatifyLogs(logs)).toEqual(expectedLogs); done(); }); } }); describe("custom plugins", () => { const createResolver = plugin => ResolverFactory.createResolver({ extensions: [".js"], plugins: [plugin], fileSystem: nodeFileSystem }); it("should correctly handle resolve in callback", done => { const getResult = request => ({ ...request, path: "/a" }); const resolver = createResolver({ apply(resolver) { resolver .getHook("described-resolve") .tapAsync( "MyResolverPlugin", (request, resolveContext, callback) => { callback(null, getResult(request)); } ); } }); const paths = []; const context = { yield: obj => paths.push(obj.path) }; resolver.resolve({}, fixtures, "unknown", context, (err, result) => { if (err) done(err); expect(err).toBeNull(); expect(result).toBeUndefined(); expect(paths).toEqual(["/a"]); done(); }); }); it("should correctly handle error in callback", done => { const resolver = createResolver({ apply(resolver) { resolver .getHook("described-resolve") .tapAsync("MyResolverPlugin", (_, __, callback) => callback(new Error("error")) ); } }); const paths = []; const context = { yield: obj => paths.push(obj.path) }; resolver.resolve({}, fixtures, "unknown", context, (err, result) => { if (!err) return done(new Error("error expected")); expect(err).not.toBe(null); expect(err.message).toBe("error"); expect(result).toBeUndefined(); expect(paths).toEqual([]); done(); }); }); }); describe("unsafe cache", () => { // same case as in "should yield all b files" it("should return result from cache", done => { const cache = {}; const resolver = ResolverFactory.createResolver({ extensions: [".js"], alias: { index: makeFixturePaths(["/a/foo", "/a/foo-2"]) }, unsafeCache: cache, fileSystem: nodeFileSystem }); resolver.resolve({}, fixtures, "index/b", { yield: () => {} }, err => { if (err) done(err); const paths = []; resolver.resolve( {}, fixtures, "index/b", { yield: obj => paths.push(obj.path) }, (err, result) => { expect(err).toBe(null); expect(result).toBeUndefined(); expect(paths).toEqual( makeFixturePaths(["/a/foo/b", "/a/foo-2/b"]) ); // original + 2 aliases expect(Object.keys(cache)).toHaveLength(3); const cacheId = Object.keys(cache).find(id => { const { request } = JSON.parse(id); return request === "index/b"; }); expect(cacheId).not.toBeUndefined(); expect(Array.isArray(cache[cacheId])).toBe(true); expect(cache[cacheId].map(o => o.path)).toEqual( makeFixturePaths(["/a/foo/b", "/a/foo-2/b"]) ); done(); } ); }); }); // same as "should handle false in alias field" it("should return ignore result from cache", done => { const cache = {}; const resolver = ResolverFactory.createResolver({ extensions: [".js"], alias: { foo: false }, unsafeCache: cache, fileSystem: nodeFileSystem }); resolver.resolve({}, fixtures, "foo", { yield: () => {} }, err => { if (err) done(err); const paths = []; resolver.resolve( {}, fixtures, "foo", { yield: obj => paths.push(obj.path) }, (err, result) => { expect(err).toBe(null); expect(result).toBeUndefined(); expect(paths).toEqual([false]); // original + 0 aliases expect(Object.keys(cache)).toHaveLength(1); const cacheId = Object.keys(cache)[0]; expect(cacheId).not.toBeUndefined(); expect(Array.isArray(cache[cacheId])).toBe(true); expect(cache[cacheId].map(o => o.path)).toEqual([false]); done(); } ); }); }); }); }); }); enhanced-resolve-5.15.0/tooling/000077500000000000000000000000001444210260000164705ustar00rootroot00000000000000enhanced-resolve-5.15.0/tooling/format-file-header.js000066400000000000000000000111641444210260000224640ustar00rootroot00000000000000const path = require("path"); const fs = require("fs"); // When --write is set, files will be written in place // Otherwise it only prints outdated files const doWrite = process.argv.includes("--write"); const allFiles = new Set(); const findFiles = p => { const s = fs.statSync(p); if (s.isDirectory()) { for (const name of fs.readdirSync(p)) { if (name.startsWith(".")) continue; findFiles(path.join(p, name)); } } else if (s.isFile()) { allFiles.add(p); } }; findFiles(path.resolve(__dirname, "../lib")); let canUpdateWithWrite = false; const sortImport = (a, b) => { if (!a.key.startsWith(".") && b.key.startsWith(".")) return -1; if (a.key.startsWith(".") && !b.key.startsWith(".")) return 1; if (a.key < b.key) return -1; if (a.key > b.key) return 1; return 0; }; const execToArray = (content, regexp) => { const items = []; let match = regexp.exec(content); while (match) { items.push({ content: match[0], key: match[1] + match[2] }); match = regexp.exec(content); } return items; }; const schema = [ { title: "license comment", regexp: /\/\*\n\s*MIT License http:\/\/www\.opensource\.org\/licenses\/mit-license\.php\n\s*(?:(Authors? .+)\n)?\s*\*\/\n/g, updateMessage: "update the license comment", update(content, author) { return ( [ "/*", "\tMIT License http://www.opensource.org/licenses/mit-license.php", author && `\t${author}`, "*/" ] .filter(Boolean) .join("\n") + "\n" ); } }, { title: "new line after license comment", regexp: /\n?/g, updateMessage: "insert a new line after the license comment", update() { return "\n"; } }, { title: "strict mode", regexp: /"use strict";\n/g }, { title: "new line after strict mode", regexp: /\n?/g, updateMessage: 'insert a new line after "use strict"', update() { return "\n"; } }, { title: "imports", regexp: /(const (\{\s+\w+(?::\s+\w+)?(,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (\/\*\* @type \{TODO\} \*\/\s\()?require\("[^"]+"\)\)?(\.\w+)*;\n)+\n/g, updateMessage: "sort imports alphabetically", update(content) { const items = execToArray( content, /const (?:\{\s+\w+(?::\s+\w+)?(?:,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (?:\/\*\* @type \{TODO\} \*\/\s\()?require\("([^"]+)"\)\)?((?:\.\w+)*);\n/g ); items.sort(sortImport); return items.map(item => item.content).join("") + "\n"; }, optional: true, repeat: true }, { title: "type imports", regexp: /(\/\*\* (?:@template \w+ )*@typedef \{import\("[^"]+"\)(\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n)+\n/g, updateMessage: "sort type imports alphabetically", update(content) { const items = execToArray( content, /\/\*\* (?:@template \w+ )*@typedef \{import\("([^"]+)"\)((?:\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?)\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n/g ); items.sort(sortImport); return items.map(item => item.content).join("") + "\n"; }, optional: true, repeat: true } ]; for (const filePath of allFiles) { let content = fs.readFileSync(filePath, "utf-8"); const nl = /(\r?\n)/.exec(content); content = content.replace(/\r?\n/g, "\n"); let newContent = content; let state = 0; let pos = 0; // eslint-disable-next-line no-constant-condition while (true) { const current = schema[state]; if (!current) break; current.regexp.lastIndex = pos; const match = current.regexp.exec(newContent); if (!match) { if (current.optional) { state++; continue; } console.log(`${filePath}: Missing ${current.title} at ${pos}`); process.exitCode = 1; break; } if (match.index !== pos) { console.log( `${filePath}: Unexpected code at ${pos}-${match.index}, expected ${current.title}` ); process.exitCode = 1; pos = match.index; } if (!current.repeat) { state++; } if (current.update) { const update = current.update(...match); if (update !== match[0]) { newContent = newContent.slice(0, pos) + update + newContent.slice(pos + match[0].length); pos += update.length; if (!doWrite) { const updateMessage = current.updateMessage || `${current.title} need to be updated`; console.log(`${filePath}: ${updateMessage}`); } continue; } } pos += match[0].length; } if (newContent !== content) { if (doWrite) { if (nl) { newContent = newContent.replace(/\n/g, nl[0]); } fs.writeFileSync(filePath, newContent, "utf-8"); console.log(filePath); } else { canUpdateWithWrite = true; process.exitCode = 1; } } } if (canUpdateWithWrite) { console.log("Run 'yarn fix' to try to fix the problem automatically"); } enhanced-resolve-5.15.0/tsconfig.json000066400000000000000000000004451444210260000175270ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES2017", "module": "commonjs", "lib": ["es2017"], "allowJs": true, "checkJs": true, "noEmit": true, "strict": true, "alwaysStrict": true, "types": ["node"], "esModuleInterop": true }, "include": ["lib/**/*.js"] } enhanced-resolve-5.15.0/tsconfig.types.json000066400000000000000000000005371444210260000206740ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES2017", "module": "commonjs", "lib": ["es2017"], "allowJs": true, "checkJs": true, "noEmit": true, "strict": true, "noImplicitThis": true, "alwaysStrict": true, "strictNullChecks": true, "types": ["node"], "esModuleInterop": true }, "include": ["lib/**/*.js"] } enhanced-resolve-5.15.0/tsconfig.types.test.json000066400000000000000000000005461444210260000216520ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES2017", "module": "commonjs", "lib": ["es2017"], "allowJs": true, "checkJs": true, "noEmit": true, "strict": false, "noImplicitThis": true, "alwaysStrict": true, "strictNullChecks": true, "types": ["node", "jest"], "esModuleInterop": true }, "include": ["test/*.js"] } enhanced-resolve-5.15.0/types.d.ts000066400000000000000000000370201444210260000167550ustar00rootroot00000000000000/* * This file was automatically generated. * DO NOT MODIFY BY HAND. * Run `yarn special-lint-fix` to update */ import { Dirent } from "fs"; import { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable"; type Alias = string | false | string[]; declare interface AliasOption { alias: Alias; name: string; onlyModule?: boolean; } type AliasOptionNewRequest = string | false | string[]; declare interface AliasOptions { [index: string]: AliasOptionNewRequest; } declare interface BaseResolveRequest { path: string | false; context?: object; descriptionFilePath?: string; descriptionFileRoot?: string; descriptionFileData?: JsonObject; relativePath?: string; ignoreSymlinks?: boolean; fullySpecified?: boolean; __innerRequest?: string; __innerRequest_request?: string; __innerRequest_relativePath?: string; } declare class CachedInputFileSystem { constructor(fileSystem: any, duration: number); fileSystem: any; lstat?: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; lstatSync?: (arg0: string, arg1?: object) => FileSystemStats; stat: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; statSync: (arg0: string, arg1?: object) => FileSystemStats; readdir: ( arg0: string, arg1?: | null | (( arg0?: null | NodeJS.ErrnoException, arg1?: (string | Buffer)[] | Dirent[] ) => void) | ReaddirOptions | "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | "buffer", arg2?: ( arg0?: null | NodeJS.ErrnoException, arg1?: (string | Buffer)[] | Dirent[] ) => void ) => void; readdirSync: ( arg0: string, arg1?: object ) => (string | Buffer)[] | FileSystemDirent[]; readFile: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; readFileSync: (arg0: string, arg1?: object) => string | Buffer; readJson?: { (arg0: string, arg1: FileSystemCallback): void; (arg0: string, arg1: object, arg2: FileSystemCallback): void; }; readJsonSync?: (arg0: string, arg1?: object) => object; readlink: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; readlinkSync: (arg0: string, arg1?: object) => string | Buffer; purge(what?: string | Set | string[]): void; } declare class CloneBasenamePlugin { constructor( source: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >, target: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest > ); source: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; target: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; apply(resolver: Resolver): void; } type ErrorWithDetail = Error & { details?: string }; declare interface ExtensionAliasOption { alias: string | string[]; extension: string; } declare interface ExtensionAliasOptions { [index: string]: string | string[]; } declare interface FileSystem { readFile: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; readdir: ( arg0: string, arg1?: | null | (( arg0?: null | NodeJS.ErrnoException, arg1?: (string | Buffer)[] | Dirent[] ) => void) | ReaddirOptions | "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | "buffer", arg2?: ( arg0?: null | NodeJS.ErrnoException, arg1?: (string | Buffer)[] | Dirent[] ) => void ) => void; readJson?: { (arg0: string, arg1: FileSystemCallback): void; (arg0: string, arg1: object, arg2: FileSystemCallback): void; }; readlink: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; lstat?: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; stat: { (arg0: string, arg1: FileSystemCallback): void; ( arg0: string, arg1: object, arg2: FileSystemCallback ): void; }; } declare interface FileSystemCallback { (err?: null | (PossibleFileSystemError & Error), result?: T): any; } declare interface FileSystemDirent { name: string | Buffer; isDirectory: () => boolean; isFile: () => boolean; } declare interface FileSystemStats { isDirectory: () => boolean; isFile: () => boolean; } declare interface Iterator { ( item: T, callback: (err?: null | Error, result?: null | Z) => void, i: number ): void; } type JsonObject = { [index: string]: JsonValue } & { [index: string]: | undefined | null | string | number | boolean | JsonObject | JsonValue[]; }; type JsonValue = null | string | number | boolean | JsonObject | JsonValue[]; declare interface KnownHooks { resolveStep: SyncHook< [ AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >, ResolveRequest ] >; noResolve: SyncHook<[ResolveRequest, Error]>; resolve: AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; result: AsyncSeriesHook<[ResolveRequest, ResolveContext]>; } declare class LogInfoPlugin { constructor( source: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest > ); source: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; apply(resolver: Resolver): void; } declare interface ParsedIdentifier { request: string; query: string; fragment: string; directory: boolean; module: boolean; file: boolean; internal: boolean; } type Plugin = | undefined | null | false | "" | 0 | { apply: (arg0: Resolver) => void } | ((this: Resolver, arg1: Resolver) => void); declare interface PnpApiImpl { resolveToUnqualified: (arg0: string, arg1: string, arg2: object) => string; } declare interface PossibleFileSystemError { code?: string; errno?: number; path?: string; syscall?: string; } declare interface ReaddirOptions { encoding?: | null | "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | "buffer"; withFileTypes?: boolean; } /** * Resolve context */ declare interface ResolveContext { contextDependencies?: WriteOnlySet; /** * files that was found on file system */ fileDependencies?: WriteOnlySet; /** * dependencies that was not found on file system */ missingDependencies?: WriteOnlySet; /** * set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`, */ stack?: Set; /** * log function */ log?: (arg0: string) => void; /** * yield result, if provided plugins can return several results */ yield?: (arg0: ResolveRequest) => void; } declare interface ResolveFunction { (context: object, path: string, request: string): string | false; (path: string, request: string): string | false; } declare interface ResolveFunctionAsync { ( context: object, path: string, request: string, resolveContext: ResolveContext, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; ( context: object, path: string, request: string, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; ( path: string, request: string, resolveContext: ResolveContext, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; ( path: string, request: string, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; } declare interface ResolveOptions { alias: AliasOption[]; fallback: AliasOption[]; aliasFields: Set; extensionAlias: ExtensionAliasOption[]; cachePredicate: (arg0: ResolveRequest) => boolean; cacheWithContext: boolean; /** * A list of exports field condition names. */ conditionNames: Set; descriptionFiles: string[]; enforceExtension: boolean; exportsFields: Set; importsFields: Set; extensions: Set; fileSystem: FileSystem; unsafeCache: false | object; symlinks: boolean; resolver?: Resolver; modules: (string | string[])[]; mainFields: { name: string[]; forceRelative: boolean }[]; mainFiles: Set; plugins: Plugin[]; pnpApi: null | PnpApiImpl; roots: Set; fullySpecified: boolean; resolveToContext: boolean; restrictions: Set; preferRelative: boolean; preferAbsolute: boolean; } type ResolveOptionsOptionalFS = Omit & Partial>; type ResolveRequest = BaseResolveRequest & Partial; declare abstract class Resolver { fileSystem: FileSystem; options: ResolveOptions; hooks: KnownHooks; ensureHook( name: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest > ): AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; getHook( name: | string | AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest > ): AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >; resolveSync(context: object, path: string, request: string): string | false; resolve( context: object, path: string, request: string, resolveContext: ResolveContext, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; doResolve( hook: AsyncSeriesBailHook< [ResolveRequest, ResolveContext], null | ResolveRequest >, request: ResolveRequest, message: null | string, resolveContext: ResolveContext, callback: (err?: null | Error, result?: ResolveRequest) => void ): void; parse(identifier: string): ParsedIdentifier; isModule(path: string): boolean; isPrivate(path: string): boolean; isDirectory(path: string): boolean; join(path: string, request: string): string; normalize(path: string): string; } declare interface UserResolveOptions { /** * A list of module alias configurations or an object which maps key to value */ alias?: AliasOptions | AliasOption[]; /** * A list of module alias configurations or an object which maps key to value, applied only after modules option */ fallback?: AliasOptions | AliasOption[]; /** * An object which maps extension to extension aliases */ extensionAlias?: ExtensionAliasOptions; /** * A list of alias fields in description files */ aliasFields?: (string | string[])[]; /** * A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties. */ cachePredicate?: (arg0: ResolveRequest) => boolean; /** * Whether or not the unsafeCache should include request context as part of the cache key. */ cacheWithContext?: boolean; /** * A list of description files to read from */ descriptionFiles?: string[]; /** * A list of exports field condition names. */ conditionNames?: string[]; /** * Enforce that a extension from extensions must be used */ enforceExtension?: boolean; /** * A list of exports fields in description files */ exportsFields?: (string | string[])[]; /** * A list of imports fields in description files */ importsFields?: (string | string[])[]; /** * A list of extensions which should be tried for files */ extensions?: string[]; /** * The file system which should be used */ fileSystem: FileSystem; /** * Use this cache object to unsafely cache the successful requests */ unsafeCache?: boolean | object; /** * Resolve symlinks to their symlinked location */ symlinks?: boolean; /** * A prepared Resolver to which the plugins are attached */ resolver?: Resolver; /** * A list of directories to resolve modules from, can be absolute path or folder name */ modules?: string | string[]; /** * A list of main fields in description files */ mainFields?: ( | string | string[] | { name: string | string[]; forceRelative: boolean } )[]; /** * A list of main files in directories */ mainFiles?: string[]; /** * A list of additional resolve plugins which should be applied */ plugins?: Plugin[]; /** * A PnP API that should be used - null is "never", undefined is "auto" */ pnpApi?: null | PnpApiImpl; /** * A list of root paths */ roots?: string[]; /** * The request is already fully specified and no extensions or directories are resolved for it */ fullySpecified?: boolean; /** * Resolve to a context instead of a file */ resolveToContext?: boolean; /** * A list of resolve restrictions */ restrictions?: (string | RegExp)[]; /** * Use only the sync constraints of the file system calls */ useSyncFileSystemCalls?: boolean; /** * Prefer to resolve module requests as relative requests before falling back to modules */ preferRelative?: boolean; /** * Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots */ preferAbsolute?: boolean; } declare interface WriteOnlySet { add: (item: T) => void; } declare function exports( context: object, path: string, request: string, resolveContext: ResolveContext, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; declare function exports( context: object, path: string, request: string, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; declare function exports( path: string, request: string, resolveContext: ResolveContext, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; declare function exports( path: string, request: string, callback: ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void ): void; declare namespace exports { export const sync: ResolveFunction; export function create( options: ResolveOptionsOptionalFS ): ResolveFunctionAsync; export namespace create { export const sync: (options: ResolveOptionsOptionalFS) => ResolveFunction; } export namespace ResolverFactory { export let createResolver: (options: UserResolveOptions) => Resolver; } export const forEachBail: ( array: T[], iterator: Iterator, callback: (err?: null | Error, result?: null | Z) => void ) => void; export type ResolveCallback = ( err: null | ErrorWithDetail, res?: string | false, req?: ResolveRequest ) => void; export { CachedInputFileSystem, CloneBasenamePlugin, LogInfoPlugin, ResolveOptionsOptionalFS, PnpApiImpl as PnpApi, Resolver, FileSystem, ResolveContext, ResolveRequest, Plugin, UserResolveOptions as ResolveOptions, ResolveFunctionAsync, ResolveFunction }; } export = exports; enhanced-resolve-5.15.0/yarn.lock000066400000000000000000005502661444210260000166560ustar00rootroot00000000000000# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. # yarn lockfile v1 "@ampproject/remapping@^2.2.0": version "2.2.1" resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.1.tgz#99e8e11851128b8702cd57c33684f1d0f260b630" integrity sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg== dependencies: "@jridgewell/gen-mapping" "^0.3.0" "@jridgewell/trace-mapping" "^0.3.9" "@apidevtools/json-schema-ref-parser@9.0.9": version "9.0.9" resolved "https://registry.yarnpkg.com/@apidevtools/json-schema-ref-parser/-/json-schema-ref-parser-9.0.9.tgz#d720f9256e3609621280584f2b47ae165359268b" integrity sha512-GBD2Le9w2+lVFoc4vswGI/TjkNIZSVp7+9xPf+X3uidBfWnAeUWmquteSyt0+VCrhNMWj/FTABISQrD3Z/YA+w== dependencies: "@jsdevtools/ono" "^7.1.3" "@types/json-schema" "^7.0.6" call-me-maybe "^1.0.1" js-yaml "^4.1.0" "@babel/code-frame@7.12.11": version "7.12.11" resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f" integrity sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw== dependencies: "@babel/highlight" "^7.10.4" "@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.18.6", "@babel/code-frame@^7.21.4": version "7.21.4" resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.21.4.tgz#d0fa9e4413aca81f2b23b9442797bda1826edb39" integrity sha512-LYvhNKfwWSPpocw8GI7gpK2nq3HSDuEPC/uSYaALSJu9xjsalaaYFOq0Pwt5KmVqwEbZlDu81aLXwBOmD/Fv9g== dependencies: "@babel/highlight" "^7.18.6" "@babel/compat-data@^7.21.5": version "7.21.7" resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.21.7.tgz#61caffb60776e49a57ba61a88f02bedd8714f6bc" integrity sha512-KYMqFYTaenzMK4yUtf4EW9wc4N9ef80FsbMtkwool5zpwl4YrT1SdWYSTRcT94KO4hannogdS+LxY7L+arP3gA== "@babel/core@^7.1.0", "@babel/core@^7.12.3", "@babel/core@^7.7.2", "@babel/core@^7.8.0": version "7.21.8" resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.21.8.tgz#2a8c7f0f53d60100ba4c32470ba0281c92aa9aa4" integrity sha512-YeM22Sondbo523Sz0+CirSPnbj9bG3P0CdHcBZdqUuaeOaYEFbOLoGU7lebvGP6P5J/WE9wOn7u7C4J9HvS1xQ== dependencies: "@ampproject/remapping" "^2.2.0" "@babel/code-frame" "^7.21.4" "@babel/generator" "^7.21.5" "@babel/helper-compilation-targets" "^7.21.5" "@babel/helper-module-transforms" "^7.21.5" "@babel/helpers" "^7.21.5" "@babel/parser" "^7.21.8" "@babel/template" "^7.20.7" "@babel/traverse" "^7.21.5" "@babel/types" "^7.21.5" convert-source-map "^1.7.0" debug "^4.1.0" gensync "^1.0.0-beta.2" json5 "^2.2.2" semver "^6.3.0" "@babel/generator@^7.21.5", "@babel/generator@^7.7.2": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.21.5.tgz#c0c0e5449504c7b7de8236d99338c3e2a340745f" integrity sha512-SrKK/sRv8GesIW1bDagf9cCG38IOMYZusoe1dfg0D8aiUe3Amvoj1QtjTPAWcfrZFvIwlleLb0gxzQidL9w14w== dependencies: "@babel/types" "^7.21.5" "@jridgewell/gen-mapping" "^0.3.2" "@jridgewell/trace-mapping" "^0.3.17" jsesc "^2.5.1" "@babel/helper-compilation-targets@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.21.5.tgz#631e6cc784c7b660417421349aac304c94115366" integrity sha512-1RkbFGUKex4lvsB9yhIfWltJM5cZKUftB2eNajaDv3dCMEp49iBG0K14uH8NnX9IPux2+mK7JGEOB0jn48/J6w== dependencies: "@babel/compat-data" "^7.21.5" "@babel/helper-validator-option" "^7.21.0" browserslist "^4.21.3" lru-cache "^5.1.1" semver "^6.3.0" "@babel/helper-environment-visitor@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.21.5.tgz#c769afefd41d171836f7cb63e295bedf689d48ba" integrity sha512-IYl4gZ3ETsWocUWgsFZLM5i1BYx9SoemminVEXadgLBa9TdeorzgLKm8wWLA6J1N/kT3Kch8XIk1laNzYoHKvQ== "@babel/helper-function-name@^7.21.0": version "7.21.0" resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.21.0.tgz#d552829b10ea9f120969304023cd0645fa00b1b4" integrity sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg== dependencies: "@babel/template" "^7.20.7" "@babel/types" "^7.21.0" "@babel/helper-hoist-variables@^7.18.6": version "7.18.6" resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678" integrity sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q== dependencies: "@babel/types" "^7.18.6" "@babel/helper-module-imports@^7.21.4": version "7.21.4" resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.21.4.tgz#ac88b2f76093637489e718a90cec6cf8a9b029af" integrity sha512-orajc5T2PsRYUN3ZryCEFeMDYwyw09c/pZeaQEZPH0MpKzSvn3e0uXsDBu3k03VI+9DBiRo+l22BfKTpKwa/Wg== dependencies: "@babel/types" "^7.21.4" "@babel/helper-module-transforms@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.21.5.tgz#d937c82e9af68d31ab49039136a222b17ac0b420" integrity sha512-bI2Z9zBGY2q5yMHoBvJ2a9iX3ZOAzJPm7Q8Yz6YeoUjU/Cvhmi2G4QyTNyPBqqXSgTjUxRg3L0xV45HvkNWWBw== dependencies: "@babel/helper-environment-visitor" "^7.21.5" "@babel/helper-module-imports" "^7.21.4" "@babel/helper-simple-access" "^7.21.5" "@babel/helper-split-export-declaration" "^7.18.6" "@babel/helper-validator-identifier" "^7.19.1" "@babel/template" "^7.20.7" "@babel/traverse" "^7.21.5" "@babel/types" "^7.21.5" "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.20.2", "@babel/helper-plugin-utils@^7.8.0": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.21.5.tgz#345f2377d05a720a4e5ecfa39cbf4474a4daed56" integrity sha512-0WDaIlXKOX/3KfBK/dwP1oQGiPh6rjMkT7HIRv7i5RR2VUMwrx5ZL0dwBkKx7+SW1zwNdgjHd34IMk5ZjTeHVg== "@babel/helper-simple-access@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.21.5.tgz#d697a7971a5c39eac32c7e63c0921c06c8a249ee" integrity sha512-ENPDAMC1wAjR0uaCUwliBdiSl1KBJAVnMTzXqi64c2MG8MPR6ii4qf7bSXDqSFbr4W6W028/rf5ivoHop5/mkg== dependencies: "@babel/types" "^7.21.5" "@babel/helper-split-export-declaration@^7.18.6": version "7.18.6" resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075" integrity sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA== dependencies: "@babel/types" "^7.18.6" "@babel/helper-string-parser@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.21.5.tgz#2b3eea65443c6bdc31c22d037c65f6d323b6b2bd" integrity sha512-5pTUx3hAJaZIdW99sJ6ZUUgWq/Y+Hja7TowEnLNMm1VivRgZQL3vpBY3qUACVsvw+yQU6+YgfBVmcbLaZtrA1w== "@babel/helper-validator-identifier@^7.18.6", "@babel/helper-validator-identifier@^7.19.1": version "7.19.1" resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz#7eea834cf32901ffdc1a7ee555e2f9c27e249ca2" integrity sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w== "@babel/helper-validator-option@^7.21.0": version "7.21.0" resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.21.0.tgz#8224c7e13ace4bafdc4004da2cf064ef42673180" integrity sha512-rmL/B8/f0mKS2baE9ZpyTcTavvEuWhTTW8amjzXNvYG4AwBsqTLikfXsEofsJEfKHf+HQVQbFOHy6o+4cnC/fQ== "@babel/helpers@^7.21.5": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.21.5.tgz#5bac66e084d7a4d2d9696bdf0175a93f7fb63c08" integrity sha512-BSY+JSlHxOmGsPTydUkPf1MdMQ3M81x5xGCOVgWM3G8XH77sJ292Y2oqcp0CbbgxhqBuI46iUz1tT7hqP7EfgA== dependencies: "@babel/template" "^7.20.7" "@babel/traverse" "^7.21.5" "@babel/types" "^7.21.5" "@babel/highlight@^7.10.4", "@babel/highlight@^7.18.6": version "7.18.6" resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf" integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g== dependencies: "@babel/helper-validator-identifier" "^7.18.6" chalk "^2.0.0" js-tokens "^4.0.0" "@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.21.5", "@babel/parser@^7.21.8": version "7.21.8" resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.21.8.tgz#642af7d0333eab9c0ad70b14ac5e76dbde7bfdf8" integrity sha512-6zavDGdzG3gUqAdWvlLFfk+36RilI+Pwyuuh7HItyeScCWP3k6i8vKclAQ0bM/0y/Kz/xiwvxhMv9MgTJP5gmA== "@babel/plugin-syntax-async-generators@^7.8.4": version "7.8.4" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d" integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-bigint@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea" integrity sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-class-properties@^7.8.3": version "7.12.13" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10" integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA== dependencies: "@babel/helper-plugin-utils" "^7.12.13" "@babel/plugin-syntax-import-meta@^7.8.3": version "7.10.4" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51" integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-json-strings@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a" integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-logical-assignment-operators@^7.8.3": version "7.10.4" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699" integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9" integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-numeric-separator@^7.8.3": version "7.10.4" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97" integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-object-rest-spread@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871" integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-optional-catch-binding@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1" integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-optional-chaining@^7.8.3": version "7.8.3" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a" integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-top-level-await@^7.8.3": version "7.14.5" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c" integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw== dependencies: "@babel/helper-plugin-utils" "^7.14.5" "@babel/plugin-syntax-typescript@^7.7.2": version "7.21.4" resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.21.4.tgz#2751948e9b7c6d771a8efa59340c15d4a2891ff8" integrity sha512-xz0D39NvhQn4t4RNsHmDnnsaQizIlUkdtYvLs8La1BlfjQ6JEwxkJGeqJMW2tAXx+q6H+WFuUTXNdYVpEya0YA== dependencies: "@babel/helper-plugin-utils" "^7.20.2" "@babel/template@^7.20.7", "@babel/template@^7.3.3": version "7.20.7" resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.20.7.tgz#a15090c2839a83b02aa996c0b4994005841fd5a8" integrity sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw== dependencies: "@babel/code-frame" "^7.18.6" "@babel/parser" "^7.20.7" "@babel/types" "^7.20.7" "@babel/traverse@^7.21.5", "@babel/traverse@^7.7.2": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.21.5.tgz#ad22361d352a5154b498299d523cf72998a4b133" integrity sha512-AhQoI3YjWi6u/y/ntv7k48mcrCXmus0t79J9qPNlk/lAsFlCiJ047RmbfMOawySTHtywXhbXgpx/8nXMYd+oFw== dependencies: "@babel/code-frame" "^7.21.4" "@babel/generator" "^7.21.5" "@babel/helper-environment-visitor" "^7.21.5" "@babel/helper-function-name" "^7.21.0" "@babel/helper-hoist-variables" "^7.18.6" "@babel/helper-split-export-declaration" "^7.18.6" "@babel/parser" "^7.21.5" "@babel/types" "^7.21.5" debug "^4.1.0" globals "^11.1.0" "@babel/types@^7.0.0", "@babel/types@^7.18.6", "@babel/types@^7.20.7", "@babel/types@^7.21.0", "@babel/types@^7.21.4", "@babel/types@^7.21.5", "@babel/types@^7.3.0", "@babel/types@^7.3.3": version "7.21.5" resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.21.5.tgz#18dfbd47c39d3904d5db3d3dc2cc80bedb60e5b6" integrity sha512-m4AfNvVF2mVC/F7fDEdH2El3HzUg9It/XsCxZiOTTA3m3qYfcSVSbTfM6Q9xG+hYDniZssYhlXKKUMD5m8tF4Q== dependencies: "@babel/helper-string-parser" "^7.21.5" "@babel/helper-validator-identifier" "^7.19.1" to-fast-properties "^2.0.0" "@bcoe/v8-coverage@^0.2.3": version "0.2.3" resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39" integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw== "@cspell/dict-aws@^1.0.13": version "1.0.14" resolved "https://registry.yarnpkg.com/@cspell/dict-aws/-/dict-aws-1.0.14.tgz#beddede1053ce3622400e36c65da9fd2954e939d" integrity sha512-K21CfB4ZpKYwwDQiPfic2zJA/uxkbsd4IQGejEvDAhE3z8wBs6g6BwwqdVO767M9NgZqc021yAVpr79N5pWe3w== "@cspell/dict-bash@^1.0.11": version "1.0.18" resolved "https://registry.yarnpkg.com/@cspell/dict-bash/-/dict-bash-1.0.18.tgz#1a2a07075c1ea97923f405e32713bf23d26d67ab" integrity sha512-kJIqQ+FD2TCSgaaP5XLEDgy222+pVWTc+VhveNO++gnTWU3BCVjkD5LjfW7g/CmGONnz+nwXDueWspProaSdJw== "@cspell/dict-companies@^1.0.35": version "1.0.40" resolved "https://registry.yarnpkg.com/@cspell/dict-companies/-/dict-companies-1.0.40.tgz#edd7f47fc683dfa1b02cd48fb12ad732d2eece61" integrity sha512-Aw07qiTroqSST2P5joSrC4uOA05zTXzI2wMb+me3q4Davv1D9sCkzXY0TGoC2vzhNv5ooemRi9KATGaBSdU1sw== "@cspell/dict-cpp@^1.1.37": version "1.1.40" resolved "https://registry.yarnpkg.com/@cspell/dict-cpp/-/dict-cpp-1.1.40.tgz#f9a859e19d31b83f07a106e4c3c8720a2d93595b" integrity sha512-sscfB3woNDNj60/yGXAdwNtIRWZ89y35xnIaJVDMk5TPMMpaDvuk0a34iOPIq0g4V+Y8e3RyAg71SH6ADwSjGw== "@cspell/dict-cryptocurrencies@^1.0.10": version "1.0.10" resolved "https://registry.yarnpkg.com/@cspell/dict-cryptocurrencies/-/dict-cryptocurrencies-1.0.10.tgz#04426fdfee8752818b375686d34a154b2fb40c7d" integrity sha512-47ABvDJOkaST/rXipNMfNvneHUzASvmL6K/CbOFpYKfsd0x23Jc9k1yaOC7JAm82XSC/8a7+3Yu+Fk2jVJNnsA== "@cspell/dict-csharp@^1.0.10": version "1.0.11" resolved "https://registry.yarnpkg.com/@cspell/dict-csharp/-/dict-csharp-1.0.11.tgz#cacdf477a31ca8326c2c91bee0b42b9f6b3c4a7c" integrity sha512-nub+ZCiTgmT87O+swI+FIAzNwaZPWUGckJU4GN402wBq420V+F4ZFqNV7dVALJrGaWH7LvADRtJxi6cZVHJKeA== "@cspell/dict-css@^1.0.10": version "1.0.13" resolved "https://registry.yarnpkg.com/@cspell/dict-css/-/dict-css-1.0.13.tgz#805a5844dd9739b6cd026b5f1b4ce8e4213d560b" integrity sha512-HU8RbFRoGanFH85mT01Ot/Ay48ixr/gG25VPLtdq56QTrmPsw79gxYm/5Qay16eQbpoPIxaj5CAWNam+DX4GbA== "@cspell/dict-django@^1.0.25": version "1.0.26" resolved "https://registry.yarnpkg.com/@cspell/dict-django/-/dict-django-1.0.26.tgz#b97ce0112fbe8c3c3ada0387c68971b5e27483ab" integrity sha512-mn9bd7Et1L2zuibc08GVHTiD2Go3/hdjyX5KLukXDklBkq06r+tb0OtKtf1zKodtFDTIaYekGADhNhA6AnKLkg== "@cspell/dict-dotnet@^1.0.24": version "1.0.32" resolved "https://registry.yarnpkg.com/@cspell/dict-dotnet/-/dict-dotnet-1.0.32.tgz#412af0bf1f65c5902c8ef8a4f1decae2892790e2" integrity sha512-9H9vXrgJB4KF8xsyTToXO53cXD33iyfrpT4mhCds+YLUw3P3x3E9myszgJzshnrxYBvQZ+QMII57Qr6SjZVk4Q== "@cspell/dict-elixir@^1.0.23": version "1.0.26" resolved "https://registry.yarnpkg.com/@cspell/dict-elixir/-/dict-elixir-1.0.26.tgz#dd86697b351a9c74a7d033b6f2d37a5088587aa6" integrity sha512-hz1yETUiRJM7yjN3mITSnxcmZaEyaBbyJhpZPpg+cKUil+xhHeZ2wwfbRc83QHGmlqEuDWbdCFqKSpCDJYpYhg== "@cspell/dict-en-gb@^1.1.27": version "1.1.33" resolved "https://registry.yarnpkg.com/@cspell/dict-en-gb/-/dict-en-gb-1.1.33.tgz#7f1fd90fc364a5cb77111b5438fc9fcf9cc6da0e" integrity sha512-tKSSUf9BJEV+GJQAYGw5e+ouhEe2ZXE620S7BLKe3ZmpnjlNG9JqlnaBhkIMxKnNFkLY2BP/EARzw31AZnOv4g== "@cspell/dict-en_us@^1.2.39": version "1.2.45" resolved "https://registry.yarnpkg.com/@cspell/dict-en_us/-/dict-en_us-1.2.45.tgz#1314a9d81a1fd3cc7ed381dc6a0da10e7c2d02f9" integrity sha512-UPwR4rfiJCxnS+Py+EK9E4AUj3aPZE4p/yBRSHN+5aBQConlI0lLDtMceH5wlupA/sQTU1ERZGPJA9L96jVSyQ== "@cspell/dict-filetypes@^1.1.5": version "1.1.8" resolved "https://registry.yarnpkg.com/@cspell/dict-filetypes/-/dict-filetypes-1.1.8.tgz#c161ab48667b6539cbc91a70ff0b037fa436a64e" integrity sha512-EllahNkhzvLWo0ptwu0l3oEeAJOQSUpZnDfnKRIh6mJVehuSovNHwA9vrdZ8jBUjuqcfaN2e7c32zN0D/qvWJQ== "@cspell/dict-fonts@^1.0.13": version "1.0.14" resolved "https://registry.yarnpkg.com/@cspell/dict-fonts/-/dict-fonts-1.0.14.tgz#7b18129910d30bd23cd9187d0c0009dfc3fef4ba" integrity sha512-VhIX+FVYAnqQrOuoFEtya6+H72J82cIicz9QddgknsTqZQ3dvgp6lmVnsQXPM3EnzA8n1peTGpLDwHzT7ociLA== "@cspell/dict-fullstack@^1.0.36": version "1.0.39" resolved "https://registry.yarnpkg.com/@cspell/dict-fullstack/-/dict-fullstack-1.0.39.tgz#65a9031826062a1b9934a87c419fd1c4407ebcb1" integrity sha512-Mbi+zWdiP9yzL+X4YD9Tgcm5YQ95Ql+Y3vF2LRnOY6g2QWaijTRN1rgksVuxzpFqHi//+bx2uoUb0XEKBYDi8g== "@cspell/dict-golang@^1.1.24": version "1.1.24" resolved "https://registry.yarnpkg.com/@cspell/dict-golang/-/dict-golang-1.1.24.tgz#3830812aec816eca46a6d793fcc7710c09d4f5b9" integrity sha512-qq3Cjnx2U1jpeWAGJL1GL0ylEhUMqyaR36Xij6Y6Aq4bViCRp+HRRqk0x5/IHHbOrti45h3yy7ii1itRFo+Xkg== "@cspell/dict-haskell@^1.0.12": version "1.0.13" resolved "https://registry.yarnpkg.com/@cspell/dict-haskell/-/dict-haskell-1.0.13.tgz#bd159ef474ef427757dd4bc6a66cda977946c927" integrity sha512-kvl8T84cnYRPpND/P3D86P6WRSqebsbk0FnMfy27zo15L5MLAb3d3MOiT1kW3vEWfQgzUD7uddX/vUiuroQ8TA== "@cspell/dict-html-symbol-entities@^1.0.23": version "1.0.23" resolved "https://registry.yarnpkg.com/@cspell/dict-html-symbol-entities/-/dict-html-symbol-entities-1.0.23.tgz#0efbdbc7712c9fbe545e14acac637226ac948f2d" integrity sha512-PV0UBgcBFbBLf/m1wfkVMM8w96kvfHoiCGLWO6BR3Q9v70IXoE4ae0+T+f0CkxcEkacMqEQk/I7vuE9MzrjaNw== "@cspell/dict-html@^1.1.5": version "1.1.9" resolved "https://registry.yarnpkg.com/@cspell/dict-html/-/dict-html-1.1.9.tgz#e506ca550ffcdad820ba0aa157a48be869f23bf2" integrity sha512-vvnYia0tyIS5Fdoz+gEQm77MGZZE66kOJjuNpIYyRHCXFAhWdYz3SmkRm6YKJSWSvuO+WBJYTKDvkOxSh3Fx/w== "@cspell/dict-java@^1.0.22": version "1.0.23" resolved "https://registry.yarnpkg.com/@cspell/dict-java/-/dict-java-1.0.23.tgz#ec95ff2f2c34d5e8e08ba817980b37e387e608cb" integrity sha512-LcOg9srYLDoNGd8n3kbfDBlZD+LOC9IVcnFCdua1b/luCHNVmlgBx7e677qPu7olpMYOD5TQIVW2OmM1+/6MFA== "@cspell/dict-latex@^1.0.23": version "1.0.25" resolved "https://registry.yarnpkg.com/@cspell/dict-latex/-/dict-latex-1.0.25.tgz#6ecf5b8b8fdf46cb8a0f070052dd687e25089e59" integrity sha512-cEgg91Migqcp1SdVV7dUeMxbPDhxdNo6Fgq2eygAXQjIOFK520FFvh/qxyBvW90qdZbIRoU2AJpchyHfGuwZFA== "@cspell/dict-lorem-ipsum@^1.0.22": version "1.0.22" resolved "https://registry.yarnpkg.com/@cspell/dict-lorem-ipsum/-/dict-lorem-ipsum-1.0.22.tgz#a89f53dadda7d5bfdb978ab61f19d74d2fb69eab" integrity sha512-yqzspR+2ADeAGUxLTfZ4pXvPl7FmkENMRcGDECmddkOiuEwBCWMZdMP5fng9B0Q6j91hQ8w9CLvJKBz10TqNYg== "@cspell/dict-lua@^1.0.16": version "1.0.16" resolved "https://registry.yarnpkg.com/@cspell/dict-lua/-/dict-lua-1.0.16.tgz#c0ca43628f8927fc10731fd27cd9ee0af651bf6a" integrity sha512-YiHDt8kmHJ8nSBy0tHzaxiuitYp+oJ66ffCYuFWTNB3//Y0SI4OGHU3omLsQVeXIfCeVrO4DrVvRDoCls9B5zQ== "@cspell/dict-node@^1.0.10": version "1.0.12" resolved "https://registry.yarnpkg.com/@cspell/dict-node/-/dict-node-1.0.12.tgz#a7236be30340ff8fe365f62c8d13121fdbe7f51c" integrity sha512-RPNn/7CSkflAWk0sbSoOkg0ORrgBARUjOW3QjB11KwV1gSu8f5W/ij/S50uIXtlrfoBLqd4OyE04jyON+g/Xfg== "@cspell/dict-npm@^1.0.10": version "1.0.16" resolved "https://registry.yarnpkg.com/@cspell/dict-npm/-/dict-npm-1.0.16.tgz#86870686cd0af6354a206ab297872db1d84e9c1b" integrity sha512-RwkuZGcYBxL3Yux3cSG/IOWGlQ1e9HLCpHeyMtTVGYKAIkFAVUnGrz20l16/Q7zUG7IEktBz5O42kAozrEnqMQ== "@cspell/dict-php@^1.0.23": version "1.0.25" resolved "https://registry.yarnpkg.com/@cspell/dict-php/-/dict-php-1.0.25.tgz#b065314c43b668b982356de59986e10fc26bc390" integrity sha512-RoBIP5MRdByyPaXcznZMfOY1JdCMYPPLua5E9gkq0TJO7bX5mC9hyAKfYBSWVQunZydd82HZixjb5MPkDFU1uw== "@cspell/dict-powershell@^1.0.14": version "1.0.19" resolved "https://registry.yarnpkg.com/@cspell/dict-powershell/-/dict-powershell-1.0.19.tgz#b50d14b3b20e33f86b80318ccd7ef986ecba2549" integrity sha512-zF/raM/lkhXeHf4I43OtK0gP9rBeEJFArscTVwLWOCIvNk21MJcNoTYoaGw+c056+Q+hJL0psGLO7QN+mxYH1A== "@cspell/dict-python@^1.0.32": version "1.0.38" resolved "https://registry.yarnpkg.com/@cspell/dict-python/-/dict-python-1.0.38.tgz#5212536e00dda94ae001c77f492478c6ce0a348e" integrity sha512-KuyOQaby9NID/pn7EkXilpUxjVIvvyLzhr7BPsDS6FcvUE8Yhss6bJowEDHSv6pa+W2387phoqbDf2rTicquAA== "@cspell/dict-ruby@^1.0.12": version "1.0.15" resolved "https://registry.yarnpkg.com/@cspell/dict-ruby/-/dict-ruby-1.0.15.tgz#5da9f54d97deed31cc35772502282b45b20e7aa7" integrity sha512-I76hJA///lc1pgmDTGUFHN/O8KLIZIU/8TgIYIGI6Ix/YzSEvWNdQYbANn6JbCynS0X+7IbZ2Ft+QqvmGtIWuA== "@cspell/dict-rust@^1.0.22": version "1.0.23" resolved "https://registry.yarnpkg.com/@cspell/dict-rust/-/dict-rust-1.0.23.tgz#bcef79f74932d90a07f86efa11a8696788079ad8" integrity sha512-lR4boDzs79YD6+30mmiSGAMMdwh7HTBAPUFSB0obR3Kidibfc3GZ+MHWZXay5dxZ4nBKM06vyjtanF9VJ8q1Iw== "@cspell/dict-scala@^1.0.21": version "1.0.21" resolved "https://registry.yarnpkg.com/@cspell/dict-scala/-/dict-scala-1.0.21.tgz#bfda392329061e2352fbcd33d228617742c93831" integrity sha512-5V/R7PRbbminTpPS3ywgdAalI9BHzcEjEj9ug4kWYvBIGwSnS7T6QCFCiu+e9LvEGUqQC+NHgLY4zs1NaBj2vA== "@cspell/dict-software-terms@^1.0.24": version "1.0.48" resolved "https://registry.yarnpkg.com/@cspell/dict-software-terms/-/dict-software-terms-1.0.48.tgz#dc45a91c64f9f86df3a047879d9f34aa17435bd0" integrity sha512-pfF3Ys2gRffu5ElqkH7FQMDMi/iZMyOzpGMb3FSH0PJ2AnRQ5rRNWght1h2L36YxvXl0mWVaFrrfwiOyRIc8ZQ== "@cspell/dict-typescript@^1.0.16": version "1.0.20" resolved "https://registry.yarnpkg.com/@cspell/dict-typescript/-/dict-typescript-1.0.20.tgz#2a28bb94a06490b25bbb9180b875d6f16ebb8400" integrity sha512-yIuGeeZtQA2gqpGefGjZqBl8iGJpIYWz0QzDqsscNi2qfSnLsbjM0RkRbTehM8y9gGGe7xfgUP5adxceJa5Krg== "@eslint/eslintrc@^0.4.3": version "0.4.3" resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.3.tgz#9e42981ef035beb3dd49add17acb96e8ff6f394c" integrity sha512-J6KFFz5QCYUJq3pf0mjEcCJVERbzv71PUIDczuh9JkwGEzced6CO5ADLHB1rbf/+oPBtoPfMYNOpGDzCANlbXw== dependencies: ajv "^6.12.4" debug "^4.1.1" espree "^7.3.0" globals "^13.9.0" ignore "^4.0.6" import-fresh "^3.2.1" js-yaml "^3.13.1" minimatch "^3.0.4" strip-json-comments "^3.1.1" "@humanwhocodes/config-array@^0.5.0": version "0.5.0" resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.5.0.tgz#1407967d4c6eecd7388f83acf1eaf4d0c6e58ef9" integrity sha512-FagtKFz74XrTl7y6HCzQpwDfXP0yhxe9lHLD1UZxjvZIcbyRz8zTFF/yYNfSfzU414eDwZ1SrO0Qvtyf+wFMQg== dependencies: "@humanwhocodes/object-schema" "^1.2.0" debug "^4.1.1" minimatch "^3.0.4" "@humanwhocodes/object-schema@^1.2.0": version "1.2.1" resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45" integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== "@istanbuljs/load-nyc-config@^1.0.0": version "1.1.0" resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced" integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ== dependencies: camelcase "^5.3.1" find-up "^4.1.0" get-package-type "^0.1.0" js-yaml "^3.13.1" resolve-from "^5.0.0" "@istanbuljs/schema@^0.1.2": version "0.1.3" resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98" integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== "@jest/console@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/console/-/console-27.5.1.tgz#260fe7239602fe5130a94f1aa386eff54b014bba" integrity sha512-kZ/tNpS3NXn0mlXXXPNuDZnb4c0oZ20r4K5eemM2k30ZC3G0T02nXUvyhf5YdbXWHPEJLc9qGLxEZ216MdL+Zg== dependencies: "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" jest-message-util "^27.5.1" jest-util "^27.5.1" slash "^3.0.0" "@jest/core@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/core/-/core-27.5.1.tgz#267ac5f704e09dc52de2922cbf3af9edcd64b626" integrity sha512-AK6/UTrvQD0Cd24NSqmIA6rKsu0tKIxfiCducZvqxYdmMisOYAsdItspT+fQDQYARPf8XgjAFZi0ogW2agH5nQ== dependencies: "@jest/console" "^27.5.1" "@jest/reporters" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" ansi-escapes "^4.2.1" chalk "^4.0.0" emittery "^0.8.1" exit "^0.1.2" graceful-fs "^4.2.9" jest-changed-files "^27.5.1" jest-config "^27.5.1" jest-haste-map "^27.5.1" jest-message-util "^27.5.1" jest-regex-util "^27.5.1" jest-resolve "^27.5.1" jest-resolve-dependencies "^27.5.1" jest-runner "^27.5.1" jest-runtime "^27.5.1" jest-snapshot "^27.5.1" jest-util "^27.5.1" jest-validate "^27.5.1" jest-watcher "^27.5.1" micromatch "^4.0.4" rimraf "^3.0.0" slash "^3.0.0" strip-ansi "^6.0.0" "@jest/environment@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-27.5.1.tgz#d7425820511fe7158abbecc010140c3fd3be9c74" integrity sha512-/WQjhPJe3/ghaol/4Bq480JKXV/Rfw8nQdN7f41fM8VDHLcxKXou6QyXAh3EFr9/bVG3x74z1NWDkP87EiY8gA== dependencies: "@jest/fake-timers" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" jest-mock "^27.5.1" "@jest/fake-timers@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-27.5.1.tgz#76979745ce0579c8a94a4678af7a748eda8ada74" integrity sha512-/aPowoolwa07k7/oM3aASneNeBGCmGQsc3ugN4u6s4C/+s5M64MFo/+djTdiwcbQlRfFElGuDXWzaWj6QgKObQ== dependencies: "@jest/types" "^27.5.1" "@sinonjs/fake-timers" "^8.0.1" "@types/node" "*" jest-message-util "^27.5.1" jest-mock "^27.5.1" jest-util "^27.5.1" "@jest/globals@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-27.5.1.tgz#7ac06ce57ab966566c7963431cef458434601b2b" integrity sha512-ZEJNB41OBQQgGzgyInAv0UUfDDj3upmHydjieSxFvTRuZElrx7tXg/uVQ5hYVEwiXs3+aMsAeEc9X7xiSKCm4Q== dependencies: "@jest/environment" "^27.5.1" "@jest/types" "^27.5.1" expect "^27.5.1" "@jest/reporters@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-27.5.1.tgz#ceda7be96170b03c923c37987b64015812ffec04" integrity sha512-cPXh9hWIlVJMQkVk84aIvXuBB4uQQmFqZiacloFuGiP3ah1sbCxCosidXFDfqG8+6fO1oR2dTJTlsOy4VFmUfw== dependencies: "@bcoe/v8-coverage" "^0.2.3" "@jest/console" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" collect-v8-coverage "^1.0.0" exit "^0.1.2" glob "^7.1.2" graceful-fs "^4.2.9" istanbul-lib-coverage "^3.0.0" istanbul-lib-instrument "^5.1.0" istanbul-lib-report "^3.0.0" istanbul-lib-source-maps "^4.0.0" istanbul-reports "^3.1.3" jest-haste-map "^27.5.1" jest-resolve "^27.5.1" jest-util "^27.5.1" jest-worker "^27.5.1" slash "^3.0.0" source-map "^0.6.0" string-length "^4.0.1" terminal-link "^2.0.0" v8-to-istanbul "^8.1.0" "@jest/source-map@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-27.5.1.tgz#6608391e465add4205eae073b55e7f279e04e8cf" integrity sha512-y9NIHUYF3PJRlHk98NdC/N1gl88BL08aQQgu4k4ZopQkCw9t9cV8mtl3TV8b/YCB8XaVTFrmUTAJvjsntDireg== dependencies: callsites "^3.0.0" graceful-fs "^4.2.9" source-map "^0.6.0" "@jest/test-result@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-27.5.1.tgz#56a6585fa80f7cdab72b8c5fc2e871d03832f5bb" integrity sha512-EW35l2RYFUcUQxFJz5Cv5MTOxlJIQs4I7gxzi2zVU7PJhOwfYq1MdC5nhSmYjX1gmMmLPvB3sIaC+BkcHRBfag== dependencies: "@jest/console" "^27.5.1" "@jest/types" "^27.5.1" "@types/istanbul-lib-coverage" "^2.0.0" collect-v8-coverage "^1.0.0" "@jest/test-sequencer@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-27.5.1.tgz#4057e0e9cea4439e544c6353c6affe58d095745b" integrity sha512-LCheJF7WB2+9JuCS7VB/EmGIdQuhtqjRNI9A43idHv3E4KltCTsPsLxvdaubFHSYwY/fNjMWjl6vNRhDiN7vpQ== dependencies: "@jest/test-result" "^27.5.1" graceful-fs "^4.2.9" jest-haste-map "^27.5.1" jest-runtime "^27.5.1" "@jest/transform@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-27.5.1.tgz#6c3501dcc00c4c08915f292a600ece5ecfe1f409" integrity sha512-ipON6WtYgl/1329g5AIJVbUuEh0wZVbdpGwC99Jw4LwuoBNS95MVphU6zOeD9pDkon+LLbFL7lOQRapbB8SCHw== dependencies: "@babel/core" "^7.1.0" "@jest/types" "^27.5.1" babel-plugin-istanbul "^6.1.1" chalk "^4.0.0" convert-source-map "^1.4.0" fast-json-stable-stringify "^2.0.0" graceful-fs "^4.2.9" jest-haste-map "^27.5.1" jest-regex-util "^27.5.1" jest-util "^27.5.1" micromatch "^4.0.4" pirates "^4.0.4" slash "^3.0.0" source-map "^0.6.1" write-file-atomic "^3.0.0" "@jest/types@^27.5.1": version "27.5.1" resolved "https://registry.yarnpkg.com/@jest/types/-/types-27.5.1.tgz#3c79ec4a8ba61c170bf937bcf9e98a9df175ec80" integrity sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw== dependencies: "@types/istanbul-lib-coverage" "^2.0.0" "@types/istanbul-reports" "^3.0.0" "@types/node" "*" "@types/yargs" "^16.0.0" chalk "^4.0.0" "@jridgewell/gen-mapping@^0.3.0", "@jridgewell/gen-mapping@^0.3.2": version "0.3.3" resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098" integrity sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ== dependencies: "@jridgewell/set-array" "^1.0.1" "@jridgewell/sourcemap-codec" "^1.4.10" "@jridgewell/trace-mapping" "^0.3.9" "@jridgewell/resolve-uri@3.1.0": version "3.1.0" resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78" integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w== "@jridgewell/set-array@^1.0.1": version "1.1.2" resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72" integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw== "@jridgewell/sourcemap-codec@1.4.14": version "1.4.14" resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24" integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw== "@jridgewell/sourcemap-codec@^1.4.10": version "1.4.15" resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32" integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9": version "0.3.18" resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz#25783b2086daf6ff1dcb53c9249ae480e4dd4cd6" integrity sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA== dependencies: "@jridgewell/resolve-uri" "3.1.0" "@jridgewell/sourcemap-codec" "1.4.14" "@jsdevtools/ono@^7.1.3": version "7.1.3" resolved "https://registry.yarnpkg.com/@jsdevtools/ono/-/ono-7.1.3.tgz#9df03bbd7c696a5c58885c34aa06da41c8543796" integrity sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg== "@sinonjs/commons@^1.7.0": version "1.8.6" resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-1.8.6.tgz#80c516a4dc264c2a69115e7578d62581ff455ed9" integrity sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ== dependencies: type-detect "4.0.8" "@sinonjs/fake-timers@^8.0.1": version "8.1.0" resolved "https://registry.yarnpkg.com/@sinonjs/fake-timers/-/fake-timers-8.1.0.tgz#3fdc2b6cb58935b21bfb8d1625eb1300484316e7" integrity sha512-OAPJUAtgeINhh/TAlUID4QTs53Njm7xzddaVlEs/SXwgtiD1tW22zAB/W1wdqfrpmikgaWQ9Fw6Ws+hsiRm5Vg== dependencies: "@sinonjs/commons" "^1.7.0" "@tootallnate/once@1": version "1.1.2" resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82" integrity sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw== "@types/babel__core@^7.0.0", "@types/babel__core@^7.1.14": version "7.20.0" resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.20.0.tgz#61bc5a4cae505ce98e1e36c5445e4bee060d8891" integrity sha512-+n8dL/9GWblDO0iU6eZAwEIJVr5DWigtle+Q6HLOrh/pdbXOhOtqzq8VPPE2zvNJzSKY4vH/z3iT3tn0A3ypiQ== dependencies: "@babel/parser" "^7.20.7" "@babel/types" "^7.20.7" "@types/babel__generator" "*" "@types/babel__template" "*" "@types/babel__traverse" "*" "@types/babel__generator@*": version "7.6.4" resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.4.tgz#1f20ce4c5b1990b37900b63f050182d28c2439b7" integrity sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg== dependencies: "@babel/types" "^7.0.0" "@types/babel__template@*": version "7.4.1" resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.1.tgz#3d1a48fd9d6c0edfd56f2ff578daed48f36c8969" integrity sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g== dependencies: "@babel/parser" "^7.1.0" "@babel/types" "^7.0.0" "@types/babel__traverse@*", "@types/babel__traverse@^7.0.4", "@types/babel__traverse@^7.0.6": version "7.18.5" resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.18.5.tgz#c107216842905afafd3b6e774f6f935da6f5db80" integrity sha512-enCvTL8m/EHS/zIvJno9nE+ndYPh1/oNFzRYRmtUqJICG2VnCSBzMLW5VN2KCQU91f23tsNKR8v7VJJQMatl7Q== dependencies: "@babel/types" "^7.3.0" "@types/graceful-fs@^4.1.2", "@types/graceful-fs@^4.1.6": version "4.1.6" resolved "https://registry.yarnpkg.com/@types/graceful-fs/-/graceful-fs-4.1.6.tgz#e14b2576a1c25026b7f02ede1de3b84c3a1efeae" integrity sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw== dependencies: "@types/node" "*" "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": version "2.0.4" resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44" integrity sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g== "@types/istanbul-lib-report@*": version "3.0.0" resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#c14c24f18ea8190c118ee7562b7ff99a36552686" integrity sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg== dependencies: "@types/istanbul-lib-coverage" "*" "@types/istanbul-reports@^3.0.0": version "3.0.1" resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz#9153fe98bba2bd565a63add9436d6f0d7f8468ff" integrity sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw== dependencies: "@types/istanbul-lib-report" "*" "@types/jest@^27.5.1": version "27.5.2" resolved "https://registry.yarnpkg.com/@types/jest/-/jest-27.5.2.tgz#ec49d29d926500ffb9fd22b84262e862049c026c" integrity sha512-mpT8LJJ4CMeeahobofYWIjFo0xonRS/HfxnVEPMPFSQdGUt1uHCnoPT7Zhb+sjDU2wz0oKV0OLUR0WzrHNgfeA== dependencies: jest-matcher-utils "^27.0.0" pretty-format "^27.0.0" "@types/json-schema@^7.0.4", "@types/json-schema@^7.0.6": version "7.0.11" resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3" integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== "@types/node@*": version "20.1.7" resolved "https://registry.yarnpkg.com/@types/node/-/node-20.1.7.tgz#ce10c802f7731909d0a44ac9888e8b3a9125eb62" integrity sha512-WCuw/o4GSwDGMoonES8rcvwsig77dGCMbZDrZr2x4ZZiNW4P/gcoZXe/0twgtobcTkmg9TuKflxYL/DuwDyJzg== "@types/node@^14.11.1": version "14.18.47" resolved "https://registry.yarnpkg.com/@types/node/-/node-14.18.47.tgz#89a56b05804d136cb99bf2f823bb00814a889aae" integrity sha512-OuJi8bIng4wYHHA3YpKauL58dZrPxro3d0tabPHyiNF8rKfGKuVfr83oFlPLmKri1cX+Z3cJP39GXmnqkP11Gw== "@types/parse-json@^4.0.0": version "4.0.0" resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.0.tgz#2f8bb441434d163b35fb8ffdccd7138927ffb8c0" integrity sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA== "@types/prettier@^2.1.5": version "2.7.2" resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.7.2.tgz#6c2324641cc4ba050a8c710b2b251b377581fbf0" integrity sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg== "@types/stack-utils@^2.0.0": version "2.0.1" resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c" integrity sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw== "@types/yargs-parser@*": version "21.0.0" resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b" integrity sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA== "@types/yargs@^16.0.0": version "16.0.5" resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-16.0.5.tgz#12cc86393985735a283e387936398c2f9e5f88e3" integrity sha512-AxO/ADJOBFJScHbWhq2xAhlWP24rY4aCEG/NFaMvbT3X2MgRsLjhjQwsn0Zi5zn0LG9jUhCCZMeX9Dkuw6k+vQ== dependencies: "@types/yargs-parser" "*" "@yarnpkg/lockfile@^1.1.0": version "1.1.0" resolved "https://registry.yarnpkg.com/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz#e77a97fbd345b76d83245edcd17d393b1b41fb31" integrity sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ== abab@^2.0.3, abab@^2.0.5: version "2.0.6" resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.6.tgz#41b80f2c871d19686216b82309231cfd3cb3d291" integrity sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA== acorn-globals@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/acorn-globals/-/acorn-globals-6.0.0.tgz#46cdd39f0f8ff08a876619b55f5ac8a6dc770b45" integrity sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg== dependencies: acorn "^7.1.1" acorn-walk "^7.1.1" acorn-jsx@^5.3.1: version "5.3.2" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== acorn-walk@^7.1.1: version "7.2.0" resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-7.2.0.tgz#0de889a601203909b0fbe07b8938dc21d2e967bc" integrity sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA== acorn@^7.1.1, acorn@^7.4.0: version "7.4.1" resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa" integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== acorn@^8.2.4: version "8.8.2" resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a" integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw== agent-base@6: version "6.0.2" resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77" integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ== dependencies: debug "4" aggregate-error@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a" integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA== dependencies: clean-stack "^2.0.0" indent-string "^4.0.0" ajv@^6.10.0, ajv@^6.12.4: version "6.12.6" resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== dependencies: fast-deep-equal "^3.1.1" fast-json-stable-stringify "^2.0.0" json-schema-traverse "^0.4.1" uri-js "^4.2.2" ajv@^8.0.1: version "8.12.0" resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.12.0.tgz#d1a0527323e22f53562c567c00991577dfbe19d1" integrity sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA== dependencies: fast-deep-equal "^3.1.1" json-schema-traverse "^1.0.0" require-from-string "^2.0.2" uri-js "^4.2.2" ansi-colors@^4.1.1: version "4.1.3" resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b" integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw== ansi-escapes@^4.2.1, ansi-escapes@^4.3.0: version "4.3.2" resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e" integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== dependencies: type-fest "^0.21.3" ansi-regex@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== ansi-styles@^3.2.1: version "3.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d" integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== dependencies: color-convert "^1.9.0" ansi-styles@^4.0.0, ansi-styles@^4.1.0: version "4.3.0" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== dependencies: color-convert "^2.0.1" ansi-styles@^5.0.0: version "5.2.0" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b" integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== any-promise@^1.0.0: version "1.3.0" resolved "https://registry.yarnpkg.com/any-promise/-/any-promise-1.3.0.tgz#abc6afeedcea52e809cdc0376aed3ce39635d17f" integrity sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A== anymatch@^3.0.3: version "3.1.3" resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== dependencies: normalize-path "^3.0.0" picomatch "^2.0.4" argparse@^1.0.7: version "1.0.10" resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== dependencies: sprintf-js "~1.0.2" argparse@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== array-timsort@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/array-timsort/-/array-timsort-1.0.3.tgz#3c9e4199e54fb2b9c3fe5976396a21614ef0d926" integrity sha512-/+3GRL7dDAGEfM6TseQk/U+mi18TU2Ms9I3UlLdUMhz2hbvGNTKdj9xniwXfUqgYhHxRx0+8UnKkvlNwVU+cWQ== astral-regex@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31" integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ== asynckit@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== at-least-node@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2" integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg== babel-jest@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-27.5.1.tgz#a1bf8d61928edfefd21da27eb86a695bfd691444" integrity sha512-cdQ5dXjGRd0IBRATiQ4mZGlGlRE8kJpjPOixdNRdT+m3UcNqmYWN6rK6nvtXYfY3D76cb8s/O1Ss8ea24PIwcg== dependencies: "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" "@types/babel__core" "^7.1.14" babel-plugin-istanbul "^6.1.1" babel-preset-jest "^27.5.1" chalk "^4.0.0" graceful-fs "^4.2.9" slash "^3.0.0" babel-plugin-istanbul@^6.1.1: version "6.1.1" resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73" integrity sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA== dependencies: "@babel/helper-plugin-utils" "^7.0.0" "@istanbuljs/load-nyc-config" "^1.0.0" "@istanbuljs/schema" "^0.1.2" istanbul-lib-instrument "^5.0.4" test-exclude "^6.0.0" babel-plugin-jest-hoist@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-27.5.1.tgz#9be98ecf28c331eb9f5df9c72d6f89deb8181c2e" integrity sha512-50wCwD5EMNW4aRpOwtqzyZHIewTYNxLA4nhB+09d8BIssfNfzBRhkBIHiaPv1Si226TQSvp8gxAJm2iY2qs2hQ== dependencies: "@babel/template" "^7.3.3" "@babel/types" "^7.3.3" "@types/babel__core" "^7.0.0" "@types/babel__traverse" "^7.0.6" babel-preset-current-node-syntax@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz#b4399239b89b2a011f9ddbe3e4f401fc40cff73b" integrity sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ== dependencies: "@babel/plugin-syntax-async-generators" "^7.8.4" "@babel/plugin-syntax-bigint" "^7.8.3" "@babel/plugin-syntax-class-properties" "^7.8.3" "@babel/plugin-syntax-import-meta" "^7.8.3" "@babel/plugin-syntax-json-strings" "^7.8.3" "@babel/plugin-syntax-logical-assignment-operators" "^7.8.3" "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3" "@babel/plugin-syntax-numeric-separator" "^7.8.3" "@babel/plugin-syntax-object-rest-spread" "^7.8.3" "@babel/plugin-syntax-optional-catch-binding" "^7.8.3" "@babel/plugin-syntax-optional-chaining" "^7.8.3" "@babel/plugin-syntax-top-level-await" "^7.8.3" babel-preset-jest@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/babel-preset-jest/-/babel-preset-jest-27.5.1.tgz#91f10f58034cb7989cb4f962b69fa6eef6a6bc81" integrity sha512-Nptf2FzlPCWYuJg41HBqXVT8ym6bXOevuCTbhxlUpjwtysGaIWFvDEjp4y+G7fl13FgOdjs7P/DmErqH7da0Ag== dependencies: babel-plugin-jest-hoist "^27.5.1" babel-preset-current-node-syntax "^1.0.0" balanced-match@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== brace-expansion@^1.1.7: version "1.1.11" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== dependencies: balanced-match "^1.0.0" concat-map "0.0.1" braces@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107" integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== dependencies: fill-range "^7.0.1" browser-process-hrtime@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz#3c9b4b7d782c8121e56f10106d84c0d0ffc94626" integrity sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow== browserslist@^4.21.3: version "4.21.5" resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.5.tgz#75c5dae60063ee641f977e00edd3cfb2fb7af6a7" integrity sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w== dependencies: caniuse-lite "^1.0.30001449" electron-to-chromium "^1.4.284" node-releases "^2.0.8" update-browserslist-db "^1.0.10" bser@2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05" integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== dependencies: node-int64 "^0.4.0" buffer-from@^1.0.0: version "1.1.2" resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5" integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== call-me-maybe@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/call-me-maybe/-/call-me-maybe-1.0.2.tgz#03f964f19522ba643b1b0693acb9152fe2074baa" integrity sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ== callsites@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== camelcase@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== camelcase@^6.2.0: version "6.3.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== caniuse-lite@^1.0.30001449: version "1.0.30001488" resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001488.tgz#d19d7b6e913afae3e98f023db97c19e9ddc5e91f" integrity sha512-NORIQuuL4xGpIy6iCCQGN4iFjlBXtfKWIenlUuyZJumLRIindLb7wXM+GO8erEhb7vXfcnf4BAg2PrSDN5TNLQ== chalk@^2.0.0: version "2.4.2" resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== dependencies: ansi-styles "^3.2.1" escape-string-regexp "^1.0.5" supports-color "^5.3.0" chalk@^4.0.0, chalk@^4.1.0: version "4.1.2" resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== dependencies: ansi-styles "^4.1.0" supports-color "^7.1.0" char-regex@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== ci-info@^3.2.0: version "3.8.0" resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.8.0.tgz#81408265a5380c929f0bc665d62256628ce9ef91" integrity sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw== cjs-module-lexer@^1.0.0: version "1.2.2" resolved "https://registry.yarnpkg.com/cjs-module-lexer/-/cjs-module-lexer-1.2.2.tgz#9f84ba3244a512f3a54e5277e8eef4c489864e40" integrity sha512-cOU9usZw8/dXIXKtwa8pM0OTJQuJkxMN6w30csNRUerHfeQ5R6U3kkU/FtJeIf3M202OHfY2U8ccInBG7/xogA== clean-stack@^2.0.0: version "2.2.0" resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b" integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A== cli-color@^2.0.0: version "2.0.3" resolved "https://registry.yarnpkg.com/cli-color/-/cli-color-2.0.3.tgz#73769ba969080629670f3f2ef69a4bf4e7cc1879" integrity sha512-OkoZnxyC4ERN3zLzZaY9Emb7f/MhBOIpePv0Ycok0fJYT+Ouo00UBEIwsVsr0yoow++n5YWlSUgST9GKhNHiRQ== dependencies: d "^1.0.1" es5-ext "^0.10.61" es6-iterator "^2.0.3" memoizee "^0.4.15" timers-ext "^0.1.7" cli-cursor@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307" integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw== dependencies: restore-cursor "^3.1.0" cli-truncate@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-2.1.0.tgz#c39e28bf05edcde5be3b98992a22deed5a2b93c7" integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg== dependencies: slice-ansi "^3.0.0" string-width "^4.2.0" cliui@^7.0.2: version "7.0.4" resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f" integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== dependencies: string-width "^4.2.0" strip-ansi "^6.0.0" wrap-ansi "^7.0.0" co@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ== collect-v8-coverage@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz#cc2c8e94fc18bbdffe64d6534570c8a673b27f59" integrity sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg== color-convert@^1.9.0: version "1.9.3" resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8" integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== dependencies: color-name "1.1.3" color-convert@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== dependencies: color-name "~1.1.4" color-name@1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25" integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw== color-name@~1.1.4: version "1.1.4" resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== colorette@^2.0.16: version "2.0.20" resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a" integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w== combined-stream@^1.0.8: version "1.0.8" resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== dependencies: delayed-stream "~1.0.0" commander@^6.2.0: version "6.2.1" resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c" integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA== commander@^7.0.0: version "7.2.0" resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7" integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw== comment-json@^4.0.6, comment-json@^4.1.0: version "4.2.3" resolved "https://registry.yarnpkg.com/comment-json/-/comment-json-4.2.3.tgz#50b487ebbf43abe44431f575ebda07d30d015365" integrity sha512-SsxdiOf064DWoZLH799Ata6u7iV658A11PlWtZATDlXPpKGJnbJZ5Z24ybixAi+LUUqJ/GKowAejtC5GFUG7Tw== dependencies: array-timsort "^1.0.3" core-util-is "^1.0.3" esprima "^4.0.1" has-own-prop "^2.0.0" repeat-string "^1.6.1" comment-parser@^0.7.6: version "0.7.6" resolved "https://registry.yarnpkg.com/comment-parser/-/comment-parser-0.7.6.tgz#0e743a53c8e646c899a1323db31f6cd337b10f12" integrity sha512-GKNxVA7/iuTnAqGADlTWX4tkhzxZKXp5fLJqKTlQLHkE65XDUKutZ3BHaJC5IGcper2tT3QRD1xr4o3jNpgXXg== commondir@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b" integrity sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg== concat-map@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== configstore@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/configstore/-/configstore-5.0.1.tgz#d365021b5df4b98cdd187d6a3b0e3f6a7cc5ed96" integrity sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA== dependencies: dot-prop "^5.2.0" graceful-fs "^4.1.2" make-dir "^3.0.0" unique-string "^2.0.0" write-file-atomic "^3.0.0" xdg-basedir "^4.0.0" convert-source-map@^1.4.0, convert-source-map@^1.6.0, convert-source-map@^1.7.0: version "1.9.0" resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f" integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A== core-util-is@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85" integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== cosmiconfig@^7.0.0: version "7.1.0" resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.1.0.tgz#1443b9afa596b670082ea46cbd8f6a62b84635f6" integrity sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA== dependencies: "@types/parse-json" "^4.0.0" import-fresh "^3.2.1" parse-json "^5.0.0" path-type "^4.0.0" yaml "^1.10.0" cross-spawn@^7.0.0, cross-spawn@^7.0.2, cross-spawn@^7.0.3: version "7.0.3" resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6" integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== dependencies: path-key "^3.1.0" shebang-command "^2.0.0" which "^2.0.1" crypto-random-string@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-2.0.0.tgz#ef2a7a966ec11083388369baa02ebead229b30d5" integrity sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA== cspell-glob@^0.1.25: version "0.1.25" resolved "https://registry.yarnpkg.com/cspell-glob/-/cspell-glob-0.1.25.tgz#5d55b03ac5e7a379d435ebd5685178806b0c372f" integrity sha512-/XaSHrGBpMJa+duFz3GKOWfrijrfdHT7a/XGgIcq3cymCSpOH+DPho42sl0jLI/hjM+8yv2m8aEoxRT8yVSnlg== dependencies: micromatch "^4.0.2" cspell-io@^4.1.7: version "4.1.7" resolved "https://registry.yarnpkg.com/cspell-io/-/cspell-io-4.1.7.tgz#ff2c0d44560fe26fa8c5714d2b973a940a66bffe" integrity sha512-V0/tUu9FnIS3v+vAvDT6NNa14Nc/zUNX8+YUUOfFAiDJJTdqefmvcWjOJBIMYBf3wIk9iWLmLbMM+bNHqr7DSQ== dependencies: iconv-lite "^0.6.2" iterable-to-stream "^1.0.1" cspell-lib@^4.3.12: version "4.3.12" resolved "https://registry.yarnpkg.com/cspell-lib/-/cspell-lib-4.3.12.tgz#9ba30591079562534ef47e5552b86cadaf7383d8" integrity sha512-yCCb6MoW1K8Tsr/WVEQoO4dfYhH9bCsjQayccb8MlyDaNNuWJHuX+gUGHsZSXSuChSh8PrTWKXJzs13/uM977g== dependencies: "@cspell/dict-aws" "^1.0.13" "@cspell/dict-bash" "^1.0.11" "@cspell/dict-companies" "^1.0.35" "@cspell/dict-cpp" "^1.1.37" "@cspell/dict-cryptocurrencies" "^1.0.10" "@cspell/dict-csharp" "^1.0.10" "@cspell/dict-css" "^1.0.10" "@cspell/dict-django" "^1.0.25" "@cspell/dict-dotnet" "^1.0.24" "@cspell/dict-elixir" "^1.0.23" "@cspell/dict-en-gb" "^1.1.27" "@cspell/dict-en_us" "^1.2.39" "@cspell/dict-filetypes" "^1.1.5" "@cspell/dict-fonts" "^1.0.13" "@cspell/dict-fullstack" "^1.0.36" "@cspell/dict-golang" "^1.1.24" "@cspell/dict-haskell" "^1.0.12" "@cspell/dict-html" "^1.1.5" "@cspell/dict-html-symbol-entities" "^1.0.23" "@cspell/dict-java" "^1.0.22" "@cspell/dict-latex" "^1.0.23" "@cspell/dict-lorem-ipsum" "^1.0.22" "@cspell/dict-lua" "^1.0.16" "@cspell/dict-node" "^1.0.10" "@cspell/dict-npm" "^1.0.10" "@cspell/dict-php" "^1.0.23" "@cspell/dict-powershell" "^1.0.14" "@cspell/dict-python" "^1.0.32" "@cspell/dict-ruby" "^1.0.12" "@cspell/dict-rust" "^1.0.22" "@cspell/dict-scala" "^1.0.21" "@cspell/dict-software-terms" "^1.0.24" "@cspell/dict-typescript" "^1.0.16" comment-json "^4.1.0" configstore "^5.0.1" cspell-io "^4.1.7" cspell-trie-lib "^4.2.8" cspell-util-bundle "^4.1.11" fs-extra "^9.1.0" gensequence "^3.1.1" minimatch "^3.0.4" resolve-from "^5.0.0" resolve-global "^1.0.0" vscode-uri "^3.0.2" cspell-trie-lib@^4.2.8: version "4.2.8" resolved "https://registry.yarnpkg.com/cspell-trie-lib/-/cspell-trie-lib-4.2.8.tgz#50d9841945274b7c879e2ebe3caa360828355bda" integrity sha512-Nt3c0gxOYXIc3/yhALDukpje1BgR6guvlUKWQO2zb0r7qRWpwUw2j2YM4dWbHQeH/3Hx5ei4Braa6cMaiJ5YBw== dependencies: gensequence "^3.1.1" cspell-util-bundle@^4.1.11: version "4.1.11" resolved "https://registry.yarnpkg.com/cspell-util-bundle/-/cspell-util-bundle-4.1.11.tgz#96840af030dcac5baeb3480e249e7402413015d0" integrity sha512-or3OGKydZs1NwweMIgnA48k8H3F5zK4e5lonjUhpEzLYQZ2nB23decdoqZ8ogFC8pFTA40tZKDsMJ0b+65gX4Q== cspell@4.2.8: version "4.2.8" resolved "https://registry.yarnpkg.com/cspell/-/cspell-4.2.8.tgz#69b4c6f4c1b628f0b51d8618738d061e497d76d3" integrity sha512-eqan8+lCU9bSp8Tl4+SR/ccBnuPyMmp7evck/RlMdFTjLh/s+3vQ5hQyBzbzK8w2MMqL84CymW7BwIOKjpylSg== dependencies: chalk "^4.1.0" commander "^7.0.0" comment-json "^4.0.6" cspell-glob "^0.1.25" cspell-lib "^4.3.12" fs-extra "^9.1.0" gensequence "^3.1.1" get-stdin "^8.0.0" glob "^7.1.6" minimatch "^3.0.4" cssom@^0.4.4: version "0.4.4" resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.4.4.tgz#5a66cf93d2d0b661d80bf6a44fb65f5c2e4e0a10" integrity sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw== cssom@~0.3.6: version "0.3.8" resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.3.8.tgz#9f1276f5b2b463f2114d3f2c75250af8c1a36f4a" integrity sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg== cssstyle@^2.3.0: version "2.3.0" resolved "https://registry.yarnpkg.com/cssstyle/-/cssstyle-2.3.0.tgz#ff665a0ddbdc31864b09647f34163443d90b0852" integrity sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A== dependencies: cssom "~0.3.6" d@1, d@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a" integrity sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA== dependencies: es5-ext "^0.10.50" type "^1.0.1" data-urls@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/data-urls/-/data-urls-2.0.0.tgz#156485a72963a970f5d5821aaf642bef2bf2db9b" integrity sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ== dependencies: abab "^2.0.3" whatwg-mimetype "^2.3.0" whatwg-url "^8.0.0" debug@4, debug@^4.0.1, debug@^4.1.0, debug@^4.1.1, debug@^4.2.0, debug@^4.3.1: version "4.3.4" resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865" integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== dependencies: ms "2.1.2" decimal.js@^10.2.1: version "10.4.3" resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.4.3.tgz#1044092884d245d1b7f65725fa4ad4c6f781cc23" integrity sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA== dedent@^0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c" integrity sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA== deep-is@^0.1.3, deep-is@~0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== deepmerge@^4.2.2: version "4.3.1" resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a" integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== delayed-stream@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== detect-newline@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== diff-sequences@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-27.5.1.tgz#eaecc0d327fd68c8d9672a1e64ab8dccb2ef5327" integrity sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ== doctrine@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961" integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== dependencies: esutils "^2.0.2" domexception@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/domexception/-/domexception-2.0.1.tgz#fb44aefba793e1574b0af6aed2801d057529f304" integrity sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg== dependencies: webidl-conversions "^5.0.0" dot-prop@^5.2.0: version "5.3.0" resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88" integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q== dependencies: is-obj "^2.0.0" electron-to-chromium@^1.4.284: version "1.4.397" resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.397.tgz#82a7e26c657538d59bb713b97ac22f97ea3a90ea" integrity sha512-jwnPxhh350Q/aMatQia31KAIQdhEsYS0fFZ0BQQlN9tfvOEwShu6ZNwI4kL/xBabjcB/nTy6lSt17kNIluJZ8Q== emittery@^0.8.1: version "0.8.1" resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.8.1.tgz#bb23cc86d03b30aa75a7f734819dee2e1ba70860" integrity sha512-uDfvUjVrfGJJhymx/kz6prltenw1u7WrCg1oa94zYY8xxVpLLUu045LAT0dhDZdXG58/EpPL/5kA180fQ/qudg== emoji-regex@^8.0.0: version "8.0.0" resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== end-of-stream@^1.1.0: version "1.4.4" resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0" integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== dependencies: once "^1.4.0" enquirer@^2.3.5, enquirer@^2.3.6: version "2.3.6" resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d" integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg== dependencies: ansi-colors "^4.1.1" error-ex@^1.3.1: version "1.3.2" resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf" integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== dependencies: is-arrayish "^0.2.1" es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@^0.10.53, es5-ext@^0.10.61, es5-ext@~0.10.14, es5-ext@~0.10.2, es5-ext@~0.10.46: version "0.10.62" resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.62.tgz#5e6adc19a6da524bf3d1e02bbc8960e5eb49a9a5" integrity sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA== dependencies: es6-iterator "^2.0.3" es6-symbol "^3.1.3" next-tick "^1.1.0" es6-iterator@^2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7" integrity sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g== dependencies: d "1" es5-ext "^0.10.35" es6-symbol "^3.1.1" es6-symbol@^3.1.1, es6-symbol@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18" integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA== dependencies: d "^1.0.1" ext "^1.1.2" es6-weak-map@^2.0.3: version "2.0.3" resolved "https://registry.yarnpkg.com/es6-weak-map/-/es6-weak-map-2.0.3.tgz#b6da1f16cc2cc0d9be43e6bdbfc5e7dfcdf31d53" integrity sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA== dependencies: d "1" es5-ext "^0.10.46" es6-iterator "^2.0.3" es6-symbol "^3.1.1" escalade@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40" integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== escape-string-regexp@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== escape-string-regexp@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== escape-string-regexp@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34" integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== escodegen@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.0.0.tgz#5e32b12833e8aa8fa35e1bf0befa89380484c7dd" integrity sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw== dependencies: esprima "^4.0.1" estraverse "^5.2.0" esutils "^2.0.2" optionator "^0.8.1" optionalDependencies: source-map "~0.6.1" eslint-config-prettier@^6.11.0: version "6.15.0" resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-6.15.0.tgz#7f93f6cb7d45a92f1537a70ecc06366e1ac6fed9" integrity sha512-a1+kOYLR8wMGustcgAjdydMsQ2A/2ipRPwRKUmfYaSxc9ZPcrku080Ctl6zrZzZNs/U82MjSv+qKREkoq3bJaw== dependencies: get-stdin "^6.0.0" eslint-plugin-es@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/eslint-plugin-es/-/eslint-plugin-es-3.0.1.tgz#75a7cdfdccddc0589934aeeb384175f221c57893" integrity sha512-GUmAsJaN4Fc7Gbtl8uOBlayo2DqhwWvEzykMHSCZHU3XdJ+NSzzZcVhXh3VxX5icqQ+oQdIEawXX8xkR3mIFmQ== dependencies: eslint-utils "^2.0.0" regexpp "^3.0.0" eslint-plugin-jsdoc@^30.5.1: version "30.7.13" resolved "https://registry.yarnpkg.com/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-30.7.13.tgz#52e5c74fb806d3bbeb51d04a0c829508c3c6b563" integrity sha512-YM4WIsmurrp0rHX6XiXQppqKB8Ne5ATiZLJe2+/fkp9l9ExXFr43BbAbjZaVrpCT+tuPYOZ8k1MICARHnURUNQ== dependencies: comment-parser "^0.7.6" debug "^4.3.1" jsdoctypeparser "^9.0.0" lodash "^4.17.20" regextras "^0.7.1" semver "^7.3.4" spdx-expression-parse "^3.0.1" eslint-plugin-node@^11.1.0: version "11.1.0" resolved "https://registry.yarnpkg.com/eslint-plugin-node/-/eslint-plugin-node-11.1.0.tgz#c95544416ee4ada26740a30474eefc5402dc671d" integrity sha512-oUwtPJ1W0SKD0Tr+wqu92c5xuCeQqB3hSCHasn/ZgjFdA9iDGNkNf2Zi9ztY7X+hNuMib23LNGRm6+uN+KLE3g== dependencies: eslint-plugin-es "^3.0.0" eslint-utils "^2.0.0" ignore "^5.1.1" minimatch "^3.0.4" resolve "^1.10.1" semver "^6.1.0" eslint-plugin-prettier@^3.1.4: version "3.4.1" resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-3.4.1.tgz#e9ddb200efb6f3d05ffe83b1665a716af4a387e5" integrity sha512-htg25EUYUeIhKHXjOinK4BgCcDwtLHjqaxCDsMy5nbnUMkKFvIhMVCp+5GFUXQ4Nr8lBsPqtGAqBenbpFqAA2g== dependencies: prettier-linter-helpers "^1.0.0" eslint-scope@^5.1.1: version "5.1.1" resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c" integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== dependencies: esrecurse "^4.3.0" estraverse "^4.1.1" eslint-utils@^2.0.0, eslint-utils@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-2.1.0.tgz#d2de5e03424e707dc10c74068ddedae708741b27" integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg== dependencies: eslint-visitor-keys "^1.1.0" eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e" integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ== eslint-visitor-keys@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303" integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw== eslint@^7.9.0: version "7.32.0" resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d" integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA== dependencies: "@babel/code-frame" "7.12.11" "@eslint/eslintrc" "^0.4.3" "@humanwhocodes/config-array" "^0.5.0" ajv "^6.10.0" chalk "^4.0.0" cross-spawn "^7.0.2" debug "^4.0.1" doctrine "^3.0.0" enquirer "^2.3.5" escape-string-regexp "^4.0.0" eslint-scope "^5.1.1" eslint-utils "^2.1.0" eslint-visitor-keys "^2.0.0" espree "^7.3.1" esquery "^1.4.0" esutils "^2.0.2" fast-deep-equal "^3.1.3" file-entry-cache "^6.0.1" functional-red-black-tree "^1.0.1" glob-parent "^5.1.2" globals "^13.6.0" ignore "^4.0.6" import-fresh "^3.0.0" imurmurhash "^0.1.4" is-glob "^4.0.0" js-yaml "^3.13.1" json-stable-stringify-without-jsonify "^1.0.1" levn "^0.4.1" lodash.merge "^4.6.2" minimatch "^3.0.4" natural-compare "^1.4.0" optionator "^0.9.1" progress "^2.0.0" regexpp "^3.1.0" semver "^7.2.1" strip-ansi "^6.0.0" strip-json-comments "^3.1.0" table "^6.0.9" text-table "^0.2.0" v8-compile-cache "^2.0.3" espree@^7.3.0, espree@^7.3.1: version "7.3.1" resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.1.tgz#f2df330b752c6f55019f8bd89b7660039c1bbbb6" integrity sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g== dependencies: acorn "^7.4.0" acorn-jsx "^5.3.1" eslint-visitor-keys "^1.3.0" esprima@^4.0.0, esprima@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== esquery@^1.4.0: version "1.5.0" resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b" integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg== dependencies: estraverse "^5.1.0" esrecurse@^4.3.0: version "4.3.0" resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921" integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== dependencies: estraverse "^5.2.0" estraverse@^4.1.1: version "4.3.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== estraverse@^5.1.0, estraverse@^5.2.0: version "5.3.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== esutils@^2.0.2: version "2.0.3" resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== event-emitter@^0.3.5: version "0.3.5" resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39" integrity sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA== dependencies: d "1" es5-ext "~0.10.14" execa@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/execa/-/execa-4.1.0.tgz#4e5491ad1572f2f17a77d388c6c857135b22847a" integrity sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA== dependencies: cross-spawn "^7.0.0" get-stream "^5.0.0" human-signals "^1.1.1" is-stream "^2.0.0" merge-stream "^2.0.0" npm-run-path "^4.0.0" onetime "^5.1.0" signal-exit "^3.0.2" strip-final-newline "^2.0.0" execa@^5.0.0: version "5.1.1" resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd" integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== dependencies: cross-spawn "^7.0.3" get-stream "^6.0.0" human-signals "^2.1.0" is-stream "^2.0.0" merge-stream "^2.0.0" npm-run-path "^4.0.1" onetime "^5.1.2" signal-exit "^3.0.3" strip-final-newline "^2.0.0" exit@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" integrity sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ== expect@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/expect/-/expect-27.5.1.tgz#83ce59f1e5bdf5f9d2b94b61d2050db48f3fef74" integrity sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw== dependencies: "@jest/types" "^27.5.1" jest-get-type "^27.5.1" jest-matcher-utils "^27.5.1" jest-message-util "^27.5.1" ext@^1.1.2: version "1.7.0" resolved "https://registry.yarnpkg.com/ext/-/ext-1.7.0.tgz#0ea4383c0103d60e70be99e9a7f11027a33c4f5f" integrity sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw== dependencies: type "^2.7.2" fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== fast-diff@^1.1.2: version "1.2.0" resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.2.0.tgz#73ee11982d86caaf7959828d519cfe927fac5f03" integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w== fast-json-stable-stringify@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== fb-watchman@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c" integrity sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== dependencies: bser "2.1.1" file-entry-cache@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027" integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== dependencies: flat-cache "^3.0.4" fill-range@^7.0.1: version "7.0.1" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40" integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== dependencies: to-regex-range "^5.0.1" find-up@^4.0.0, find-up@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== dependencies: locate-path "^5.0.0" path-exists "^4.0.0" flat-cache@^3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11" integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== dependencies: flatted "^3.1.0" rimraf "^3.0.2" flatted@^3.1.0: version "3.2.7" resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787" integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ== form-data@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f" integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg== dependencies: asynckit "^0.4.0" combined-stream "^1.0.8" mime-types "^2.1.12" fs-extra@^9.1.0: version "9.1.0" resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d" integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ== dependencies: at-least-node "^1.0.0" graceful-fs "^4.2.0" jsonfile "^6.0.1" universalify "^2.0.0" fs-monkey@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/fs-monkey/-/fs-monkey-1.0.3.tgz#ae3ac92d53bb328efe0e9a1d9541f6ad8d48e2d3" integrity sha512-cybjIfiiE+pTWicSCLFHSrXZ6EilF30oh91FDP9S2B051prEa7QWfrVTQm10/dDpswBDXZugPa1Ogu8Yh+HV0Q== fs.realpath@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== fsevents@^2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== function-bind@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== functional-red-black-tree@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" integrity sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g== gensequence@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/gensequence/-/gensequence-3.1.1.tgz#95c1afc7c0680f92942c17f2d6f83f3d26ea97af" integrity sha512-ys3h0hiteRwmY6BsvSttPmkhC0vEQHPJduANBRtH/dlDPZ0UBIb/dXy80IcckXyuQ6LKg+PloRqvGER9IS7F7g== gensync@^1.0.0-beta.2: version "1.0.0-beta.2" resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== get-caller-file@^2.0.5: version "2.0.5" resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== get-own-enumerable-property-symbols@^3.0.0: version "3.0.2" resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz#b5fde77f22cbe35f390b4e089922c50bce6ef664" integrity sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g== get-package-type@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a" integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q== get-stdin@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-6.0.0.tgz#9e09bf712b360ab9225e812048f71fde9c89657b" integrity sha512-jp4tHawyV7+fkkSKyvjuLZswblUtz+SQKzSWnBbii16BuZksJlU1wuBYXY75r+duh/llF1ur6oNwi+2ZzjKZ7g== get-stdin@^8.0.0: version "8.0.0" resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-8.0.0.tgz#cbad6a73feb75f6eeb22ba9e01f89aa28aa97a53" integrity sha512-sY22aA6xchAzprjyqmSEQv4UbAAzRN0L2dQB0NlN5acTTK9Don6nhoc3eAbUnpZiCANAMfd/+40kVdKfFygohg== get-stream@^5.0.0: version "5.2.0" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3" integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA== dependencies: pump "^3.0.0" get-stream@^6.0.0: version "6.0.1" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7" integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== glob-parent@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== dependencies: is-glob "^4.0.1" glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, glob@^7.1.6: version "7.2.3" resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" minimatch "^3.1.1" once "^1.3.0" path-is-absolute "^1.0.0" global-dirs@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-0.1.1.tgz#b319c0dd4607f353f3be9cca4c72fc148c49f445" integrity sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg== dependencies: ini "^1.3.4" globals@^11.1.0: version "11.12.0" resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== globals@^13.6.0, globals@^13.9.0: version "13.20.0" resolved "https://registry.yarnpkg.com/globals/-/globals-13.20.0.tgz#ea276a1e508ffd4f1612888f9d1bad1e2717bf82" integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ== dependencies: type-fest "^0.20.2" graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.4, graceful-fs@^4.2.9: version "4.2.11" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== has-flag@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw== has-flag@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== has-own-prop@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/has-own-prop/-/has-own-prop-2.0.0.tgz#f0f95d58f65804f5d218db32563bb85b8e0417af" integrity sha512-Pq0h+hvsVm6dDEa8x82GnLSYHOzNDt7f0ddFa3FqcQlgzEiptPqL+XrOJNavjOzSYiYWIrgeVYYgGlLmnxwilQ== has@^1.0.3: version "1.0.3" resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796" integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== dependencies: function-bind "^1.1.1" html-encoding-sniffer@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz#42a6dc4fd33f00281176e8b23759ca4e4fa185f3" integrity sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ== dependencies: whatwg-encoding "^1.0.5" html-escaper@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== http-proxy-agent@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz#8a8c8ef7f5932ccf953c296ca8291b95aa74aa3a" integrity sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg== dependencies: "@tootallnate/once" "1" agent-base "6" debug "4" https-proxy-agent@^5.0.0: version "5.0.1" resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6" integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA== dependencies: agent-base "6" debug "4" human-signals@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-1.1.1.tgz#c5b1cd14f50aeae09ab6c59fe63ba3395fe4dfa3" integrity sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw== human-signals@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== husky@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/husky/-/husky-6.0.0.tgz#810f11869adf51604c32ea577edbc377d7f9319e" integrity sha512-SQS2gDTB7tBN486QSoKPKQItZw97BMOd+Kdb6ghfpBc0yXyzrddI0oDV5MkDAbuB4X2mO3/nj60TRMcYxwzZeQ== iconv-lite@0.4.24: version "0.4.24" resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b" integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== dependencies: safer-buffer ">= 2.1.2 < 3" iconv-lite@^0.6.2: version "0.6.3" resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501" integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== dependencies: safer-buffer ">= 2.1.2 < 3.0.0" ignore@^4.0.6: version "4.0.6" resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc" integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg== ignore@^5.1.1: version "5.2.4" resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324" integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ== import-fresh@^3.0.0, import-fresh@^3.2.1: version "3.3.0" resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b" integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== dependencies: parent-module "^1.0.0" resolve-from "^4.0.0" import-local@^3.0.2: version "3.1.0" resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.1.0.tgz#b4479df8a5fd44f6cdce24070675676063c95cb4" integrity sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg== dependencies: pkg-dir "^4.2.0" resolve-cwd "^3.0.0" imurmurhash@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== indent-string@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251" integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg== inflight@^1.0.4: version "1.0.6" resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== dependencies: once "^1.3.0" wrappy "1" inherits@2: version "2.0.4" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== ini@^1.3.4: version "1.3.8" resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== is-arrayish@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== is-core-module@^2.11.0: version "2.12.1" resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.1.tgz#0c0b6885b6f80011c71541ce15c8d66cf5a4f9fd" integrity sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg== dependencies: has "^1.0.3" is-extglob@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== is-fullwidth-code-point@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== is-generator-fn@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118" integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== is-glob@^4.0.0, is-glob@^4.0.1: version "4.0.3" resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== dependencies: is-extglob "^2.1.1" is-number@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== is-obj@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f" integrity sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg== is-obj@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982" integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w== is-potential-custom-element-name@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz#171ed6f19e3ac554394edf78caa05784a45bebb5" integrity sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ== is-promise@^2.2.2: version "2.2.2" resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.2.2.tgz#39ab959ccbf9a774cf079f7b40c7a26f763135f1" integrity sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ== is-regexp@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069" integrity sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA== is-stream@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077" integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== is-typedarray@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA== is-unicode-supported@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7" integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw== isexe@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3" integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw== istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0: version "5.2.1" resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz#d10c8885c2125574e1c231cacadf955675e1ce3d" integrity sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg== dependencies: "@babel/core" "^7.12.3" "@babel/parser" "^7.14.7" "@istanbuljs/schema" "^0.1.2" istanbul-lib-coverage "^3.2.0" semver "^6.3.0" istanbul-lib-report@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6" integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw== dependencies: istanbul-lib-coverage "^3.0.0" make-dir "^3.0.0" supports-color "^7.1.0" istanbul-lib-source-maps@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551" integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw== dependencies: debug "^4.1.1" istanbul-lib-coverage "^3.0.0" source-map "^0.6.1" istanbul-reports@^3.1.3: version "3.1.5" resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.5.tgz#cc9a6ab25cb25659810e4785ed9d9fb742578bae" integrity sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w== dependencies: html-escaper "^2.0.0" istanbul-lib-report "^3.0.0" iterable-to-stream@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/iterable-to-stream/-/iterable-to-stream-1.0.1.tgz#37e86baacf6b1a0e9233dad4eb526d0423d08bf3" integrity sha512-O62gD5ADMUGtJoOoM9U6LQ7i4byPXUNoHJ6mqsmkQJcom331ZJGDApWgDESWyBMEHEJRjtHozgIiTzYo9RU4UA== jest-changed-files@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-27.5.1.tgz#a348aed00ec9bf671cc58a66fcbe7c3dfd6a68f5" integrity sha512-buBLMiByfWGCoMsLLzGUUSpAmIAGnbR2KJoMN10ziLhOLvP4e0SlypHnAel8iqQXTrcbmfEY9sSqae5sgUsTvw== dependencies: "@jest/types" "^27.5.1" execa "^5.0.0" throat "^6.0.1" jest-circus@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-circus/-/jest-circus-27.5.1.tgz#37a5a4459b7bf4406e53d637b49d22c65d125ecc" integrity sha512-D95R7x5UtlMA5iBYsOHFFbMD/GVA4R/Kdq15f7xYWUfWHBto9NYRsOvnSauTgdF+ogCpJ4tyKOXhUifxS65gdw== dependencies: "@jest/environment" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" co "^4.6.0" dedent "^0.7.0" expect "^27.5.1" is-generator-fn "^2.0.0" jest-each "^27.5.1" jest-matcher-utils "^27.5.1" jest-message-util "^27.5.1" jest-runtime "^27.5.1" jest-snapshot "^27.5.1" jest-util "^27.5.1" pretty-format "^27.5.1" slash "^3.0.0" stack-utils "^2.0.3" throat "^6.0.1" jest-cli@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-27.5.1.tgz#278794a6e6458ea8029547e6c6cbf673bd30b145" integrity sha512-Hc6HOOwYq4/74/c62dEE3r5elx8wjYqxY0r0G/nFrLDPMFRu6RA/u8qINOIkvhxG7mMQ5EJsOGfRpI8L6eFUVw== dependencies: "@jest/core" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/types" "^27.5.1" chalk "^4.0.0" exit "^0.1.2" graceful-fs "^4.2.9" import-local "^3.0.2" jest-config "^27.5.1" jest-util "^27.5.1" jest-validate "^27.5.1" prompts "^2.0.1" yargs "^16.2.0" jest-config@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-27.5.1.tgz#5c387de33dca3f99ad6357ddeccd91bf3a0e4a41" integrity sha512-5sAsjm6tGdsVbW9ahcChPAFCk4IlkQUknH5AvKjuLTSlcO/wCZKyFdn7Rg0EkC+OGgWODEy2hDpWB1PgzH0JNA== dependencies: "@babel/core" "^7.8.0" "@jest/test-sequencer" "^27.5.1" "@jest/types" "^27.5.1" babel-jest "^27.5.1" chalk "^4.0.0" ci-info "^3.2.0" deepmerge "^4.2.2" glob "^7.1.1" graceful-fs "^4.2.9" jest-circus "^27.5.1" jest-environment-jsdom "^27.5.1" jest-environment-node "^27.5.1" jest-get-type "^27.5.1" jest-jasmine2 "^27.5.1" jest-regex-util "^27.5.1" jest-resolve "^27.5.1" jest-runner "^27.5.1" jest-util "^27.5.1" jest-validate "^27.5.1" micromatch "^4.0.4" parse-json "^5.2.0" pretty-format "^27.5.1" slash "^3.0.0" strip-json-comments "^3.1.1" jest-diff@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-27.5.1.tgz#a07f5011ac9e6643cf8a95a462b7b1ecf6680def" integrity sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw== dependencies: chalk "^4.0.0" diff-sequences "^27.5.1" jest-get-type "^27.5.1" pretty-format "^27.5.1" jest-docblock@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-27.5.1.tgz#14092f364a42c6108d42c33c8cf30e058e25f6c0" integrity sha512-rl7hlABeTsRYxKiUfpHrQrG4e2obOiTQWfMEH3PxPjOtdsfLQO4ReWSZaQ7DETm4xu07rl4q/h4zcKXyU0/OzQ== dependencies: detect-newline "^3.0.0" jest-each@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-27.5.1.tgz#5bc87016f45ed9507fed6e4702a5b468a5b2c44e" integrity sha512-1Ff6p+FbhT/bXQnEouYy00bkNSY7OUpfIcmdl8vZ31A1UUaurOLPA8a8BbJOF2RDUElwJhmeaV7LnagI+5UwNQ== dependencies: "@jest/types" "^27.5.1" chalk "^4.0.0" jest-get-type "^27.5.1" jest-util "^27.5.1" pretty-format "^27.5.1" jest-environment-jsdom@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-environment-jsdom/-/jest-environment-jsdom-27.5.1.tgz#ea9ccd1fc610209655a77898f86b2b559516a546" integrity sha512-TFBvkTC1Hnnnrka/fUb56atfDtJ9VMZ94JkjTbggl1PEpwrYtUBKMezB3inLmWqQsXYLcMwNoDQwoBTAvFfsfw== dependencies: "@jest/environment" "^27.5.1" "@jest/fake-timers" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" jest-mock "^27.5.1" jest-util "^27.5.1" jsdom "^16.6.0" jest-environment-node@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-27.5.1.tgz#dedc2cfe52fab6b8f5714b4808aefa85357a365e" integrity sha512-Jt4ZUnxdOsTGwSRAfKEnE6BcwsSPNOijjwifq5sDFSA2kesnXTvNqKHYgM0hDq3549Uf/KzdXNYn4wMZJPlFLw== dependencies: "@jest/environment" "^27.5.1" "@jest/fake-timers" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" jest-mock "^27.5.1" jest-util "^27.5.1" jest-get-type@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-27.5.1.tgz#3cd613c507b0f7ace013df407a1c1cd578bcb4f1" integrity sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw== jest-haste-map@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-27.5.1.tgz#9fd8bd7e7b4fa502d9c6164c5640512b4e811e7f" integrity sha512-7GgkZ4Fw4NFbMSDSpZwXeBiIbx+t/46nJ2QitkOjvwPYyZmqttu2TDSimMHP1EkPOi4xUZAN1doE5Vd25H4Jng== dependencies: "@jest/types" "^27.5.1" "@types/graceful-fs" "^4.1.2" "@types/node" "*" anymatch "^3.0.3" fb-watchman "^2.0.0" graceful-fs "^4.2.9" jest-regex-util "^27.5.1" jest-serializer "^27.5.1" jest-util "^27.5.1" jest-worker "^27.5.1" micromatch "^4.0.4" walker "^1.0.7" optionalDependencies: fsevents "^2.3.2" jest-jasmine2@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-jasmine2/-/jest-jasmine2-27.5.1.tgz#a037b0034ef49a9f3d71c4375a796f3b230d1ac4" integrity sha512-jtq7VVyG8SqAorDpApwiJJImd0V2wv1xzdheGHRGyuT7gZm6gG47QEskOlzsN1PG/6WNaCo5pmwMHDf3AkG2pQ== dependencies: "@jest/environment" "^27.5.1" "@jest/source-map" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" co "^4.6.0" expect "^27.5.1" is-generator-fn "^2.0.0" jest-each "^27.5.1" jest-matcher-utils "^27.5.1" jest-message-util "^27.5.1" jest-runtime "^27.5.1" jest-snapshot "^27.5.1" jest-util "^27.5.1" pretty-format "^27.5.1" throat "^6.0.1" jest-leak-detector@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-27.5.1.tgz#6ec9d54c3579dd6e3e66d70e3498adf80fde3fb8" integrity sha512-POXfWAMvfU6WMUXftV4HolnJfnPOGEu10fscNCA76KBpRRhcMN2c8d3iT2pxQS3HLbA+5X4sOUPzYO2NUyIlHQ== dependencies: jest-get-type "^27.5.1" pretty-format "^27.5.1" jest-matcher-utils@^27.0.0, jest-matcher-utils@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz#9c0cdbda8245bc22d2331729d1091308b40cf8ab" integrity sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw== dependencies: chalk "^4.0.0" jest-diff "^27.5.1" jest-get-type "^27.5.1" pretty-format "^27.5.1" jest-message-util@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-27.5.1.tgz#bdda72806da10d9ed6425e12afff38cd1458b6cf" integrity sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g== dependencies: "@babel/code-frame" "^7.12.13" "@jest/types" "^27.5.1" "@types/stack-utils" "^2.0.0" chalk "^4.0.0" graceful-fs "^4.2.9" micromatch "^4.0.4" pretty-format "^27.5.1" slash "^3.0.0" stack-utils "^2.0.3" jest-mock@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-27.5.1.tgz#19948336d49ef4d9c52021d34ac7b5f36ff967d6" integrity sha512-K4jKbY1d4ENhbrG2zuPWaQBvDly+iZ2yAW+T1fATN78hc0sInwn7wZB8XtlNnvHug5RMwV897Xm4LqmPM4e2Og== dependencies: "@jest/types" "^27.5.1" "@types/node" "*" jest-pnp-resolver@^1.2.2: version "1.2.3" resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e" integrity sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== jest-regex-util@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-27.5.1.tgz#4da143f7e9fd1e542d4aa69617b38e4a78365b95" integrity sha512-4bfKq2zie+x16okqDXjXn9ql2B0dScQu+vcwe4TvFVhkVyuWLqpZrZtXxLLWoXYgn0E87I6r6GRYHF7wFZBUvg== jest-resolve-dependencies@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-27.5.1.tgz#d811ecc8305e731cc86dd79741ee98fed06f1da8" integrity sha512-QQOOdY4PE39iawDn5rzbIePNigfe5B9Z91GDD1ae/xNDlu9kaat8QQ5EKnNmVWPV54hUdxCVwwj6YMgR2O7IOg== dependencies: "@jest/types" "^27.5.1" jest-regex-util "^27.5.1" jest-snapshot "^27.5.1" jest-resolve@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-27.5.1.tgz#a2f1c5a0796ec18fe9eb1536ac3814c23617b384" integrity sha512-FFDy8/9E6CV83IMbDpcjOhumAQPDyETnU2KZ1O98DwTnz8AOBsW/Xv3GySr1mOZdItLR+zDZ7I/UdTFbgSOVCw== dependencies: "@jest/types" "^27.5.1" chalk "^4.0.0" graceful-fs "^4.2.9" jest-haste-map "^27.5.1" jest-pnp-resolver "^1.2.2" jest-util "^27.5.1" jest-validate "^27.5.1" resolve "^1.20.0" resolve.exports "^1.1.0" slash "^3.0.0" jest-runner@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-27.5.1.tgz#071b27c1fa30d90540805c5645a0ec167c7b62e5" integrity sha512-g4NPsM4mFCOwFKXO4p/H/kWGdJp9V8kURY2lX8Me2drgXqG7rrZAx5kv+5H7wtt/cdFIjhqYx1HrlqWHaOvDaQ== dependencies: "@jest/console" "^27.5.1" "@jest/environment" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" emittery "^0.8.1" graceful-fs "^4.2.9" jest-docblock "^27.5.1" jest-environment-jsdom "^27.5.1" jest-environment-node "^27.5.1" jest-haste-map "^27.5.1" jest-leak-detector "^27.5.1" jest-message-util "^27.5.1" jest-resolve "^27.5.1" jest-runtime "^27.5.1" jest-util "^27.5.1" jest-worker "^27.5.1" source-map-support "^0.5.6" throat "^6.0.1" jest-runtime@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-27.5.1.tgz#4896003d7a334f7e8e4a53ba93fb9bcd3db0a1af" integrity sha512-o7gxw3Gf+H2IGt8fv0RiyE1+r83FJBRruoA+FXrlHw6xEyBsU8ugA6IPfTdVyA0w8HClpbK+DGJxH59UrNMx8A== dependencies: "@jest/environment" "^27.5.1" "@jest/fake-timers" "^27.5.1" "@jest/globals" "^27.5.1" "@jest/source-map" "^27.5.1" "@jest/test-result" "^27.5.1" "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" chalk "^4.0.0" cjs-module-lexer "^1.0.0" collect-v8-coverage "^1.0.0" execa "^5.0.0" glob "^7.1.3" graceful-fs "^4.2.9" jest-haste-map "^27.5.1" jest-message-util "^27.5.1" jest-mock "^27.5.1" jest-regex-util "^27.5.1" jest-resolve "^27.5.1" jest-snapshot "^27.5.1" jest-util "^27.5.1" slash "^3.0.0" strip-bom "^4.0.0" jest-serializer@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-serializer/-/jest-serializer-27.5.1.tgz#81438410a30ea66fd57ff730835123dea1fb1f64" integrity sha512-jZCyo6iIxO1aqUxpuBlwTDMkzOAJS4a3eYz3YzgxxVQFwLeSA7Jfq5cbqCY+JLvTDrWirgusI/0KwxKMgrdf7w== dependencies: "@types/node" "*" graceful-fs "^4.2.9" jest-snapshot@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-27.5.1.tgz#b668d50d23d38054a51b42c4039cab59ae6eb6a1" integrity sha512-yYykXI5a0I31xX67mgeLw1DZ0bJB+gpq5IpSuCAoyDi0+BhgU/RIrL+RTzDmkNTchvDFWKP8lp+w/42Z3us5sA== dependencies: "@babel/core" "^7.7.2" "@babel/generator" "^7.7.2" "@babel/plugin-syntax-typescript" "^7.7.2" "@babel/traverse" "^7.7.2" "@babel/types" "^7.0.0" "@jest/transform" "^27.5.1" "@jest/types" "^27.5.1" "@types/babel__traverse" "^7.0.4" "@types/prettier" "^2.1.5" babel-preset-current-node-syntax "^1.0.0" chalk "^4.0.0" expect "^27.5.1" graceful-fs "^4.2.9" jest-diff "^27.5.1" jest-get-type "^27.5.1" jest-haste-map "^27.5.1" jest-matcher-utils "^27.5.1" jest-message-util "^27.5.1" jest-util "^27.5.1" natural-compare "^1.4.0" pretty-format "^27.5.1" semver "^7.3.2" jest-util@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-27.5.1.tgz#3ba9771e8e31a0b85da48fe0b0891fb86c01c2f9" integrity sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw== dependencies: "@jest/types" "^27.5.1" "@types/node" "*" chalk "^4.0.0" ci-info "^3.2.0" graceful-fs "^4.2.9" picomatch "^2.2.3" jest-validate@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-27.5.1.tgz#9197d54dc0bdb52260b8db40b46ae668e04df067" integrity sha512-thkNli0LYTmOI1tDB3FI1S1RTp/Bqyd9pTarJwL87OIBFuqEb5Apv5EaApEudYg4g86e3CT6kM0RowkhtEnCBQ== dependencies: "@jest/types" "^27.5.1" camelcase "^6.2.0" chalk "^4.0.0" jest-get-type "^27.5.1" leven "^3.1.0" pretty-format "^27.5.1" jest-watcher@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-27.5.1.tgz#71bd85fb9bde3a2c2ec4dc353437971c43c642a2" integrity sha512-z676SuD6Z8o8qbmEGhoEUFOM1+jfEiL3DXHK/xgEiG2EyNYfFG60jluWcupY6dATjfEsKQuibReS1djInQnoVw== dependencies: "@jest/test-result" "^27.5.1" "@jest/types" "^27.5.1" "@types/node" "*" ansi-escapes "^4.2.1" chalk "^4.0.0" jest-util "^27.5.1" string-length "^4.0.1" jest-worker@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0" integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg== dependencies: "@types/node" "*" merge-stream "^2.0.0" supports-color "^8.0.0" jest@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/jest/-/jest-27.5.1.tgz#dadf33ba70a779be7a6fc33015843b51494f63fc" integrity sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ== dependencies: "@jest/core" "^27.5.1" import-local "^3.0.2" jest-cli "^27.5.1" js-tokens@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== js-yaml@^3.13.1: version "3.14.1" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== dependencies: argparse "^1.0.7" esprima "^4.0.0" js-yaml@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602" integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== dependencies: argparse "^2.0.1" jsdoctypeparser@^9.0.0: version "9.0.0" resolved "https://registry.yarnpkg.com/jsdoctypeparser/-/jsdoctypeparser-9.0.0.tgz#8c97e2fb69315eb274b0f01377eaa5c940bd7b26" integrity sha512-jrTA2jJIL6/DAEILBEh2/w9QxCuwmvNXIry39Ay/HVfhE3o2yVV0U44blYkqdHA/OKloJEqvJy0xU+GSdE2SIw== jsdom@^16.6.0: version "16.7.0" resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-16.7.0.tgz#918ae71965424b197c819f8183a754e18977b710" integrity sha512-u9Smc2G1USStM+s/x1ru5Sxrl6mPYCbByG1U/hUmqaVsm4tbNyS7CicOSRyuGQYZhTu0h84qkZZQ/I+dzizSVw== dependencies: abab "^2.0.5" acorn "^8.2.4" acorn-globals "^6.0.0" cssom "^0.4.4" cssstyle "^2.3.0" data-urls "^2.0.0" decimal.js "^10.2.1" domexception "^2.0.1" escodegen "^2.0.0" form-data "^3.0.0" html-encoding-sniffer "^2.0.1" http-proxy-agent "^4.0.1" https-proxy-agent "^5.0.0" is-potential-custom-element-name "^1.0.1" nwsapi "^2.2.0" parse5 "6.0.1" saxes "^5.0.1" symbol-tree "^3.2.4" tough-cookie "^4.0.0" w3c-hr-time "^1.0.2" w3c-xmlserializer "^2.0.0" webidl-conversions "^6.1.0" whatwg-encoding "^1.0.5" whatwg-mimetype "^2.3.0" whatwg-url "^8.5.0" ws "^7.4.6" xml-name-validator "^3.0.0" jsesc@^2.5.1: version "2.5.2" resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4" integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA== json-parse-even-better-errors@^2.3.0: version "2.3.1" resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== json-schema-ref-parser@^9.0.1: version "9.0.9" resolved "https://registry.yarnpkg.com/json-schema-ref-parser/-/json-schema-ref-parser-9.0.9.tgz#66ea538e7450b12af342fa3d5b8458bc1e1e013f" integrity sha512-qcP2lmGy+JUoQJ4DOQeLaZDqH9qSkeGCK3suKWxJXS82dg728Mn3j97azDMaOUmJAN4uCq91LdPx4K7E8F1a7Q== dependencies: "@apidevtools/json-schema-ref-parser" "9.0.9" json-schema-to-typescript@^9.1.1: version "9.1.1" resolved "https://registry.yarnpkg.com/json-schema-to-typescript/-/json-schema-to-typescript-9.1.1.tgz#572c1eb8b7ca82d6534c023c4651f3fe925171c0" integrity sha512-VrdxmwQROjPBRlHxXwGUa2xzhOMPiNZIVsxZrZjMYtbI7suRFMiEktqaD/gqhfSya7Djy+x8dnJT+H0/0sZO0Q== dependencies: "@types/json-schema" "^7.0.4" cli-color "^2.0.0" glob "^7.1.6" is-glob "^4.0.1" json-schema-ref-parser "^9.0.1" json-stringify-safe "^5.0.1" lodash "^4.17.15" minimist "^1.2.5" mkdirp "^1.0.4" mz "^2.7.0" prettier "^2.0.5" stdin "0.0.1" json-schema-traverse@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== json-schema-traverse@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== json-stable-stringify-without-jsonify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== json-stringify-safe@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA== json5@^2.2.2: version "2.2.3" resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== jsonfile@^6.0.1: version "6.1.0" resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae" integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ== dependencies: universalify "^2.0.0" optionalDependencies: graceful-fs "^4.1.6" kleur@^3.0.3: version "3.0.3" resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e" integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== leven@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2" integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== levn@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade" integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== dependencies: prelude-ls "^1.2.1" type-check "~0.4.0" levn@~0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" integrity sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA== dependencies: prelude-ls "~1.1.2" type-check "~0.3.2" lines-and-columns@^1.1.6: version "1.2.4" resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== lint-staged@^10.4.0: version "10.5.4" resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-10.5.4.tgz#cd153b5f0987d2371fc1d2847a409a2fe705b665" integrity sha512-EechC3DdFic/TdOPgj/RB3FicqE6932LTHCUm0Y2fsD9KGlLB+RwJl2q1IYBIvEsKzDOgn0D4gll+YxG5RsrKg== dependencies: chalk "^4.1.0" cli-truncate "^2.1.0" commander "^6.2.0" cosmiconfig "^7.0.0" debug "^4.2.0" dedent "^0.7.0" enquirer "^2.3.6" execa "^4.1.0" listr2 "^3.2.2" log-symbols "^4.0.0" micromatch "^4.0.2" normalize-path "^3.0.0" please-upgrade-node "^3.2.0" string-argv "0.3.1" stringify-object "^3.3.0" listr2@^3.2.2: version "3.14.0" resolved "https://registry.yarnpkg.com/listr2/-/listr2-3.14.0.tgz#23101cc62e1375fd5836b248276d1d2b51fdbe9e" integrity sha512-TyWI8G99GX9GjE54cJ+RrNMcIFBfwMPxc3XTFiAYGN4s10hWROGtOg7+O6u6LE3mNkyld7RSLE6nrKBvTfcs3g== dependencies: cli-truncate "^2.1.0" colorette "^2.0.16" log-update "^4.0.0" p-map "^4.0.0" rfdc "^1.3.0" rxjs "^7.5.1" through "^2.3.8" wrap-ansi "^7.0.0" locate-path@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== dependencies: p-locate "^4.1.0" lodash.merge@^4.6.2: version "4.6.2" resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a" integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== lodash.truncate@^4.4.2: version "4.4.2" resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193" integrity sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw== lodash@^4.17.15, lodash@^4.17.20, lodash@^4.7.0: version "4.17.21" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== log-symbols@^4.0.0: version "4.1.0" resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503" integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg== dependencies: chalk "^4.1.0" is-unicode-supported "^0.1.0" log-update@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1" integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg== dependencies: ansi-escapes "^4.3.0" cli-cursor "^3.1.0" slice-ansi "^4.0.0" wrap-ansi "^6.2.0" lru-cache@^5.1.1: version "5.1.1" resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920" integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== dependencies: yallist "^3.0.2" lru-cache@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== dependencies: yallist "^4.0.0" lru-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/lru-queue/-/lru-queue-0.1.0.tgz#2738bd9f0d3cf4f84490c5736c48699ac632cda3" integrity sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ== dependencies: es5-ext "~0.10.2" make-dir@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f" integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw== dependencies: semver "^6.0.0" makeerror@1.0.12: version "1.0.12" resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a" integrity sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== dependencies: tmpl "1.0.5" memfs@^3.2.0: version "3.5.1" resolved "https://registry.yarnpkg.com/memfs/-/memfs-3.5.1.tgz#f0cd1e2bfaef58f6fe09bfb9c2288f07fea099ec" integrity sha512-UWbFJKvj5k+nETdteFndTpYxdeTMox/ULeqX5k/dpaQJCCFmj5EeKv3dBcyO2xmkRAx2vppRu5dVG7SOtsGOzA== dependencies: fs-monkey "^1.0.3" memoizee@^0.4.15: version "0.4.15" resolved "https://registry.yarnpkg.com/memoizee/-/memoizee-0.4.15.tgz#e6f3d2da863f318d02225391829a6c5956555b72" integrity sha512-UBWmJpLZd5STPm7PMUlOw/TSy972M+z8gcyQ5veOnSDRREz/0bmpyTfKt3/51DhEBqCZQn1udM/5flcSPYhkdQ== dependencies: d "^1.0.1" es5-ext "^0.10.53" es6-weak-map "^2.0.3" event-emitter "^0.3.5" is-promise "^2.2.2" lru-queue "^0.1.0" next-tick "^1.1.0" timers-ext "^0.1.7" merge-stream@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== micromatch@^4.0.2, micromatch@^4.0.4: version "4.0.5" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6" integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA== dependencies: braces "^3.0.2" picomatch "^2.3.1" mime-db@1.52.0: version "1.52.0" resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== mime-types@^2.1.12: version "2.1.35" resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== dependencies: mime-db "1.52.0" mimic-fn@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== minimatch@^3.0.4, minimatch@^3.1.1: version "3.1.2" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== dependencies: brace-expansion "^1.1.7" minimist@^1.2.5: version "1.2.8" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== mkdirp@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== ms@2.1.2: version "2.1.2" resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== mz@^2.7.0: version "2.7.0" resolved "https://registry.yarnpkg.com/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32" integrity sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q== dependencies: any-promise "^1.0.0" object-assign "^4.0.1" thenify-all "^1.0.0" natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== next-tick@1, next-tick@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb" integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ== node-int64@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" integrity sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== node-releases@^2.0.8: version "2.0.10" resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.10.tgz#c311ebae3b6a148c89b1813fd7c4d3c024ef537f" integrity sha512-5GFldHPXVG/YZmFzJvKK2zDSzPKhEp0+ZR5SVaoSag9fsL5YgHbUHDfnG5494ISANDcK4KwPXAx2xqVEydmd7w== normalize-path@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== npm-run-path@^4.0.0, npm-run-path@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== dependencies: path-key "^3.0.0" nwsapi@^2.2.0: version "2.2.4" resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.4.tgz#fd59d5e904e8e1f03c25a7d5a15cfa16c714a1e5" integrity sha512-NHj4rzRo0tQdijE9ZqAx6kYDcoRwYwSYzCA8MY3JzfxlrvEU0jhnhJT9BhqhJs7I/dKcrDm6TyulaRqZPIhN5g== object-assign@^4.0.1: version "4.1.1" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== once@^1.3.0, once@^1.3.1, once@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== dependencies: wrappy "1" onetime@^5.1.0, onetime@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== dependencies: mimic-fn "^2.1.0" optionator@^0.8.1: version "0.8.3" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495" integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== dependencies: deep-is "~0.1.3" fast-levenshtein "~2.0.6" levn "~0.3.0" prelude-ls "~1.1.2" type-check "~0.3.2" word-wrap "~1.2.3" optionator@^0.9.1: version "0.9.1" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499" integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw== dependencies: deep-is "^0.1.3" fast-levenshtein "^2.0.6" levn "^0.4.1" prelude-ls "^1.2.1" type-check "^0.4.0" word-wrap "^1.2.3" p-limit@^2.2.0: version "2.3.0" resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1" integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== dependencies: p-try "^2.0.0" p-locate@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== dependencies: p-limit "^2.2.0" p-map@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b" integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ== dependencies: aggregate-error "^3.0.0" p-try@^2.0.0: version "2.2.0" resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== parent-module@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2" integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== dependencies: callsites "^3.0.0" parse-json@^5.0.0, parse-json@^5.2.0: version "5.2.0" resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd" integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== dependencies: "@babel/code-frame" "^7.0.0" error-ex "^1.3.1" json-parse-even-better-errors "^2.3.0" lines-and-columns "^1.1.6" parse5@6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/parse5/-/parse5-6.0.1.tgz#e1a1c085c569b3dc08321184f19a39cc27f7c30b" integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw== path-exists@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== path-is-absolute@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== path-key@^3.0.0, path-key@^3.1.0: version "3.1.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== path-parse@^1.0.7: version "1.0.7" resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== path-type@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b" integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== picocolors@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c" integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ== picomatch@^2.0.4, picomatch@^2.2.3, picomatch@^2.3.1: version "2.3.1" resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== pirates@^4.0.4: version "4.0.5" resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b" integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ== pkg-dir@^4.2.0: version "4.2.0" resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3" integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== dependencies: find-up "^4.0.0" please-upgrade-node@^3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/please-upgrade-node/-/please-upgrade-node-3.2.0.tgz#aeddd3f994c933e4ad98b99d9a556efa0e2fe942" integrity sha512-gQR3WpIgNIKwBMVLkpMUeR3e1/E1y42bqDQZfql+kDeXd8COYfM8PQA4X6y7a8u9Ua9FHmsrrmirW2vHs45hWg== dependencies: semver-compare "^1.0.0" prelude-ls@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396" integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== prelude-ls@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w== prettier-linter-helpers@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== dependencies: fast-diff "^1.1.2" prettier@^2.0.5, prettier@^2.1.2: version "2.8.8" resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da" integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q== pretty-format@^27.0.0, pretty-format@^27.5.1: version "27.5.1" resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.5.1.tgz#2181879fdea51a7a5851fb39d920faa63f01d88e" integrity sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ== dependencies: ansi-regex "^5.0.1" ansi-styles "^5.0.0" react-is "^17.0.1" progress@^2.0.0: version "2.0.3" resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8" integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA== prompts@^2.0.1: version "2.4.2" resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069" integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== dependencies: kleur "^3.0.3" sisteransi "^1.0.5" psl@^1.1.33: version "1.9.0" resolved "https://registry.yarnpkg.com/psl/-/psl-1.9.0.tgz#d0df2a137f00794565fcaf3b2c00cd09f8d5a5a7" integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag== pump@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64" integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww== dependencies: end-of-stream "^1.1.0" once "^1.3.1" punycode@^2.1.0, punycode@^2.1.1: version "2.3.0" resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f" integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA== querystringify@^2.1.1: version "2.2.0" resolved "https://registry.yarnpkg.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6" integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ== react-is@^17.0.1: version "17.0.2" resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.2.tgz#e691d4a8e9c789365655539ab372762b0efb54f0" integrity sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w== regexpp@^3.0.0, regexpp@^3.1.0: version "3.2.0" resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== regextras@^0.7.1: version "0.7.1" resolved "https://registry.yarnpkg.com/regextras/-/regextras-0.7.1.tgz#be95719d5f43f9ef0b9fa07ad89b7c606995a3b2" integrity sha512-9YXf6xtW+qzQ+hcMQXx95MOvfqXFgsKDZodX3qZB0x2n5Z94ioetIITsBtvJbiOyxa/6s9AtyweBLCdPmPko/w== repeat-string@^1.6.1: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w== require-directory@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== require-from-string@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== requires-port@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff" integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ== resolve-cwd@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d" integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg== dependencies: resolve-from "^5.0.0" resolve-from@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6" integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== resolve-from@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== resolve-global@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/resolve-global/-/resolve-global-1.0.0.tgz#a2a79df4af2ca3f49bf77ef9ddacd322dad19255" integrity sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw== dependencies: global-dirs "^0.1.1" resolve.exports@^1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/resolve.exports/-/resolve.exports-1.1.1.tgz#05cfd5b3edf641571fd46fa608b610dda9ead999" integrity sha512-/NtpHNDN7jWhAaQ9BvBUYZ6YTXsRBgfqWFWP7BZBaoMJO/I3G5OFzvTuWNlZC3aPjins1F+TNrLKsGbH4rfsRQ== resolve@^1.10.1, resolve@^1.20.0: version "1.22.2" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.2.tgz#0ed0943d4e301867955766c9f3e1ae6d01c6845f" integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g== dependencies: is-core-module "^2.11.0" path-parse "^1.0.7" supports-preserve-symlinks-flag "^1.0.0" restore-cursor@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e" integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA== dependencies: onetime "^5.1.0" signal-exit "^3.0.2" rfdc@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.3.0.tgz#d0b7c441ab2720d05dc4cf26e01c89631d9da08b" integrity sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA== rimraf@^3.0.0, rimraf@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== dependencies: glob "^7.1.3" rxjs@^7.5.1: version "7.8.1" resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543" integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg== dependencies: tslib "^2.1.0" "safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0": version "2.1.2" resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== saxes@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/saxes/-/saxes-5.0.1.tgz#eebab953fa3b7608dbe94e5dadb15c888fa6696d" integrity sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw== dependencies: xmlchars "^2.2.0" semver-compare@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc" integrity sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow== semver@^6.0.0, semver@^6.1.0, semver@^6.3.0: version "6.3.0" resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== semver@^7.2.1, semver@^7.3.2, semver@^7.3.4: version "7.5.1" resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.1.tgz#c90c4d631cf74720e46b21c1d37ea07edfab91ec" integrity sha512-Wvss5ivl8TMRZXXESstBA4uR5iXgEN/VC5/sOcuXdVLzcdkz4HWetIoRfG5gb5X+ij/G9rw9YoGn3QoQ8OCSpw== dependencies: lru-cache "^6.0.0" shebang-command@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== dependencies: shebang-regex "^3.0.0" shebang-regex@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== signal-exit@^3.0.2, signal-exit@^3.0.3: version "3.0.7" resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== sisteransi@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== slash@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634" integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== slice-ansi@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-3.0.0.tgz#31ddc10930a1b7e0b67b08c96c2f49b77a789787" integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ== dependencies: ansi-styles "^4.0.0" astral-regex "^2.0.0" is-fullwidth-code-point "^3.0.0" slice-ansi@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b" integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ== dependencies: ansi-styles "^4.0.0" astral-regex "^2.0.0" is-fullwidth-code-point "^3.0.0" source-map-support@^0.5.6: version "0.5.21" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f" integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== dependencies: buffer-from "^1.0.0" source-map "^0.6.0" source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== source-map@^0.7.3: version "0.7.4" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.4.tgz#a9bbe705c9d8846f4e08ff6765acf0f1b0898656" integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA== spdx-exceptions@^2.1.0: version "2.3.0" resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d" integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A== spdx-expression-parse@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679" integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q== dependencies: spdx-exceptions "^2.1.0" spdx-license-ids "^3.0.0" spdx-license-ids@^3.0.0: version "3.0.13" resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.13.tgz#7189a474c46f8d47c7b0da4b987bb45e908bd2d5" integrity sha512-XkD+zwiqXHikFZm4AX/7JSCXA98U5Db4AFd5XUg/+9UNtnH75+Z9KxtpYiJZx36mUDVOwH83pl7yvCer6ewM3w== sprintf-js@~1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== stack-utils@^2.0.3: version "2.0.6" resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-2.0.6.tgz#aaf0748169c02fc33c8232abccf933f54a1cc34f" integrity sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ== dependencies: escape-string-regexp "^2.0.0" stdin@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/stdin/-/stdin-0.0.1.tgz#d3041981aaec3dfdbc77a1b38d6372e38f5fb71e" integrity sha512-2bacd1TXzqOEsqRa+eEWkRdOSznwptrs4gqFcpMq5tOtmJUGPZd10W5Lam6wQ4YQ/+qjQt4e9u35yXCF6mrlfQ== string-argv@0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.3.1.tgz#95e2fbec0427ae19184935f816d74aaa4c5c19da" integrity sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg== string-length@^4.0.1: version "4.0.2" resolved "https://registry.yarnpkg.com/string-length/-/string-length-4.0.2.tgz#a8a8dc7bd5c1a82b9b3c8b87e125f66871b6e57a" integrity sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ== dependencies: char-regex "^1.0.2" strip-ansi "^6.0.0" string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: version "4.2.3" resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== dependencies: emoji-regex "^8.0.0" is-fullwidth-code-point "^3.0.0" strip-ansi "^6.0.1" stringify-object@^3.3.0: version "3.3.0" resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629" integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw== dependencies: get-own-enumerable-property-symbols "^3.0.0" is-obj "^1.0.1" is-regexp "^1.0.0" strip-ansi@^6.0.0, strip-ansi@^6.0.1: version "6.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== dependencies: ansi-regex "^5.0.1" strip-bom@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878" integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== strip-final-newline@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== supports-color@^5.3.0: version "5.5.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f" integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== dependencies: has-flag "^3.0.0" supports-color@^7.0.0, supports-color@^7.1.0: version "7.2.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== dependencies: has-flag "^4.0.0" supports-color@^8.0.0: version "8.1.1" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c" integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== dependencies: has-flag "^4.0.0" supports-hyperlinks@^2.0.0: version "2.3.0" resolved "https://registry.yarnpkg.com/supports-hyperlinks/-/supports-hyperlinks-2.3.0.tgz#3943544347c1ff90b15effb03fc14ae45ec10624" integrity sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA== dependencies: has-flag "^4.0.0" supports-color "^7.0.0" supports-preserve-symlinks-flag@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== symbol-tree@^3.2.4: version "3.2.4" resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2" integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw== table@^6.0.9: version "6.8.1" resolved "https://registry.yarnpkg.com/table/-/table-6.8.1.tgz#ea2b71359fe03b017a5fbc296204471158080bdf" integrity sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA== dependencies: ajv "^8.0.1" lodash.truncate "^4.4.2" slice-ansi "^4.0.0" string-width "^4.2.3" strip-ansi "^6.0.1" tapable@^2.2.0: version "2.2.1" resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0" integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ== terminal-link@^2.0.0: version "2.1.1" resolved "https://registry.yarnpkg.com/terminal-link/-/terminal-link-2.1.1.tgz#14a64a27ab3c0df933ea546fba55f2d078edc994" integrity sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ== dependencies: ansi-escapes "^4.2.1" supports-hyperlinks "^2.0.0" test-exclude@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e" integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w== dependencies: "@istanbuljs/schema" "^0.1.2" glob "^7.1.4" minimatch "^3.0.4" text-table@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw== thenify-all@^1.0.0: version "1.6.0" resolved "https://registry.yarnpkg.com/thenify-all/-/thenify-all-1.6.0.tgz#1a1918d402d8fc3f98fbf234db0bcc8cc10e9726" integrity sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA== dependencies: thenify ">= 3.1.0 < 4" "thenify@>= 3.1.0 < 4": version "3.3.1" resolved "https://registry.yarnpkg.com/thenify/-/thenify-3.3.1.tgz#8932e686a4066038a016dd9e2ca46add9838a95f" integrity sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw== dependencies: any-promise "^1.0.0" throat@^6.0.1: version "6.0.2" resolved "https://registry.yarnpkg.com/throat/-/throat-6.0.2.tgz#51a3fbb5e11ae72e2cf74861ed5c8020f89f29fe" integrity sha512-WKexMoJj3vEuK0yFEapj8y64V0A6xcuPuK9Gt1d0R+dzCSJc0lHqQytAbSB4cDAK0dWh4T0E2ETkoLE2WZ41OQ== through@^2.3.8: version "2.3.8" resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg== timers-ext@^0.1.7: version "0.1.7" resolved "https://registry.yarnpkg.com/timers-ext/-/timers-ext-0.1.7.tgz#6f57ad8578e07a3fb9f91d9387d65647555e25c6" integrity sha512-b85NUNzTSdodShTIbky6ZF02e8STtVVfD+fu4aXXShEELpozH+bCpJLYMPZbsABN2wDH7fJpqIoXxJpzbf0NqQ== dependencies: es5-ext "~0.10.46" next-tick "1" tmpl@1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc" integrity sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== to-fast-properties@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e" integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog== to-regex-range@^5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== dependencies: is-number "^7.0.0" tooling@webpack/tooling#v1.14.0: version "1.14.0" resolved "https://codeload.github.com/webpack/tooling/tar.gz/f8500c02cf2a04b3a0c0c2ca38ad9df959b9d02a" dependencies: "@yarnpkg/lockfile" "^1.1.0" commondir "^1.0.1" glob "^7.1.6" json-schema-to-typescript "^9.1.1" yargs "^16.1.1" tough-cookie@^4.0.0: version "4.1.2" resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-4.1.2.tgz#e53e84b85f24e0b65dd526f46628db6c85f6b874" integrity sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ== dependencies: psl "^1.1.33" punycode "^2.1.1" universalify "^0.2.0" url-parse "^1.5.3" tr46@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/tr46/-/tr46-2.1.0.tgz#fa87aa81ca5d5941da8cbf1f9b749dc969a4e240" integrity sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw== dependencies: punycode "^2.1.1" tslib@^2.1.0: version "2.5.0" resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.0.tgz#42bfed86f5787aeb41d031866c8f402429e0fddf" integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg== type-check@^0.4.0, type-check@~0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1" integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== dependencies: prelude-ls "^1.2.1" type-check@~0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" integrity sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg== dependencies: prelude-ls "~1.1.2" type-detect@4.0.8: version "4.0.8" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== type-fest@^0.20.2: version "0.20.2" resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4" integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== type-fest@^0.21.3: version "0.21.3" resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37" integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== type@^1.0.1: version "1.2.0" resolved "https://registry.yarnpkg.com/type/-/type-1.2.0.tgz#848dd7698dafa3e54a6c479e759c4bc3f18847a0" integrity sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg== type@^2.7.2: version "2.7.2" resolved "https://registry.yarnpkg.com/type/-/type-2.7.2.tgz#2376a15a3a28b1efa0f5350dcf72d24df6ef98d0" integrity sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw== typedarray-to-buffer@^3.1.5: version "3.1.5" resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080" integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q== dependencies: is-typedarray "^1.0.0" typescript@^5.0.4: version "5.0.4" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.0.4.tgz#b217fd20119bd61a94d4011274e0ab369058da3b" integrity sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw== unique-string@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/unique-string/-/unique-string-2.0.0.tgz#39c6451f81afb2749de2b233e3f7c5e8843bd89d" integrity sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg== dependencies: crypto-random-string "^2.0.0" universalify@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.2.0.tgz#6451760566fa857534745ab1dde952d1b1761be0" integrity sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg== universalify@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717" integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ== update-browserslist-db@^1.0.10: version "1.0.11" resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz#9a2a641ad2907ae7b3616506f4b977851db5b940" integrity sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA== dependencies: escalade "^3.1.1" picocolors "^1.0.0" uri-js@^4.2.2: version "4.4.1" resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== dependencies: punycode "^2.1.0" url-parse@^1.5.3: version "1.5.10" resolved "https://registry.yarnpkg.com/url-parse/-/url-parse-1.5.10.tgz#9d3c2f736c1d75dd3bd2be507dcc111f1e2ea9c1" integrity sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ== dependencies: querystringify "^2.1.1" requires-port "^1.0.0" v8-compile-cache@^2.0.3: version "2.3.0" resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee" integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA== v8-to-istanbul@^8.1.0: version "8.1.1" resolved "https://registry.yarnpkg.com/v8-to-istanbul/-/v8-to-istanbul-8.1.1.tgz#77b752fd3975e31bbcef938f85e9bd1c7a8d60ed" integrity sha512-FGtKtv3xIpR6BYhvgH8MI/y78oT7d8Au3ww4QIxymrCtZEh5b8gCw2siywE+puhEmuWKDtmfrvF5UlB298ut3w== dependencies: "@types/istanbul-lib-coverage" "^2.0.1" convert-source-map "^1.6.0" source-map "^0.7.3" vscode-uri@^3.0.2: version "3.0.7" resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.7.tgz#6d19fef387ee6b46c479e5fb00870e15e58c1eb8" integrity sha512-eOpPHogvorZRobNqJGhapa0JdwaxpjVvyBp0QIUMRMSf8ZAlqOdEquKuRmw9Qwu0qXtJIWqFtMkmvJjUZmMjVA== w3c-hr-time@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz#0a89cdf5cc15822df9c360543676963e0cc308cd" integrity sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ== dependencies: browser-process-hrtime "^1.0.0" w3c-xmlserializer@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz#3e7104a05b75146cc60f564380b7f683acf1020a" integrity sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA== dependencies: xml-name-validator "^3.0.0" walker@^1.0.7: version "1.0.8" resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f" integrity sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== dependencies: makeerror "1.0.12" webidl-conversions@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-5.0.0.tgz#ae59c8a00b121543a2acc65c0434f57b0fc11aff" integrity sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA== webidl-conversions@^6.1.0: version "6.1.0" resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-6.1.0.tgz#9111b4d7ea80acd40f5270d666621afa78b69514" integrity sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w== whatwg-encoding@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz#5abacf777c32166a51d085d6b4f3e7d27113ddb0" integrity sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw== dependencies: iconv-lite "0.4.24" whatwg-mimetype@^2.3.0: version "2.3.0" resolved "https://registry.yarnpkg.com/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz#3d4b1e0312d2079879f826aff18dbeeca5960fbf" integrity sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g== whatwg-url@^8.0.0, whatwg-url@^8.5.0: version "8.7.0" resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-8.7.0.tgz#656a78e510ff8f3937bc0bcbe9f5c0ac35941b77" integrity sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg== dependencies: lodash "^4.7.0" tr46 "^2.1.0" webidl-conversions "^6.1.0" which@^2.0.1: version "2.0.2" resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== dependencies: isexe "^2.0.0" word-wrap@^1.2.3, word-wrap@~1.2.3: version "1.2.3" resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== wrap-ansi@^6.2.0: version "6.2.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53" integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== dependencies: ansi-styles "^4.0.0" string-width "^4.1.0" strip-ansi "^6.0.0" wrap-ansi@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== dependencies: ansi-styles "^4.0.0" string-width "^4.1.0" strip-ansi "^6.0.0" wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== write-file-atomic@^3.0.0: version "3.0.3" resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-3.0.3.tgz#56bd5c5a5c70481cd19c571bd39ab965a5de56e8" integrity sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q== dependencies: imurmurhash "^0.1.4" is-typedarray "^1.0.0" signal-exit "^3.0.2" typedarray-to-buffer "^3.1.5" ws@^7.4.6: version "7.5.9" resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591" integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q== xdg-basedir@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-4.0.0.tgz#4bc8d9984403696225ef83a1573cbbcb4e79db13" integrity sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q== xml-name-validator@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-3.0.0.tgz#6ae73e06de4d8c6e47f9fb181f78d648ad457c6a" integrity sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw== xmlchars@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb" integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw== y18n@^5.0.5: version "5.0.8" resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== yallist@^3.0.2: version "3.1.1" resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd" integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== yallist@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== yaml@^1.10.0: version "1.10.2" resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b" integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg== yargs-parser@^20.2.2: version "20.2.9" resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee" integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== yargs@^16.1.1, yargs@^16.2.0: version "16.2.0" resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66" integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== dependencies: cliui "^7.0.2" escalade "^3.1.1" get-caller-file "^2.0.5" require-directory "^2.1.1" string-width "^4.2.0" y18n "^5.0.5" yargs-parser "^20.2.2"