JSPM

Find a file or directory by walking up parent directories

resolve like require.resolve() on behalf of files asynchronously and synchronously

Resolve the path of a module like `require.resolve()` but from a given path

Find the root directory of a Node.js project or npm package

`Start a promise chain

Check if a path is inside another path

Resolve a URI relative to an optional base URI

Let a globally installed package use a locally installed version of itself if available

Resolve the path of a module like `require.resolve()` but from the current working directory

A tiny (952b), correct, general-purpose, and configurable "exports" and "imports" resolver without file-system reliance

The directory used by npm for globally installed npm modules.

Get the npm global path prefix.

Generates an asynchronous resolver function from a PAC file

Resolve a directory that is either local, global or in the user's home directory.

Find the first file matching a given pattern in the current directory or the nearest ancestor directory.

Enhance ESLint with better support for large scale monorepos

Webpack loader that resolves relative paths in url() statements based on the original source file

Returns `true` if the path appears to be relative.

Create a deferred promise

Webpack loader that adjusts source maps

Resolve things like Node.js — ponyfill for `import.meta.resolve`

micromark utility to resolve subtokens

Detects if a file exists and returns the resolved filepath.

Import a module like with `require()` but from a given path

Delay a promise a specified amount of time

Parse, Resolve, and Dereference JSON Schema $ref pointers

Returns true if a file path is absolute. Does not rely on the path module and can be used as a polyfill for node.js native `path.isAbolute`.

A Promise-compatible abstraction that defers resolving/rejecting promises to another closure.

Get the directory of globally installed packages and binaries

Import a module like with `require()` but from the current working directory

Module resolver plugin for Babel

Find a file or directory by walking up parent directories — Zero dependencies

resolve which handles browser field support in package.json

Resole and parse `tsconfig.json`, replicating to TypeScript's behaviour

Parser for Github, GitLab and Bitbucket issues actions, references and mentions

Check if a module ID is resolvable with require()

Resolve the path of a globally installed module

Find the first directory with a package.json, recursing up, starting with the given directory. Similar to look-up but does not support globs and only searches for package.json. Async and sync.

A fork of `import-meta-resolve` with commonjs + ESM support at the same time, AKA dual package.

Easily get the CWD (current working directory) of a project based on package.json, optionally starting from a given path. (node.js/javascript util)

Make a glob pattern absolute, ensuring that negative globs and patterns with trailing slashes are correctly handled.

Read the closest package.json file

Create aliases of directories and register custom module paths

Resolve the path of a package regardless of it having an entry point

Define and resolve aliases for bundle dependencies

Require and resolve global modules like a boss

a simple Node behavior import resolution plugin for eslint-plugin-import, supporting module alias.

Import a module like with require() but from a given path (for ESM)

Resolve the path to the user's local or global .gitconfig.

Resolve a relative path against a root path with validation

Simple module to add additional directories to the Node module search for top-level app modules

Promisified setTimeout

Recursively resolve JSON pointers and remote authorities.

Helper for creating "exposed" promise object (with resolve & reject methods).

Brings the node url api layer to whatwg-url class

require and resolve modules relative to a path of your choice

Make a glob pattern absolute, ensuring that negative globs and patterns with trailing slashes are correctly handled.

Finds the first parent directory that contains a given file or directory.

Library to help resolve module locations.

Get the relative filepath from path A to path B. Calculates from file-to-directory, file-to-file, directory-to-file, and directory-to-directory.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Resolve a path by walking parent directories.

Reconstruct the original URL used in an HTTP request based on the HTTP request headers

Caching DNS resolve

A wrapper for the "resolve" module that targets GLSL shaders instead of JavaScript

Promisified version of node-which

Fulfill long runinng promises on timeout.

babel-plugin-module-resolver resolver for eslint-plugin-import

Fast relative path resolution

Get installation path where the given package is installed. Works for globally and locally installed packages

Make a glob pattern absolute, ensuring that negative globs and patterns with trailing slashes are correctly handled.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Parse, Resolve, and Dereference JSON Schema $ref pointers

An algorithm for resolving imports in Sass

a webpack plugin that transforms core-js v2 paths to core-js v3 paths

ES 2021 spec-compliant shim for Promise.any

Resolves a given package if it is installed locally, then tries to resolve it from global registry, using battle-tested [global-modules][] package. Better approach than internal `require.resolve`, so you can trust. You just get absolute filepath to some p

A lightweight Deferred implementation, on top of Promises/A+

Caches dns resolutions made with async dns.resolve instead of default sync dns.lookup, refreshes in background

Resolves the full path to the bin file of a given package by inspecting the "bin" field in its package.json.

Resolve module path with custom entry point `package.json` field relative to caller file

Waits until the given predicate function returns a truthy value, then resolves

Use the node way to resolve required path to absolute path.

Node's URL module plus relative pathing

resolve package root and package.json paths , work on node 17 too

Loads package.json, by finding the first directory with a package.json, recursing up, starting with the given directory.

A helper function to resolve a module name or path in relation to the specified context and require it.

Find the closest package.json file

Aids humans and automation in managing npm audit results

Resolve an absolute file path from local directories, local node_modules or global node_modules.

Core modules for audit-resolve.json file and logic of its processing

A small and fast library for validating parsing and resolving URIs and IRIs

Find an asset in a set of locations

Resolve relative IRIs to absolute IRIs given a base IRI

Helps a module find its package.json mothership.

ES6 Promise Shim

Get the name of a project, from package.json, git config, or basename of the current working directory.

Resolve a symlink's (or junction's) target

Ensures that absolute file paths are always returned from a glob pattern or array of glob patterns.

A promise based node resolution library based on enhanced-resolve.

Simplify JsonSchema/Openapi by combining allOf safely

Given an url resolve it as fast as possible

Resolve the preferred locale based on the value of an `Accept-Language` HTTP header.

Collect Node.JS Stream Data Into Catchment: Stream With Promise Property Resolved On Finish.

Install Git for Windows by npm.

Walk up the tree to resolve `tsconfig.json` configuration objects.

Ensures that module (import-like or `url`) can be resolved to a module on the file system.

Get global npm prefix. Respects npmrc configs

Library that resolves AWS Cloudformation templates with exact values

Delay a promise a specified amount of time

A simple promise resolver

resolve "imports" in package.json

Resolve a whole structure of promises

Replace absolute paths to relative paths for package compilation

One step closer to your destination.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Allow rollup to resolve local files with any extension

PATTERN_KEY_COMPARE implementation

Extremely light weight way to resolve jsonschema '$ref' references & inheritance: create circular/graphs, fractals from json (browser/coffeescript/javascript).

fork of eslint-import-resolver-babel-root-import that works

Plugin for using import maps in @web/dev-server

Resolves symbols for dynamic code generated by a JIT via a map file.

> Apply React refs

Resolves index.js files with Rollup

Change where a module dependency is resolved/imported from.

Creates a queue of sync or async functions with resolve and reject callback.

Like `Promise.all`, but when all `Promise`s are settled.

Asynchronous require.resolve() implementation

Resolves @import statements in CSS

For limiting the time to resolve a promise.

Delay a promise a minimum amount of time

webpack plugin to resolve TypeScript files when importing with js file extension in ESM projects

Wrap `require` in a try/catch block.

Returns an array of NPM directory paths based on the user's platform and environment.

Create a Promise which will resolve with the provided value after a timeout.

Resolve a possibly relative URL agains a source URL

A Synchronous Promise.resolve. Preserve Sync/Async. Only Go Async If Necessary.

like require.resolve() on behalf of bower files asynchronously and synchronously

Attempt to resolve the absolute filepath to a file and verify that it exists.

Babel plugin to dynamically rewrite the path in require() and ES6 import

XMPP connection methods resolution for JavaScript

Custom resolve module content.

Find the path(s) package.json.

Utils for `generate` generators.

Traverse JSON objects through json pointers and dereference JSON schemeas

Resolves parts and plugins from a Sanity configuration

A JavaScript extension package for building strong and modern applications.

path.relative for generating short require'able paths.

ES Proposal spec-compliant shim for Promise.withResolvers

A Custom Sass Import Resolver with included support for Node Module Resolution, additional file extensions, and path aliases/path mapping

Module resolver plugin for Gatsby

Async-rendering & data-fetching for universal React applications

A GraphQL batching model which groups execution by GraphQL fields.

Recursively resolve templates in an object, string or array.

A tiny library to help with promises you can check and resolve from outside

Yaml Parser with additional functionality.

Turn css @import statements into full urls

Table resolution utilities

cache layer for jest-resolve

TypeScript path alias resolver, re-writes JS files with relative paths according to @paths specified in tsconfig

Resolves AWS credentials (and region) using env, file and IAM strategies

Builtins that were extracted from node-browser-resolve on which browserify depends

Node.js Javascript/Typescript library for keeping and resolving a given state of CasparCG into commands for casparcg-connection.

Node utility to list packages that are npm linked

Bypass the require cache when requiring a module – works with both node and browserify

Measure the time a promise takes to resolve

Execute an error-first callback upon resolution or rejection of a promise (and return the promise)

Vite plugin to handle your resources. For example, to replace occurrences by a regular expression, or resolving paths in cases where the usual tools do not help you, or something else.

Resolver for Jest which uses the enhanced-resolve module

resolvewith with extra power

Resolve dot notation strings

Find a file by walking up parent directories

A file loader plugin for esbuild for `require.resolve` statements.

Return an array of resolved filepaths for require-able local or named npm modules. Wildcard (glob) patterns may be used.

require.resolve for binaries

Requires a module found relative to given root or working directory.

Solidity import url resolver engine

Find files or directories by walking up parent directories.

CLI for source-map tool

Returns a promise resolved in the next event loop - think `setImmediate()`

a shortstop resolver like path but for node modules

A simple Node behavior import resolution plugin for eslint-plugin-import, supporting module alias, modified to allow for arrays of aliases.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Preprocessor for Jest that is able to resolve require() statements using webpack aliases.

Shim for `import.meta.resolve`

Import, export, require path redirect plugin for Babel

Find the root directory of a `git` repository

Human friendly file system utilities for Node.js

Returns an array of unique "global" directories based on the user's platform and environment. The resulting paths can be used for doing lookups for generators or other globally installed npm packages. Node.js / JavaScript.

Gets the home dir or resolves home directories.

Parse fields from AST (GraphQLResolveInfo) into a JSON tree

The CLI for working with JSON Schema. Covers formatting, linting, testing, and much more for both local development and CI/CD pipelines

Resolve the path of `npm-cli.js` included in the user-installed npm on Windows

Resolve the path of `npm-cli.js` included in the globally installed npm CLI

Create actions that return promises, which are resolved/rejected by a redux saga

rollup plugin that represents bundle content as convenient interactive zoomable treemap

A path of the currently executed npm CLI

<h3 align="center"> @merger203/expert-invention </h3>

Solves the relative path problem in Node.js by allowing a require call to reference the current package

Parse, Resolve, and Dereference JSON Schema $ref pointers

Generates an asynchronous resolver function from a PAC file

Resolve the directory path where npm CLI is installed

Resolve the path of a module from the directory where npm is installed

Load a module from either CWD or npm CLI directory

Return an accessor function for retrieving an element from an array-like object.

Find the root directory of a Node.js project from a given path

Resolve or reject only last Promise.

URL manipulation library

delay before run next command

babel-plugin-root-import resolver for eslint-plugin-import

Calculate the relative path from a file's destination path to another directory or file.

Promise related utilities

Fork of axios-cached-dns-resolve in CJS and with type safety. Caches dns resolutions made with async dns.resolve instead of default sync dns.lookup, refreshes in background

JSON schema validation with a chainable syntax.

Resolve version of an installed module.

Resolve modules from any directory.

Resolve the path of a module through a sequence of packages

Require a module like `require()` but via a sequence of nested packages

A babel plugin that resolves modules using the tsconfig.json or jsconfig.json configuration

Resolve parent directories, execute a function on every dir found until a result is returned

Utility for returning a list of arrays that contain matching keywords. Useful for filtering package.json files.

A simple module to auto resolve module paths.

Require a module like `require()` but via a sequence of nested packages from the current working directory

React components for [Stripe.js and Elements](https://stripe.com/docs/stripe-js).

Gives full control over when ES6 promises are resolved by providing an implementation of Promise with behavior controlled by .resolve(result) and .reject(error) methods. Intended for use in unit tests.

Supports tsconfig paths in Parcelv2.

Inside-out promise; lets you call resolve and reject from outside the Promise constructor function.

Resolve a deeply nested structure of q-promises into a promise for the whole structure

Babel Plugin Root Import ESLint resolver.

Skip hoops with promises Edit

Let a globally installed package use a locally installed version of itself if available

Use this to load modules whose location is specified in the `paths` section of `jsconfig.json` when using jest.

Tangerine is the best Node.js drop-in replacement for dns.promises.Resolver using DNS over HTTPS ("DoH") via undici with built-in retries, timeouts, smart server rotation, AbortControllers, and caching support for multiple backends (with TTL and purge sup

A simple selective option resolver

Display the dependency tree of a certain module based on your yarn.lock file

resolve like require.resolve() on behalf of files asynchronously and synchronously

Resolves aliases with Rollup

Use this to load modules whose location is specified in the `paths` section of `jsconfig.json` when using webpack.

URL host resolver for Docker applications

returns first successful promise. As in Promise.any() which is not part of the ES6 spec

Webpack Theme Resolver plugin to resolve files through directory chain with a package fallback at compile time.

Offers an enhanced bower support for enhanced-resolve plugin.

simply resolves a path, using resolve after expanding a tilde

Find The File That Dependency Path Resolves To.

Use Webpack's enhanced-resolve inside Jest

Resolves import paths to their CDN equivalents

Resolves The Location Of The Package.Json File For The Given Dependency By Traversing The File System Up Starting From Given Path.

Simple module to add additional directories to the Node module search for top-level app modules

Loads package.json, by finding the first directory with a package.json, recursing up, starting with the given directory.

returns a valid filesystem path.