chromonym 2.0.0 → 3.0.0

package/NOTICE.md

@@ -51,6 +51,38 @@ color-library lookup that rounds it through sRGB loses information.
 If you need Pantone-certified color values, consult Pantone directly:
 <https://www.pantone.com/>.
 
+## Crayola®
+
+**Crayola®** is a registered trademark of **Crayola LLC**. Chromonym is
+**not affiliated with, endorsed by, licensed by, or certified by Crayola
+LLC**.
+
+The `crayola` palette in this library ships a **community-curated
+subset** of Crayola crayon-color names with sRGB approximations of their
+wrappers. The names are used as **nominative references** to publicly
+identified Crayola colors — there is no trademark claim, and no
+endorsement is implied. Hex values are derived from the widely-cited
+Wikipedia list of Crayola crayon colors (CC BY-SA), which itself cites
+Crayola's published approximations.
+
+### Scope
+
+The shipped set is ~85 entries — the current 64-standard box, the
+iconic fluorescent "Neon" range, and widely-recognized modern
+additions. It is not exhaustive: historical, retired, specialty-box
+(Gem Tones, Heads 'N Tails, Multicultural, etc.), and regional-variant
+colors are not included. If you need a specific Crayola color that
+isn't present, open an issue or define a BYO palette.
+
+### Accuracy
+
+- Fluorescents and neons saturate outside sRGB by design; on-screen
+  sRGB approximations are necessarily softer than the physical crayons.
+- Metallics (Silver, Gold, Copper) are flat sRGB approximations; the
+  physical crayons' reflective behavior is lost.
+- Classic hues are close enough for comparative UI / identification
+  work but should not be used as a reference for print color matching.
+
 ## X11 / X.Org
 
 The `x11` palette is derived from the X.Org `rgb.txt` file, which is in

package/README.md

@@ -20,7 +20,7 @@
   <code>identify</code> &nbsp;•&nbsp; <code>resolve</code> &nbsp;•&nbsp; <code>convert</code>
 </p>
 
-**The last color-naming library you'll ever need.** One API — `identify`, `resolve`, `convert` — works against any palette you throw at it. Ships CSS, X11, and Pantone out of the box; bring your own (brand colors, paint chips, game factions, chart themes) with full TypeScript inference and zero registration. Perceptual accuracy via six distance metrics. Tree-shakes to the bone — you only pay for palettes you import.
+**The last color-naming library you'll ever need.** One API — `identify`, `resolve`, `convert` — works against any palette you throw at it. Ships CSS, X11, Pantone, and Crayola out of the box; bring your own (brand colors, paint chips, game factions, chart themes) with full TypeScript inference and zero registration. Six distance metrics — from fast Euclidean to industry-standard CIEDE2000 and OKLAB. Tree-shakes to the bone — you only pay for palettes you import.
 
 <p align="center">
   <a href="https://simiancraft.github.io/chromonym/">
@@ -33,7 +33,7 @@ Because "it's sort of magenta-ish, maybe?" doesn't copy-paste into code — and
 For color *manipulation* (mixing, scales, gamut mapping), reach for [`chroma-js`](https://gka.github.io/chroma.js/) or [`color.js`](https://colorjs.io/) — chromonym is the tool for *naming*.
 
 ```ts
-import { identify, resolve, convert, pantone, type Palette } from 'chromonym';
+import { identify, resolve, convert, pantone, crayola, web, type Palette } from 'chromonym';
 
 // Your palette — defined inline, type-checked, no registration. Works the
 // same as the built-in ones because that's the whole point.
@@ -47,12 +47,16 @@ const brand = {
 identify('#ff2b3c', { palette: brand })         // 'acme red'
 resolve('Acme Ink', { palette: brand })         // '#0a0f2c'
 
-// Built-in palettes follow the identical shape — CSS, X11, Pantone out of the box.
+// Built-in palettes follow the identical shape — CSS, X11, Pantone, Crayola out of the box.
 identify('#ff8080')                                // 'lightcoral' (web is the default)
 identify('#663399')                                // 'rebeccapurple'
 identify('#E20074', { palette: pantone })       // '213 C' — T-Mobile magenta
+identify('#E20074', { palette: crayola })       // 'Razzmatazz' — the closest Crayon
 resolve('Pantone 185 C', { palette: pantone })  // '#e4002b'
 
+// Cross-palette in one call: parse input as a name from `source`, return nearest in `palette`.
+identify('rebeccapurple', { palette: pantone, source: web })  // '267 C'
+
 // Format conversion: HEX / RGB / RGBA / HSL / HSV (palette-free, tree-shakes cleanly)
 convert('#ff0000', { format: 'HSL' })              // 'hsl(0, 100%, 50%)'
 convert({ h: 120, s: 100, l: 50 }, { format: 'HEX' })  // '#00ff00'
@@ -76,67 +80,127 @@ yarn add chromonym
 npm install chromonym
 ```
 
+## Migrating from 1.x
+
+v2 collapsed the five-verb draft API (`identify`, `identifyAll`, `translate`, `resolve`, `convert`) into **three verbs** by folding the duplicates into options on existing verbs. Mechanical rewrites:
+
+```ts
+// v1 → v2
+identifyAll(color, { palette, k: 3 })          // → identify(color, { palette, k: 3 })
+translate(name, { from: web, to: pantone })    // → identify(name, { palette: pantone, source: web })
+```
+
+`resolve` and `convert` are unchanged. If you were only using those two, no edits are needed. See `CHANGELOG.md` for the full list of breaking changes.
+
 ## API
 
-Three primary functions. All accept an optional `opts` object; defaults fire when omitted.
+Three verbs. All accept an optional `opts` object; defaults fire when omitted.
+
+### Options × verbs, at a glance
+
+chromonym's API is deliberately tight: **three verbs, five options, no new nouns per feature**. Options earn their seat on each verb only where the semantics fit. Same-named options mean the same thing everywhere they appear.
+
+| | `identify` | `resolve` | `convert` |
+|---|:---:|:---:|:---:|
+| `palette` | ✓ target (default: `web`) | ✓ source (default: `web`) | ✓ optional — enables name I/O |
+| `source` | ✓ when input is a name from another palette | — (the palette *is* the source) | — |
+| `metric` | ✓ ΔE dispatch | — (no distance) | — (structural / exact-name only) |
+| `format` | — (returns a name) | ✓ output format | ✓ output format |
+| `k` | ✓ top-k (in the chosen metric's units) | ✓ fuzzy top-k by Levenshtein | ✗ — breaks strict-convert contract |
+
+No aliases, no plugin hooks. Every verb defaults to single-result / strict behavior; supplying `k` opts into the ranked-array return and (for `resolve`) the fuzzy-matching path.
 
 ### `identify(input, opts?)`
 
-**Color → name.** Finds the nearest-match name in the chosen palette using the selected perceptual distance metric.
+**Color (or palette name) → name.** Finds the nearest-match name in the chosen palette using the selected perceptual distance metric.
 
 ```ts
-function identify<C extends Palette = typeof web>(
-  input: ColorInput,
-  opts?: { palette?: C; metric?: DistanceMetric },
-): Extract<keyof C['colors'], string> | null
+// Simple case — single nearest name.
+function identify<P extends Palette = typeof web>(
+  input: ColorInput | string,
+  opts?: { palette?: P; source?: Palette; metric?: DistanceMetric },
+): Extract<keyof P['colors'], string> | null;
+
+// With `k` — ranked top-k matches with distances.
+function identify<P extends Palette = typeof web>(
+  input: ColorInput | string,
+  opts: { palette?: P; source?: Palette; metric?: DistanceMetric; k: number },
+): Array<{ name: Extract<keyof P['colors'], string>; value: HexColor; distance: number }>;
 ```
 
-- **Default palette**: the built-in `web` palette (148 entries, small — included if you call `identify` without a palette).
-- **Default metric**: read from the palette's own `defaultMetric` — `'deltaE76'` for web and x11 (well-separated palettes), `'deltaE2000'` for pantone (dense, perceptually-packed). Override freely via `metric`.
-- Returns the matched name, or `null` if input is unrecognized (`detectFormat` returns `'UNKNOWN'`).
-- Return type is inferred from the palette's `colors` keys — so passing `{ palette: pantone }` narrows to `PantoneColorName | null`, and a BYO palette with a literal key union narrows to that union.
-- Ties go to whichever color was defined first — deterministic across runs, but not semantically meaningful.
+- **`palette`** — target (default: `web`). The palette to search in.
+- **`source`** — when `input` is a string that isn't structurally a color (hex / rgb / hsl / …), parse it as a name in this palette. Enables cross-palette lookups in one verb. Structural inputs always parse structurally even when `source` is set.
+- **`metric`** — distance metric for the nearest-match step. Defaults to the target palette's own `defaultMetric`.
+- **`k`** — when present, return the top-k matches sorted ascending by distance. Return type flips from `Name | null` to `Array<Match>`; each `Match` carries `{ name, value, distance }`. `value` is the palette's stored hex for rendering swatches; `distance` is in the metric's natural units (ΔE units for all `deltaE*` metrics, channel-unit Euclidean for the others).
+- Returns `null` / `[]` when the input can't be parsed. Ties go to whichever color was defined first in the palette.
 
 ```ts
-import { identify, pantone, x11 } from 'chromonym';
-
-identify('#ff0000')                               // 'red' (web default)
-identify([255, 0, 0])                             // 'red'
-identify({ r: 250, g: 20, b: 60 })                // 'crimson' (nearest)
-identify('#ff0000', { palette: x11 })             // 'red' (x11 also has 'red 1' through 'red 4')
-identify('#e4002b', { palette: pantone })         // '185 C' (exact match — Target/Coca-Cola red)
-identify('#ff0000', { palette: pantone })         // '172 C' (nearest — pure red isn't a Pantone)
-identify('#ff0080', { metric: 'deltaE2000' })     // force perceptual-accurate match
-identify('#ff0000', { metric: 'euclidean-srgb' }) // force fastest (non-perceptual) match
+import { identify, pantone, x11, web, crayola } from 'chromonym';
+
+// Classic color → name
+identify('#ff0000')                                                 // 'red' (web default)
+identify({ r: 250, g: 20, b: 60 })                                  // 'crimson' (nearest)
+identify('#e4002b', { palette: pantone })                           // '185 C' (exact match)
+identify('#ff0000', { palette: pantone })                           // '172 C' (nearest — pure red isn't a Pantone)
+
+// Cross-palette: parse input as a name in `source`, match in `palette`
+identify('rebeccapurple', { palette: pantone, source: web })        // '267 C'
+identify('Razzmatazz',    { palette: pantone, source: crayola })    // '213 C' (same family as T-Mobile magenta)
+identify('dodgerblue',    { palette: x11, source: web })            // 'dodger blue' (shared hex)
+
+// Top-k matches with ΔE distances — powers "did you mean" UIs
+identify('#ff4488', { palette: crayola, k: 3 })
+// [
+//   { name: 'Violet Red',      value: '#f75394', distance: 0.0251 },
+//   { name: 'Wild Watermelon', value: '#fc6c85', distance: 0.0682 },
+//   { name: 'Cerise',          value: '#dd4492', distance: 0.0685 },
+// ]
 ```
 
 ### `resolve(name, opts?)`
 
-**Name → color.** Normalizes the input (lowercases it, strips all non-alphanumeric characters), looks up the canonical key in the chosen palette, and returns the value in the chosen format.
+**Name → color.** Normalizes the input, looks up the canonical key in the chosen palette, and returns the value in the chosen format. With `k`, switches to fuzzy matching via Levenshtein edit distance — perfect for user-typed input where typos, casing, and punctuation vary.
 
 ```ts
+// Strict — exact match via normalizer.
 function resolve(
   name: string,
   opts?: { palette?: Palette; format?: ColorFormat },
-): ColorValue | null
+): ColorValue | null;
+
+// Fuzzy top-k via Levenshtein edit distance.
+function resolve<P extends Palette = typeof web>(
+  name: string,
+  opts: { palette?: P; format?: ColorFormat; k: number },
+): Array<{ name: Extract<keyof P['colors'], string>; value: ColorValue; distance: number }>;
 ```
 
-- **Default palette**: the built-in `web` palette.
-- **Default format**: `'HEX'`.
-- Returns `null` if the normalized name isn't in the palette.
-- Normalization is the palette's own `normalize` function — web/x11 lowercase + strip non-alphanumeric, pantone also strips a `Pantone` / `PMS` prefix. So `'Alice Blue'`, `'alice-blue'`, `'ALICEBLUE'`, `'Pantone 185 C'` all resolve identically in their respective palettes.
+- **`palette`** — source (default: `web`). The palette to look the name up in.
+- **`format`** — output format (default: `'HEX'`). Affects both the strict return and the `value` field in each fuzzy `Match`.
+- **`k`** — when present, bypass strict lookup and do fuzzy top-k. `distance` is the Levenshtein edit count against the palette's normalized key. Strict exact matches have distance `0`.
+- Normalization is always the palette's own `normalize` function, applied to both the input and the keys before comparison. So `'Alice Blue'`, `'alice-blue'`, `'ALICEBLUE'`, `'Pantone 185 C'` all resolve identically in their respective palettes — strict mode uses normalization to reach exact match; fuzzy mode uses it as the input to the edit-distance ranking.
 
 ```ts
-import { resolve, pantone } from 'chromonym';
+import { resolve, pantone, crayola } from 'chromonym';
 
+// Strict (default) — exact match or null
 resolve('crimson')                                 // '#dc143c'
 resolve('Alice Blue')                              // '#f0f8ff'
 resolve('alice-blue!')                             // '#f0f8ff'
-resolve('185 C', { palette: pantone })          // '#e4002b'
-resolve('Pantone 185 C', { palette: pantone })  // '#e4002b' (same, normalized)
+resolve('185 C', { palette: pantone })             // '#e4002b'
+resolve('Pantone 185 C', { palette: pantone })     // '#e4002b' (same, normalized)
 resolve('crimson', { format: 'RGB' })              // 'rgb(220, 20, 60)'
-resolve('crimson', { format: 'RGBA' })             // { r: 220, g: 20, b: 60, a: 1 }
 resolve('not-a-color')                             // null
+
+// Fuzzy — typo-tolerant user input
+resolve('rebecapurple', { palette: web, k: 3 })
+// [
+//   { name: 'rebeccapurple', value: '#663399', distance: 1 },
+//   { name: 'mediumpurple',  value: '#9370db', distance: 5 },
+//   { name: 'purple',        value: '#800080', distance: 6 },
+// ]
+resolve('Razmataz', { palette: crayola, k: 1 })
+// [{ name: 'Razzmatazz', value: '#e3256b', distance: 2 }]
 ```
 
 ### `convert(input, opts?)`
@@ -233,72 +297,74 @@ resolve('Nurgle Green', { palette: warhammer })
 // → '#748c3f'           (your normalizer handles case + punctuation)
 ```
 
-### The three we ship
+### The four we ship
 
 | Name | Entries | Source |
 |---|---|---|
 | `web` (default) | 148 | CSS Color Module Level 4 named colors |
 | `x11` | 658 | X.Org `rgb.txt` (public domain) |
 | `pantone` | 907 | Pantone Coated (C) — community approximations (not Pantone-licensed) |
+| `crayola` | ~85 | Crayola crayon colors — community approximations (not Crayola-licensed) |
 
 Importable directly, or via subpath exports for stricter tree-shaking:
 
 ```ts
-import { web, x11, pantone } from 'chromonym';
+import { web, x11, pantone, crayola } from 'chromonym';
 // or:  import { pantone } from 'chromonym/pantone';
 
 web.colors.crimson               // '#dc143c'
-web.colors.aliceblue             // '#f0f8ff'   (CSS keyword form — paste-compatible)
+web.colors.aliceblue             // '#f0f8ff'     (CSS keyword form — paste-compatible)
 pantone.colors['185 C']          // '#e4002b'
+crayola.colors.Razzmatazz        // '#e3256b'
+crayola.colors['Granny Smith Apple']  // '#a8e4a0'
 ```
 
-Each palette's keys follow its own domain convention — so `identify`'s output pastes back into whatever ecosystem the name came from. `web` uses the CSS spec's single-word form (`rebeccapurple`), `x11` uses the X.Org docs' spaced form (`'antique white 1'`), `pantone` uses the official print notation (`'185 C'`).
+Each palette's keys follow its own domain convention — so `identify`'s output pastes back into whatever ecosystem the name came from. `web` uses the CSS spec's single-word form (`rebeccapurple`), `x11` uses the X.Org docs' spaced form (`'antique white 1'`), `pantone` uses the official print notation (`'185 C'`), `crayola` uses the Title Case form printed on the crayon wrapper (`'Granny Smith Apple'`).
 
 *Trivia:* `web.colors.rebeccapurple` (`#663399`) entered CSS Color 4 in 2014 in memory of [Rebecca Meyer](https://meyerweb.com/eric/thoughts/2014/06/19/rebeccapurple/). The X11 set ships every gray name twice (`gray`, `grey`) plus numbered variants up to 99, so `x11.colors['gray 73']` is a real key (`#bababa`). Yes, these are Greys. No, not the kind that visit during sleep paralysis.
 
 ### Cross-palette translation
 
-"What's this CSS color in X11?" / "What's our brand red in Pantone?" is a *nearest-match* question — palettes almost never share exact hex values, so there's no strict round-trip. That's `identify`'s job. Chain `convert` (strict name → hex) with `identify` (fuzzy hex → nearest name):
+"What's this CSS color in X11?" / "What's our brand red in Pantone?" is a *nearest-match* question — palettes almost never share exact hex values, so there's no strict round-trip. `identify` handles it directly via `source`: parse the input as a name from one palette, return the nearest name from another.
 
 ```ts
-import { convert, identify, web, x11, pantone } from 'chromonym';
-
-// web → x11
-identify(convert('rebeccapurple', { palette: web }), { palette: x11 })
-// → 'dark orchid 4'
-
-identify(convert('dodgerblue', { palette: web }), { palette: x11 })
-// → 'dodger blue'   (hex shared across both palettes — exact hit)
-
-// x11 → pantone
-identify(convert('dark slate gray 4', { palette: x11 }), { palette: pantone })
-// → '5483 C'
-
-identify(convert('debian red', { palette: x11 }), { palette: pantone })
-// → '1925 C'
-
-// web → pantone  (the classic brand-matching case)
-identify(convert('hotpink', { palette: web }), { palette: pantone })        // → '812 C'
-identify(convert('dodgerblue', { palette: web }), { palette: pantone })     // → '279 C'
-
-// BYO → pantone  (ship your brand palette, find the closest Pantone for print)
-identify(convert('acme red', { palette: brand }), { palette: pantone })     // → '1788 C'
-
-// Override the metric for the *nearest-match* leg if you want — input parsing
-// is always exact, so only the second call takes `metric`.
-identify(convert('rebeccapurple', { palette: web }), { palette: pantone, metric: 'deltaEok' })
-// → '526 C'  (OKLAB disagrees with ΔE2000's '267 C' in the saturated-purple region)
+import { identify, web, x11, pantone, crayola } from 'chromonym';
+
+// Name in one palette → nearest name in another.
+identify('rebeccapurple',    { palette: x11,     source: web })      // 'dark orchid 4'
+identify('dodgerblue',       { palette: x11,     source: web })      // 'dodger blue' (shared hex)
+identify('dark slate gray 4',{ palette: pantone, source: x11 })      // '5483 C'
+identify('hotpink',          { palette: pantone, source: web })      // '812 C'
+identify('Razzmatazz',       { palette: pantone, source: crayola })  // '213 C' (same family as T-Mobile magenta)
+identify('Razzmatazz',       { palette: web,     source: crayola })  // 'deeppink'
+identify('hotpink',          { palette: crayola, source: web })      // 'Violet Red'
+identify('forestgreen',      { palette: crayola, source: web })      // 'Green'
+
+// BYO works on either side — ship your brand palette, find the closest Pantone for print.
+identify('acme red', { palette: pantone, source: brand })            // '1788 C'
+
+// Override the metric for the nearest-match side.
+identify('rebeccapurple', { palette: pantone, source: web, metric: 'deltaEok' })
+// '526 C'  (OKLAB disagrees with ΔE2000's '267 C' in the saturated-purple region)
+
+// Top-k across palettes — what are the three closest Pantones to CSS "hotpink"?
+identify('hotpink', { palette: pantone, source: web, k: 3 })
+// [
+//   { name: '812 C', value: '#ff5fa2', distance: 3.56 },
+//   { name: '211 C', value: '#f57eb6', distance: 3.95 },
+//   { name: '218 C', value: '#e56db1', distance: 4.30 },
+// ]
 ```
 
-Why two calls instead of one: `convert` is the strict verb (throws on a name miss), `identify` is the fuzzy one (always returns a nearest). Keeping them separate lets you decide — per call — whether you want a hard error on an unknown input or a best-effort neighbor.
-
-If this chain shows up often in your code, wrap it in your own helper:
+If you want the underlying chain — keeping the intermediate hex, or using `convert`'s strict throw-on-miss behavior for unknown source names — `identify(convert(…))` still works:
 
 ```ts
-const translate = (name: string, from: Palette, to: Palette) =>
-  identify(convert(name, { palette: from }), { palette: to });
+const hex = convert('rebeccapurple', { palette: web });   // '#663399' (throws on miss)
+const near = identify(hex, { palette: pantone });         // '267 C'
 ```
 
+Rule of thumb: use `source` when you want one clean call and `null` on miss; use the chain when you want to inspect the intermediate hex or trigger a loud failure on unknown source names.
+
 ## Distance metrics
 
 *Six ways to ask "how different are two colors?"*
@@ -309,7 +375,7 @@ const translate = (name: string, from: Palette, to: Palette) =>
 |---|---|---|
 | `'euclidean-srgb'` | Raw `sqrt(Δr² + Δg² + Δb²)` in sRGB. Fastest. Not perceptually uniform — a unit of distance doesn't mean a unit of "visual difference." | Tight perf budgets; well-separated palettes where you just need the obvious answer. |
 | `'euclidean-linear'` | Same math, but on linearized (gamma-removed) RGB. Somewhat better in dark regions. Still not perceptual. | Physical-light mixing contexts; incremental upgrade from sRGB Euclidean. |
-| `'deltaE76'` | Euclidean in CIELAB (CIE 1976). Simple perceptual metric. 1 ΔE ≈ "just noticeable difference" for most of the gamut. | **Default for web and x11.** Meaningful perceptual accuracy at low cost. |
+| `'deltaE76'` | Euclidean in CIELAB (CIE 1976). Simple perceptual metric. 1 ΔE is often cited as roughly a just-noticeable difference, though uniformity breaks down in saturated blues/purples — which is the reason ΔE2000 exists. | **Default for web and x11.** Meaningful perceptual accuracy at low cost. |
 | `'deltaE94'` | ΔE76 + chroma/hue weighting (CIE 1994). Fixes "saturated colors feel too far apart." | When ΔE76 is over-penalizing saturated matches in your use case. |
 | `'deltaE2000'` | Full CIEDE2000 formula with blue/purple rotation correction. Industry standard for print, design tools, Pantone workflows. | **Default for pantone.** Use whenever accuracy matters, especially in the blue region where ΔE76/94 break down. |
 | `'deltaEok'` | Euclidean distance in OKLAB (Björn Ottosson, 2020). OKLAB is perceptually uniform by construction — no weighting formula needed. Strictly more uniform than CIELAB; often a better nearest-match than ΔE2000 in saturated-blue regions, and cheaper to compute. | Use when you want perceptual accuracy without the CIEDE2000 rotation-term complexity. |

package/dist/identify.d.ts

@@ -1,25 +1,50 @@
 import { web } from './palettes/web.js';
-import type { ColorInput, DistanceMetric, Palette } from './types.js';
+import type { ColorInput, DistanceMetric, HexColor, Palette } from './types.js';
 /** Extract string keys from a Palette's `colors` map. */
 type PaletteKey<P extends Palette> = Extract<keyof P['colors'], string>;
 /**
- * Identify the nearest-named color for any color input.
+ * One ranked nearest-match entry when `identify` is called with `k`.
+ * `value` is the palette's stored hex for the match (useful for rendering
+ * swatches). `distance` is in the selected metric's natural units — ΔE
+ * for `deltaE*` metrics, channel-unit Euclidean for the others.
+ */
+export type IdentifyMatch<Name extends string> = {
+    readonly name: Name;
+    readonly value: HexColor;
+    readonly distance: number;
+};
+/**
+ * Identify the nearest-named color for any color input (or palette name
+ * from another palette via `source`).
+ *
+ * **Simple case — color in, name out:**
+ *   identify('#ff0000')                           → 'red'
+ *   identify('#ff0000', { palette: pantone })     → '172 C'
  *
- * The distance metric defaults to the palette's own `defaultMetric`
- * (web/x11: `deltaE76`, pantone: `deltaE2000`). Override with the `metric`
- * option — e.g. `{ metric: 'euclidean-srgb' }` for maximum speed, or
- * `{ metric: 'deltaE2000' }` for strictest perceptual accuracy.
+ * **Cross-palette — name from one palette, nearest in another:**
+ *   identify('rebeccapurple', { palette: pantone, source: web })  → '267 C'
+ *   identify('Razzmatazz',    { palette: pantone, source: crayola }) → '213 C'
  *
- * Returns `null` if the input isn't a recognized color shape.
+ * **Top-k ranked matches with ΔE distances:**
+ *   identify('#ff0000', { palette: pantone, k: 3 })
+ *   // [{ name: '172 C', value: '#fa4616', distance: 3.2 }, ...]
  *
- * Defaults: palette = `web`.
+ * The distance metric defaults to the target palette's `defaultMetric`
+ * (web/x11: `deltaE76`, pantone: `deltaE2000`, crayola: `deltaEok`).
+ * Override with `metric`.
  *
- * BYO palettes: pass any object matching `Palette<Name>` and the
- * return type is inferred from its `colors` keys — no registration needed.
+ * Returns `null` (or `[]` when `k` is set) if the input can't be parsed.
  */
-export declare function identify<P extends Palette = typeof web>(input: ColorInput, opts?: {
+export declare function identify<P extends Palette = typeof web>(input: ColorInput | string, opts?: {
     palette?: P;
+    source?: Palette;
     metric?: DistanceMetric;
 }): PaletteKey<P> | null;
+export declare function identify<P extends Palette = typeof web>(input: ColorInput | string, opts: {
+    palette?: P;
+    source?: Palette;
+    metric?: DistanceMetric;
+    k: number;
+}): Array<IdentifyMatch<PaletteKey<P>>>;
 export {};
 //# sourceMappingURL=identify.d.ts.map

package/dist/identify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identify.d.ts","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEtE,yDAAyD;AACzD,KAAK,UAAU,CAAC,CAAC,SAAS,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,GAAG,EACrD,KAAK,EAAE,UAAU,EACjB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,cAAc,CAAA;CAAO,GAClD,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAQtB","sourcesContent":["import { toRgba } from './convert.js';\nimport { detectFormat } from './detectFormat.js';\nimport { nearest } from './indexing.js';\nimport { web } from './palettes/web.js';\nimport type { ColorInput, DistanceMetric, Palette } from './types.js';\n\n/** Extract string keys from a Palette's `colors` map. */\ntype PaletteKey<P extends Palette> = Extract<keyof P['colors'], string>;\n\n/**\n * Identify the nearest-named color for any color input.\n *\n * The distance metric defaults to the palette's own `defaultMetric`\n * (web/x11: `deltaE76`, pantone: `deltaE2000`). Override with the `metric`\n * option — e.g. `{ metric: 'euclidean-srgb' }` for maximum speed, or\n * `{ metric: 'deltaE2000' }` for strictest perceptual accuracy.\n *\n * Returns `null` if the input isn't a recognized color shape.\n *\n * Defaults: palette = `web`.\n *\n * BYO palettes: pass any object matching `Palette<Name>` and the\n * return type is inferred from its `colors` keys — no registration needed.\n */\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput,\n  opts: { palette?: P; metric?: DistanceMetric } = {},\n): PaletteKey<P> | null {\n  const format = detectFormat(input);\n  if (format === 'UNKNOWN') return null;\n\n  const palette = (opts.palette ?? web) as P;\n  const rgba = toRgba(input, format);\n  const name = nearest(rgba, palette, opts.metric ?? palette.defaultMetric);\n  return (name as PaletteKey<P>) || null;\n}\n"]}
+{"version":3,"file":"identify.d.ts","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAQ,MAAM,YAAY,CAAC;AAEtF,yDAAyD;AACzD,KAAK,UAAU,CAAC,CAAC,SAAS,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,IAAI,SAAS,MAAM,IAAI;IAC/C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAmBF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,GAAG,EACrD,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,cAAc,CAAA;CAAE,GAChE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAGxB,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,GAAG,EACrD,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,IAAI,EAAE;IAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1E,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC","sourcesContent":["import { hexToRgba } from './conversions/hex.js';\nimport { toRgba } from './convert.js';\nimport { detectFormat } from './detectFormat.js';\nimport { getNameIndex, nearest, nearestAll } from './indexing.js';\nimport { web } from './palettes/web.js';\nimport type { ColorInput, DistanceMetric, HexColor, Palette, Rgba } from './types.js';\n\n/** Extract string keys from a Palette's `colors` map. */\ntype PaletteKey<P extends Palette> = Extract<keyof P['colors'], string>;\n\n/**\n * One ranked nearest-match entry when `identify` is called with `k`.\n * `value` is the palette's stored hex for the match (useful for rendering\n * swatches). `distance` is in the selected metric's natural units — ΔE\n * for `deltaE*` metrics, channel-unit Euclidean for the others.\n */\nexport type IdentifyMatch<Name extends string> = {\n  readonly name: Name;\n  readonly value: HexColor;\n  readonly distance: number;\n};\n\n/**\n * Parse a string input that may be a color literal or a palette name.\n * Returns the canonical Rgba, or `null` if nothing matches.\n */\nfunction parseInput(input: ColorInput | string, source?: Palette): Rgba | null {\n  const detected = detectFormat(input as ColorInput);\n  if (detected !== 'UNKNOWN') return toRgba(input as ColorInput, detected);\n  if (source !== undefined && typeof input === 'string') {\n    const canonical = getNameIndex(source).get(source.normalize(input));\n    if (canonical === undefined) return null;\n    const hex = (source.colors as Record<string, HexColor>)[canonical];\n    if (hex === undefined) return null;\n    return hexToRgba(hex);\n  }\n  return null;\n}\n\n/**\n * Identify the nearest-named color for any color input (or palette name\n * from another palette via `source`).\n *\n * **Simple case — color in, name out:**\n *   identify('#ff0000')                           → 'red'\n *   identify('#ff0000', { palette: pantone })     → '172 C'\n *\n * **Cross-palette — name from one palette, nearest in another:**\n *   identify('rebeccapurple', { palette: pantone, source: web })  → '267 C'\n *   identify('Razzmatazz',    { palette: pantone, source: crayola }) → '213 C'\n *\n * **Top-k ranked matches with ΔE distances:**\n *   identify('#ff0000', { palette: pantone, k: 3 })\n *   // [{ name: '172 C', value: '#fa4616', distance: 3.2 }, ...]\n *\n * The distance metric defaults to the target palette's `defaultMetric`\n * (web/x11: `deltaE76`, pantone: `deltaE2000`, crayola: `deltaEok`).\n * Override with `metric`.\n *\n * Returns `null` (or `[]` when `k` is set) if the input can't be parsed.\n */\n\n// Overload 1: no `k` — single name (or null). Unchanged legacy shape.\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput | string,\n  opts?: { palette?: P; source?: Palette; metric?: DistanceMetric },\n): PaletteKey<P> | null;\n\n// Overload 2: `k` present — ranked Match[] with distances.\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput | string,\n  opts: { palette?: P; source?: Palette; metric?: DistanceMetric; k: number },\n): Array<IdentifyMatch<PaletteKey<P>>>;\n\n// Implementation.\nexport function identify(\n  input: ColorInput | string,\n  opts: { palette?: Palette; source?: Palette; metric?: DistanceMetric; k?: number } = {},\n): string | null | Array<IdentifyMatch<string>> {\n  const palette = opts.palette ?? web;\n  const metric = opts.metric ?? palette.defaultMetric;\n  const rgba = parseInput(input, opts.source);\n\n  if (opts.k !== undefined) {\n    if (rgba === null) return [];\n    const raw = nearestAll(rgba, palette, metric, opts.k);\n    return raw.map((m) => {\n      const value = (palette.colors as Record<string, HexColor>)[m.name];\n      return { name: m.name, value: value as HexColor, distance: m.distance };\n    });\n  }\n\n  if (rgba === null) return null;\n  const name = nearest(rgba, palette, metric);\n  return name || null;\n}\n"]}

package/dist/identify.js

@@ -1,29 +1,44 @@
+import { hexToRgba } from './conversions/hex.js';
 import { toRgba } from './convert.js';
 import { detectFormat } from './detectFormat.js';
-import { nearest } from './indexing.js';
+import { getNameIndex, nearest, nearestAll } from './indexing.js';
 import { web } from './palettes/web.js';
 /**
- * Identify the nearest-named color for any color input.
- *
- * The distance metric defaults to the palette's own `defaultMetric`
- * (web/x11: `deltaE76`, pantone: `deltaE2000`). Override with the `metric`
- * option — e.g. `{ metric: 'euclidean-srgb' }` for maximum speed, or
- * `{ metric: 'deltaE2000' }` for strictest perceptual accuracy.
- *
- * Returns `null` if the input isn't a recognized color shape.
- *
- * Defaults: palette = `web`.
- *
- * BYO palettes: pass any object matching `Palette<Name>` and the
- * return type is inferred from its `colors` keys — no registration needed.
+ * Parse a string input that may be a color literal or a palette name.
+ * Returns the canonical Rgba, or `null` if nothing matches.
  */
+function parseInput(input, source) {
+    const detected = detectFormat(input);
+    if (detected !== 'UNKNOWN')
+        return toRgba(input, detected);
+    if (source !== undefined && typeof input === 'string') {
+        const canonical = getNameIndex(source).get(source.normalize(input));
+        if (canonical === undefined)
+            return null;
+        const hex = source.colors[canonical];
+        if (hex === undefined)
+            return null;
+        return hexToRgba(hex);
+    }
+    return null;
+}
+// Implementation.
 export function identify(input, opts = {}) {
-    const format = detectFormat(input);
-    if (format === 'UNKNOWN')
+    const palette = opts.palette ?? web;
+    const metric = opts.metric ?? palette.defaultMetric;
+    const rgba = parseInput(input, opts.source);
+    if (opts.k !== undefined) {
+        if (rgba === null)
+            return [];
+        const raw = nearestAll(rgba, palette, metric, opts.k);
+        return raw.map((m) => {
+            const value = palette.colors[m.name];
+            return { name: m.name, value: value, distance: m.distance };
+        });
+    }
+    if (rgba === null)
         return null;
-    const palette = (opts.palette ?? web);
-    const rgba = toRgba(input, format);
-    const name = nearest(rgba, palette, opts.metric ?? palette.defaultMetric);
+    const name = nearest(rgba, palette, metric);
     return name || null;
 }
 //# sourceMappingURL=identify.js.map

package/dist/identify.js.map

@@ -1 +1 @@
-{"version":3,"file":"identify.js","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAMxC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAiB,EACjB,IAAI,GAA6C,EAAE;IAEnD,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAEtC,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,GAAG,CAAM,CAAC;IAC3C,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAC1E,OAAQ,IAAsB,IAAI,IAAI,CAAC;AACzC,CAAC","sourcesContent":["import { toRgba } from './convert.js';\nimport { detectFormat } from './detectFormat.js';\nimport { nearest } from './indexing.js';\nimport { web } from './palettes/web.js';\nimport type { ColorInput, DistanceMetric, Palette } from './types.js';\n\n/** Extract string keys from a Palette's `colors` map. */\ntype PaletteKey<P extends Palette> = Extract<keyof P['colors'], string>;\n\n/**\n * Identify the nearest-named color for any color input.\n *\n * The distance metric defaults to the palette's own `defaultMetric`\n * (web/x11: `deltaE76`, pantone: `deltaE2000`). Override with the `metric`\n * option — e.g. `{ metric: 'euclidean-srgb' }` for maximum speed, or\n * `{ metric: 'deltaE2000' }` for strictest perceptual accuracy.\n *\n * Returns `null` if the input isn't a recognized color shape.\n *\n * Defaults: palette = `web`.\n *\n * BYO palettes: pass any object matching `Palette<Name>` and the\n * return type is inferred from its `colors` keys — no registration needed.\n */\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput,\n  opts: { palette?: P; metric?: DistanceMetric } = {},\n): PaletteKey<P> | null {\n  const format = detectFormat(input);\n  if (format === 'UNKNOWN') return null;\n\n  const palette = (opts.palette ?? web) as P;\n  const rgba = toRgba(input, format);\n  const name = nearest(rgba, palette, opts.metric ?? palette.defaultMetric);\n  return (name as PaletteKey<P>) || null;\n}\n"]}
+{"version":3,"file":"identify.js","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAkBxC;;;GAGG;AACH,SAAS,UAAU,CAAC,KAA0B,EAAE,MAAgB;IAC9D,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAmB,CAAC,CAAC;IACnD,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC,KAAmB,EAAE,QAAQ,CAAC,CAAC;IACzE,IAAI,MAAM,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACtD,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QACpE,IAAI,SAAS,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACzC,MAAM,GAAG,GAAI,MAAM,CAAC,MAAmC,CAAC,SAAS,CAAC,CAAC;QACnE,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACnC,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAqCD,kBAAkB;AAClB,MAAM,UAAU,QAAQ,CACtB,KAA0B,EAC1B,IAAI,GAAiF,EAAE;IAEvF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;IACpC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC;IACpD,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAE5C,IAAI,IAAI,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACzB,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QACtD,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACnB,MAAM,KAAK,GAAI,OAAO,CAAC,MAAmC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACnE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,KAAiB,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC1E,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC/B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,OAAO,IAAI,IAAI,IAAI,CAAC;AACtB,CAAC","sourcesContent":["import { hexToRgba } from './conversions/hex.js';\nimport { toRgba } from './convert.js';\nimport { detectFormat } from './detectFormat.js';\nimport { getNameIndex, nearest, nearestAll } from './indexing.js';\nimport { web } from './palettes/web.js';\nimport type { ColorInput, DistanceMetric, HexColor, Palette, Rgba } from './types.js';\n\n/** Extract string keys from a Palette's `colors` map. */\ntype PaletteKey<P extends Palette> = Extract<keyof P['colors'], string>;\n\n/**\n * One ranked nearest-match entry when `identify` is called with `k`.\n * `value` is the palette's stored hex for the match (useful for rendering\n * swatches). `distance` is in the selected metric's natural units — ΔE\n * for `deltaE*` metrics, channel-unit Euclidean for the others.\n */\nexport type IdentifyMatch<Name extends string> = {\n  readonly name: Name;\n  readonly value: HexColor;\n  readonly distance: number;\n};\n\n/**\n * Parse a string input that may be a color literal or a palette name.\n * Returns the canonical Rgba, or `null` if nothing matches.\n */\nfunction parseInput(input: ColorInput | string, source?: Palette): Rgba | null {\n  const detected = detectFormat(input as ColorInput);\n  if (detected !== 'UNKNOWN') return toRgba(input as ColorInput, detected);\n  if (source !== undefined && typeof input === 'string') {\n    const canonical = getNameIndex(source).get(source.normalize(input));\n    if (canonical === undefined) return null;\n    const hex = (source.colors as Record<string, HexColor>)[canonical];\n    if (hex === undefined) return null;\n    return hexToRgba(hex);\n  }\n  return null;\n}\n\n/**\n * Identify the nearest-named color for any color input (or palette name\n * from another palette via `source`).\n *\n * **Simple case — color in, name out:**\n *   identify('#ff0000')                           → 'red'\n *   identify('#ff0000', { palette: pantone })     → '172 C'\n *\n * **Cross-palette — name from one palette, nearest in another:**\n *   identify('rebeccapurple', { palette: pantone, source: web })  → '267 C'\n *   identify('Razzmatazz',    { palette: pantone, source: crayola }) → '213 C'\n *\n * **Top-k ranked matches with ΔE distances:**\n *   identify('#ff0000', { palette: pantone, k: 3 })\n *   // [{ name: '172 C', value: '#fa4616', distance: 3.2 }, ...]\n *\n * The distance metric defaults to the target palette's `defaultMetric`\n * (web/x11: `deltaE76`, pantone: `deltaE2000`, crayola: `deltaEok`).\n * Override with `metric`.\n *\n * Returns `null` (or `[]` when `k` is set) if the input can't be parsed.\n */\n\n// Overload 1: no `k` — single name (or null). Unchanged legacy shape.\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput | string,\n  opts?: { palette?: P; source?: Palette; metric?: DistanceMetric },\n): PaletteKey<P> | null;\n\n// Overload 2: `k` present — ranked Match[] with distances.\nexport function identify<P extends Palette = typeof web>(\n  input: ColorInput | string,\n  opts: { palette?: P; source?: Palette; metric?: DistanceMetric; k: number },\n): Array<IdentifyMatch<PaletteKey<P>>>;\n\n// Implementation.\nexport function identify(\n  input: ColorInput | string,\n  opts: { palette?: Palette; source?: Palette; metric?: DistanceMetric; k?: number } = {},\n): string | null | Array<IdentifyMatch<string>> {\n  const palette = opts.palette ?? web;\n  const metric = opts.metric ?? palette.defaultMetric;\n  const rgba = parseInput(input, opts.source);\n\n  if (opts.k !== undefined) {\n    if (rgba === null) return [];\n    const raw = nearestAll(rgba, palette, metric, opts.k);\n    return raw.map((m) => {\n      const value = (palette.colors as Record<string, HexColor>)[m.name];\n      return { name: m.name, value: value as HexColor, distance: m.distance };\n    });\n  }\n\n  if (rgba === null) return null;\n  const name = nearest(rgba, palette, metric);\n  return name || null;\n}\n"]}

package/dist/index.d.ts

@@ -5,11 +5,12 @@ export { pantoneToRgba, rgbaToPantone } from './conversions/pantone.js';
 export { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';
 export { convert, fromRgba, toRgba } from './convert.js';
 export { type DetectedFormat, detectFormat, isColor } from './detectFormat.js';
-export { identify } from './identify.js';
+export { type IdentifyMatch, identify } from './identify.js';
+export { type CrayolaColorName, crayola } from './palettes/crayola.js';
 export { type PantoneColorName, pantone } from './palettes/pantone.js';
 export { type WebColorName, web } from './palettes/web.js';
 export { type X11ColorName, x11 } from './palettes/x11.js';
-export { resolve } from './resolve.js';
+export { type ResolveMatch, resolve } from './resolve.js';
 export type { ColorFormat, ColorInput, ColorValue, DistanceMetric, HexColor, HslInput, HslObject, HslString, HsvInput, HsvObject, HsvString, NormalizeFn, Palette, Rgba, RgbaInput, RgbaString, RgbaTuple, RgbInput, RgbObject, RgbString, RgbTuple, } from './types.js';
 export { COLOR_FORMATS } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC","sourcesContent":["// Public API barrel — explicit named re-exports only (tree-shake friendly).\n// No default export; no side effects at module scope.\n\nexport { hexToRgba, rgbaToHex } from './conversions/hex.js';\nexport { hslToRgba, rgbaToHsl } from './conversions/hsl.js';\nexport { hsvToRgba, rgbaToHsv } from './conversions/hsv.js';\nexport { pantoneToRgba, rgbaToPantone } from './conversions/pantone.js';\nexport { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';\nexport { convert, fromRgba, toRgba } from './convert.js';\nexport { type DetectedFormat, detectFormat, isColor } from './detectFormat.js';\nexport { identify } from './identify.js';\nexport { type PantoneColorName, pantone } from './palettes/pantone.js';\nexport { type WebColorName, web } from './palettes/web.js';\nexport { type X11ColorName, x11 } from './palettes/x11.js';\nexport { resolve } from './resolve.js';\nexport type {\n  ColorFormat,\n  ColorInput,\n  ColorValue,\n  DistanceMetric,\n  HexColor,\n  HslInput,\n  HslObject,\n  HslString,\n  HsvInput,\n  HsvObject,\n  HsvString,\n  NormalizeFn,\n  Palette,\n  Rgba,\n  RgbaInput,\n  RgbaString,\n  RgbaTuple,\n  RgbInput,\n  RgbObject,\n  RgbString,\n  RgbTuple,\n} from './types.js';\nexport { COLOR_FORMATS } from './types.js';\n"]}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,KAAK,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,YAAY,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,WAAW,EACX,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC","sourcesContent":["// Public API barrel — explicit named re-exports only (tree-shake friendly).\n// No default export; no side effects at module scope.\n\nexport { hexToRgba, rgbaToHex } from './conversions/hex.js';\nexport { hslToRgba, rgbaToHsl } from './conversions/hsl.js';\nexport { hsvToRgba, rgbaToHsv } from './conversions/hsv.js';\nexport { pantoneToRgba, rgbaToPantone } from './conversions/pantone.js';\nexport { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';\nexport { convert, fromRgba, toRgba } from './convert.js';\nexport { type DetectedFormat, detectFormat, isColor } from './detectFormat.js';\nexport { type IdentifyMatch, identify } from './identify.js';\nexport { type CrayolaColorName, crayola } from './palettes/crayola.js';\nexport { type PantoneColorName, pantone } from './palettes/pantone.js';\nexport { type WebColorName, web } from './palettes/web.js';\nexport { type X11ColorName, x11 } from './palettes/x11.js';\nexport { type ResolveMatch, resolve } from './resolve.js';\nexport type {\n  ColorFormat,\n  ColorInput,\n  ColorValue,\n  DistanceMetric,\n  HexColor,\n  HslInput,\n  HslObject,\n  HslString,\n  HsvInput,\n  HsvObject,\n  HsvString,\n  NormalizeFn,\n  Palette,\n  Rgba,\n  RgbaInput,\n  RgbaString,\n  RgbaTuple,\n  RgbInput,\n  RgbObject,\n  RgbString,\n  RgbTuple,\n} from './types.js';\nexport { COLOR_FORMATS } from './types.js';\n"]}

package/dist/index.js

@@ -8,6 +8,7 @@ export { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';
 export { convert, fromRgba, toRgba } from './convert.js';
 export { detectFormat, isColor } from './detectFormat.js';
 export { identify } from './identify.js';
+export { crayola } from './palettes/crayola.js';
 export { pantone } from './palettes/pantone.js';
 export { web } from './palettes/web.js';
 export { x11 } from './palettes/x11.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,sDAAsD;AAEtD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAuB,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAyB,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAqB,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAqB,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAwBvC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC","sourcesContent":["// Public API barrel — explicit named re-exports only (tree-shake friendly).\n// No default export; no side effects at module scope.\n\nexport { hexToRgba, rgbaToHex } from './conversions/hex.js';\nexport { hslToRgba, rgbaToHsl } from './conversions/hsl.js';\nexport { hsvToRgba, rgbaToHsv } from './conversions/hsv.js';\nexport { pantoneToRgba, rgbaToPantone } from './conversions/pantone.js';\nexport { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';\nexport { convert, fromRgba, toRgba } from './convert.js';\nexport { type DetectedFormat, detectFormat, isColor } from './detectFormat.js';\nexport { identify } from './identify.js';\nexport { type PantoneColorName, pantone } from './palettes/pantone.js';\nexport { type WebColorName, web } from './palettes/web.js';\nexport { type X11ColorName, x11 } from './palettes/x11.js';\nexport { resolve } from './resolve.js';\nexport type {\n  ColorFormat,\n  ColorInput,\n  ColorValue,\n  DistanceMetric,\n  HexColor,\n  HslInput,\n  HslObject,\n  HslString,\n  HsvInput,\n  HsvObject,\n  HsvString,\n  NormalizeFn,\n  Palette,\n  Rgba,\n  RgbaInput,\n  RgbaString,\n  RgbaTuple,\n  RgbInput,\n  RgbObject,\n  RgbString,\n  RgbTuple,\n} from './types.js';\nexport { COLOR_FORMATS } from './types.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,sDAAsD;AAEtD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAuB,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EAAsB,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAyB,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAyB,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAqB,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAqB,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAqB,OAAO,EAAE,MAAM,cAAc,CAAC;AAwB1D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC","sourcesContent":["// Public API barrel — explicit named re-exports only (tree-shake friendly).\n// No default export; no side effects at module scope.\n\nexport { hexToRgba, rgbaToHex } from './conversions/hex.js';\nexport { hslToRgba, rgbaToHsl } from './conversions/hsl.js';\nexport { hsvToRgba, rgbaToHsv } from './conversions/hsv.js';\nexport { pantoneToRgba, rgbaToPantone } from './conversions/pantone.js';\nexport { rgbaToRgb, rgbToRgba } from './conversions/rgb.js';\nexport { convert, fromRgba, toRgba } from './convert.js';\nexport { type DetectedFormat, detectFormat, isColor } from './detectFormat.js';\nexport { type IdentifyMatch, identify } from './identify.js';\nexport { type CrayolaColorName, crayola } from './palettes/crayola.js';\nexport { type PantoneColorName, pantone } from './palettes/pantone.js';\nexport { type WebColorName, web } from './palettes/web.js';\nexport { type X11ColorName, x11 } from './palettes/x11.js';\nexport { type ResolveMatch, resolve } from './resolve.js';\nexport type {\n  ColorFormat,\n  ColorInput,\n  ColorValue,\n  DistanceMetric,\n  HexColor,\n  HslInput,\n  HslObject,\n  HslString,\n  HsvInput,\n  HsvObject,\n  HsvString,\n  NormalizeFn,\n  Palette,\n  Rgba,\n  RgbaInput,\n  RgbaString,\n  RgbaTuple,\n  RgbInput,\n  RgbObject,\n  RgbString,\n  RgbTuple,\n} from './types.js';\nexport { COLOR_FORMATS } from './types.js';\n"]}