JSPM

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

Resolve a path by walking parent directories.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Caching DNS resolve

Promisified version of node-which

Fast relative path resolution

Fulfill long runinng promises on timeout.

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

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

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

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

ES 2021 spec-compliant shim for Promise.any

Parse, Resolve, and Dereference JSON Schema $ref pointers

An algorithm for resolving imports in Sass

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

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

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

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

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

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

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

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

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.

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

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

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

A simple promise resolver

Node's URL module plus relative pathing

Find the path(s) package.json.

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

Simplify JsonSchema/Openapi by combining allOf safely

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

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

Find an asset in a set of locations

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

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

ES6 Promise Shim

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

Get global npm prefix. Respects npmrc configs

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

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.

One step closer to your destination.

Helps a module find its package.json mothership.

Install Git for Windows by npm.

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

Resolve relative IRIs to absolute IRIs given a base IRI

Library that resolves AWS Cloudformation templates with exact values

Given an url resolve it as fast as possible

Delay a promise a specified amount of time

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

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

Replace absolute paths to relative paths for package compilation

Resolve a whole structure of promises

resolve "imports" in package.json

Resolves @import statements in CSS

Change where a module dependency is resolved/imported from.

A JavaScript extension package for building strong and modern applications.

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

PATTERN_KEY_COMPARE implementation

For limiting the time to resolve a promise.

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

Yaml Parser with additional functionality.

Resolve a possibly relative URL agains a source URL

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

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

Resolves index.js files with Rollup

Delay a promise a minimum amount of time

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

Find files or directories by walking up parent directories.

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

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

ES Proposal spec-compliant shim for Promise.withResolvers

> Apply React refs

Custom resolve module content.

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

A GraphQL batching model which groups execution by GraphQL fields.

## What is it?

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

rollup plugin that represents bundle content as convenient interactive zoomable treemap

Module resolver plugin for Gatsby

Table resolution utilities

Resolves parts and plugins from a Sanity configuration

Async-rendering & data-fetching for universal React applications

a shortstop resolver like path but for node modules

Asynchronous require.resolve() implementation

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

path.relative for generating short require'able paths.

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

Turn css @import statements into full urls

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

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

Recursively resolve templates in an object, string or array.

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

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

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

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

[![github actions][actions-image]][actions-url] [![coverage][codecov-image]][codecov-url] [![dependency status][deps-svg]][deps-url] [![dev dependency status][dev-deps-svg]][dev-deps-url] [![License][license-image]][license-url] [![Downloads][downloads-im

Traverse JSON objects through json pointers and dereference JSON schemeas

Wrap `require` in a try/catch block.

Human friendly file system utilities for Node.js

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

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.

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

NodeJS hook to resolve `.ts` files when a `.js` file is imported so that --experimental-strip-types works

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

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

Resolve dot notation strings

Resolver for Jest which uses the enhanced-resolve module

CLI for source-map tool

Node utility to list packages that are npm linked

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

Import, export, require path redirect plugin for Babel

Supports tsconfig paths in Parcelv2.

Chmod + Directory Resolver + Shebang Rollup plugins by Harald Rudell

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

Generates an asynchronous resolver function from a PAC file

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

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

Find a file by walking up parent directories

Measure the time a promise takes to resolve

Light weight JSON Schema $ref resolver. Expands a JSON Schema by resolving `$ref` references from a mapping of definitions. Does not handle remote references. Has comprehensive unit tests and no dependencies.

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

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

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

Utils for `generate` generators.

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

Allow rollup to resolve local files with any extension

Shim for `import.meta.resolve`

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.

Parse, Resolve, and Dereference JSON Schema $ref pointers

Resolves aliases with Rollup

Parse fields from AST (GraphQLResolveInfo) into a JSON tree

delay before run next command

require.resolve for binaries

Gets the home dir or resolves home directories.

A simple module to auto resolve module paths.

Resolve the path of a module through a sequence of packages

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

Find the root directory of a `git` repository

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

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

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

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

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

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.

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

Resolve version of an installed module.

Resolve the directory path where npm CLI is installed

A path of the currently executed npm CLI

Template helper for generating a list of links to the homepages of related GitHub/npm projects.

Promise related utilities

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

JSON schema validation with a chainable syntax.

Resolve or reject only last Promise.

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

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

Load a module from either CWD or npm CLI directory

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

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

Load plugins for gulp, grunt, assemble, verb any node.js app that needs to load plugins from node_modules or local folders.

Babel Plugin Root Import ESLint resolver.

Skip hoops with promises Edit

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

Find The File That Dependency Path Resolves To.

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

URL host resolver for Docker applications

Resolve modules from any directory.

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.

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.

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

Offers an enhanced bower support for enhanced-resolve plugin.

Normalize a glob pattern by expanding braces, making it absolute and resolving parent directories '..'

Get the absolute path to the yarn global modules directory (globally installed modules).

Resolve a promise or value and all of its embedded promises (key values, elements of array, including nested)

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 custom `dns.lookup` based on dns resolver with timeout and cancellation handlers

Get the absolute path to the global yarn config directory.

A familiar set of functions that operate on JavaScript iterables (ES2015+) in a similar way to .NET's LINQ does with enumerables.

A simple TCP ping utility to ping a port of an IP or domain

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

Smart caching for promises. Like memoization, but better.

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

Solidity import url resolver engine

Nodejs module loader from Typescript path alias

A flexible find-up implementation supporting string, RegExp, CJS/ESM dual build, and custom matcher.

Declarative arguments-resolver

Use Gulp to resolve Typescript path aliases during compilation.

Resolve modules from any directory.

Use Webpack's enhanced-resolve inside Jest

A hookable AMD module resolution implementation.

Find the first instance of an executable in the PATH, with expanding all symbolic links

A wrapper around event emitters that returns a bluerbird promise resolved or rejected when certain events are fired.

Checks if a Promise is resolved or rejected asynchronously

URL manipulation library

Webpack resolver plugin to load relative paths from a different directory or directories.

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

Find a file by walking down parent directories.

cache layer for jest-resolve

A ponyfill for Node.js path.resolve

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

A tiny TypeScript library to resolve URLs.

An extension for redux-toolkit that allows sagas to resolve async thunk actions.

NodeJS local resolve and require module

resolvewith with extra power

A simple selective option resolver

Gulp plugin that resolves relative paths in url() statements based on the original source file

Resolve paths to globally installed npm modules using glob patterns. Useful for getting paths to yeoman or Generate generators, etc.

Resolve relative paths as though it were in the caller's file

Rollup plugin to resolve relative imports from local folders without stating the index file

returns a valid filesystem path.

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

A lightweight Deferred implementation, using native Promises

creates a module.exports map for all modules in a directory

Rewrite module resolving path

package.json dependency resolver

A data transformation resolver

Load `request` module from either CWD or npm CLI directory

A simple module to get the path with __dirname

Modify the webpack resolve section of CRA

To resolve external modules for bundlers

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

Higher allowed path based on a root and a given path

Resolve path from CWD (Current Working Directory)

Meta-package for LeanCode linting configurations

Replace modules with Rollup

Module to hook into the Node.js require and require.resolve function

Allow root-of-project (closest package.json) requires in node with `^`

Copy test-fixtures to temp dir and get resolved file paths.

Simple static server middleware with ES Module path resolution

simply resolves a path, using resolve after expanding a tilde

Get the path of npm cache folder

Lightweight isomorphic url parser.

Resolves import paths to their CDN equivalents

Test whether a semver range resolves

vite plugin resolve externals

Copy local page assets to permalink folder

Replaces a caret with the root path

A Vite plugin that resolves TypeScript compilerOptions.paths.

A Rollup plugin to resolve, transform, minify TypeScript and generate type declarations with oxc.