tinycolor2

tinycolor2 is a small, zero-dependency JavaScript library for parsing, converting, and manipulating colors. It accepts a wide range of loosely-formatted input — hex, RGB, RGBA, HSL, HSLA, HSV, HSVA, and CSS named colors — and exposes a chainable API for operations like lightening, darkening, desaturating, and spinning the hue, plus utilities for generating color combinations, checking WCAG readability, and picking the most readable color from a palette.

It has shipped essentially unchanged in API shape since 2011 and is widely used as a color-handling primitive underneath higher-level design-system and theming tools, thanks to its permissive parser and predictable, well-tested output formats.

What You Get

• A permissive parser that accepts hex (3/6/8-digit), RGB(A), HSL(A), HSV(A), CSS named colors, and plain objects as input
• Chainable manipulation methods — lighten, darken, brighten, desaturate, saturate, greyscale, spin, and setAlpha
• Format conversion and string output for every supported color space (toHex, toRgbString, toHslString, toHsvString, toName, toFilter, and more)
• Color combination generators — analogous, monochromatic, splitcomplement, triad, and tetrad palettes
• WCAG readability utilities — readability(), isReadable(), and mostReadable() for accessible color-pair selection
• Zero runtime dependencies and dual ESM/CJS builds published to npm

Common Use Cases

• Normalizing arbitrary user- or API-supplied color strings into a single consistent format before storing or rendering them
• Building theming or design-token systems that need to programmatically lighten/darken a base brand color for hover, active, or disabled states
• Checking foreground/background color pairs for WCAG contrast compliance in accessibility tooling
• Generating complementary or analogous color palettes for charts, avatars, or generative UI

Under The Hood

Architecture: The library is a single UMD module (tinycolor.js, ~1,200 lines after the Babel-transpiled build) wrapped around one constructor function, tinycolor(), that normalizes any accepted input through an internal inputToRGB → stringInputToObject pipeline into a canonical {r, g, b, a} representation stored on this. All public behavior — conversions, manipulations, combinations, readability checks — is implemented as prototype methods or static helpers layered on top of that single normalized state, so every method is a thin, composable wrapper around the same core RGB representation. The distributable files are generated from a single mod.js source via a Deno + Rollup + Babel build script (build.js) that emits matching UMD, CJS, and ESM bundles into npm/cjs and npm/esm.

Tech Stack: Runtime has zero dependencies — the entire library is dependency-free hand-written JavaScript. The build toolchain (Deno, Rollup, @rollup/plugin-babel, Terser) is dev-only and used solely to produce the UMD/CJS/ESM artifacts and a minified CDN bundle; it does not affect consumers. Package metadata (npm/package.json) declares module/main/browser/exports fields for correct resolution under both require and import.

Code Quality: test.js (2,174 lines) exercises parsing, every conversion method, every manipulation method, combination generators, and the readability utilities with concrete input/output assertions run via Deno’s test runner across both the CJS and ESM builds, so the two bundles are verified to behave identically. There is no TypeScript in the source itself (types are maintained separately via DefinitelyTyped), and there is no runtime input validation beyond the isValid() flag the constructor sets when parsing fails, but the test coverage of the parsing surface is unusually thorough given the size of the library.

API Design: The API is deliberately minimal and forgiving: a single factory function accepts almost any reasonable color representation without requiring exact formatting (commas, percent signs, and parentheses are all optional), and every mutating method returns this for chaining, e.g. tinycolor("red").lighten().desaturate().toHexString(). Method names mirror the color spaces and operations they represent one-to-one, keeping the surface predictable for anyone already familiar with basic color theory, and the README documents every method with a runnable example.