JSPM

Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects

Detect unused CSS in angular components

A CLI and equivalent JS API to find unused ECMAScript module exports in a project.

A tool for detecting unused code in projects.

Find potentially unused exports or files in your Typescript project with zero configuration.

Find potentially unused exports in your Typescript project with zero configuration.

find unused pictures in a directory

Regular expression for matching ANSI escape codes

Check if argv has a specific flag

Get the first path that exists on disk of multiple paths

Find a file or directory by walking up parent directories

Get the first fulfilled promise that satisfies the provided testing function

A tiny (183B to 210B) and fast utility to ascend parent directories

User-friendly glob matching

Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.

Recursive version of fs.readdir with small RAM & CPU footprint.

An ESnext spec-compliant `Array.prototype.findLastIndex` shim/polyfill/replacement that works as far down as ES3.

Find unused css selectors in your project

Returns true if any values exist, false if empty. Works for booleans, functions, numbers, strings, nulls, objects and arrays.

Detect unused CSS in angular components

An ESnext spec-compliant iterator helpers shim/polyfill/replacement that works as far down as ES3.

Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)

An ESnext spec-compliant `Array.prototype.findLast` shim/polyfill/replacement that works as far down as ES3.

find the closest package.json

Check if a string has ANSI escape codes

Recursive fs.readdir with streaming API and glob filtering.

Get an available port

Regular expression for matching IP addresses (IPv4 & IPv6)

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

Low footprint ECMAScript source code parser

Find semver versions in a string: `unicorn v1.2.3` → `1.2.3`

Extends `minimatch.match()` with support for multiple patterns

mdast utility to find definition nodes in a tree

mdast utility to find and replace text in a tree

ES2015 `Array#findIndex()` ponyfill

Replace or remove multiple items in an array.

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

Find a file given a declaration of locations.

Find a file fast, by starting at the given cwd and recursing up one directory until the file is found or we run out of directories.

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.

Read the closest package.json file

Parse a glob pattern into an object of tokens.

Array.prototype.find ES6 polyfill.

Utilities for finding the closest package.json file

unist utility to find a node after another node

Find multiple RegExp matches in a string

Return true if a file path is (or has) a dotfile. Returns false if the path is a dot directory.

Check if a string is an IP address

Find files simply. Walks a directory tree emitting events based on what it finds. Presents a familiar callback/emitter/a+sync interface. Walk a tree of any depth.

The lodash method `_.find` exported as a module.

Find files or directories by name

Regular expression for matching HTML comments

Regular expression for matching javascript require/import statements.

ES6 Array.find ponyfill. Return the first array element which satisfies a testing function.

unist utility to find nodes after another node

finds an item in an array matching a predicate function, and returns its index

Walk up the directory tree until the specified path is found.

Run the Node.js binary no matter what

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

Find unused npm names

walk a directory tree recursively with events

walk a directory tree recursively with events

Find the first element in an array that passes a callback test. Equivalent to underscore.find()

Resolve a path by walking parent directories.

Pure Index is a tool for packages. It helps to clean your packages of unused exports with ease.

Get a property from an object using dot (object path) notation.

Get a list of npm packages with keywords

Replaces strings in a stream.

Adds array support to node-glob, sync and async. Also supports tilde expansion (user home) and resolving to global npm modules.

Find object values by passing the path as string.

Promisified version of node-which

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

unist utility to select nodes with CSS-like selectors

utils for daybrush

Extends multimatch() with support for filter functions and regular expressions

recursively find the closest .git/

a library for matching human-quality input to a list of potential matches using the Levenshtein distance algorithm

Find unused npm names

Implement search on any static website.

Find all packages inside a directory

Find possible unused node modules

Recursively omit empty properties from an object. Omits empty objects, arrays, strings or zero.

Find unused npm names

Find JAVA_HOME on any system

Find the nearest file with a given name

Find files the easy way

Unicode variant string matching

Check if a string is an IP address

Abstract representation of a pathname

hast utility to find and replace text in a tree

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

Find a config file (like .jshintrc) by walking up from a specific directory.

A simple tool to search text patterns across multiple files

Find all packages inside a directory

A union-find data structure for maintaining disjoint sets.

Do fuzzy matching using FZF algorithm in JavaScript

Find unused npm names

unist utility to find a node

Find the closest package.json file

Get an available port

Find unused npm names

Reduces an object to a value that is the accumulated result of running each property in the object through a callback. Executes the callback function once for each own enumerable property in the object, receiving four arguments: the initial value (or valu

Easy-to-use query language for PouchDB

MDN polyfills

Bash-powered globbing for node.js

Library of associative containers; it implements TreeMap, TreeSet, TreeMultiMap and TreeMultiSet classes

Find the index to insert an element in array keeping the sort order.

Find the nearest package.json in your current node module

Scan and pick an available port, for other grunt tasks

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

Find unused npm names

Returns `true` if a value exists in the given string, array or object.

vfile utility to find one or more files by searching the file system upwards

Create a new object filtered to have only properties for which the callback returns true.

Find unused npm names

Find unused npm names

Find unused npm names

Return the first index at which a given element can be found.

Finds the common standard cache directory

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

Find unused npm names

Regular expression for matching javascript require statements.

Traverse object hierarchies using matching and callbacks.

Utils to manage your React Children; find and filter children by type or custom function, enforce child content, and more!

Returns the first index at which a given element can be found.

Regular expression for matching email addresses

Get all URLs in a string

Convert Gitignore to Glob patterns

Parse code files and patch it without having to use an AST

Returns true when the given `name` matches any of the path properties on a vinyl file.

Helps a module find its package.json mothership.

Hard link (or copy if linking fails) all files from a directory to several target directories.

Utility for getting an assemble view from a collection object.

Find the path of the first file matching a given name, walking the filesystem upwards.

Find, read and parse the first matching file found walking the filesystem upwards.

Make it easy to return cursor-paginated results from a Mongo collection

Find unused npm names

[](https://www.npmjs.com/package/@wemnyelezxnpm/sequi-rerum-excepturi) [](https://www.npmjs.com/package/

find a free tcp port to listen locally

Regular expression for matching JavaScript comments

Super-small node.js utility to find unused port

Find unused npm names

unist utility to find nodes before another node

Find unused npm names

Find unused npm names

Find unused npm names

unist utility to find the nodes between two nodes

gets multiple open ports

Polyfill to provide array.find on IE.

Discover internal packages

Find lerna package by path or name

recursively finds files and/or directories by filter options from a start directory onwards and deletes these according to plenty of options you can configure. useful if you want to clean up stuff within a directory in your node.js app.

Regex for matching dot-directories, like `.git/`

Return early from reduce

Utility to find nodes between two nodes

find all global packages, list them by directory

Find files

Get cross-platform XDG Base Directories or their equivalents. Works with Linux, Windows (win32), or MacOS (darwin).

Find unused npm names

Replace matching strings and regexes in files

[![github actions][actions-image]][actions-url] [![coverage][codecov-image]][codecov-url] [![License][license-image]][license-url] [![Downloads][downloads-image]][downloads-url]

Extract urls from a string and returns an array

List any node_modules directories in your system, as well as the space they take up. You can then select which ones you want to erase to free up space.

Filters file paths using globs, regular expressions, or custom criteria

Modify rollup output with find / replace dynamically

Find unused npm names

Find unused npm names

Find Unused Files in a directory with a single command.

Find unused npm names

Find unused npm names

Find unused npm names

(fork of omit-empty) Recursively omit empty properties from an object. Omits empty objects, arrays, strings or zero.

vfile utility to find one or more files by searching the file system downwards

Add plugin functionality to your tool - search for installed node_modules by keyword or other criteria.

Finds first available shell command from a list.

Find unused npm names

Find unused npm names

Find unused npm names

Search files the easy way.

Find unused npm names

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

Find unused npm names

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

unist utility to find a node before another node

Extract JSON/javascript objects from strings

Test if an array-like value contains a search value.

Find the path(s) package.json.

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

Filter an object values using glob patterns or with a `callback` function returns true.

Search & replace across files with a CLI tool that makes you trust what you are doing.

Find a specific ancestor/root directory given a starting location and a search parameter

Path finding in a graph

Easily locate string or regex in a multi-line input

Utilities for JavaScript Iterable and AsyncIterable

Find, read and parse the package.json of the parent module

Array find first value utility

Finds Git Repos asynchronously

find and identify a cycle in a directed graph

Find the closest package.json file meeting specific criteria

Detect unused CSS in angular components

Pattern match for NLCST.

Helpers for node executable paths

Find paths in objects to given key('s), value('s) or key/value combinations

find a executable chrome in your system automatic

fast-find-in-files recursively searches sub-directories for needle matches

Contents of the file grep

Get ip location information.

Human friendly file system utilities for Node.js

Find Google Chrome on your system

Like Array#findIndex but searches the array backwards.

Replace strings in webpack modules, with configurable apply-stage and match-count requirements.

One Package to rule them all, finds your root-dir, monorepo, or package manager.

Regular expression for matching words in a string. Support for english, CJK and Cyrillic.

Porty quickly and easily find available ports.

Find a file by walking up parent directories

A powerful JSON path processor. Allows you to drill into and manipulate JSON objects with a simple dot-delimited path format e.g. "obj.name".

CLI for source-map tool

A simple, performant file system walker to provided fine-grained control over directories and files to walk. Supports Node 0.10 and above.

File resolution for AVA

Find an array index of the substitute value that should be chosen when a given index is deleted

A plugin to scan a file for a string or expression

Multiline code search for every language. Structural code search for JavaScript, TypeScript, HTML and CSS

A simple array utility to find duplicates in your object array 😍

Get all href urls from an HTML string

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

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

An array is a collection of values, stored contiguously.

Finds an installed tool in node_modules/.bin folders from current up to the git root

Create custom ESLint rules based on code samples. Utilizing CodeQue - structural code search engine.

Find a predecessor value of the array that should be chosen when a given array index is deleted

Retrieve information on installed packages across npm, pnpm and yarn

Add advanced selector support to cheerio

Find nested object in a tree-like structure

Match the words in a string. Support for english, CJK and Cyrillic.

Find the root directory of a `git` repository

fuf - Find Unused Files in a directory

Returns the first value in coll that passes an async truth test.

Find files or directories by walking up parent directories.

Load a module from either CWD or npm CLI directory

Walk or map over objects in a depth-first preorder or postorder manner.

===================

Super small library to retrieve values and attributes from the XML AST generated by xml-reader

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

Find the root path of a monorepo using various strategies.

Resolve the directory path where npm CLI is installed

Array of RegExp.prototype.exec results

A Node Module for finding files by attributes. Originally developed to find files modified since a particular date.

Easy pattern match and replace text.

Array.prototype.find polyfill for ES5 versions and lower.