JSPM

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

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

Allows importing modules by symbolic name, rather than by path

Additional ESLint's rules for Node.js

Get the file associated with a Sass import

* 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

Intercept imports in Node.js

Import a globally installed module

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

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

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

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

Clear a module from the cache

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

Get the dependencies of a TypeScript module

Module resolver plugin for Babel

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

micromark extension to support MDX JS import/exports

Babel plugin to make raw files importable

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

Get CSS @imports from a string

Esbuild plugin for Rails applications

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

A prettier plugins to sort imports in provided RegEx order

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

Babel plugin for variable auto imports

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.

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

Globbing support for LESS

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

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.

A better way to import NodeJS modules

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

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

Eslint plugin checking architecture boundaries between elements

Import documents to a Sanity dataset

Zero-config import from NPM packages

Access to __filename and __dirname within ECMAScript modules

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

provides native ESM import and globals mocking for unit tests

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

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

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

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

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.

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

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

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

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

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

Translate import statements to require statements

Karma preprocessor to bundle ES modules using Rollup

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

parse and handle import/export for browserify

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

ESLint Rules to Aid with Imports

Import WebAssembly code with Rollup

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

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

A Webpack loader to restrict imports in ES and TypeScript

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.

Ensures imported file paths are well-defined

Resolve imports/requires alias according to tsconfig paths

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.

Parse ES6 imports from a string

Path resolver babel plugin using variables

LESS plugin to use aliases in @importing files.

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.

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

Tomorrow's ECMAScript modules today!

Require and transpile JSX on the fly

Import SVG images in javascript file

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

Absurdly simple on-demand script loader.

A Rollup plugin to import CSS into JavaScript

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

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

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

Lazy compile dynamic imports to boost your webpack startup time.

@import file map creation for Sass

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

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

Intuitive mocking for Typescript class imports

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

Babel plugin to make .gql/.graphql files importable

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

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

A JSDoc plugin to support the typescript module import syntax.

[](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.

AS3 to JS converter.

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

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.

Enforce placing import or export variables on a newline

A prettier plugin for sorting imports by length

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

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

Reference implementation playground for import maps proposal.

PostCSS plugin to import CSS files

GrapesJS component for the embed of custom code

Resource import support package

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

Load module from string using require or import.

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

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

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

walk directory for esm and cjs modules

Normalize file for emotion JSS library

Webpack loader to import files at once with glob

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.

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

Rename import sources

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

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

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

Transform CommonJS require statements into lazily evaluated imports

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

Tomorrow's ECMAScript modules today!

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

require/import dependency validation

A plug-in that imports component library styles on demand

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

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.

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

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

import and export tools for elasticsearch

Turn svg imports into strings

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

React CSV import widget with user-customizable mapping

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

Webpack plugin to fix default import for non ES6 modules

import directories in your SCSS

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

Resolves @import statements in CSS

Change where a module dependency is resolved/imported from.

TypeScript SDK for Composable Commerce Import API features

A babel plugin to remove import and export declaration in the source file.

A Regex-Based Transpiler Of Source Code To Allow Writing Import And Export Statements And JSX With 0 Dependencies.

CommonJS to ES2015 modules (export/import) transformation plugin for Babel

Resolves import statements using aliases and file extensions, (sync with webpack resolve specs)

An ESLint plugin to sort both import and require declarations in a unified manner.

Import modules isomorphically

Dynamic imports for all

module.exports and module.import for browsers too

Tomorrow's ECMAScript modules today!

Watches SASS files, adding @import-ing files to the stream

Provides directory aliases for es2015 import statements

Transform the Import Attributes proposal (`import ... from '...' with { ... }`) to the previous version known as Import Assertions (`import ... from '...' assert { ... }`).

[](https://circleci.com/gh/graphcool/graphql-import-loader) [](https://badge.fury.io/js/graphql-import-l