JSPM

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

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

Define and resolve aliases for bundle dependencies

Reads and parses a JSON file.

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

`Start a promise chain

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

Check if a module ID is resolvable with require()

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

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

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

Create aliases of directories and register custom module paths

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

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

Recursively resolve JSON pointers and remote authorities.

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

The directory used by npm for globally installed npm modules.

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

Library to help resolve module locations.

Get the npm global path prefix.

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

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

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

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

Find and load a YAML or JSON config file (like .jshintrc, package.json, bower.json etc) from either a local project, installed npm module, or the user's home directory.

> Minimal and efficient cross-platform file watching library

Parse, Resolve, and Dereference JSON Schema $ref pointers

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

Extensible JSON Schema library with support for multi-file schemas using $ref

Create a deferred promise

micromark utility to resolve subtokens

An algorithm for resolving imports in Sass

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

Webpack loader that adjusts source maps

Read the closest package.json file

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

Delay a promise a specified amount of time

Resolve a path by walking parent directories.

Get the directory of globally installed packages and binaries

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

Find a file or directory by walking up parent directories

This packages lets you autoload your environment variables from your `.env` file, no code changes required.

resolve which handles browser field support in package.json

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

Module resolver plugin for Babel

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

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.

File-based routing plugin for fastify. Inspired from [fastify-autoroutes](https://github.com/GiovanniCardamone/fastify-autoroutes).

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

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

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

Resolve the path of a globally installed module

Require and resolve global modules like a boss

Resolve required module's bin file.

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

Node's URL module plus relative pathing

Aids humans and automation in managing npm audit results

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

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

Resolve a relative path against a root path with validation

One step closer to your destination.

<!-- -- This file is auto-generated from src/README_js.md. Changes should be made there. --> # Mime

Promisified setTimeout

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

import the closest file as a node module with loader

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

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

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

Resolve and bundle data loader file exports at build-time.

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

Find files or directories by walking up parent directories.

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

[//]: # "This README.md file is auto-generated, all changes to this file will be lost." [//]: # "To regenerate it, use `python -m synthtool`." <img src="https://avatars2.githubusercontent.com/u/2810941?v=3&s=96" alt="Google Cloud Platform logo" title="Goo

Resolves a file within a dat archive based on how web browsers would load it

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

Caching DNS resolve

Promisified version of node-which

Fast relative path resolution

Fulfill long runinng promises on timeout.

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

The `Easylibs` library is a collection of reusable JavaScript modules that can be used to build web applications. The library includes modules for progress form, file uploading, image processing, and data validation and more.

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

The `Easylibs` library is a collection of reusable JavaScript modules that can be used to build web applications. The library includes modules for progress form, file uploading, image processing, and data validation and more.

ES 2021 spec-compliant shim for Promise.any

Parse, Resolve, and Dereference JSON Schema $ref pointers

given a filepath return a unique id with serialised info from any package.json file is discovered on the path

Library that resolves AWS Cloudformation templates with exact values

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

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

A JavaScript extension package for building strong and modern applications.

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

Replace absolute paths to relative paths for package compilation

Resolve a package entry point to a file path (like require.resolve/import.meta.resolve) OR a file path to a package entry point

File Resolution for Esbuild running in the Browser

rollup plugin that represents bundle content as convenient interactive zoomable treemap

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

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

resolve "imports" in package.json

Read the closest package.json file

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

A simple promise resolver

PATTERN_KEY_COMPARE implementation

Yaml Parser with additional functionality.

Find the path(s) package.json.

Simplify JsonSchema/Openapi by combining allOf safely

Find an asset in a set of locations

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.

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

ES6 Promise Shim

Get global npm prefix. Respects npmrc configs

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

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

Resolves index.js files with Rollup

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

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

Custom resolve module content.

Helps a module find its package.json mothership.

Install Git for Windows by npm.

Resolve relative IRIs to absolute IRIs given a base IRI

Given an url resolve it as fast as possible

Delay a promise a specified amount of time

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

Supports tsconfig paths in Parcelv2.

Module resolver plugin for Gatsby

[![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

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

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

Resolve a whole structure of promises

path.relative for generating short require'able paths.

Resolves @import statements in CSS

Change where a module dependency is resolved/imported from.

Asynchronous require.resolve() implementation

Find a file or directory by walking up parent directories

Import, export, require path redirect plugin for Babel

Resolve dependencies file paths in a package.json

CLI for source-map tool

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).

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

Resolve a possibly relative URL agains a source URL

Delay a promise a minimum amount of time

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

Parse, Resolve, and Dereference JSON Schema $ref pointers

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.

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

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

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

A GraphQL batching model which groups execution by GraphQL fields.

## What is it?

XMPP connection methods resolution for JavaScript

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

Table resolution utilities

Resolves parts and plugins from a Sanity configuration

Find the root directory of a `git` repository

Async-rendering & data-fetching for universal React applications

a shortstop resolver like path but for node modules

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

Use Webpack's enhanced-resolve inside Jest

resolvewith with extra power

Allow rollup to resolve local files with any extension

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

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

Recursively resolve templates in an object, string or array.

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

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

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

Traverse JSON objects through json pointers and dereference JSON schemeas

Wrap `require` in a try/catch block.

Babel Plugin Root Import ESLint resolver.

Nodejs module loader from Typescript path alias

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

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

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

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

Offers an enhanced bower support for enhanced-resolve plugin.

Resolve dot notation strings

Node utility to list packages that are npm linked

Resolver for Jest which uses the enhanced-resolve module

Chmod + Directory Resolver + Shebang Rollup plugins by Harald Rudell

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

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

Shim for `import.meta.resolve`

A little bundler for resolving dependencies graphs into a single concatenated file.

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.

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

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

Resolves aliases with Rollup

Parse fields from AST (GraphQLResolveInfo) into a JSON tree

delay before run next command

require.resolve for binaries

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

File Resolution for Esbuild running in the Browser

Gets the home dir or resolves home directories.

Webpack resolver plugin to load relative paths from a different directory or 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

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

Find a file by walking up parent directories

Solidity import url resolver engine

Save [CouchDB sequence #s](http://docs.couchdb.org/en/2.1.1/api/database/changes.html#changes-feeds) to a configurable backend. This allows you to resume CouchDB replication from the point where you left off.

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

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.

URL manipulation library

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

Resolve version of an installed module.

Resolve the directory path where npm CLI is installed

file resolver for component

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

A path of the currently executed npm CLI

Promise related utilities

Resolution of domain names or IP addresses given or from a file

JSON schema validation with a chainable syntax.

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

Resolve or reject only last Promise.

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

> This is a fork of eugeneware/fs-tail-stream that fixes an encoding issue. > Switch back to the original when https://github.com/eugeneware/fs-tail-stream/pull/2 is merged and released.

[](https://www.npmjs.com/package/@ffras4vnpm/totam-dolorem-impedit) [](h

Load a module from either CWD or npm CLI directory

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

[](https://github.com/odczynflnpm/cum-quam-eligendi/actions/workflows/test.yaml) [![npm version](https://img.shields.io/npm

[](https://www.npmjs.org/package/@xdanangelxoqenpm/vel-ab-inventore) [![Build Status](https://api.travis-ci.org/Alex-Werner/@xdanangelxoqenpm/vel-ab-inve

Resolve your packages configuration from a .*rc or package.json with a given property up the file-tree.

Express Handlebars ==================

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

[](https://badge.fury.io/js/@wemnyelezxnpm/quia-quaerat-tenetur) [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/bpatrik/@wemnyelezxnpm/quia-quae

Modify the webpack resolve section of CRA

An [ESLint](https://eslint.org) plugin for your [Cypress](https://cypress.io) tests.

 

React-Hook-Form-Mantine is a library that simplifies the integration of Mantine components with React Hook Form. By adding a "name" prop to Mantine components, the library seamlessly connects them to the corresponding form field.

A super simple & flexible & intuitive config module, support `yaml` & `toml`.

Find a file by walking up parent directories

a yarn cli tool helper