Sindre Sorhus

Terminal string styling done right

A collection of essential TypeScript types

Tiny and elegant HTTP client based on the Fetch API

Human-friendly and powerful HTTP request library for Node.js

Pretty, minimal and fast ZSH prompt

Capture website screenshots

Elegant terminal spinner

The minimal amount of CSS to replicate the GitHub Markdown style

JavaScript/TypeScript linter (ESLint wrapper) with great defaults

A better `npm publish`

Process execution for humans

Normalize browsers' default style

Simple wrapper for cross-browser usage of the JavaScript Fullscreen API, which lets you bring the page or any element into fullscreen.

Fabulously kill processes. Cross-platform.

Parse and stringify URL query strings

More than 100 powerful ESLint rules

Create a good-looking DMG for your macOS app in seconds

Simple data persistence for your Electron app or module - Save and load user settings, app state, cache, etc

Promise queue with concurrency control

Detect the file type of a file, stream, or data

Function argument validation for humans

CLI app helper

Open stuff like URLs, files, executables. Cross-platform.

Spinners for use in the terminal

Run multiple promise-returning & async functions with limited concurrency

Test your download and upload speed using fast.com

Move files and folders to the trash

Create Alfred workflows with ease

User-friendly glob matching

Check TypeScript type definitions

Find relevant emoji from text on the command-line

Framework for effortlessly building Ink apps

Simple and modern async event emitter

Capture screenshots of websites

Access the system clipboard (copy/paste)

Collection of customizable UI components for CLIs made with Ink

Update notifications for your CLI app

Type check values

Capture website screenshots

Runs an accessibility audit against a URL

Create boxes in the terminal

Static asset revisioning by appending content hash to filenames: unicorn.css => unicorn-d41d8cd98f.css

Promisify a callback-style function

Map over promises concurrently

Context menu for your Electron app

Move files and folders to the trash

Check if the internet connection is up

Simple config handling for your app or module

Convert bytes to a human readable string: 1337 → 1.34 kB

Convert milliseconds to a human readable string: `1337000000` → `15d 11h 23m 20s`

Simplified file downloads for your Electron app

Memoize functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input

Log by overwriting the previous output in the terminal. Useful for rendering progress bars, animations, etc.

Display images in the terminal

Copy text to the clipboard in modern browsers (0.2 kB)

Retry a promise-returning or async function

Hashing made simple. Get the hash of a buffer/string/stream/file.

Minify images seamlessly

Run shell commands

Load multiple grunt tasks using globbing patterns

ES2015 `Object.assign()` ponyfill

Get metadata about the active window and open windows (title, id, bounds, owner, URL, etc)

Easily load and save config without having to think about where and how

Normalize a URL

CommonJS version - The smallest and fastest command-line coloring package on the internet

Capture screenshots of websites from the command-line

Delay function calls until a set time elapses after the last invocation

Fabulously kill processes. Cross-platform.

Run grunt tasks concurrently

Adds useful debug features to your Electron app

Colored symbols for various log levels. Example: `✔︎ Success`

Create a promise that reports progress

Essential utilities for TypeScript projects

Convert object keys to camel case

Only pass through changed files

Linter for Awesome lists

Measure the difference between two strings using the Levenshtein distance algorithm

Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`

Use Ky in both Node.js and browsers

Create clickable links in the terminal

Tiny hashing module that uses the native crypto API in Node.js and the browser

Find a file or directory by walking up parent directories

Delay a promise a specified amount of time

Strip comments from JSON. Lets you use comments in your JSON files!

Unicode symbols with fallbacks for older terminals

Simple event emitter

Escape RegExp special characters

Escape RegExp special characters

Simple auto-reloading for Electron apps during development

Get the dimensions of an image

Download multiple files at once in the browser

Generate a cryptographically strong random string

Tiny process execution for humans — a better child_process

Global identifiers from different JavaScript environments

Stylish reporter for JSHint

Escape a string for use in HTML or the inverse

Pretty formatter for ESLint

ANSI escape codes for manipulating the terminal

Get the visual width of a string - the number of columns required to display it

Convert a string to a valid safe filename

WebP imagemin plugin

Throttle promise-returning & async functions

Strip ANSI escape codes from a string

Get Pokémon names

Access the system clipboard (copy/paste)

Static file serving for Electron apps

Make a directory and its parents if needed - Think `mkdir -p`

Automatically bind methods to their class instance

Catch unhandled errors and promise rejections in your Electron app

ANSI escape codes for styling strings in the terminal

Promisify an event by waiting for it to be emitted

Get a random temporary file or directory path

Memoize promise-returning & async functions

Open stuff like URLs, files, executables. Cross-platform.

Tiny queue data structure

Get paths for storing things like data, config, cache, etc

Copy files

ASCII cows 🐮

Detect the image type of an ArrayBuffer/Uint8Array

Pretty logger for Electron apps

Extracting archives made easy

Generate a Code of Conduct for your project - Provided by Contributor Covenant

Check if servers are reachable

Shared TypeScript config for my projects

Simple micro templating

Get all URLs in a string

Parse JSON with more helpful errors

Detect whether a terminal supports color

Copy files

Get a stream as a string, Buffer, ArrayBuffer or array

Regular expression for matching URLs

Get your internal IP address

Get stdin as a string or Uint8Array

Clean up error stack traces

Run promise-returning & async functions concurrently with optional limited concurrency

Convert Windows backslash paths to slash paths

Delete files and directories - Cross-platform

Fast CSV parser

Make an asynchronous function synchronous

Display images in terminals using the iTerm inline image protocol

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

Run some code when the process exits

Timeout a promise after a specified amount of time

Terminal string styling done right

Fix the $PATH on macOS and Linux when run from a GUI app

Tiny terminal spinner

Render/precompile Lodash/Underscore templates

ESLint shareable config for XO

Get running processes

Import a module while bypassing the cache

Create a lazy promise that defers execution until it's awaited or when `.then()`, `.catch()`, or `.finally()` is called

Make unhandled promise rejections fail loudly instead of the default silent fail

Display images in the terminal

Get popular cat names

Parse yes/no like values

Useful utilities for working with Uint8Array (and Buffer)

ZIP compress files

Get callsites from the V8 stack trace API

Read the closest package.json file

Turn a HTML string into DOM elements, cross-platform

FNV-1a non-cryptographic hash function

Make a synchronous function asynchronous by running it in a worker

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

Generate a URL for opening a new GitHub issue with prefilled title, body, and other fields

Create an error from multiple errors

Read and parse a JSON file

Import a module lazily

Get metadata of a package from the npm registry

Filter out system junk files like .DS_Store and Thumbs.db

Convert a camelized string into a lowercased one with a custom separator: unicornRainbow → unicorn_rainbow

Cycle through the items of an array

ESLint rules for AVA

Debounce promise-returning & async functions

Check if the process is running inside a Docker container

Get the system locale

Elegant spinner for interactive CLI apps

Control the macOS `Do Not Disturb` feature

Observe changes to the DOM using an async iterable — A nicer API for MutationObserver

A cacheable dns.lookup(…) that respects TTL

Stringify and write JSON to a file atomically

Debug Vinyl file streams to see what files are run through your Gulp pipeline

Make a regular expression time out if it takes too long to execute

Map object keys and values into a new object

Convert a string/promise/array/iterable/asynciterable/buffer/typedarray/arraybuffer/object into a stream

Open files in your editor at a specific line and column

CSS for TodoMVC apps

Tell Yeoman what to say

Move a file, directory, or symlink - Even works across devices

Run Electron without all the junk terminal output

Regular expression for matching ANSI escape codes

Detect the indentation of code

Validate files with ESLint

Check if the process is running inside Windows Subsystem for Linux (Bash on Windows)

Check if JPEG images are progressive

Regular expression for matching IP addresses (IPv4 & IPv6)

Get the gzipped size of a file or stdin

List of standard HTML tags

Link component for Ink