diff --git a/.github/funding.yml b/.github/funding.yml
index b7f380a..3826c63 100644
--- a/.github/funding.yml
+++ b/.github/funding.yml
@@ -1,2 +1,2 @@
-github: [sindresorhus,Qix-]
+github: [sindresorhus, Qix-]
 tidelift: npm/ansi-styles
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index c1870cf..d36e1a8 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -12,10 +12,9 @@ jobs:
         node-version:
           - 14
           - 12
-          - 10
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
diff --git a/index.d.ts b/index.d.ts
index e0170aa..c31f21b 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -1,167 +1,165 @@
-declare namespace ansiStyles {
-	interface CSPair {
-		/**
-		The ANSI terminal control sequence for starting this style.
-		*/
-		readonly open: string;
-
-		/**
-		The ANSI terminal control sequence for ending this style.
-		*/
-		readonly close: string;
-	}
-
-	interface ColorBase {
-		/**
-		The ANSI terminal control sequence for ending this color.
-		*/
-		readonly close: string;
-
-		ansi256(code: number): string;
-
-		ansi16m(red: number, green: number, blue: number): string;
-	}
-
-	interface Modifier {
-		/**
-		Resets the current color chain.
-		*/
-		readonly reset: CSPair;
-
-		/**
-		Make text bold.
-		*/
-		readonly bold: CSPair;
-
-		/**
-		Emitting only a small amount of light.
-		*/
-		readonly dim: CSPair;
-
-		/**
-		Make text italic. (Not widely supported)
-		*/
-		readonly italic: CSPair;
-
-		/**
-		Make text underline. (Not widely supported)
-		*/
-		readonly underline: CSPair;
-
-		/**
-		Make text overline.
-
-		Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
-		*/
-		readonly overline: CSPair;
-
-		/**
-		Inverse background and foreground colors.
-		*/
-		readonly inverse: CSPair;
-
-		/**
-		Prints the text, but makes it invisible.
-		*/
-		readonly hidden: CSPair;
-
-		/**
-		Puts a horizontal line through the center of the text. (Not widely supported)
-		*/
-		readonly strikethrough: CSPair;
-	}
-
-	interface ForegroundColor {
-		readonly black: CSPair;
-		readonly red: CSPair;
-		readonly green: CSPair;
-		readonly yellow: CSPair;
-		readonly blue: CSPair;
-		readonly cyan: CSPair;
-		readonly magenta: CSPair;
-		readonly white: CSPair;
-
-		/**
-		Alias for `blackBright`.
-		*/
-		readonly gray: CSPair;
-
-		/**
-		Alias for `blackBright`.
-		*/
-		readonly grey: CSPair;
-
-		readonly blackBright: CSPair;
-		readonly redBright: CSPair;
-		readonly greenBright: CSPair;
-		readonly yellowBright: CSPair;
-		readonly blueBright: CSPair;
-		readonly cyanBright: CSPair;
-		readonly magentaBright: CSPair;
-		readonly whiteBright: CSPair;
-	}
-
-	interface BackgroundColor {
-		readonly bgBlack: CSPair;
-		readonly bgRed: CSPair;
-		readonly bgGreen: CSPair;
-		readonly bgYellow: CSPair;
-		readonly bgBlue: CSPair;
-		readonly bgCyan: CSPair;
-		readonly bgMagenta: CSPair;
-		readonly bgWhite: CSPair;
-
-		/**
-		Alias for `bgBlackBright`.
-		*/
-		readonly bgGray: CSPair;
-
-		/**
-		Alias for `bgBlackBright`.
-		*/
-		readonly bgGrey: CSPair;
-
-		readonly bgBlackBright: CSPair;
-		readonly bgRedBright: CSPair;
-		readonly bgGreenBright: CSPair;
-		readonly bgYellowBright: CSPair;
-		readonly bgBlueBright: CSPair;
-		readonly bgCyanBright: CSPair;
-		readonly bgMagentaBright: CSPair;
-		readonly bgWhiteBright: CSPair;
-	}
-
-	interface ConvertColor {
-		/**
-		Convert from the RGB color space to the ANSI 256 color space.
-
-		@param red - (`0...255`)
-		@param green - (`0...255`)
-		@param blue - (`0...255`)
-		*/
-		rgbToAnsi256(red: number, green: number, blue: number): number;
-
-		/**
-		Convert from the RGB HEX color space to the RGB color space.
-
-		@param hex - A hexadecimal string containing RGB data.
-		*/
-		hexToRgb(hex: string): [red: number, green: number, blue: number];
-
-		/**
-		Convert from the RGB HEX color space to the ANSI 256 color space.
-
-		@param hex - A hexadecimal string containing RGB data.
-		*/
-		hexToAnsi256(hex: string): number;
-	}
+export interface CSPair {
+	/**
+	The ANSI terminal control sequence for starting this style.
+	*/
+	readonly open: string;
+
+	/**
+	The ANSI terminal control sequence for ending this style.
+	*/
+	readonly close: string;
+}
+
+export interface ColorBase {
+	/**
+	The ANSI terminal control sequence for ending this color.
+	*/
+	readonly close: string;
+
+	ansi256(code: number): string;
+
+	ansi16m(red: number, green: number, blue: number): string;
+}
+
+export interface Modifier {
+	/**
+	Resets the current color chain.
+	*/
+	readonly reset: CSPair;
+
+	/**
+	Make text bold.
+	*/
+	readonly bold: CSPair;
+
+	/**
+	Emitting only a small amount of light.
+	*/
+	readonly dim: CSPair;
+
+	/**
+	Make text italic. (Not widely supported)
+	*/
+	readonly italic: CSPair;
+
+	/**
+	Make text underline. (Not widely supported)
+	*/
+	readonly underline: CSPair;
+
+	/**
+	Make text overline.
+
+	Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
+	*/
+	readonly overline: CSPair;
+
+	/**
+	Inverse background and foreground colors.
+	*/
+	readonly inverse: CSPair;
+
+	/**
+	Prints the text, but makes it invisible.
+	*/
+	readonly hidden: CSPair;
+
+	/**
+	Puts a horizontal line through the center of the text. (Not widely supported)
+	*/
+	readonly strikethrough: CSPair;
+}
+
+export interface ForegroundColor {
+	readonly black: CSPair;
+	readonly red: CSPair;
+	readonly green: CSPair;
+	readonly yellow: CSPair;
+	readonly blue: CSPair;
+	readonly cyan: CSPair;
+	readonly magenta: CSPair;
+	readonly white: CSPair;
+
+	/**
+	Alias for `blackBright`.
+	*/
+	readonly gray: CSPair;
+
+	/**
+	Alias for `blackBright`.
+	*/
+	readonly grey: CSPair;
+
+	readonly blackBright: CSPair;
+	readonly redBright: CSPair;
+	readonly greenBright: CSPair;
+	readonly yellowBright: CSPair;
+	readonly blueBright: CSPair;
+	readonly cyanBright: CSPair;
+	readonly magentaBright: CSPair;
+	readonly whiteBright: CSPair;
+}
+
+export interface BackgroundColor {
+	readonly bgBlack: CSPair;
+	readonly bgRed: CSPair;
+	readonly bgGreen: CSPair;
+	readonly bgYellow: CSPair;
+	readonly bgBlue: CSPair;
+	readonly bgCyan: CSPair;
+	readonly bgMagenta: CSPair;
+	readonly bgWhite: CSPair;
+
+	/**
+	Alias for `bgBlackBright`.
+	*/
+	readonly bgGray: CSPair;
+
+	/**
+	Alias for `bgBlackBright`.
+	*/
+	readonly bgGrey: CSPair;
+
+	readonly bgBlackBright: CSPair;
+	readonly bgRedBright: CSPair;
+	readonly bgGreenBright: CSPair;
+	readonly bgYellowBright: CSPair;
+	readonly bgBlueBright: CSPair;
+	readonly bgCyanBright: CSPair;
+	readonly bgMagentaBright: CSPair;
+	readonly bgWhiteBright: CSPair;
+}
+
+export interface ConvertColor {
+	/**
+	Convert from the RGB color space to the ANSI 256 color space.
+
+	@param red - (`0...255`)
+	@param green - (`0...255`)
+	@param blue - (`0...255`)
+	*/
+	rgbToAnsi256(red: number, green: number, blue: number): number;
+
+	/**
+	Convert from the RGB HEX color space to the RGB color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+	hexToRgb(hex: string): [red: number, green: number, blue: number];
+
+	/**
+	Convert from the RGB HEX color space to the ANSI 256 color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+	hexToAnsi256(hex: string): number;
 }
 
 declare const ansiStyles: {
-	readonly modifier: ansiStyles.Modifier;
-	readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
-	readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+	readonly modifier: Modifier;
+	readonly color: ColorBase & ForegroundColor;
+	readonly bgColor: ColorBase & BackgroundColor;
 	readonly codes: ReadonlyMap<number, number>;
-} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier & ansiStyles.ConvertColor;
+} & ForegroundColor & BackgroundColor & Modifier & ConvertColor;
 
-export = ansiStyles;
+export default ansiStyles;
diff --git a/index.js b/index.js
index a9eac58..5e16f63 100644
--- a/index.js
+++ b/index.js
@@ -1,5 +1,3 @@
-'use strict';
-
 const ANSI_BACKGROUND_OFFSET = 10;
 
 const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
@@ -157,8 +155,6 @@ function assembleStyles() {
 	return styles;
 }
 
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
-	enumerable: true,
-	get: assembleStyles
-});
+const ansiStyles = assembleStyles();
+
+export default ansiStyles;
diff --git a/index.test-d.ts b/index.test-d.ts
index 9979cb8..5b87ff4 100644
--- a/index.test-d.ts
+++ b/index.test-d.ts
@@ -1,120 +1,120 @@
 import {expectType} from 'tsd';
-import ansiStyles = require('.');
+import ansiStyles, {CSPair} from './index.js';
 
 expectType<ReadonlyMap<number, number>>(ansiStyles.codes);
 
 // - Static colors -
 // -- Namespaced --
 // --- Foreground color ---
-expectType<ansiStyles.CSPair>(ansiStyles.color.black);
-expectType<ansiStyles.CSPair>(ansiStyles.color.red);
-expectType<ansiStyles.CSPair>(ansiStyles.color.green);
-expectType<ansiStyles.CSPair>(ansiStyles.color.yellow);
-expectType<ansiStyles.CSPair>(ansiStyles.color.blue);
-expectType<ansiStyles.CSPair>(ansiStyles.color.cyan);
-expectType<ansiStyles.CSPair>(ansiStyles.color.magenta);
-expectType<ansiStyles.CSPair>(ansiStyles.color.white);
-
-expectType<ansiStyles.CSPair>(ansiStyles.color.gray);
-expectType<ansiStyles.CSPair>(ansiStyles.color.grey);
-
-expectType<ansiStyles.CSPair>(ansiStyles.color.blackBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.redBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.greenBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.yellowBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.blueBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.cyanBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.magentaBright);
-expectType<ansiStyles.CSPair>(ansiStyles.color.whiteBright);
+expectType<CSPair>(ansiStyles.color.black);
+expectType<CSPair>(ansiStyles.color.red);
+expectType<CSPair>(ansiStyles.color.green);
+expectType<CSPair>(ansiStyles.color.yellow);
+expectType<CSPair>(ansiStyles.color.blue);
+expectType<CSPair>(ansiStyles.color.cyan);
+expectType<CSPair>(ansiStyles.color.magenta);
+expectType<CSPair>(ansiStyles.color.white);
+
+expectType<CSPair>(ansiStyles.color.gray);
+expectType<CSPair>(ansiStyles.color.grey);
+
+expectType<CSPair>(ansiStyles.color.blackBright);
+expectType<CSPair>(ansiStyles.color.redBright);
+expectType<CSPair>(ansiStyles.color.greenBright);
+expectType<CSPair>(ansiStyles.color.yellowBright);
+expectType<CSPair>(ansiStyles.color.blueBright);
+expectType<CSPair>(ansiStyles.color.cyanBright);
+expectType<CSPair>(ansiStyles.color.magentaBright);
+expectType<CSPair>(ansiStyles.color.whiteBright);
 
 expectType<string>(ansiStyles.color.close);
 
 // --- Background color ---
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgBlack);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgRed);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgGreen);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgYellow);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgBlue);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgCyan);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgMagenta);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgWhite);
-
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgGray);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgGrey);
-
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgBlackBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgRedBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgGreenBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgYellowBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgBlueBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgCyanBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgMagentaBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgColor.bgWhiteBright);
+expectType<CSPair>(ansiStyles.bgColor.bgBlack);
+expectType<CSPair>(ansiStyles.bgColor.bgRed);
+expectType<CSPair>(ansiStyles.bgColor.bgGreen);
+expectType<CSPair>(ansiStyles.bgColor.bgYellow);
+expectType<CSPair>(ansiStyles.bgColor.bgBlue);
+expectType<CSPair>(ansiStyles.bgColor.bgCyan);
+expectType<CSPair>(ansiStyles.bgColor.bgMagenta);
+expectType<CSPair>(ansiStyles.bgColor.bgWhite);
+
+expectType<CSPair>(ansiStyles.bgColor.bgGray);
+expectType<CSPair>(ansiStyles.bgColor.bgGrey);
+
+expectType<CSPair>(ansiStyles.bgColor.bgBlackBright);
+expectType<CSPair>(ansiStyles.bgColor.bgRedBright);
+expectType<CSPair>(ansiStyles.bgColor.bgGreenBright);
+expectType<CSPair>(ansiStyles.bgColor.bgYellowBright);
+expectType<CSPair>(ansiStyles.bgColor.bgBlueBright);
+expectType<CSPair>(ansiStyles.bgColor.bgCyanBright);
+expectType<CSPair>(ansiStyles.bgColor.bgMagentaBright);
+expectType<CSPair>(ansiStyles.bgColor.bgWhiteBright);
 
 expectType<string>(ansiStyles.bgColor.close);
 
 // --- Modifiers ---
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.bold);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.dim);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.hidden);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.inverse);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.italic);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.reset);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.strikethrough);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.underline);
-expectType<ansiStyles.CSPair>(ansiStyles.modifier.overline);
+expectType<CSPair>(ansiStyles.modifier.bold);
+expectType<CSPair>(ansiStyles.modifier.dim);
+expectType<CSPair>(ansiStyles.modifier.hidden);
+expectType<CSPair>(ansiStyles.modifier.inverse);
+expectType<CSPair>(ansiStyles.modifier.italic);
+expectType<CSPair>(ansiStyles.modifier.reset);
+expectType<CSPair>(ansiStyles.modifier.strikethrough);
+expectType<CSPair>(ansiStyles.modifier.underline);
+expectType<CSPair>(ansiStyles.modifier.overline);
 
 // -- Top level --
 // --- Foreground color ---
-expectType<ansiStyles.CSPair>(ansiStyles.black);
-expectType<ansiStyles.CSPair>(ansiStyles.red);
-expectType<ansiStyles.CSPair>(ansiStyles.green);
-expectType<ansiStyles.CSPair>(ansiStyles.yellow);
-expectType<ansiStyles.CSPair>(ansiStyles.blue);
-expectType<ansiStyles.CSPair>(ansiStyles.cyan);
-expectType<ansiStyles.CSPair>(ansiStyles.magenta);
-expectType<ansiStyles.CSPair>(ansiStyles.white);
-
-expectType<ansiStyles.CSPair>(ansiStyles.gray);
-expectType<ansiStyles.CSPair>(ansiStyles.grey);
-
-expectType<ansiStyles.CSPair>(ansiStyles.blackBright);
-expectType<ansiStyles.CSPair>(ansiStyles.redBright);
-expectType<ansiStyles.CSPair>(ansiStyles.greenBright);
-expectType<ansiStyles.CSPair>(ansiStyles.yellowBright);
-expectType<ansiStyles.CSPair>(ansiStyles.blueBright);
-expectType<ansiStyles.CSPair>(ansiStyles.cyanBright);
-expectType<ansiStyles.CSPair>(ansiStyles.magentaBright);
-expectType<ansiStyles.CSPair>(ansiStyles.whiteBright);
+expectType<CSPair>(ansiStyles.black);
+expectType<CSPair>(ansiStyles.red);
+expectType<CSPair>(ansiStyles.green);
+expectType<CSPair>(ansiStyles.yellow);
+expectType<CSPair>(ansiStyles.blue);
+expectType<CSPair>(ansiStyles.cyan);
+expectType<CSPair>(ansiStyles.magenta);
+expectType<CSPair>(ansiStyles.white);
+
+expectType<CSPair>(ansiStyles.gray);
+expectType<CSPair>(ansiStyles.grey);
+
+expectType<CSPair>(ansiStyles.blackBright);
+expectType<CSPair>(ansiStyles.redBright);
+expectType<CSPair>(ansiStyles.greenBright);
+expectType<CSPair>(ansiStyles.yellowBright);
+expectType<CSPair>(ansiStyles.blueBright);
+expectType<CSPair>(ansiStyles.cyanBright);
+expectType<CSPair>(ansiStyles.magentaBright);
+expectType<CSPair>(ansiStyles.whiteBright);
 
 // --- Background color ---
-expectType<ansiStyles.CSPair>(ansiStyles.bgBlack);
-expectType<ansiStyles.CSPair>(ansiStyles.bgRed);
-expectType<ansiStyles.CSPair>(ansiStyles.bgGreen);
-expectType<ansiStyles.CSPair>(ansiStyles.bgYellow);
-expectType<ansiStyles.CSPair>(ansiStyles.bgBlue);
-expectType<ansiStyles.CSPair>(ansiStyles.bgCyan);
-expectType<ansiStyles.CSPair>(ansiStyles.bgMagenta);
-expectType<ansiStyles.CSPair>(ansiStyles.bgWhite);
-
-expectType<ansiStyles.CSPair>(ansiStyles.bgGray);
-expectType<ansiStyles.CSPair>(ansiStyles.bgGrey);
-
-expectType<ansiStyles.CSPair>(ansiStyles.bgBlackBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgRedBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgGreenBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgYellowBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgBlueBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgCyanBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgMagentaBright);
-expectType<ansiStyles.CSPair>(ansiStyles.bgWhiteBright);
+expectType<CSPair>(ansiStyles.bgBlack);
+expectType<CSPair>(ansiStyles.bgRed);
+expectType<CSPair>(ansiStyles.bgGreen);
+expectType<CSPair>(ansiStyles.bgYellow);
+expectType<CSPair>(ansiStyles.bgBlue);
+expectType<CSPair>(ansiStyles.bgCyan);
+expectType<CSPair>(ansiStyles.bgMagenta);
+expectType<CSPair>(ansiStyles.bgWhite);
+
+expectType<CSPair>(ansiStyles.bgGray);
+expectType<CSPair>(ansiStyles.bgGrey);
+
+expectType<CSPair>(ansiStyles.bgBlackBright);
+expectType<CSPair>(ansiStyles.bgRedBright);
+expectType<CSPair>(ansiStyles.bgGreenBright);
+expectType<CSPair>(ansiStyles.bgYellowBright);
+expectType<CSPair>(ansiStyles.bgBlueBright);
+expectType<CSPair>(ansiStyles.bgCyanBright);
+expectType<CSPair>(ansiStyles.bgMagentaBright);
+expectType<CSPair>(ansiStyles.bgWhiteBright);
 
 // --- Modifiers ---
-expectType<ansiStyles.CSPair>(ansiStyles.bold);
-expectType<ansiStyles.CSPair>(ansiStyles.dim);
-expectType<ansiStyles.CSPair>(ansiStyles.hidden);
-expectType<ansiStyles.CSPair>(ansiStyles.inverse);
-expectType<ansiStyles.CSPair>(ansiStyles.italic);
-expectType<ansiStyles.CSPair>(ansiStyles.reset);
-expectType<ansiStyles.CSPair>(ansiStyles.strikethrough);
-expectType<ansiStyles.CSPair>(ansiStyles.underline);
+expectType<CSPair>(ansiStyles.bold);
+expectType<CSPair>(ansiStyles.dim);
+expectType<CSPair>(ansiStyles.hidden);
+expectType<CSPair>(ansiStyles.inverse);
+expectType<CSPair>(ansiStyles.italic);
+expectType<CSPair>(ansiStyles.reset);
+expectType<CSPair>(ansiStyles.strikethrough);
+expectType<CSPair>(ansiStyles.underline);
diff --git a/license b/license
index e7af2f7..fa7ceba 100644
--- a/license
+++ b/license
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
diff --git a/package.json b/package.json
index b3c89c9..837553c 100644
--- a/package.json
+++ b/package.json
@@ -10,8 +10,10 @@
 		"email": "sindresorhus@gmail.com",
 		"url": "https://sindresorhus.com"
 	},
+	"type": "module",
+	"exports": "./index.js",
 	"engines": {
-		"node": ">=10"
+		"node": ">=12"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd",
@@ -44,9 +46,9 @@
 		"text"
 	],
 	"devDependencies": {
-		"ava": "^2.4.0",
+		"ava": "^3.15.0",
 		"svg-term-cli": "^2.1.1",
 		"tsd": "^0.14.0",
-		"xo": "^0.37.1"
+		"xo": "^0.38.2"
 	}
 }
diff --git a/readme.md b/readme.md
index 7d12466..401f49d 100644
--- a/readme.md
+++ b/readme.md
@@ -15,9 +15,9 @@ $ npm install ansi-styles
 ## Usage
 
 ```js
-const style = require('ansi-styles');
+import styles from 'ansi-styles';
 
-console.log(`${style.green.open}Hello world!${style.green.close}`);
+console.log(`${styles.green.open}Hello world!${styles.green.close}`);
 
 
 // Color conversion between 256/truecolor
@@ -25,8 +25,8 @@ console.log(`${style.green.open}Hello world!${style.green.close}`);
 //       may be degraded to fit the new color palette. This means terminals
 //       that do not support 16 million colors will best-match the
 //       original color.
-console.log(`${style.color.ansi256(style.rgbToAnsi256(199, 20, 250))}Hello World${style.color.close}`)
-console.log(`${style.color.ansi16m(...style.hexToRgb('#abcdef'))}Hello World${style.color.close}`)
+console.log(`${styles.color.ansi256(styles.rgbToAnsi256(199, 20, 250))}Hello World${styles.color.close}`)
+console.log(`${styles.color.ansi16m(...styles.hexToRgb('#abcdef'))}Hello World${styles.color.close}`)
 ```
 
 ## API
@@ -89,22 +89,26 @@ Each style has an `open` and `close` property.
 
 By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
 
-- `style.modifier`
-- `style.color`
-- `style.bgColor`
+- `styles.modifier`
+- `styles.color`
+- `styles.bgColor`
 
 ###### Example
 
 ```js
-console.log(style.color.green.open);
+import styles from 'ansi-styles';
+
+console.log(styles.color.green.open);
 ```
 
-Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `styles.codes`, which returns a `Map` with the open codes as keys and close codes as values.
 
 ###### Example
 
 ```js
-console.log(style.codes.get(36));
+import styles from 'ansi-styles';
+
+console.log(styles.codes.get(36));
 //=> 39
 ```
 
@@ -121,11 +125,13 @@ The following color spaces from `color-convert` are supported:
 To use these, call the associated conversion function with the intended output, for example:
 
 ```js
-style.color.ansi256(style.rgbToAnsi256(100, 200, 15)); // RGB to 256 color ansi foreground code
-style.bgColor.ansi256(style.hexToAnsi256('#C0FFEE')); // HEX to 256 color ansi foreground code
+import styles from 'ansi-styles';
+
+styles.color.ansi256(styles.rgbToAnsi256(100, 200, 15)); // RGB to 256 color ansi foreground code
+styles.bgColor.ansi256(styles.hexToAnsi256('#C0FFEE')); // HEX to 256 color ansi foreground code
 
-style.color.ansi16m(100, 200, 15); // RGB to 16 million color foreground code
-style.bgColor.ansi16m(...style.hexToRgb('#C0FFEE')); // Hex (RGB) to 16 million color foreground code
+styles.color.ansi16m(100, 200, 15); // RGB to 16 million color foreground code
+styles.bgColor.ansi16m(...styles.hexToRgb('#C0FFEE')); // Hex (RGB) to 16 million color foreground code
 ```
 
 ## Related
diff --git a/screenshot.js b/screenshot.js
index cc63746..d53a177 100644
--- a/screenshot.js
+++ b/screenshot.js
@@ -1,10 +1,9 @@
-'use strict';
-const style = require('.');
+import ansiStyles from './index.js';
 
 const width = 55;
 let lineLength = 0;
 
-for (const [key, value] of Object.entries(style)) {
+for (const [key, value] of Object.entries(ansiStyles)) {
 	let code = value.open;
 	let projectedLength = lineLength + key.length + 1;
 
@@ -13,7 +12,7 @@ for (const [key, value] of Object.entries(style)) {
 	}
 
 	if (/^bg[^B]/.test(key)) {
-		code = style.black.open + code;
+		code = ansiStyles.black.open + code;
 	}
 
 	if (width < projectedLength) {
@@ -22,6 +21,6 @@ for (const [key, value] of Object.entries(style)) {
 		projectedLength = key.length + 1;
 	}
 
-	process.stdout.write(code + key + style.reset.close + ' ');
+	process.stdout.write(code + key + ansiStyles.reset.close + ' ');
 	lineLength = projectedLength;
 }
diff --git a/test/test.js b/test/test.js
index eca2c41..930da22 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,65 +1,57 @@
 import test from 'ava';
-import style from '../index.js';
+import ansiStyles from '../index.js';
 
 test('return ANSI escape codes', t => {
-	t.is(style.green.open, '\u001B[32m');
-	t.is(style.bgGreen.open, '\u001B[42m');
-	t.is(style.green.close, '\u001B[39m');
-	t.is(style.gray.open, style.grey.open);
+	t.is(ansiStyles.green.open, '\u001B[32m');
+	t.is(ansiStyles.bgGreen.open, '\u001B[42m');
+	t.is(ansiStyles.green.close, '\u001B[39m');
+	t.is(ansiStyles.gray.open, ansiStyles.grey.open);
 });
 
 test('group related codes into categories', t => {
-	t.is(style.color.magenta, style.magenta);
-	t.is(style.bgColor.bgYellow, style.bgYellow);
-	t.is(style.modifier.bold, style.bold);
+	t.is(ansiStyles.color.magenta, ansiStyles.magenta);
+	t.is(ansiStyles.bgColor.bgYellow, ansiStyles.bgYellow);
+	t.is(ansiStyles.modifier.bold, ansiStyles.bold);
 });
 
 test('groups should not be enumerable', t => {
-	t.not(Object.getOwnPropertyDescriptor(style, 'modifier'), undefined);
-	t.false(Object.keys(style).includes('modifier'));
-});
-
-test('don\'t pollute other objects', t => {
-	const object1 = require('..');
-	const object2 = require('..');
-
-	object1.foo = true;
-	t.not(object1.foo, object2.foo);
+	t.not(Object.getOwnPropertyDescriptor(ansiStyles, 'modifier'), undefined);
+	t.false(Object.keys(ansiStyles).includes('modifier'));
 });
 
 test('support conversion to ansi (256 colors)', t => {
-	t.is(style.color.ansi256(style.rgbToAnsi256(255, 255, 255)), '\u001B[38;5;231m');
-	t.is(style.color.ansi256(style.hexToAnsi256('#990099')), '\u001B[38;5;127m');
-	t.is(style.color.ansi256(style.hexToAnsi256('#FF00FF')), '\u001B[38;5;201m');
+	t.is(ansiStyles.color.ansi256(ansiStyles.rgbToAnsi256(255, 255, 255)), '\u001B[38;5;231m');
+	t.is(ansiStyles.color.ansi256(ansiStyles.hexToAnsi256('#990099')), '\u001B[38;5;127m');
+	t.is(ansiStyles.color.ansi256(ansiStyles.hexToAnsi256('#FF00FF')), '\u001B[38;5;201m');
 
-	t.is(style.bgColor.ansi256(style.rgbToAnsi256(255, 255, 255)), '\u001B[48;5;231m');
-	t.is(style.bgColor.ansi256(style.hexToAnsi256('#990099')), '\u001B[48;5;127m');
-	t.is(style.bgColor.ansi256(style.hexToAnsi256('#FF00FF')), '\u001B[48;5;201m');
+	t.is(ansiStyles.bgColor.ansi256(ansiStyles.rgbToAnsi256(255, 255, 255)), '\u001B[48;5;231m');
+	t.is(ansiStyles.bgColor.ansi256(ansiStyles.hexToAnsi256('#990099')), '\u001B[48;5;127m');
+	t.is(ansiStyles.bgColor.ansi256(ansiStyles.hexToAnsi256('#FF00FF')), '\u001B[48;5;201m');
 });
 
 test('support conversion to ansi (16 million colors)', t => {
-	t.is(style.color.ansi16m(255, 255, 255), '\u001B[38;2;255;255;255m');
-	t.is(style.color.ansi16m(...style.hexToRgb('#990099')), '\u001B[38;2;153;0;153m');
-	t.is(style.color.ansi16m(...style.hexToRgb('#FF00FF')), '\u001B[38;2;255;0;255m');
+	t.is(ansiStyles.color.ansi16m(255, 255, 255), '\u001B[38;2;255;255;255m');
+	t.is(ansiStyles.color.ansi16m(...ansiStyles.hexToRgb('#990099')), '\u001B[38;2;153;0;153m');
+	t.is(ansiStyles.color.ansi16m(...ansiStyles.hexToRgb('#FF00FF')), '\u001B[38;2;255;0;255m');
 
-	t.is(style.bgColor.ansi16m(255, 255, 255), '\u001B[48;2;255;255;255m');
-	t.is(style.bgColor.ansi16m(...style.hexToRgb('#990099')), '\u001B[48;2;153;0;153m');
-	t.is(style.bgColor.ansi16m(...style.hexToRgb('#FF00FF')), '\u001B[48;2;255;0;255m');
+	t.is(ansiStyles.bgColor.ansi16m(255, 255, 255), '\u001B[48;2;255;255;255m');
+	t.is(ansiStyles.bgColor.ansi16m(...ansiStyles.hexToRgb('#990099')), '\u001B[48;2;153;0;153m');
+	t.is(ansiStyles.bgColor.ansi16m(...ansiStyles.hexToRgb('#FF00FF')), '\u001B[48;2;255;0;255m');
 });
 
 test('16/256/16m color close escapes', t => {
-	t.is(style.color.close, '\u001B[39m');
-	t.is(style.bgColor.close, '\u001B[49m');
+	t.is(ansiStyles.color.close, '\u001B[39m');
+	t.is(ansiStyles.bgColor.close, '\u001B[49m');
 });
 
 test('export raw ANSI escape codes', t => {
-	t.is(style.codes.get(0), 0);
-	t.is(style.codes.get(1), 22);
-	t.is(style.codes.get(91), 39);
-	t.is(style.codes.get(40), 49);
-	t.is(style.codes.get(100), 49);
+	t.is(ansiStyles.codes.get(0), 0);
+	t.is(ansiStyles.codes.get(1), 22);
+	t.is(ansiStyles.codes.get(91), 39);
+	t.is(ansiStyles.codes.get(40), 49);
+	t.is(ansiStyles.codes.get(100), 49);
 });
 
-test('rgb -> truecolor is stubbed', t => {
-	t.is(style.color.ansi16m(123, 45, 67), '\u001B[38;2;123;45;67m');
+test('rgb → truecolor is stubbed', t => {
+	t.is(ansiStyles.color.ansi16m(123, 45, 67), '\u001B[38;2;123;45;67m');
 });