diff --git a/src/_prepare.js b/src/_prepare.js
index ed19efe9..39ca7a21 100644
--- a/src/_prepare.js
+++ b/src/_prepare.js
@@ -1,6 +1,6 @@
 import parse from './parse';
 
-export default (color, mode) =>
+const prepare = (color, mode) =>
 	color === undefined
 		? undefined
 		: typeof color !== 'object'
@@ -10,3 +10,5 @@ export default (color, mode) =>
 		: mode
 		? { ...color, mode }
 		: undefined;
+
+export default prepare;
diff --git a/src/a98/convertA98ToXyz65.js b/src/a98/convertA98ToXyz65.js
index 35e49da8..d5f39c08 100644
--- a/src/a98/convertA98ToXyz65.js
+++ b/src/a98/convertA98ToXyz65.js
@@ -9,7 +9,7 @@
 
 const linearize = v => Math.pow(Math.abs(v), 563 / 256) * Math.sign(v);
 
-export default a98 => {
+const convertA98ToXyz65 = a98 => {
 	let r = linearize(a98.r);
 	let g = linearize(a98.g);
 	let b = linearize(a98.b);
@@ -33,3 +33,5 @@ export default a98 => {
 	}
 	return res;
 };
+
+export default convertA98ToXyz65;
diff --git a/src/a98/convertXyz65ToA98.js b/src/a98/convertXyz65ToA98.js
index 116d9fc8..411d47e1 100644
--- a/src/a98/convertXyz65ToA98.js
+++ b/src/a98/convertXyz65ToA98.js
@@ -8,7 +8,7 @@
 
 const gamma = v => Math.pow(Math.abs(v), 256 / 563) * Math.sign(v);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToA98 = ({ x, y, z, alpha }) => {
 	let res = {
 		mode: 'a98',
 		r: gamma(
@@ -32,3 +32,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyz65ToA98;
diff --git a/src/a98/definition.js b/src/a98/definition.js
index 656b996d..de7b58aa 100644
--- a/src/a98/definition.js
+++ b/src/a98/definition.js
@@ -5,17 +5,21 @@ import convertXyz65ToA98 from './convertXyz65ToA98';
 import convertRgbToXyz65 from '../xyz65/convertRgbToXyz65';
 import convertXyz65ToRgb from '../xyz65/convertXyz65ToRgb';
 
-export default {
+const definition = {
 	...rgb,
 	mode: 'a98',
 	alias: ['a98-rgb'],
 	parsers: [],
+
 	input: {
 		rgb: color => convertXyz65ToA98(convertRgbToXyz65(color)),
 		xyz65: convertXyz65ToA98
 	},
+
 	output: {
 		rgb: color => convertXyz65ToRgb(convertA98ToXyz65(color)),
 		xyz65: convertA98ToXyz65
 	}
 };
+
+export default definition;
diff --git a/src/blend.js b/src/blend.js
index 4e3ae00f..bdca9d1b 100644
--- a/src/blend.js
+++ b/src/blend.js
@@ -34,7 +34,7 @@ const BLENDS = {
 	exclusion: (b, s) => b + s - 2 * b * s
 };
 
-export default (colors, type = 'normal', mode = 'rgb') => {
+const blend = (colors, type = 'normal', mode = 'rgb') => {
 	let fn = typeof type === 'function' ? type : BLENDS[type];
 
 	let conv = converter(mode);
@@ -77,3 +77,5 @@ export default (colors, type = 'normal', mode = 'rgb') => {
 		);
 	});
 };
+
+export default blend;
diff --git a/src/colors/named.js b/src/colors/named.js
index e47756ff..2e8bb597 100644
--- a/src/colors/named.js
+++ b/src/colors/named.js
@@ -1,4 +1,4 @@
-export default {
+const named = {
 	aliceblue: 0xf0f8ff,
 	antiquewhite: 0xfaebd7,
 	aqua: 0x00ffff,
@@ -118,9 +118,11 @@ export default {
 	plum: 0xdda0dd,
 	powderblue: 0xb0e0e6,
 	purple: 0x800080,
+
 	// Added in CSS Colors Level 4:
 	// https://drafts.csswg.org/css-color/#changes-from-3
 	rebeccapurple: 0x663399,
+
 	red: 0xff0000,
 	rosybrown: 0xbc8f8f,
 	royalblue: 0x4169e1,
@@ -150,3 +152,5 @@ export default {
 	yellow: 0xffff00,
 	yellowgreen: 0x9acd32
 };
+
+export default named;
diff --git a/src/cubehelix/convertCubehelixToRgb.js b/src/cubehelix/convertCubehelixToRgb.js
index 1c9b5757..68876b21 100644
--- a/src/cubehelix/convertCubehelixToRgb.js
+++ b/src/cubehelix/convertCubehelixToRgb.js
@@ -1,6 +1,6 @@
 import { degToRad, M } from './constants';
 
-export default ({ h, s, l, alpha }) => {
+const convertCubehelixToRgb = ({ h, s, l, alpha }) => {
 	let res = { mode: 'rgb' };
 
 	h = (h === undefined ? 0 : h + 120) * degToRad;
@@ -17,3 +17,5 @@ export default ({ h, s, l, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertCubehelixToRgb;
diff --git a/src/cubehelix/convertRgbToCubehelix.js b/src/cubehelix/convertRgbToCubehelix.js
index eb54fd49..3b54564b 100644
--- a/src/cubehelix/convertRgbToCubehelix.js
+++ b/src/cubehelix/convertRgbToCubehelix.js
@@ -17,7 +17,7 @@ let DE = M[3] * M[4];
 let BE = M[1] * M[4];
 let BCAD = M[1] * M[2] - M[0] * M[3];
 
-export default ({ r, g, b, alpha }) => {
+const convertRgbToCubehelix = ({ r, g, b, alpha }) => {
 	let l = (BCAD * b + r * DE - g * BE) / (BCAD + DE - BE);
 	let x = b - l;
 	let y = (M[4] * (g - l) - M[2] * x) / M[3];
@@ -36,3 +36,5 @@ export default ({ r, g, b, alpha }) => {
 
 	return res;
 };
+
+export default convertRgbToCubehelix;
diff --git a/src/cubehelix/definition.js b/src/cubehelix/definition.js
index 12003dd7..bf965fc9 100644
--- a/src/cubehelix/definition.js
+++ b/src/cubehelix/definition.js
@@ -39,19 +39,23 @@ import convertCubehelixToRgb from './convertCubehelixToRgb';
 import { differenceHueSaturation } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'cubehelix',
 	channels: ['h', 's', 'l', 'alpha'],
+
 	ranges: {
 		h: [0, 360],
 		s: [0, 4.6143]
 	},
+
 	input: {
 		rgb: convertRgbToCubehelix
 	},
+
 	output: {
 		rgb: convertCubehelixToRgb
 	},
+
 	interpolate: {
 		h: {
 			use: interpolatorLinear,
@@ -64,10 +68,14 @@ export default {
 			fixup: fixupAlpha
 		}
 	},
+
 	difference: {
 		h: differenceHueSaturation
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/displayable.js b/src/displayable.js
index d61e3928..a393b700 100644
--- a/src/displayable.js
+++ b/src/displayable.js
@@ -2,7 +2,7 @@ import converter from './converter';
 
 let rgb = converter('rgb');
 
-export default color => {
+const displayable = color => {
 	let c = rgb(color);
 	return (
 		c !== undefined &&
@@ -14,3 +14,5 @@ export default color => {
 		c.b <= 1
 	);
 };
+
+export default displayable;
diff --git a/src/dlab/convertDlabToLab65.js b/src/dlab/convertDlabToLab65.js
index e0e832fc..656f7270 100644
--- a/src/dlab/convertDlabToLab65.js
+++ b/src/dlab/convertDlabToLab65.js
@@ -1,4 +1,6 @@
 import convertDlabToDlch from '../dlch/convertDlabToDlch';
 import convertDlchToLab65 from '../dlch/convertDlchToLab65';
 
-export default c => convertDlchToLab65(convertDlabToDlch(c));
+const convertDlabToLab65 = c => convertDlchToLab65(convertDlabToDlch(c));
+
+export default convertDlabToLab65;
diff --git a/src/dlab/convertLab65ToDlab.js b/src/dlab/convertLab65ToDlab.js
index 775849e8..9f58aef5 100644
--- a/src/dlab/convertLab65ToDlab.js
+++ b/src/dlab/convertLab65ToDlab.js
@@ -1,4 +1,6 @@
 import convertLab65ToDlch from '../dlch/convertLab65ToDlch';
 import convertDlchToDlab from '../dlch/convertDlchToDlab';
 
-export default c => convertDlchToDlab(convertLab65ToDlch(c));
+const convertLab65ToDlab = c => convertDlchToDlab(convertLab65ToDlch(c));
+
+export default convertLab65ToDlab;
diff --git a/src/dlab/definition.js b/src/dlab/definition.js
index 70f9fe54..e59b97e8 100644
--- a/src/dlab/definition.js
+++ b/src/dlab/definition.js
@@ -5,22 +5,27 @@ import convertRgbToLab65 from '../lab65/convertRgbToLab65';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'dlab',
+
 	output: {
 		lab65: convertDlabToLab65,
 		rgb: c => convertLab65ToRgb(convertDlabToLab65(c))
 	},
+
 	input: {
 		lab65: convertLab65ToDlab,
 		rgb: c => convertLab65ToDlab(convertRgbToLab65(c))
 	},
+
 	channels: ['l', 'a', 'b', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		a: [-40.09, 45.5],
 		b: [-40.47, 44.344]
 	},
+
 	interpolate: {
 		l: interpolatorLinear,
 		a: interpolatorLinear,
@@ -31,3 +36,5 @@ export default {
 		}
 	}
 };
+
+export default definition;
diff --git a/src/dlch/convertDlabToDlch.js b/src/dlch/convertDlabToDlch.js
index bb3bf9d9..b73db792 100644
--- a/src/dlch/convertDlabToDlch.js
+++ b/src/dlch/convertDlabToDlch.js
@@ -1,6 +1,6 @@
 import normalizeHue from '../util/normalizeHue';
 
-export default ({ l, a, b, alpha }) => {
+const convertDlabToDlch = ({ l, a, b, alpha }) => {
 	let c = Math.sqrt(a * a + b * b);
 	let res = {
 		mode: 'dlch',
@@ -11,3 +11,5 @@ export default ({ l, a, b, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertDlabToDlch;
diff --git a/src/dlch/convertDlchToDlab.js b/src/dlch/convertDlchToDlab.js
index b7b3cfc3..339ac338 100644
--- a/src/dlch/convertDlchToDlab.js
+++ b/src/dlch/convertDlchToDlab.js
@@ -1,4 +1,4 @@
-export default ({ l, c, h, alpha }) => {
+const convertDlchToDlab = ({ l, c, h, alpha }) => {
 	let res = {
 		mode: 'dlab',
 		l: l,
@@ -8,3 +8,5 @@ export default ({ l, c, h, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertDlchToDlab;
diff --git a/src/dlch/convertDlchToLab65.js b/src/dlch/convertDlchToLab65.js
index c11477a8..2d11ff50 100644
--- a/src/dlch/convertDlchToLab65.js
+++ b/src/dlch/convertDlchToLab65.js
@@ -5,7 +5,7 @@ import { kCH, kE, sinθ, cosθ, θ, factor } from './constants';
 	--------------------------------
  */
 
-export default ({ l, c, h, alpha }) => {
+const convertDlchToLab65 = ({ l, c, h, alpha }) => {
 	let res = {
 		mode: 'lab65',
 		l: (Math.exp((l * kE) / factor) - 1) / 0.0039
@@ -24,3 +24,5 @@ export default ({ l, c, h, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertDlchToLab65;
diff --git a/src/dlch/convertLab65ToDlch.js b/src/dlch/convertLab65ToDlch.js
index 2c5bb607..2400df80 100644
--- a/src/dlch/convertLab65ToDlch.js
+++ b/src/dlch/convertLab65ToDlch.js
@@ -6,7 +6,7 @@ import normalizeHue from '../util/normalizeHue';
 	================================
  */
 
-export default ({ l, a, b, alpha }) => {
+const convertLab65ToDlch = ({ l, a, b, alpha }) => {
 	let e = a * cosθ + b * sinθ;
 	let f = 0.83 * (b * cosθ - a * sinθ);
 	let G = Math.sqrt(e * e + f * f);
@@ -23,3 +23,5 @@ export default ({ l, a, b, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertLab65ToDlch;
diff --git a/src/dlch/definition.js b/src/dlch/definition.js
index 25115902..285e508f 100644
--- a/src/dlch/definition.js
+++ b/src/dlch/definition.js
@@ -11,24 +11,29 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueChroma } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'dlch',
+
 	output: {
 		lab65: convertDlchToLab65,
 		dlab: convertDlchToDlab,
 		rgb: c => convertLab65ToRgb(convertDlchToLab65(c))
 	},
+
 	input: {
 		lab65: convertLab65ToDlch,
 		dlab: convertDlabToDlch,
 		rgb: c => convertLab65ToDlch(convertRgbToLab65(c))
 	},
+
 	channels: ['l', 'c', 'h', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		c: [0, 51.484],
 		h: [0, 360]
 	},
+
 	interpolate: {
 		l: interpolatorLinear,
 		c: interpolatorLinear,
@@ -41,10 +46,14 @@ export default {
 			fixup: fixupAlpha
 		}
 	},
+
 	difference: {
 		h: differenceHueChroma
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/easing/gamma.js b/src/easing/gamma.js
index 4acdee44..47320513 100644
--- a/src/easing/gamma.js
+++ b/src/easing/gamma.js
@@ -1 +1,3 @@
-export default (γ = 1) => (γ === 1 ? t => t : t => Math.pow(t, γ));
+const gamma = (γ = 1) => (γ === 1 ? t => t : t => Math.pow(t, γ));
+
+export default gamma;
diff --git a/src/easing/inOutSine.js b/src/easing/inOutSine.js
index e336734a..9b4ed7ba 100644
--- a/src/easing/inOutSine.js
+++ b/src/easing/inOutSine.js
@@ -1,4 +1,6 @@
 /* 
 	Sinusoidal (cosine) in-out easing
 */
-export default t => (1 - Math.cos(t * Math.PI)) / 2;
+const inOutSine = t => (1 - Math.cos(t * Math.PI)) / 2;
+
+export default inOutSine;
diff --git a/src/easing/midpoint.js b/src/easing/midpoint.js
index 89918e2b..28ce7810 100644
--- a/src/easing/midpoint.js
+++ b/src/easing/midpoint.js
@@ -1,3 +1,5 @@
 // Color interpolation hint exponential function
-export default (H = 0.5) => t =>
+const midpoint = (H = 0.5) => t =>
 	H <= 0 ? 1 : H >= 1 ? 0 : Math.pow(t, Math.log(0.5) / Math.log(H));
+
+export default midpoint;
diff --git a/src/easing/smootherstep.js b/src/easing/smootherstep.js
index 6ff952a8..bebdc7b3 100644
--- a/src/easing/smootherstep.js
+++ b/src/easing/smootherstep.js
@@ -2,4 +2,6 @@
 	Smootherstep easing function proposed by K. Perlin
 	Reference: https://en.wikipedia.org/wiki/Smoothstep
  */
-export default t => t * t * t * (t * (t * 6 - 15) + 10);
+const smootherstep = t => t * t * t * (t * (t * 6 - 15) + 10);
+
+export default smootherstep;
diff --git a/src/easing/smoothstep.js b/src/easing/smoothstep.js
index 08c05faf..1515b0fd 100644
--- a/src/easing/smoothstep.js
+++ b/src/easing/smoothstep.js
@@ -2,4 +2,6 @@
 	Smoothstep easing function. 
 	Reference: https://en.wikipedia.org/wiki/Smoothstep
  */
-export default t => t * t * (3 - 2 * t);
+const smoothstep = t => t * t * (3 - 2 * t);
+
+export default smoothstep;
diff --git a/src/hsi/convertHsiToRgb.js b/src/hsi/convertHsiToRgb.js
index e5ed8809..09d4aef6 100644
--- a/src/hsi/convertHsiToRgb.js
+++ b/src/hsi/convertHsiToRgb.js
@@ -2,7 +2,7 @@ import normalizeHue from '../util/normalizeHue';
 
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB
 
-export default function ({ h, s, i, alpha }) {
+export default function convertHsiToRgb({ h, s, i, alpha }) {
 	h = normalizeHue(h);
 	let f = Math.abs(((h / 60) % 2) - 1);
 	let res;
diff --git a/src/hsi/convertRgbToHsi.js b/src/hsi/convertRgbToHsi.js
index ad0a2a0c..8b3a9c10 100644
--- a/src/hsi/convertRgbToHsi.js
+++ b/src/hsi/convertRgbToHsi.js
@@ -1,6 +1,6 @@
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Formal_derivation
 
-export default function ({ r, g, b, alpha }) {
+export default function convertRgbToHsi({ r, g, b, alpha }) {
 	let M = Math.max(r, g, b),
 		m = Math.min(r, g, b);
 	let res = {
diff --git a/src/hsi/definition.js b/src/hsi/definition.js
index 47dcdf75..20c75e69 100644
--- a/src/hsi/definition.js
+++ b/src/hsi/definition.js
@@ -6,28 +6,37 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueSaturation } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'hsi',
+
 	output: {
 		rgb: convertHsiToRgb
 	},
+
 	input: {
 		rgb: convertRgbToHsi
 	},
+
 	channels: ['h', 's', 'i', 'alpha'],
+
 	ranges: {
 		h: [0, 360]
 	},
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		s: interpolatorLinear,
 		i: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueSaturation
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/hsl/convertHslToRgb.js b/src/hsl/convertHslToRgb.js
index fbfcbdf6..19a0b248 100644
--- a/src/hsl/convertHslToRgb.js
+++ b/src/hsl/convertHslToRgb.js
@@ -1,7 +1,7 @@
 import normalizeHue from '../util/normalizeHue';
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB
 
-export default function ({ h, s, l, alpha }) {
+export default function convertHslToRgb({ h, s, l, alpha }) {
 	h = normalizeHue(h);
 	let m1 = l + s * (l < 0.5 ? l : 1 - l);
 	let m2 = m1 - (m1 - l) * 2 * Math.abs(((h / 60) % 2) - 1);
diff --git a/src/hsl/convertRgbToHsl.js b/src/hsl/convertRgbToHsl.js
index ab152ecd..60985a33 100644
--- a/src/hsl/convertRgbToHsl.js
+++ b/src/hsl/convertRgbToHsl.js
@@ -1,6 +1,6 @@
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Formal_derivation
 
-export default function ({ r, g, b, alpha }) {
+export default function convertRgbToHsl({ r, g, b, alpha }) {
 	let M = Math.max(r, g, b),
 		m = Math.min(r, g, b);
 	let res = {
diff --git a/src/hsl/definition.js b/src/hsl/definition.js
index 3d794a18..c2be2b74 100644
--- a/src/hsl/definition.js
+++ b/src/hsl/definition.js
@@ -7,29 +7,39 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueSaturation } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'hsl',
+
 	output: {
 		rgb: convertHslToRgb
 	},
+
 	input: {
 		rgb: convertRgbToHsl
 	},
+
 	channels: ['h', 's', 'l', 'alpha'],
+
 	ranges: {
 		h: [0, 360]
 	},
+
 	parsers: [parseHsl],
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		s: interpolatorLinear,
 		l: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueSaturation
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/hsl/parseHsl.js b/src/hsl/parseHsl.js
index f40e1194..6dd12d9e 100644
--- a/src/hsl/parseHsl.js
+++ b/src/hsl/parseHsl.js
@@ -1,7 +1,7 @@
 import { hsl_old, hsl_new } from '../util/regex';
 import { hue } from '../util/hue';
 
-export default color => {
+const parseHsl = color => {
 	if (typeof color !== 'string') return;
 	let match = color.match(hsl_old) || color.match(hsl_new);
 	if (!match) return;
@@ -18,3 +18,5 @@ export default color => {
 	}
 	return res;
 };
+
+export default parseHsl;
diff --git a/src/hsv/convertHsvToRgb.js b/src/hsv/convertHsvToRgb.js
index 13dc7d9e..84801372 100644
--- a/src/hsv/convertHsvToRgb.js
+++ b/src/hsv/convertHsvToRgb.js
@@ -2,7 +2,7 @@ import normalizeHue from '../util/normalizeHue';
 
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB
 
-export default function ({ h, s, v, alpha }) {
+export default function convertHsvToRgb({ h, s, v, alpha }) {
 	h = normalizeHue(h);
 	let f = Math.abs(((h / 60) % 2) - 1);
 	let res;
diff --git a/src/hsv/convertRgbToHsv.js b/src/hsv/convertRgbToHsv.js
index 30cc4213..d1361480 100644
--- a/src/hsv/convertRgbToHsv.js
+++ b/src/hsv/convertRgbToHsv.js
@@ -1,6 +1,6 @@
 // Based on: https://en.wikipedia.org/wiki/HSL_and_HSV#Formal_derivation
 
-export default function ({ r, g, b, alpha }) {
+export default function convertRgbToHsv({ r, g, b, alpha }) {
 	let M = Math.max(r, g, b),
 		m = Math.min(r, g, b);
 	let res = {
diff --git a/src/hsv/definition.js b/src/hsv/definition.js
index 937ad1a0..30fc097f 100644
--- a/src/hsv/definition.js
+++ b/src/hsv/definition.js
@@ -6,28 +6,37 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueSaturation } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'hsv',
+
 	output: {
 		rgb: convertHsvToRgb
 	},
+
 	input: {
 		rgb: convertRgbToHsv
 	},
+
 	channels: ['h', 's', 'v', 'alpha'],
+
 	ranges: {
 		h: [0, 360]
 	},
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		s: interpolatorLinear,
 		v: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueSaturation
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/hwb/convertHwbToRgb.js b/src/hwb/convertHwbToRgb.js
index 27531271..953c5c8d 100644
--- a/src/hwb/convertHwbToRgb.js
+++ b/src/hwb/convertHwbToRgb.js
@@ -10,7 +10,7 @@
 
 import convertHsvToRgb from '../hsv/convertHsvToRgb';
 
-export default function ({ h, w, b, alpha }) {
+export default function convertHwbToRgb({ h, w, b, alpha }) {
 	// normalize w + b to 1
 	if (w + b > 1) {
 		let s = w + b;
diff --git a/src/hwb/convertRgbToHwb.js b/src/hwb/convertRgbToHwb.js
index 8073ab33..8cd82978 100644
--- a/src/hwb/convertRgbToHwb.js
+++ b/src/hwb/convertRgbToHwb.js
@@ -10,7 +10,7 @@
 
 import convertRgbToHsv from '../hsv/convertRgbToHsv';
 
-export default function (rgba) {
+export default function convertRgbToHwb(rgba) {
 	let hsv = convertRgbToHsv(rgba);
 	if (hsv === undefined) return undefined;
 	let res = {
diff --git a/src/hwb/definition.js b/src/hwb/definition.js
index 73d03679..97cfdd14 100644
--- a/src/hwb/definition.js
+++ b/src/hwb/definition.js
@@ -7,29 +7,39 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueNaive } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'hwb',
+
 	output: {
 		rgb: convertHwbToRgb
 	},
+
 	input: {
 		rgb: convertRgbToHwb
 	},
+
 	channels: ['h', 'w', 'b', 'alpha'],
+
 	ranges: {
 		h: [0, 360]
 	},
+
 	parsers: [parseHwb],
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		w: interpolatorLinear,
 		b: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueNaive
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/hwb/parseHwb.js b/src/hwb/parseHwb.js
index 81f88307..e608f9bc 100644
--- a/src/hwb/parseHwb.js
+++ b/src/hwb/parseHwb.js
@@ -1,7 +1,7 @@
 import { hwb } from '../util/regex';
 import { hue } from '../util/hue';
 
-export default color => {
+const parseHwb = color => {
 	if (typeof color !== 'string') return undefined;
 	let match = color.match(hwb);
 	if (!match) return undefined;
@@ -26,3 +26,5 @@ export default color => {
 	}
 	return res;
 };
+
+export default parseHwb;
diff --git a/src/interpolate/cosine.js b/src/interpolate/cosine.js
index a9e1f3e4..e952b405 100644
--- a/src/interpolate/cosine.js
+++ b/src/interpolate/cosine.js
@@ -13,10 +13,12 @@ import gamma from '../easing/gamma';
 import { interpolatorPiecewise } from './piecewise';
 
 // @deprecated
-export default (fixup, γ = 1) => arr => {
+const cosine = (fixup, γ = 1) => arr => {
 	let ease = gamma(γ);
 	let interpolator = interpolatorPiecewise((a, b, t) =>
 		lerp(a, b, easeInOutSine(t))
 	)((fixup || (v => v))(arr));
 	return t => interpolator(ease(t));
 };
+
+export default cosine;
diff --git a/src/interpolate/lerp.js b/src/interpolate/lerp.js
index 693483fc..6b7b9a6a 100644
--- a/src/interpolate/lerp.js
+++ b/src/interpolate/lerp.js
@@ -1 +1,3 @@
-export default (a, b, t) => a + t * (b - a);
+const lerp = (a, b, t) => a + t * (b - a);
+
+export default lerp;
diff --git a/src/jab/convertJabToRgb.js b/src/jab/convertJabToRgb.js
index aa3da387..992e7ff6 100644
--- a/src/jab/convertJabToRgb.js
+++ b/src/jab/convertJabToRgb.js
@@ -1,4 +1,6 @@
 import convertXyz65ToRgb from '../xyz65/convertXyz65ToRgb';
 import convertJabToXyz65 from './convertJabToXyz65';
 
-export default color => convertXyz65ToRgb(convertJabToXyz65(color));
+const convertJabToRgb = color => convertXyz65ToRgb(convertJabToXyz65(color));
+
+export default convertJabToRgb;
diff --git a/src/jab/convertJabToXyz65.js b/src/jab/convertJabToXyz65.js
index 2f54f9d0..1096a5b4 100644
--- a/src/jab/convertJabToXyz65.js
+++ b/src/jab/convertJabToXyz65.js
@@ -12,7 +12,7 @@ const pq_inv = v => {
 
 const rel = v => v / 203;
 
-export default ({ j, a, b, alpha }) => {
+const convertJabToXyz65 = ({ j, a, b, alpha }) => {
 	let i = (j + d0) / (0.44 + 0.56 * (j + d0));
 
 	let l = pq_inv(i + 0.13860504 * a + 0.058047316 * b);
@@ -40,3 +40,5 @@ export default ({ j, a, b, alpha }) => {
 
 	return res;
 };
+
+export default convertJabToXyz65;
diff --git a/src/jab/convertRgbToJab.js b/src/jab/convertRgbToJab.js
index 3cd99afe..49a7e97a 100644
--- a/src/jab/convertRgbToJab.js
+++ b/src/jab/convertRgbToJab.js
@@ -8,10 +8,12 @@
 import convertXyz65ToJab from './convertXyz65ToJab';
 import convertRgbToXyz65 from '../xyz65/convertRgbToXyz65';
 
-export default rgb => {
+const convertRgbToJab = rgb => {
 	let res = convertXyz65ToJab(convertRgbToXyz65(rgb));
 	if (rgb.r === rgb.b && rgb.b === rgb.g) {
 		res.a = res.b = 0;
 	}
 	return res;
 };
+
+export default convertRgbToJab;
diff --git a/src/jab/convertXyz65ToJab.js b/src/jab/convertXyz65ToJab.js
index d3940d19..174d30df 100644
--- a/src/jab/convertXyz65ToJab.js
+++ b/src/jab/convertXyz65ToJab.js
@@ -13,7 +13,7 @@ const pq = v => {
 // Convert to Absolute XYZ
 const abs = v => Math.max(v * 203, 0);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToJab = ({ x, y, z, alpha }) => {
 	x = abs(x);
 	y = abs(y);
 	z = abs(z);
@@ -40,3 +40,5 @@ export default ({ x, y, z, alpha }) => {
 
 	return res;
 };
+
+export default convertXyz65ToJab;
diff --git a/src/jab/definition.js b/src/jab/definition.js
index d31b2741..88defa44 100644
--- a/src/jab/definition.js
+++ b/src/jab/definition.js
@@ -19,22 +19,26 @@ import convertJabToRgb from './convertJabToRgb';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'jab',
 	channels: ['j', 'a', 'b', 'alpha'],
+
 	input: {
 		rgb: convertRgbToJab,
 		xyz65: convertXyz65ToJab
 	},
+
 	output: {
 		rgb: convertJabToRgb,
 		xyz65: convertJabToXyz65
 	},
+
 	ranges: {
 		j: [0, 0.221],
 		a: [-0.108, 0.129],
 		b: [-0.185, 0.134]
 	},
+
 	interpolate: {
 		j: interpolatorLinear,
 		a: interpolatorLinear,
@@ -42,3 +46,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/jch/convertJabToJch.js b/src/jch/convertJabToJch.js
index 7104e7a9..750e55e0 100644
--- a/src/jch/convertJabToJch.js
+++ b/src/jch/convertJabToJch.js
@@ -1,6 +1,6 @@
 import normalizeHue from '../util/normalizeHue';
 
-export default ({ j, a, b, alpha }) => {
+const convertJabToJch = ({ j, a, b, alpha }) => {
 	let c = Math.sqrt(a * a + b * b);
 	let res = {
 		mode: 'jch',
@@ -15,3 +15,5 @@ export default ({ j, a, b, alpha }) => {
 	}
 	return res;
 };
+
+export default convertJabToJch;
diff --git a/src/jch/convertJchToJab.js b/src/jch/convertJchToJab.js
index 6e794963..1b0b4bd7 100644
--- a/src/jch/convertJchToJab.js
+++ b/src/jch/convertJchToJab.js
@@ -1,4 +1,4 @@
-export default ({ j, c, h, alpha }) => {
+const convertJchToJab = ({ j, c, h, alpha }) => {
 	let res = {
 		mode: 'jab',
 		j,
@@ -8,3 +8,5 @@ export default ({ j, c, h, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertJchToJab;
diff --git a/src/jch/definition.js b/src/jch/definition.js
index c133b168..5a077a0c 100644
--- a/src/jch/definition.js
+++ b/src/jch/definition.js
@@ -9,32 +9,41 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueChroma } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'jch',
+
 	output: {
 		lab: convertJchToJab,
 		rgb: c => convertJabToRgb(convertJchToJab(c))
 	},
+
 	input: {
 		rgb: c => convertJabToJch(convertRgbToJab(c)),
 		lab: convertJabToJch
 	},
+
 	channels: ['j', 'c', 'h', 'alpha'],
+
 	ranges: {
 		j: [0, 0.221],
 		c: [0, 0.19],
 		h: [0, 360]
 	},
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		c: interpolatorLinear,
 		j: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueChroma
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/lab/convertLabToRgb.js b/src/lab/convertLabToRgb.js
index a2717678..7aa7dded 100644
--- a/src/lab/convertLabToRgb.js
+++ b/src/lab/convertLabToRgb.js
@@ -1,4 +1,6 @@
 import convertLabToXyz from './convertLabToXyz';
 import convertXyzToRgb from '../xyz/convertXyzToRgb';
 
-export default lab => convertXyzToRgb(convertLabToXyz(lab));
+const convertLabToRgb = lab => convertXyzToRgb(convertLabToXyz(lab));
+
+export default convertLabToRgb;
diff --git a/src/lab/convertLabToXyz.js b/src/lab/convertLabToXyz.js
index 925620ce..d13075f0 100644
--- a/src/lab/convertLabToXyz.js
+++ b/src/lab/convertLabToXyz.js
@@ -2,7 +2,7 @@ import { Xn, Yn, Zn, k, e } from '../xyz/constants';
 
 let fn = v => (Math.pow(v, 3) > e ? Math.pow(v, 3) : (116 * v - 16) / k);
 
-export default ({ l, a, b, alpha }) => {
+const convertLabToXyz = ({ l, a, b, alpha }) => {
 	let fy = (l + 16) / 116;
 	let fx = a / 500 + fy;
 	let fz = fy - b / 200;
@@ -20,3 +20,5 @@ export default ({ l, a, b, alpha }) => {
 
 	return res;
 };
+
+export default convertLabToXyz;
diff --git a/src/lab/convertRgbToLab.js b/src/lab/convertRgbToLab.js
index dc3275a2..0b8ace99 100644
--- a/src/lab/convertRgbToLab.js
+++ b/src/lab/convertRgbToLab.js
@@ -1,7 +1,7 @@
 import convertRgbToXyz from '../xyz/convertRgbToXyz';
 import convertXyzToLab from './convertXyzToLab';
 
-export default rgb => {
+const convertRgbToLab = rgb => {
 	let res = convertXyzToLab(convertRgbToXyz(rgb));
 
 	// Fixes achromatic RGB colors having a _slight_ chroma due to floating-point errors
@@ -12,3 +12,5 @@ export default rgb => {
 	}
 	return res;
 };
+
+export default convertRgbToLab;
diff --git a/src/lab/convertXyzToLab.js b/src/lab/convertXyzToLab.js
index f3c33244..c0b7d4eb 100644
--- a/src/lab/convertXyzToLab.js
+++ b/src/lab/convertXyzToLab.js
@@ -2,7 +2,7 @@ import { Xn, Yn, Zn, k, e } from '../xyz/constants';
 
 const f = value => (value > e ? Math.cbrt(value) : (k * value + 16) / 116);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyzToLab = ({ x, y, z, alpha }) => {
 	let f0 = f(x / Xn);
 	let f1 = f(y / Yn);
 	let f2 = f(z / Zn);
@@ -20,3 +20,5 @@ export default ({ x, y, z, alpha }) => {
 
 	return res;
 };
+
+export default convertXyzToLab;
diff --git a/src/lab/definition.js b/src/lab/definition.js
index 2db18163..5a177678 100644
--- a/src/lab/definition.js
+++ b/src/lab/definition.js
@@ -6,24 +6,30 @@ import parseLab from './parseLab';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'lab',
 	alias: ['lab-d50'],
+
 	output: {
 		xyz: convertLabToXyz,
 		rgb: convertLabToRgb
 	},
+
 	input: {
 		xyz: convertXyzToLab,
 		rgb: convertRgbToLab
 	},
+
 	channels: ['l', 'a', 'b', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		a: [-79.167, 93.408],
 		b: [-111.859, 93.246]
 	},
+
 	parsers: [parseLab],
+
 	interpolate: {
 		l: interpolatorLinear,
 		a: interpolatorLinear,
@@ -31,3 +37,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/lab/parseLab.js b/src/lab/parseLab.js
index 735e5d37..1dafb1cb 100644
--- a/src/lab/parseLab.js
+++ b/src/lab/parseLab.js
@@ -1,6 +1,6 @@
 import { lab } from '../util/regex';
 
-export default color => {
+const parseLab = color => {
 	if (typeof color !== 'string') {
 		return undefined;
 	}
@@ -25,3 +25,5 @@ export default color => {
 
 	return res;
 };
+
+export default parseLab;
diff --git a/src/lab65/convertLab65ToRgb.js b/src/lab65/convertLab65ToRgb.js
index 7536c995..8a2f6533 100644
--- a/src/lab65/convertLab65ToRgb.js
+++ b/src/lab65/convertLab65ToRgb.js
@@ -1,4 +1,6 @@
 import convertLab65ToXyz65 from './convertLab65ToXyz65';
 import convertXyz65ToRgb from '../xyz65/convertXyz65ToRgb';
 
-export default lab => convertXyz65ToRgb(convertLab65ToXyz65(lab));
+const convertLab65ToRgb = lab => convertXyz65ToRgb(convertLab65ToXyz65(lab));
+
+export default convertLab65ToRgb;
diff --git a/src/lab65/convertLab65ToXyz65.js b/src/lab65/convertLab65ToXyz65.js
index 0ab514aa..bdd24714 100644
--- a/src/lab65/convertLab65ToXyz65.js
+++ b/src/lab65/convertLab65ToXyz65.js
@@ -2,7 +2,7 @@ import { Xn, Yn, Zn, k, e } from '../xyz65/constants';
 
 let fn = v => (Math.pow(v, 3) > e ? Math.pow(v, 3) : (116 * v - 16) / k);
 
-export default ({ l, a, b, alpha }) => {
+const convertLab65ToXyz65 = ({ l, a, b, alpha }) => {
 	let fy = (l + 16) / 116;
 	let fx = a / 500 + fy;
 	let fz = fy - b / 200;
@@ -20,3 +20,5 @@ export default ({ l, a, b, alpha }) => {
 
 	return res;
 };
+
+export default convertLab65ToXyz65;
diff --git a/src/lab65/convertRgbToLab65.js b/src/lab65/convertRgbToLab65.js
index 28fa1170..7d3c577f 100644
--- a/src/lab65/convertRgbToLab65.js
+++ b/src/lab65/convertRgbToLab65.js
@@ -1,7 +1,7 @@
 import convertRgbToXyz65 from '../xyz65/convertRgbToXyz65';
 import convertXyz65ToLab65 from './convertXyz65ToLab65';
 
-export default rgb => {
+const convertRgbToLab65 = rgb => {
 	let res = convertXyz65ToLab65(convertRgbToXyz65(rgb));
 
 	// Fixes achromatic RGB colors having a _slight_ chroma due to floating-point errors
@@ -12,3 +12,5 @@ export default rgb => {
 	}
 	return res;
 };
+
+export default convertRgbToLab65;
diff --git a/src/lab65/convertXyz65ToLab65.js b/src/lab65/convertXyz65ToLab65.js
index a6daee7f..3660a281 100644
--- a/src/lab65/convertXyz65ToLab65.js
+++ b/src/lab65/convertXyz65ToLab65.js
@@ -2,7 +2,7 @@ import { Xn, Yn, Zn, k, e } from '../xyz65/constants';
 
 const f = value => (value > e ? Math.cbrt(value) : (k * value + 16) / 116);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToLab65 = ({ x, y, z, alpha }) => {
 	let f0 = f(x / Xn);
 	let f1 = f(y / Yn);
 	let f2 = f(z / Zn);
@@ -20,3 +20,5 @@ export default ({ x, y, z, alpha }) => {
 
 	return res;
 };
+
+export default convertXyz65ToLab65;
diff --git a/src/lab65/definition.js b/src/lab65/definition.js
index ef1855c1..b7c80ab1 100644
--- a/src/lab65/definition.js
+++ b/src/lab65/definition.js
@@ -4,22 +4,28 @@ import convertRgbToLab65 from './convertRgbToLab65';
 import convertXyz65ToLab65 from './convertXyz65ToLab65';
 import lab from '../lab/definition';
 
-export default {
+const definition = {
 	...lab,
 	mode: 'lab65',
 	alias: ['lab-d65'],
+
 	output: {
 		xyz65: convertLab65ToXyz65,
 		rgb: convertLab65ToRgb
 	},
+
 	input: {
 		xyz65: convertXyz65ToLab65,
 		rgb: convertRgbToLab65
 	},
+
 	ranges: {
 		l: [0, 100],
 		a: [-86.183, 98.234],
 		b: [-107.86, 94.478]
 	},
+
 	parsers: []
 };
+
+export default definition;
diff --git a/src/lch/convertLabToLch.js b/src/lch/convertLabToLch.js
index edd7cefc..8c34d39f 100644
--- a/src/lch/convertLabToLch.js
+++ b/src/lch/convertLabToLch.js
@@ -5,10 +5,12 @@ import normalizeHue from '../util/normalizeHue';
 		* https://drafts.csswg.org/css-color/#lab-to-lch
 		* https://drafts.csswg.org/css-color/#color-conversion-code
 */
-export default ({ l, a, b, alpha }, mode = 'lch') => {
+const convertLabToLch = ({ l, a, b, alpha }, mode = 'lch') => {
 	let c = Math.sqrt(a * a + b * b);
 	let res = { mode, l, c };
 	if (c) res.h = normalizeHue((Math.atan2(b, a) * 180) / Math.PI);
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertLabToLch;
diff --git a/src/lch/convertLchToLab.js b/src/lch/convertLchToLab.js
index 914f718b..caeab75d 100644
--- a/src/lch/convertLchToLab.js
+++ b/src/lch/convertLchToLab.js
@@ -3,7 +3,7 @@
 		* https://drafts.csswg.org/css-color/#lch-to-lab
 		* https://drafts.csswg.org/css-color/#color-conversion-code
 */
-export default ({ l, c, h, alpha }, mode = 'lab') => {
+const convertLchToLab = ({ l, c, h, alpha }, mode = 'lab') => {
 	let res = {
 		mode,
 		l,
@@ -13,3 +13,5 @@ export default ({ l, c, h, alpha }, mode = 'lab') => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertLchToLab;
diff --git a/src/lch/definition.js b/src/lch/definition.js
index 2b5ed04c..a835bb07 100644
--- a/src/lch/definition.js
+++ b/src/lch/definition.js
@@ -9,34 +9,44 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueChroma } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'lch',
 	alias: ['lch-d50'],
+
 	output: {
 		lab: convertLchToLab,
 		rgb: c => convertLabToRgb(convertLchToLab(c))
 	},
+
 	input: {
 		rgb: c => convertLabToLch(convertRgbToLab(c)),
 		lab: convertLabToLch
 	},
+
 	channels: ['l', 'c', 'h', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		c: [0, 131.008],
 		h: [0, 360]
 	},
+
 	parsers: [parseLch],
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		c: interpolatorLinear,
 		l: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueChroma
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/lch/parseLch.js b/src/lch/parseLch.js
index c9cfec4f..3e473ab7 100644
--- a/src/lch/parseLch.js
+++ b/src/lch/parseLch.js
@@ -1,7 +1,7 @@
 import { lch } from '../util/regex';
 import { hue } from '../util/hue';
 
-export default color => {
+const parseLch = color => {
 	if (typeof color !== 'string') return undefined;
 
 	let match = color.match(lch);
@@ -25,3 +25,5 @@ export default color => {
 
 	return res;
 };
+
+export default parseLch;
diff --git a/src/lch65/definition.js b/src/lch65/definition.js
index 302ed08f..27e0e62d 100644
--- a/src/lch65/definition.js
+++ b/src/lch65/definition.js
@@ -4,22 +4,28 @@ import convertLab65ToRgb from '../lab65/convertLab65ToRgb';
 import convertRgbToLab65 from '../lab65/convertRgbToLab65';
 import lch from '../lch/definition';
 
-export default {
+const definition = {
 	...lch,
 	mode: 'lch65',
 	alias: ['lch-d65'],
+
 	output: {
 		lab65: c => convertLchToLab(c, 'lab65'),
 		rgb: c => convertLab65ToRgb(convertLchToLab(c, 'lab65'))
 	},
+
 	input: {
 		rgb: c => convertLabToLch(convertRgbToLab65(c), 'lch65'),
 		lab65: c => convertLabToLch(c, 'lch65')
 	},
+
 	parsers: [],
+
 	ranges: {
 		l: [0, 100],
 		c: [0, 133.807],
 		h: [0, 360]
 	}
 };
+
+export default definition;
diff --git a/src/lchuv/convertLchuvToLuv.js b/src/lchuv/convertLchuvToLuv.js
index a23300f7..6be8174e 100644
--- a/src/lchuv/convertLchuvToLuv.js
+++ b/src/lchuv/convertLchuvToLuv.js
@@ -1,4 +1,4 @@
-export default ({ l, c, h, alpha }) => {
+const convertLchuvToLuv = ({ l, c, h, alpha }) => {
 	let res = {
 		mode: 'luv',
 		l: l,
@@ -10,3 +10,5 @@ export default ({ l, c, h, alpha }) => {
 	}
 	return res;
 };
+
+export default convertLchuvToLuv;
diff --git a/src/lchuv/convertLchuvToRgb.js b/src/lchuv/convertLchuvToRgb.js
index 1326a8c5..9d38492b 100644
--- a/src/lchuv/convertLchuvToRgb.js
+++ b/src/lchuv/convertLchuvToRgb.js
@@ -1,4 +1,6 @@
 import convertLuvToRgb from '../luv/convertLuvToRgb';
 import convertLchuvToLuv from './convertLchuvToLuv';
 
-export default c => convertLuvToRgb(convertLchuvToLuv(c));
+const convertLchuvToRgb = c => convertLuvToRgb(convertLchuvToLuv(c));
+
+export default convertLchuvToRgb;
diff --git a/src/lchuv/convertLuvToLchuv.js b/src/lchuv/convertLuvToLchuv.js
index 71d61cfa..92c47e4b 100644
--- a/src/lchuv/convertLuvToLchuv.js
+++ b/src/lchuv/convertLuvToLchuv.js
@@ -1,6 +1,6 @@
 import normalizeHue from '../util/normalizeHue';
 
-export default ({ l, u, v, alpha }) => {
+const convertLuvToLchuv = ({ l, u, v, alpha }) => {
 	let c = Math.sqrt(u * u + v * v);
 	let res = {
 		mode: 'lchuv',
@@ -15,3 +15,5 @@ export default ({ l, u, v, alpha }) => {
 	}
 	return res;
 };
+
+export default convertLuvToLchuv;
diff --git a/src/lchuv/convertRgbToLchuv.js b/src/lchuv/convertRgbToLchuv.js
index b120e067..4133c197 100644
--- a/src/lchuv/convertRgbToLchuv.js
+++ b/src/lchuv/convertRgbToLchuv.js
@@ -1,4 +1,6 @@
 import convertRgbToLuv from '../luv/convertRgbToLuv';
 import convertLuvToLchuv from './convertLuvToLchuv';
 
-export default c => convertLuvToLchuv(convertRgbToLuv(c));
+const convertRgbToLchuv = c => convertLuvToLchuv(convertRgbToLuv(c));
+
+export default convertRgbToLchuv;
diff --git a/src/lchuv/definition.js b/src/lchuv/definition.js
index bff3bb72..8ff5b767 100644
--- a/src/lchuv/definition.js
+++ b/src/lchuv/definition.js
@@ -17,32 +17,41 @@ import { interpolatorLinear } from '../interpolate/linear';
 import { differenceHueChroma } from '../difference';
 import { averageAngle } from '../average';
 
-export default {
+const definition = {
 	mode: 'lchuv',
+
 	output: {
 		luv: convertLchuvToLuv,
 		rgb: convertLchuvToRgb
 	},
+
 	input: {
 		rgb: convertRgbToLchuv,
 		luv: convertLuvToLchuv
 	},
+
 	channels: ['l', 'c', 'h', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		c: [0, 131.008],
 		h: [0, 360]
 	},
+
 	interpolate: {
 		h: { use: interpolatorLinear, fixup: fixupHueShorter },
 		c: interpolatorLinear,
 		l: interpolatorLinear,
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	},
+
 	difference: {
 		h: differenceHueChroma
 	},
+
 	average: {
 		h: averageAngle
 	}
 };
+
+export default definition;
diff --git a/src/lrgb/convertLrgbToRgb.js b/src/lrgb/convertLrgbToRgb.js
index 46608f1e..d8a5626c 100644
--- a/src/lrgb/convertLrgbToRgb.js
+++ b/src/lrgb/convertLrgbToRgb.js
@@ -1,7 +1,7 @@
 const fn = c =>
 	c > 0.0031308 ? 1.055 * Math.pow(c, 1 / 2.4) - 0.055 : 12.92 * c;
 
-export default ({ r, g, b, alpha }, mode = 'rgb') => {
+const convertLrgbToRgb = ({ r, g, b, alpha }, mode = 'rgb') => {
 	let res = {
 		mode,
 		r: fn(r),
@@ -11,3 +11,5 @@ export default ({ r, g, b, alpha }, mode = 'rgb') => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertLrgbToRgb;
diff --git a/src/lrgb/convertRgbToLrgb.js b/src/lrgb/convertRgbToLrgb.js
index c5a36e9c..2b25a015 100644
--- a/src/lrgb/convertRgbToLrgb.js
+++ b/src/lrgb/convertRgbToLrgb.js
@@ -1,6 +1,6 @@
 const fn = c => (c < 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
 
-export default ({ r, g, b, alpha }) => {
+const convertRgbToLrgb = ({ r, g, b, alpha }) => {
 	let res = {
 		mode: 'lrgb',
 		r: fn(r),
@@ -10,3 +10,5 @@ export default ({ r, g, b, alpha }) => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertRgbToLrgb;
diff --git a/src/lrgb/definition.js b/src/lrgb/definition.js
index 399020f9..416531f0 100644
--- a/src/lrgb/definition.js
+++ b/src/lrgb/definition.js
@@ -2,14 +2,19 @@ import rgb from '../rgb/definition';
 import convertRgbToLrgb from './convertRgbToLrgb';
 import convertLrgbToRgb from './convertLrgbToRgb';
 
-export default {
+const definition = {
 	...rgb,
 	mode: 'lrgb',
+
 	output: {
 		rgb: convertLrgbToRgb
 	},
+
 	input: {
 		rgb: convertRgbToLrgb
 	},
+
 	parsers: []
 };
+
+export default definition;
diff --git a/src/luv/convertLuvToRgb.js b/src/luv/convertLuvToRgb.js
index 508e6a0e..d3ded30c 100644
--- a/src/luv/convertLuvToRgb.js
+++ b/src/luv/convertLuvToRgb.js
@@ -1,4 +1,6 @@
 import convertLuvToXyz from './convertLuvToXyz';
 import convertXyzToRgb from '../xyz/convertXyzToRgb';
 
-export default luv => convertXyzToRgb(convertLuvToXyz(luv));
+const convertLuvToRgb = luv => convertXyzToRgb(convertLuvToXyz(luv));
+
+export default convertLuvToRgb;
diff --git a/src/luv/convertLuvToXyz.js b/src/luv/convertLuvToXyz.js
index 9b87cb32..9008030b 100644
--- a/src/luv/convertLuvToXyz.js
+++ b/src/luv/convertLuvToXyz.js
@@ -6,7 +6,7 @@ export const v_fn = (x, y, z) => (9 * y) / (x + 15 * y + 3 * z);
 export const un = u_fn(Xn, Yn, Zn);
 export const vn = v_fn(Xn, Yn, Zn);
 
-export default ({ l, u, v, alpha }) => {
+const convertLuvToXyz = ({ l, u, v, alpha }) => {
 	let up = u / (13 * l) + un;
 	let vp = v / (13 * l) + vn;
 	let y = Yn * (l <= 8 ? l / k : Math.pow((l + 16) / 116, 3));
@@ -20,3 +20,5 @@ export default ({ l, u, v, alpha }) => {
 
 	return res;
 };
+
+export default convertLuvToXyz;
diff --git a/src/luv/convertRgbToLuv.js b/src/luv/convertRgbToLuv.js
index e1f23161..f59a4652 100644
--- a/src/luv/convertRgbToLuv.js
+++ b/src/luv/convertRgbToLuv.js
@@ -1,4 +1,6 @@
 import convertRgbToXyz from '../xyz/convertRgbToXyz';
 import convertXyzToLuv from './convertXyzToLuv';
 
-export default rgb => convertXyzToLuv(convertRgbToXyz(rgb));
+const convertRgbToLuv = rgb => convertXyzToLuv(convertRgbToXyz(rgb));
+
+export default convertRgbToLuv;
diff --git a/src/luv/convertXyzToLuv.js b/src/luv/convertXyzToLuv.js
index 20750f9d..431102fc 100644
--- a/src/luv/convertXyzToLuv.js
+++ b/src/luv/convertXyzToLuv.js
@@ -8,7 +8,7 @@ export const vn = v_fn(Xn, Yn, Zn);
 
 const l_fn = value => (value <= e ? k * value : 116 * Math.cbrt(value) - 16);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyzToLuv = ({ x, y, z, alpha }) => {
 	let l = l_fn(y / Yn);
 	let u = u_fn(x, y, z);
 	let v = v_fn(x, y, z);
@@ -34,3 +34,5 @@ export default ({ x, y, z, alpha }) => {
 
 	return res;
 };
+
+export default convertXyzToLuv;
diff --git a/src/luv/definition.js b/src/luv/definition.js
index 40806f74..404fe162 100644
--- a/src/luv/definition.js
+++ b/src/luv/definition.js
@@ -14,22 +14,27 @@ import convertLuvToRgb from './convertLuvToRgb';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'luv',
+
 	output: {
 		xyz: convertLuvToXyz,
 		rgb: convertLuvToRgb
 	},
+
 	input: {
 		xyz: convertXyzToLuv,
 		rgb: convertRgbToLuv
 	},
+
 	channels: ['l', 'u', 'v', 'alpha'],
+
 	ranges: {
 		l: [0, 100],
 		u: [-84.86, 174.87],
 		v: [-125.744, 87.165]
 	},
+
 	interpolate: {
 		l: interpolatorLinear,
 		u: interpolatorLinear,
@@ -37,3 +42,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/nearest.js b/src/nearest.js
index 5a85c402..2e7beea8 100644
--- a/src/nearest.js
+++ b/src/nearest.js
@@ -8,7 +8,7 @@ import { differenceEuclidean } from './difference';
 	* http://pnylab.com/papers/vptree/main.html
  */
 
-export default (colors, metric = differenceEuclidean(), accessor = d => d) => {
+const nearest = (colors, metric = differenceEuclidean(), accessor = d => d) => {
 	let arr = colors.map((c, idx) => ({ color: accessor(c), i: idx }));
 	return (color, n = 1, τ = Infinity) => {
 		if (isFinite(n)) {
@@ -26,3 +26,5 @@ export default (colors, metric = differenceEuclidean(), accessor = d => d) => {
 			.map(c => colors[c.i]);
 	};
 };
+
+export default nearest;
diff --git a/src/oklab/convertLrgbToOklab.js b/src/oklab/convertLrgbToOklab.js
index 9474a18e..9c3af580 100644
--- a/src/oklab/convertLrgbToOklab.js
+++ b/src/oklab/convertLrgbToOklab.js
@@ -1,4 +1,4 @@
-export default ({ r, g, b, alpha }) => {
+const convertLrgbToOklab = ({ r, g, b, alpha }) => {
 	let L = Math.cbrt(0.412165612 * r + 0.536275208 * g + 0.0514575653 * b);
 	let M = Math.cbrt(0.211859107 * r + 0.6807189584 * g + 0.107406579 * b);
 	let S = Math.cbrt(0.0883097947 * r + 0.2818474174 * g + 0.6302613616 * b);
@@ -16,3 +16,5 @@ export default ({ r, g, b, alpha }) => {
 
 	return res;
 };
+
+export default convertLrgbToOklab;
diff --git a/src/oklab/convertOklabToLrgb.js b/src/oklab/convertOklabToLrgb.js
index 12c690fb..53ec74f4 100644
--- a/src/oklab/convertOklabToLrgb.js
+++ b/src/oklab/convertOklabToLrgb.js
@@ -1,4 +1,4 @@
-export default ({ l, a, b, alpha }) => {
+const convertOklabToLrgb = ({ l, a, b, alpha }) => {
 	let L = Math.pow(l + 0.3963377774 * a + 0.2158037573 * b, 3);
 	let M = Math.pow(l - 0.1055613458 * a - 0.0638541728 * b, 3);
 	let S = Math.pow(l - 0.0894841775 * a - 1.291485548 * b, 3);
@@ -16,3 +16,5 @@ export default ({ l, a, b, alpha }) => {
 
 	return res;
 };
+
+export default convertOklabToLrgb;
diff --git a/src/oklab/convertOklabToRgb.js b/src/oklab/convertOklabToRgb.js
index d1cc17a3..fed42e5d 100644
--- a/src/oklab/convertOklabToRgb.js
+++ b/src/oklab/convertOklabToRgb.js
@@ -1,4 +1,6 @@
 import convertLrgbToRgb from '../lrgb/convertLrgbToRgb';
 import convertOklabToLrgb from './convertOklabToLrgb';
 
-export default c => convertLrgbToRgb(convertOklabToLrgb(c));
+const convertOklabToRgb = c => convertLrgbToRgb(convertOklabToLrgb(c));
+
+export default convertOklabToRgb;
diff --git a/src/oklab/convertRgbToOklab.js b/src/oklab/convertRgbToOklab.js
index d7679149..5834477c 100644
--- a/src/oklab/convertRgbToOklab.js
+++ b/src/oklab/convertRgbToOklab.js
@@ -1,10 +1,12 @@
 import convertRgbToLrgb from '../lrgb/convertRgbToLrgb';
 import convertLrgbToOklab from './convertLrgbToOklab';
 
-export default rgb => {
+const convertRgbToOklab = rgb => {
 	let res = convertLrgbToOklab(convertRgbToLrgb(rgb));
 	if (rgb.r === rgb.b && rgb.b === rgb.g) {
 		res.a = res.b = 0;
 	}
 	return res;
 };
+
+export default convertRgbToOklab;
diff --git a/src/oklab/definition.js b/src/oklab/definition.js
index b7c0f893..739ea408 100644
--- a/src/oklab/definition.js
+++ b/src/oklab/definition.js
@@ -10,22 +10,28 @@ import lab from '../lab/definition';
 	Reference: https://bottosson.github.io/posts/oklab/
  */
 
-export default {
+const definition = {
 	...lab,
 	mode: 'oklab',
 	alias: [],
+
 	output: {
 		lrgb: convertOklabToLrgb,
 		rgb: convertOklabToRgb
 	},
+
 	input: {
 		lrgb: convertLrgbToOklab,
 		rgb: convertRgbToOklab
 	},
+
 	ranges: {
 		l: [0, 1],
 		a: [-0.233, 0.276],
 		b: [-0.311, 0.198]
 	},
+
 	parsers: []
 };
+
+export default definition;
diff --git a/src/oklch/definition.js b/src/oklch/definition.js
index dd078853..3d16e3df 100644
--- a/src/oklch/definition.js
+++ b/src/oklch/definition.js
@@ -4,22 +4,28 @@ import convertLchToLab from '../lch/convertLchToLab';
 import convertOklabToRgb from '../oklab/convertOklabToRgb';
 import convertRgbToOklab from '../oklab/convertRgbToOklab';
 
-export default {
+const definition = {
 	...lch,
 	mode: 'oklch',
 	alias: [],
+
 	output: {
 		oklab: c => convertLchToLab(c, 'oklab'),
 		rgb: c => convertOklabToRgb(convertLchToLab(c, 'oklab'))
 	},
+
 	input: {
 		rgb: c => convertLabToLch(convertRgbToOklab(c), 'oklch'),
 		oklab: c => convertLabToLch(c, 'oklch')
 	},
+
 	parsers: [],
+
 	ranges: {
 		l: [0, 1],
 		c: [0, 0.322],
 		h: [0, 360]
 	}
 };
+
+export default definition;
diff --git a/src/p3/convertP3ToXyz65.js b/src/p3/convertP3ToXyz65.js
index 65fe6e09..97e33ba8 100644
--- a/src/p3/convertP3ToXyz65.js
+++ b/src/p3/convertP3ToXyz65.js
@@ -8,7 +8,7 @@
 
 import convertRgbToLrgb from '../lrgb/convertRgbToLrgb';
 
-export default rgb => {
+const convertP3ToXyz65 = rgb => {
 	let { r, g, b, alpha } = convertRgbToLrgb(rgb);
 	let res = {
 		mode: 'xyz65',
@@ -21,3 +21,5 @@ export default rgb => {
 	}
 	return res;
 };
+
+export default convertP3ToXyz65;
diff --git a/src/p3/convertXyz65ToP3.js b/src/p3/convertXyz65ToP3.js
index f755f73b..a16866f2 100644
--- a/src/p3/convertXyz65ToP3.js
+++ b/src/p3/convertXyz65ToP3.js
@@ -8,7 +8,7 @@
 
 import convertLrgbToRgb from '../lrgb/convertLrgbToRgb';
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToP3 = ({ x, y, z, alpha }) => {
 	let res = convertLrgbToRgb(
 		{
 			r: x * 2.4934969 - y * 0.9313836 - 0.4027107 * z,
@@ -22,3 +22,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyz65ToP3;
diff --git a/src/p3/definition.js b/src/p3/definition.js
index ec63248e..8f0932f9 100644
--- a/src/p3/definition.js
+++ b/src/p3/definition.js
@@ -4,17 +4,22 @@ import convertXyz65ToP3 from './convertXyz65ToP3';
 import convertRgbToXyz65 from '../xyz65/convertRgbToXyz65';
 import convertXyz65ToRgb from '../xyz65/convertXyz65ToRgb';
 
-export default {
+const definition = {
 	...rgb,
 	mode: 'p3',
 	alias: ['display-p3'],
+
 	input: {
 		rgb: color => convertXyz65ToP3(convertRgbToXyz65(color)),
 		xyz65: convertXyz65ToP3
 	},
+
 	output: {
 		rgb: color => convertXyz65ToRgb(convertP3ToXyz65(color)),
 		xyz65: convertP3ToXyz65
 	},
+
 	parsers: []
 };
+
+export default definition;
diff --git a/src/prophoto/convertProphotoToXyz.js b/src/prophoto/convertProphotoToXyz.js
index 07ff0972..335c661b 100644
--- a/src/prophoto/convertProphotoToXyz.js
+++ b/src/prophoto/convertProphotoToXyz.js
@@ -8,7 +8,7 @@
 
 const linearize = v => (v >= 16 / 512 ? Math.pow(v, 1.8) : v / 16);
 
-export default prophoto => {
+const convertProphotoToXyz = prophoto => {
 	let r = linearize(prophoto.r);
 	let g = linearize(prophoto.g);
 	let b = linearize(prophoto.b);
@@ -29,3 +29,5 @@ export default prophoto => {
 	}
 	return res;
 };
+
+export default convertProphotoToXyz;
diff --git a/src/prophoto/convertXyzToProphoto.js b/src/prophoto/convertXyzToProphoto.js
index 16a674f7..95274779 100644
--- a/src/prophoto/convertXyzToProphoto.js
+++ b/src/prophoto/convertXyzToProphoto.js
@@ -8,7 +8,7 @@
 
 const gamma = v => (v >= 1 / 512 ? Math.pow(v, 1 / 1.8) : 16 * v);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyzToProphoto = ({ x, y, z, alpha }) => {
 	let res = {
 		mode: 'prophoto',
 		r: gamma(
@@ -28,3 +28,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyzToProphoto;
diff --git a/src/prophoto/definition.js b/src/prophoto/definition.js
index bb64b6c4..56ac0053 100644
--- a/src/prophoto/definition.js
+++ b/src/prophoto/definition.js
@@ -13,17 +13,21 @@ import convertRgbToXyz from '../xyz/convertRgbToXyz';
 		* https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space
  */
 
-export default {
+const definition = {
 	...rgb,
 	mode: 'prophoto',
 	alias: ['prophoto-rgb'],
 	parsers: [],
+
 	input: {
 		xyz: convertXyzToProphoto,
 		rgb: color => convertXyzToProphoto(convertRgbToXyz(color))
 	},
+
 	output: {
 		xyz: convertProphotoToXyz,
 		rgb: color => convertXyzToRgb(convertProphotoToXyz(color))
 	}
 };
+
+export default definition;
diff --git a/src/random.js b/src/random.js
index 565560f5..ce2894a4 100644
--- a/src/random.js
+++ b/src/random.js
@@ -18,7 +18,7 @@ const to_intervals = constraints =>
 /*
 	Generate a random color.
  */
-export default (mode = 'rgb', constraints = {}) => {
+const random = (mode = 'rgb', constraints = {}) => {
 	let def = getModeDefinition(mode);
 	let limits = to_intervals(constraints);
 	return def.channels.reduce(
@@ -32,3 +32,5 @@ export default (mode = 'rgb', constraints = {}) => {
 		{ mode }
 	);
 };
+
+export default random;
diff --git a/src/rec2020/convertRec2020ToXyz65.js b/src/rec2020/convertRec2020ToXyz65.js
index 574e6eac..4561a12d 100644
--- a/src/rec2020/convertRec2020ToXyz65.js
+++ b/src/rec2020/convertRec2020ToXyz65.js
@@ -12,7 +12,7 @@ const β = 0.018053968510807;
 
 const linearize = v => (v < β * 4.5 ? v / 4.5 : Math.pow((v + α - 1) / α, 2.4));
 
-export default rec2020 => {
+const convertRec2020ToXyz65 = rec2020 => {
 	let r = linearize(rec2020.r);
 	let g = linearize(rec2020.g);
 	let b = linearize(rec2020.b);
@@ -33,3 +33,5 @@ export default rec2020 => {
 	}
 	return res;
 };
+
+export default convertRec2020ToXyz65;
diff --git a/src/rec2020/convertXyz65ToRec2020.js b/src/rec2020/convertXyz65ToRec2020.js
index 7a6054a0..140074c9 100644
--- a/src/rec2020/convertXyz65ToRec2020.js
+++ b/src/rec2020/convertXyz65ToRec2020.js
@@ -11,7 +11,7 @@ const α = 1.09929682680944;
 const β = 0.018053968510807;
 const gamma = v => (v > β ? α * Math.pow(v, 1 / 2.4) - (α - 1) : 4.5 * v);
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToRec2020 = ({ x, y, z, alpha }) => {
 	let res = {
 		mode: 'rec2020',
 		r: gamma(
@@ -35,3 +35,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyz65ToRec2020;
diff --git a/src/rec2020/definition.js b/src/rec2020/definition.js
index 352cc3ba..7b2b2d14 100644
--- a/src/rec2020/definition.js
+++ b/src/rec2020/definition.js
@@ -6,16 +6,21 @@ import convertRec2020ToXyz65 from './convertRec2020ToXyz65';
 import convertRgbToXyz65 from '../xyz65/convertRgbToXyz65';
 import convertXyz65ToRgb from '../xyz65/convertXyz65ToRgb';
 
-export default {
+const definition = {
 	...rgb,
 	mode: 'rec2020',
+
 	input: {
 		xyz: convertXyz65ToRec2020,
 		rgb: color => convertXyz65ToRec2020(convertRgbToXyz65(color))
 	},
+
 	output: {
 		xyz: convertRec2020ToXyz65,
 		rgb: color => convertXyz65ToRgb(convertRec2020ToXyz65(color))
 	},
+
 	parsers: []
 };
+
+export default definition;
diff --git a/src/rgb/definition.js b/src/rgb/definition.js
index a05c019d..b8b5fe75 100644
--- a/src/rgb/definition.js
+++ b/src/rgb/definition.js
@@ -9,11 +9,12 @@ import { fixupAlpha } from '../fixup/alpha';
 	sRGB color space
  */
 
-export default {
+const definition = {
 	mode: 'rgb',
 	channels: ['r', 'g', 'b', 'alpha'],
 	alias: ['srgb'],
 	parsers: [parseHex, parseRgb, parseNamed, parseTransparent],
+
 	interpolate: {
 		r: interpolatorLinear,
 		g: interpolatorLinear,
@@ -21,3 +22,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/rgb/parseHex.js b/src/rgb/parseHex.js
index 2351b414..76ce5f4b 100644
--- a/src/rgb/parseHex.js
+++ b/src/rgb/parseHex.js
@@ -1,9 +1,11 @@
 import parseNumber from './parseNumber';
 import { hex } from '../util/regex';
 
-export default color => {
+const parseHex = color => {
 	let match;
 	return (match = color.match(hex))
 		? parseNumber(parseInt(match[1], 16), match[1].length)
 		: undefined;
 };
+
+export default parseHex;
diff --git a/src/rgb/parseNamed.js b/src/rgb/parseNamed.js
index e7f76e87..39c9ea69 100644
--- a/src/rgb/parseNamed.js
+++ b/src/rgb/parseNamed.js
@@ -3,10 +3,12 @@ import named from '../colors/named';
 
 // Also supports the `transparent` color as defined in:
 // https://drafts.csswg.org/css-color/#transparent-black
-export default color => {
+const parseNamed = color => {
 	return (
 		(typeof color === 'string' &&
 			parseNumber(named[color.toLowerCase()], 6)) ||
 		undefined
 	);
 };
+
+export default parseNamed;
diff --git a/src/rgb/parseNumber.js b/src/rgb/parseNumber.js
index d3170b41..98510036 100644
--- a/src/rgb/parseNumber.js
+++ b/src/rgb/parseNumber.js
@@ -1,4 +1,4 @@
-export default (color, len) => {
+const parseNumber = (color, len) => {
 	if (typeof color !== 'number') return;
 
 	// hex3: #c93 -> #cc9933
@@ -43,3 +43,5 @@ export default (color, len) => {
 		};
 	}
 };
+
+export default parseNumber;
diff --git a/src/rgb/parseRgb.js b/src/rgb/parseRgb.js
index a917bae5..8d707e84 100644
--- a/src/rgb/parseRgb.js
+++ b/src/rgb/parseRgb.js
@@ -5,7 +5,7 @@ import {
 	rgb_per_new
 } from '../util/regex';
 
-export default color => {
+const parseRgb = color => {
 	let match, res;
 
 	if ((match = color.match(rgb_num_old) || color.match(rgb_num_new))) {
@@ -34,3 +34,5 @@ export default color => {
 
 	return res;
 };
+
+export default parseRgb;
diff --git a/src/rgb/parseTransparent.js b/src/rgb/parseTransparent.js
index c5fc5cc0..47d151fc 100644
--- a/src/rgb/parseTransparent.js
+++ b/src/rgb/parseTransparent.js
@@ -1,4 +1,6 @@
 import parseNumber from './parseNumber';
 
-export default c =>
+const parseTransparent = c =>
 	c === 'transparent' ? parseNumber(0x00000000, 8) : undefined;
+
+export default parseTransparent;
diff --git a/src/round.js b/src/round.js
index e2dbca0c..90da8713 100644
--- a/src/round.js
+++ b/src/round.js
@@ -3,5 +3,7 @@
 const r = (value, precision) =>
 	Math.round(value * (precision = Math.pow(10, precision))) / precision;
 
-export default (precision = 4) => value =>
+const round = (precision = 4) => value =>
 	typeof value === 'number' ? r(value, precision) : value;
+
+export default round;
diff --git a/src/samples.js b/src/samples.js
index 7e02bcb6..aef6f755 100644
--- a/src/samples.js
+++ b/src/samples.js
@@ -1,6 +1,6 @@
 import gamma from './easing/gamma';
 
-export default (n = 2, γ = 1) => {
+const samples = (n = 2, γ = 1) => {
 	let ease = gamma(γ);
 	if (n < 2) {
 		return n < 1 ? [] : [ease(0.5)];
@@ -11,3 +11,5 @@ export default (n = 2, γ = 1) => {
 	}
 	return res;
 };
+
+export default samples;
diff --git a/src/util/fixup.js b/src/util/fixup.js
index b19965fd..392c1233 100644
--- a/src/util/fixup.js
+++ b/src/util/fixup.js
@@ -1 +1,3 @@
-export default value => Math.round(Math.max(0, Math.min(value, 1)) * 255);
+const fixup = value => Math.round(Math.max(0, Math.min(value, 1)) * 255);
+
+export default fixup;
diff --git a/src/util/lerp.js b/src/util/lerp.js
index 14f3cb8b..c582bfe8 100644
--- a/src/util/lerp.js
+++ b/src/util/lerp.js
@@ -1,2 +1,4 @@
-export default (a, b, t) =>
+const lerp = (a, b, t) =>
 	a === undefined || b === undefined ? undefined : a + t * (b - a);
+
+export default lerp;
diff --git a/src/util/normalizeHue.js b/src/util/normalizeHue.js
index 18aba1fc..8ecc3139 100644
--- a/src/util/normalizeHue.js
+++ b/src/util/normalizeHue.js
@@ -1 +1,3 @@
-export default hue => ((hue = hue % 360) < 0 ? hue + 360 : hue);
+const normalizeHue = hue => ((hue = hue % 360) < 0 ? hue + 360 : hue);
+
+export default normalizeHue;
diff --git a/src/util/normalizePositions.js b/src/util/normalizePositions.js
index 3ed2bdd4..80e59430 100644
--- a/src/util/normalizePositions.js
+++ b/src/util/normalizePositions.js
@@ -11,7 +11,7 @@
 	Note: this method does not make a defensive copy of the array
 	it receives as argument. Instead, it adjusts the values in-place.
  */
-export default arr => {
+const normalizePositions = arr => {
 	// 1. fix up first/last position if missing
 	if (arr[0] === undefined) {
 		arr[0] = 0;
@@ -49,3 +49,5 @@ export default arr => {
 	}
 	return arr;
 };
+
+export default normalizePositions;
diff --git a/src/xyz/convertRgbToXyz.js b/src/xyz/convertRgbToXyz.js
index 9b284136..617d14a6 100644
--- a/src/xyz/convertRgbToXyz.js
+++ b/src/xyz/convertRgbToXyz.js
@@ -9,7 +9,7 @@
 
 import convertRgbToLrgb from '../lrgb/convertRgbToLrgb';
 
-export default rgb => {
+const convertRgbToXyz = rgb => {
 	let { r, g, b, alpha } = convertRgbToLrgb(rgb);
 	let res = {
 		mode: 'xyz',
@@ -22,3 +22,5 @@ export default rgb => {
 	}
 	return res;
 };
+
+export default convertRgbToXyz;
diff --git a/src/xyz/convertXyzToRgb.js b/src/xyz/convertXyzToRgb.js
index 79e60b17..b8a0aa94 100644
--- a/src/xyz/convertXyzToRgb.js
+++ b/src/xyz/convertXyzToRgb.js
@@ -8,7 +8,7 @@
 
 import convertLrgbToRgb from '../lrgb/convertLrgbToRgb';
 
-export default ({ x, y, z, alpha }) => {
+const convertXyzToRgb = ({ x, y, z, alpha }) => {
 	let res = convertLrgbToRgb({
 		r: x * 3.1338561 - y * 1.6168667 - 0.4906146 * z,
 		g: x * -0.9787684 + y * 1.9161415 + 0.033454 * z,
@@ -19,3 +19,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyzToRgb;
diff --git a/src/xyz/definition.js b/src/xyz/definition.js
index 05089b3b..f8dcfeda 100644
--- a/src/xyz/definition.js
+++ b/src/xyz/definition.js
@@ -10,23 +10,28 @@ import convertLabToXyz from '../lab/convertLabToXyz';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'xyz',
 	alias: ['xyz-d50'],
+
 	output: {
 		rgb: convertXyzToRgb,
 		lab: convertXyzToLab
 	},
+
 	input: {
 		rgb: convertRgbToXyz,
 		lab: convertLabToXyz
 	},
+
 	channels: ['x', 'y', 'z', 'alpha'],
+
 	ranges: {
 		x: [0, 0.962],
 		y: [0, 0.997],
 		z: [0, 0.823]
 	},
+
 	interpolate: {
 		x: interpolatorLinear,
 		y: interpolatorLinear,
@@ -34,3 +39,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/xyz65/convertRgbToXyz65.js b/src/xyz65/convertRgbToXyz65.js
index aad23f23..6752172b 100644
--- a/src/xyz65/convertRgbToXyz65.js
+++ b/src/xyz65/convertRgbToXyz65.js
@@ -8,7 +8,7 @@
 
 import convertRgbToLrgb from '../lrgb/convertRgbToLrgb';
 
-export default rgb => {
+const convertRgbToXyz65 = rgb => {
 	let { r, g, b, alpha } = convertRgbToLrgb(rgb);
 	let res = {
 		mode: 'xyz65',
@@ -21,3 +21,5 @@ export default rgb => {
 	}
 	return res;
 };
+
+export default convertRgbToXyz65;
diff --git a/src/xyz65/convertXyz65ToRgb.js b/src/xyz65/convertXyz65ToRgb.js
index 346070ed..a9a77969 100644
--- a/src/xyz65/convertXyz65ToRgb.js
+++ b/src/xyz65/convertXyz65ToRgb.js
@@ -8,7 +8,7 @@
 
 import convertLrgbToRgb from '../lrgb/convertLrgbToRgb';
 
-export default ({ x, y, z, alpha }) => {
+const convertXyz65ToRgb = ({ x, y, z, alpha }) => {
 	let res = convertLrgbToRgb({
 		r: x * 3.2404542 - y * 1.5371385 - 0.4985314 * z,
 		g: x * -0.969266 + y * 1.8760108 + 0.041556 * z,
@@ -19,3 +19,5 @@ export default ({ x, y, z, alpha }) => {
 	}
 	return res;
 };
+
+export default convertXyz65ToRgb;
diff --git a/src/xyz65/convertXyz65ToXyz.js b/src/xyz65/convertXyz65ToXyz.js
index fa447714..28095a47 100644
--- a/src/xyz65/convertXyz65ToXyz.js
+++ b/src/xyz65/convertXyz65ToXyz.js
@@ -7,7 +7,7 @@
 		* http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html	
 */
 
-export default xyz65 => {
+const convertXyz65ToXyz = xyz65 => {
 	let { x, y, z, alpha } = xyz65;
 	let res = {
 		mode: 'xyz',
@@ -20,3 +20,5 @@ export default xyz65 => {
 	}
 	return res;
 };
+
+export default convertXyz65ToXyz;
diff --git a/src/xyz65/convertXyzToXyz65.js b/src/xyz65/convertXyzToXyz65.js
index f464ed6b..4aef44b1 100644
--- a/src/xyz65/convertXyzToXyz65.js
+++ b/src/xyz65/convertXyzToXyz65.js
@@ -7,7 +7,7 @@
 		* http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html	
 */
 
-export default xyz => {
+const convertXyzToXyz65 = xyz => {
 	let { x, y, z, alpha } = xyz;
 	let res = {
 		mode: 'xyz65',
@@ -20,3 +20,5 @@ export default xyz => {
 	}
 	return res;
 };
+
+export default convertXyzToXyz65;
diff --git a/src/xyz65/definition.js b/src/xyz65/definition.js
index 11fd8705..c91f0c94 100644
--- a/src/xyz65/definition.js
+++ b/src/xyz65/definition.js
@@ -12,23 +12,28 @@ import convertXyzToXyz65 from './convertXyzToXyz65';
 import { interpolatorLinear } from '../interpolate/linear';
 import { fixupAlpha } from '../fixup/alpha';
 
-export default {
+const definition = {
 	mode: 'xyz65',
 	alias: ['xyz-d65'],
+
 	output: {
 		rgb: convertXyz65ToRgb,
 		xyz: convertXyz65ToXyz
 	},
+
 	input: {
 		rgb: convertRgbToXyz65,
 		xyz: convertXyzToXyz65
 	},
+
 	ranges: {
 		x: [0, 0.946],
 		y: [0, 0.995],
 		z: [0, 1.083]
 	},
+
 	channels: ['x', 'y', 'z', 'alpha'],
+
 	interpolate: {
 		x: interpolatorLinear,
 		y: interpolatorLinear,
@@ -36,3 +41,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;
diff --git a/src/yiq/convertRgbToYiq.js b/src/yiq/convertRgbToYiq.js
index 71e95db0..047b045a 100644
--- a/src/yiq/convertRgbToYiq.js
+++ b/src/yiq/convertRgbToYiq.js
@@ -1,6 +1,6 @@
 import convertRgbToLrgb from '../lrgb/convertRgbToLrgb';
 
-export default rgb => {
+const convertRgbToYiq = rgb => {
 	let { r, g, b, alpha } = convertRgbToLrgb(rgb);
 	let res = {
 		mode: 'yiq',
@@ -11,3 +11,5 @@ export default rgb => {
 	if (alpha !== undefined) res.alpha = alpha;
 	return res;
 };
+
+export default convertRgbToYiq;
diff --git a/src/yiq/convertYiqToRgb.js b/src/yiq/convertYiqToRgb.js
index d555363d..0f3a011d 100644
--- a/src/yiq/convertYiqToRgb.js
+++ b/src/yiq/convertYiqToRgb.js
@@ -1,9 +1,11 @@
 import convertLrgbToRgb from '../lrgb/convertLrgbToRgb';
 
-export default ({ y, i, q, alpha }) =>
+const convertYiqToRgb = ({ y, i, q, alpha }) =>
 	convertLrgbToRgb({
 		r: y + 0.95608445 * i + 0.6208885 * q,
 		g: y - 0.27137664 * i - 0.6486059 * q,
 		b: y - 1.10561724 * i + 1.70250126 * q,
 		alpha
 	});
+
+export default convertYiqToRgb;
diff --git a/src/yiq/definition.js b/src/yiq/definition.js
index d9e2083c..31605f52 100644
--- a/src/yiq/definition.js
+++ b/src/yiq/definition.js
@@ -23,19 +23,24 @@ import { fixupAlpha } from '../fixup/alpha';
 		http://www.progmat.uaem.mx:8080/artVol2Num2/Articulo3Vol2Num2.pdf
  */
 
-export default {
+const definition = {
 	mode: 'yiq',
+
 	output: {
 		rgb: convertYiqToRgb
 	},
+
 	input: {
 		rgb: convertRgbToYiq
 	},
+
 	channels: ['y', 'i', 'q', 'alpha'],
+
 	ranges: {
 		i: [-0.593, 0.593],
 		q: [-0.52, 0.52]
 	},
+
 	interpolate: {
 		y: interpolatorLinear,
 		i: interpolatorLinear,
@@ -43,3 +48,5 @@ export default {
 		alpha: { use: interpolatorLinear, fixup: fixupAlpha }
 	}
 };
+
+export default definition;