JSPM

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

Enforces module path case sensitivity in Webpack

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

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

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

Transforms module resolution paths using TypeScript path mapping and/or custom paths

A PostCSS plugin to extend postcss-import path resolver to allow glob usage as path

TS AST transformer to rewrite import path

Gatsby plugin for aliasing path locations when importing files.

A import path plugin for ESDoc

Webpack plugin that allows to configure path or URL for fetching dynamic imports

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

Import, export, require path redirect plugin for Babel

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

A import path plugin for esdoc2

import & require absolute path gulp plugin

Resolve the path of a module through a sequence of packages

Fetch the current file and directory path, no matter your environment (Deno, Node.js, Web Browsers, ESM, CJS)

Transforms module resolution paths using TypeScript path mapping and/or custom paths

Resolves an import path to a filesystem path handling TypeScript, missing extensions and directory imports.

Dynamic imports transformer and CSS path rewriter for Vite when using Adobe Experience Manager

Get the closest parent folder containing a package.json file

Simple static server middleware with ES Module path resolution

An ESM/Jest friendly path utility.

Resolves the path of sass imports, following a heavily opinionated and probably very shady algorithm

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

abrequire is absolute path require

Additional ESLint's rules for Node.js

This plugin provides rules to enforce the best import path for encapsulation

Chainable ESModule Loader for import path aliases

Import a module lazily

Babel plugin to transpile import() to a deferred require(), for node

Require module from a given path

Require all files from app's root path (require-all + app-root-path)

Tomorrow's ECMAScript modules today!

PostCSS plugin to import CSS files

Require and resolve global modules like a boss

* Convert an absolute path to a tilde path: `/Users/YourUserName/dev` → `~/dev` * Inspired by [tilify](https://github.com/sindresorhus/tildify) by [Sindre Sorhus](https://github.com/sindresorhus) * Since tildify uses ES6 syntax, I created this package to

* Convert an absolute path to a tilde path: `/Users/YourUserName/dev` → `~/dev` * Inspired by [tilify](https://github.com/sindresorhus/tildify) by [Sindre Sorhus](https://github.com/sindresorhus) * Since tildify uses ES6 syntax, I created this package to

Allows importing modules by symbolic name, rather than by path

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

Get the file associated with a Sass import

Additional ESLint's rules for Node.js

* Convert an absolute path to a tilde path: `/Users/YourUserName/dev` → `~/dev` * Inspired by [tilify](https://github.com/sindresorhus/tildify) by [Sindre Sorhus](https://github.com/sindresorhus) * Since tildify uses ES6 syntax, I created this package to

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

Import with sanity.

css loader module for webpack

Import a globally installed module

Intercept imports in Node.js

This plugin adds `TypeScript` support to `eslint-plugin-import`

Transforms member style imports (import {x} from 'y') into default style imports (import x from 'y/lib/x')

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

Support for `import <defer|source>` phase syntax in Acorn

Clear a module from the cache

ESLint rule that validates ES6 imports are defined in local package.json

mdast extension to parse and serialize MDX.js ESM (import/exports)

A dependency tracing tool.

PEG.js Require Extension

Import all modules in a directory

Report and remove unused es6 modules

Concatenate files together using import statements.

Easy autofixable import sorting

Get the dependencies of an ES6 module

Quickly import from core node modules

Babel plugin to make raw files importable

Module resolver plugin for Babel

Get the dependencies of a TypeScript module

This package will allow users to require your package without writing dist/src

micromark extension to support MDX JS import/exports

Allows you to import local variables, functions and classes from other modules

Babel plugin to correctly add missing file extensions to import statements

Babel plugin to transpile import() to a deferred require(), for node

Mixins that manage rendered CSS from modular importing

A prettier plugins to sort imports in provided RegEx order

Parse CSS @import statements

Get the dependencies of a Vue module

Esbuild plugin for Rails applications

Get CSS @imports from a string

Babel 5/6 plugin that scans the AST for require calls and import statements

Regular expression for matching CSS @imports

Import with sanity.

Gatsby plugin to set Webpack to resolve import root

Creates ES6 ./index.js file in target directories that imports and exports all sibling files and directories.

Fast and easy parser for declarations of import and export in ECMAScript/TypeScript

A rework plugin to read and inline CSS files via @import

Concatenate css files, rebasing urls and inlining @import

Transforms module resolution paths using TypeScript path mapping and/or custom paths

The 2020 Most Modern Testing Framework For Node.JS With Test Contexts (Reusable BeforeEach / AfterEach Via Separate Files); Masks (Inputs/Outputs In Non-Js Files) And Fork Testing; Interactive Snapshots.

A prettier plugins to sort imports in provided RegEx order

Babel plugin for variable auto imports

Dynamic Module Loader

A polyfill for the native import() in the browser

Ignore html and css imports in your code. Useful for testing meteor without it's context

Babel plugin that replaces System.import with the equivalent UMD pattern

Babel plugin to transpile import() to a deferred require(), for node

Globbing support for LESS

Package that permit you to import every directory and files in a given path.

Enable ECMAScript 2015 modules in Node today. No caveats. Full stop.

Easy to use ES6 imports for $http, $log, and other Angular 1 services

get the file directory from import.meta.url

Allow only single quotes for import

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

ECMAScript module interop library

ESlint plugin to define custom module dependency rules.

Run ES Module syntax in any browser – even IE!

Enhance Vite builtin dynamic import

PostCSS plugin to inline @import rules content with extra features

Enable `require( ESM / EcmaScript Module )` in CommonJS / CJS modules.

Provides to all of your component React instances, you don't need to import React anymore.

Babel plugin to transpile object styles to template literal

Remove the resourceQuery param when importing modules via babel. Useful with Jest, that doesn't support resourceQueries

A webpack loader for glsl shaders - includes support for nested imports.

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

A better way to import NodeJS modules

Babel 7 plugin to transpile import() to a require(), for node

provides native ESM import and globals mocking for unit tests

Eslint plugin checking architecture boundaries between elements

Import documents to a Sanity dataset

Zero-config import from NPM packages

Like file-loader for webpack, but for Babel. Works with SSE apps.

Access to __filename and __dirname within ECMAScript modules

ESLint plugin to disallow [barrel files](https://github.com/basarat/typescript-book/blob/master/docs/tips/barrel.md).

babel plugin that emulates vite's import.meta.env functionality

Convert .gql/.graphql files to ES6 modules

Data transfer capabilities for Strapi

Does the current environment have `import()` support?

Standard dynamic imports with a few extra features

Babel plugin for rewriting requires/imports

A library for importing meta-model based file formats into JS

ESLint Plugin to make sure your imports only import the bits you need

Install and import packages on-the-fly

Normalize.css for styled-components CSS-in-JS library

A micro-library for collecting stylesheet data from link and style nodes

Babel Plugin to transform your code to include the mandatory file extensions so your output gets fully-specified imports.

import like require but async

XML import/export for documents described with moddle

Babel plugin to make raw files importable as base64 encoded data URI strings.

Replace all url paths and @import paths within css text, with custom function map.

Babel visitor that makes it easier to work with imports and require calls.

A JSCodeshift extension with helpers for modifying `import` and `require` statements.

babel plugin that emulates vite's import.meta.hot functionality

> Currently an alpha-quality, best-effort implementation. > May be unnecessary if you use TypeScript's `"module": "NodeNext", "moduleResolution": "NodeNext"`

Translate import statements to require statements

Karma preprocessor to bundle ES modules using Rollup

parse and handle import/export for browserify

Ensures imported file paths are well-defined

babel plugin that emulates vite's import.meta.glob import.meta.globEager functionality

Module resolver plugin for Gatsby

A npm package which helps importing all files from given path

ESLint plugin for enforcing newlines in ES6 import statements past a certain number of items

Import WebAssembly code with Rollup

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

ESLint Rules to Aid with Imports

A Webpack loader to restrict imports in ES and TypeScript

Parse ES6 imports from a string

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

Resolve imports/requires alias according to tsconfig paths

Gulp plugin that tracks dependencies between files and adds any files that depend on the files currently in the stream, thus enabling incremental build of pcss, less, scss, sass, with extensibility points to support other file types.

This babel plugin should be used as codemod for bulk import refactorings a.k.a module move refactorings

Webpack alias resolver to gatsby

Webpack loader for sass-extract. Extract structured variables when importing sass files.

[![npm version][npm-version-src]][npm-version-href] [![npm downloads][npm-downloads-src]][npm-downloads-href] [![Codecov][codecov-src]][codecov-href] [![License][license-src]][license-href]

An ESLint plugin that enforces the use of import aliases. Also supports autofixing.

Path resolver babel plugin using variables

Firestore data import and export

Mad metrics for your rollup bundles, know all the things

Lightweight, fast utility that resolves TypeScript import paths to absolute file paths without TypeScript compiler overhead. Zero dependencies.

LESS plugin to use aliases in @importing files.

Parses a CSS file, finds imports, grabs the content of the linked file and replaces the import statement with it.

Import SVG images in javascript file

Tomorrow's ECMAScript modules today!

ESLint rule for preventing the full import of big libraries when just a part of it can be imported.

Require and transpile JSX on the fly

Absurdly simple on-demand script loader.

A Rollup plugin to import CSS into JavaScript

Require and transpile JSX on the fly (fork of import-jsx for node 17 support)

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

Use ECMA6 import/export syntax from within NodeJS (simply require this module)

Lazy compile dynamic imports to boost your webpack startup time.

A gulp plugin which can import .js files into .js files

Ignore import rollup plugin

Takes a sample of CSV text and tries to guess newline character, col delimiter, quote character, and whether or not the first row in the file contains labels

@import file map creation for Sass

Intuitive mocking for Typescript class imports

Eslint plugin to restrict the name of imports. Works with default and CommonJS imports.

Babel plugin to make .gql/.graphql files importable

A transform stream for glslify that adds an `import` directive to your shaders.

A plugin to inline and optionally transform static imports with esbuild.

A JSDoc plugin to support the typescript module import syntax.

A rework plugin to read and inline CSS files via @import

[](https://www.npmjs.com/package/storybook-addon-module-mock) [](https://www.npmjs.com/package/storybook-addon-module-mock) [![](http

Import (compile and cache on the fly) TypeScript files dynamically with ease.

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

AS3 to JS converter.

Easy-to-use API for manipulating imports and require calls.

A simple adapter for elegantly importing CSV files via flatfile.io (Typescript, ES6, Browser)

An unofficial babel plugin for SAP UI5.

Measure the real, minified, tree-shaken impact of individual imports into your app

A handful set of package.json types and interfaces to improve working with dynamically imported package.json files.

A webpack loader that allowes to write a Golang style exports.

Powerful ESLint plugin with rules to help you achieve a scalable, consistent, and well-structured project. Create your own framework! Define your folder structure, file composition, advanced naming conventions, and create independent modules. Take your pr

Enforce placing import or export variables on a newline

A prettier plugin for sorting imports by length

This package provides the file import/export feature for Lexical.

Reference implementation playground for import maps proposal.

GrapesJS component for the embed of custom code

Resource import support package

PostCSS plugin to import CSS files

A esbuild plugin which allows to import multiple files using the glob syntax.

Ensure that import path is a full path to a module

Merge JSON (or YAML) files and objects with indicators like $import $remove $replace $merge etc

Extract URLs to stylesheets, scripts, links, images or HTML imports from HTML

Webpack loader to import files at once with glob

Transforms member style imports (import {x} from 'y') into default style imports (import x from 'y/lib/x')

React spreadsheet import for xlsx and csv files with column matching and validation

Babel plugin that transforms image assets import and requires to urls / cdn

Load module from string using require or import.

Normalize file for emotion JSS library

walk directory for esm and cjs modules

Resource import support package

Transforms importing of asset files at compile time using Babel

Grunt task to include files and replace variables. Allows for parameterised includes.

Rename import sources

A DynamoDB library that extends aws-sdk with bulk read/write, events, streams, and more

A data base store uuid to path and vice versa information

Enforce placing import or export variables on a newline

Explicitly import Jest globals

ESLint rule that helps sort export *

Import CSS from npm modules using rework

Enable ECMAScript 2015 modules in Node today. No caveats. Full stop.

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

Module will allow you to synchronously or asynchronously import (requires) all modules from the folder you specify

Transform CommonJS require statements into lazily evaluated imports

Dynamically import an existing AWS API Gateway into your Serverless stack.

A plug-in that imports component library styles on demand

require/import dependency validation

Tomorrow's ECMAScript modules today!

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

A lightweight TypeScript/JavaScript adapter for working with Flatfile's Portal

Lets you create custom aliases for CSS, less, SASS and etc. properties with an @alias rule

A Babel plugin that transforms indirect imports through a barrel file (index.js) into direct imports.

The plugin to transform path into the package for armour-antd!

Turn svg imports into strings

Allows recursive import of SCSS components from local and/or node_modules directories using npm's module resolving algorithm

import and export tools for elasticsearch

Reset file for emotion JSS library

Webpack loader for scss-extract. Extract structured variables when importing sass files.

Babel plugin to rewrite bare imports for browser use.

Rename import sources