Require Node.js 12.20 and move to ESM

.github/workflows/main.yml

@@ -11,7 +11,6 @@ jobs:
       matrix:
         node-version:
           - 16
-          - 14
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2

index.d.ts

@@ -1,79 +1,81 @@
-import * as stream from 'stream';
-
-declare const isStream: {
-	/**
-	@returns Whether `stream` is a [`Stream`](https://nodejs.org/api/stream.html#stream_stream).
-
-	@example
-	```
-	import * as fs from 'fs';
-	import isStream = require('is-stream');
-
-	isStream(fs.createReadStream('unicorn.png'));
-	//=> true
-
-	isStream({});
-	//=> false
-	```
-	*/
-	(stream: unknown): stream is stream.Stream;
-
-	/**
-	@returns Whether `stream` is a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable).
-
-	@example
-	```
-	import * as fs from 'fs';
-	import isStream = require('is-stream');
-
-	isStream.writable(fs.createWriteStrem('unicorn.txt'));
-	//=> true
-	```
-	*/
-	writable(stream: unknown): stream is stream.Writable;
-
-	/**
-	@returns Whether `stream` is a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
-
-	@example
-	```
-	import * as fs from 'fs';
-	import isStream = require('is-stream');
-
-	isStream.readable(fs.createReadStream('unicorn.png'));
-	//=> true
-	```
-	*/
-	readable(stream: unknown): stream is stream.Readable;
-
-	/**
-	@returns Whether `stream` is a [`stream.Duplex`](https://nodejs.org/api/stream.html#stream_class_stream_duplex).
-
-	@example
-	```
-	import {Duplex} from 'stream';
-	import isStream = require('is-stream');
-
-	isStream.duplex(new Duplex());
-	//=> true
-	```
-	*/
-	duplex(stream: unknown): stream is stream.Duplex;
-
-	/**
-	@returns Whether `stream` is a [`stream.Transform`](https://nodejs.org/api/stream.html#stream_class_stream_transform).
-
-	@example
-	```
-	import * as fs from 'fs';
-	import Stringify = require('streaming-json-stringify');
-	import isStream = require('is-stream');
-
-	isStream.transform(Stringify());
-	//=> true
-	```
-	*/
-	transform(input: unknown): input is stream.Transform;
-};
-
-export = isStream;
+import {
+	Stream,
+	Writable as WritableStream,
+	Readable as ReadableStream,
+	Duplex as DuplexStream,
+	Transform as TransformStream,
+} from 'node:stream';
+
+/**
+@returns Whether `stream` is a [`Stream`](https://nodejs.org/api/stream.html#stream_stream).
+
+@example
+```
+import fs from 'node:fs';
+import {isStream} from 'is-stream';
+
+isStream(fs.createReadStream('unicorn.png'));
+//=> true
+
+isStream({});
+//=> false
+```
+*/
+export function isStream(stream: unknown): stream is Stream;
+
+/**
+@returns Whether `stream` is a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable).
+
+@example
+```
+import fs from 'node:fs';
+import {isWritableStream} from 'is-stream';
+
+isWritableStream(fs.createWriteStrem('unicorn.txt'));
+//=> true
+```
+*/
+export function isWritableStream(stream: unknown): stream is WritableStream;
+
+/**
+@returns Whether `stream` is a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+
+@example
+```
+import fs from 'node:fs';
+import {isReadableStream} from 'is-stream';
+
+isReadableStream(fs.createReadStream('unicorn.png'));
+//=> true
+```
+*/
+export function isReadableStream(stream: unknown): stream is ReadableStream;
+
+/**
+@returns Whether `stream` is a [`stream.Duplex`](https://nodejs.org/api/stream.html#stream_class_stream_duplex).
+
+@example
+```
+import {Duplex as DuplexStream} from 'node:stream';
+import {isDuplexStream} from 'is-stream';
+
+isDuplexStream(new DuplexStream());
+//=> true
+```
+*/
+export function isDuplexStream(stream: unknown): stream is DuplexStream;
+
+/**
+@returns Whether `stream` is a [`stream.Transform`](https://nodejs.org/api/stream.html#stream_class_stream_transform).
+
+@example
+```
+import fs from 'node:fs';
+import StringifyStream from 'streaming-json-stringify';
+import {isTransformStream} from 'is-stream';
+
+isTransformStream(StringifyStream());
+//=> true
+```
+*/
+export function isTransformStream(stream: unknown): stream is TransformStream;

index.js

@@ -1,28 +1,29 @@
-'use strict';
+export function isStream(stream) {
+	return stream !== null
+		&& typeof stream === 'object'
+		&& typeof stream.pipe === 'function';
+}
 
-const isStream = stream =>
-	stream !== null &&
-	typeof stream === 'object' &&
-	typeof stream.pipe === 'function';
+export function isWritableStream(stream) {
+	return isStream(stream)
+		&& stream.writable !== false
+		&& typeof stream._write === 'function'
+		&& typeof stream._writableState === 'object';
+}
 
-isStream.writable = stream =>
-	isStream(stream) &&
-	stream.writable !== false &&
-	typeof stream._write === 'function' &&
-	typeof stream._writableState === 'object';
+export function isReadableStream(stream) {
+	return isStream(stream)
+		&& stream.readable !== false
+		&& typeof stream._read === 'function'
+		&& typeof stream._readableState === 'object';
+}
 
-isStream.readable = stream =>
-	isStream(stream) &&
-	stream.readable !== false &&
-	typeof stream._read === 'function' &&
-	typeof stream._readableState === 'object';
+export function isDuplexStream(stream) {
+	return isWritableStream(stream)
+		&& isReadableStream(stream);
+}
 
-isStream.duplex = stream =>
-	isStream.writable(stream) &&
-	isStream.readable(stream);
-
-isStream.transform = stream =>
-	isStream.duplex(stream) &&
-	typeof stream._transform === 'function';
-
-module.exports = isStream;
+export function isTransformStream(stream) {
+	return isDuplexStream(stream)
+		&& typeof stream._transform === 'function';
+}

index.test-d.ts

@@ -1,25 +1,37 @@
-import {expectType} from 'tsd';
-import * as stream from 'stream';
-import isStream = require('.');
+import {
+	Stream,
+	Writable as WritableStream,
+	Readable as ReadableStream,
+	Duplex as DuplexStream,
+	Transform as TransformStream,
+} from 'node:stream';
+import {expectAssignable} from 'tsd';
+import {
+	isStream,
+	isWritableStream,
+	isReadableStream,
+	isDuplexStream,
+	isTransformStream,
+} from './index.js';
 
 const foo = '';
 
 if (isStream(foo)) {
-	expectType<stream.Stream>(foo);
+	expectAssignable<Stream>(foo);
 }
 
-if (isStream.writable(foo)) {
-	expectType<stream.Writable>(foo);
+if (isWritableStream(foo)) {
+	expectAssignable<WritableStream>(foo);
 }
 
-if (isStream.readable(foo)) {
-	expectType<stream.Readable>(foo);
+if (isReadableStream(foo)) {
+	expectAssignable<ReadableStream>(foo);
 }
 
-if (isStream.duplex(foo)) {
-	expectType<stream.Duplex>(new stream.Duplex());
+if (isDuplexStream(foo)) {
+	expectAssignable<DuplexStream>(new DuplexStream());
 }
 
-if (isStream.transform(foo)) {
-	expectType<stream.Transform>(foo);
+if (isTransformStream(foo)) {
+	expectAssignable<TransformStream>(foo);
 }

package.json

@@ -10,8 +10,10 @@
 		"email": "sindresorhus@gmail.com",
 		"url": "https://sindresorhus.com"
 	},
+	"type": "module",
+	"exports": "./index.js",
 	"engines": {
-		"node": ">=8"
+		"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
@@ -33,10 +35,10 @@
 		"is"
 	],
 	"devDependencies": {
-		"@types/node": "^11.13.6",
-		"ava": "^1.4.1",
-		"tempy": "^0.3.0",
-		"tsd": "^0.7.2",
-		"xo": "^0.24.0"
+		"@types/node": "^16.4.13",
+		"ava": "^3.15.0",
+		"tempy": "^1.0.1",
+		"tsd": "^0.17.0",
+		"xo": "^0.44.0"
 	}
 }

readme.md

@@ -11,8 +11,8 @@ $ npm install is-stream
 ## Usage
 
 ```js
-const fs = require('fs');
-const isStream = require('is-stream');
+import fs from 'node:fs';
+import {isStream} from 'is-stream';
 
 isStream(fs.createReadStream('unicorn.png'));
 //=> true
@@ -27,19 +27,19 @@ isStream({});
 
 Returns a `boolean` for whether it's a [`Stream`](https://nodejs.org/api/stream.html#stream_stream).
 
-#### isStream.writable(stream)
+#### isWritableStream(stream)
 
 Returns a `boolean` for whether it's a [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable).
 
-#### isStream.readable(stream)
+#### isReadableStream(stream)
 
 Returns a `boolean` for whether it's a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable).
 
-#### isStream.duplex(stream)
+#### isDuplexStream(stream)
 
 Returns a `boolean` for whether it's a [`stream.Duplex`](https://nodejs.org/api/stream.html#stream_class_stream_duplex).
 
-#### isStream.transform(stream)
+#### isTransformStream(stream)
 
 Returns a `boolean` for whether it's a [`stream.Transform`](https://nodejs.org/api/stream.html#stream_class_stream_transform).