fashionable 0.0.0 → 0.2.0

package/dist/shared/color-BvNJ2YqL.d.mts

@@ -0,0 +1,590 @@
+import { f as ChannelLeaf, i as Input, n as Bindings, o as SerializeOptions, r as Calc, t as ApplyBindings } from "./index-BvtwY4FQ.mjs";
+import { t as Pipeable } from "./utils-BKm298I-.mjs";
+declare namespace colorSpace_d_exports {
+  export { ColorSpace, Polar, PolarSpace, a98Rgb, displayP3, hsl, hwb, lab, lch, oklab, oklch$1 as oklch, prophotoRgb, rec2020, srgb$1 as srgb, srgbLinear, xyz, xyzD50, xyzD65 };
+}
+declare const ColorSpaceChannels: unique symbol;
+declare const PolarId: unique symbol;
+/**
+ * The trait a polar color space carries — one with a hue channel. `Color.mix`
+ * requires it to take a `HueInterpolation`, and `PolarSpace` is the space type
+ * that has it. Composes by intersection with future space traits, as curvy's
+ * brands do.
+ *
+ * @since 0.2.0
+ */
+type Polar = {
+  readonly [PolarId]: 'polar';
+};
+/**
+ * A color space. `Channels` carries the origin-channel keyword brands
+ * (`Channel`) valid for `Color.from`; `Trait` accumulates the space's
+ * capability brands (`Polar`), defaulting to `unknown` — a space with no
+ * capability claims. A position requires a capability by naming its brand in
+ * `Trait` (`ColorSpace<Channels, Polar>`).
+ *
+ * @since 0.2.0
+ */
+interface ColorSpace<out Channels = ChannelLeaf<string>, out Trait = unknown> {
+  readonly [ColorSpaceTypeId]: ColorSpaceTypeId;
+  readonly [ColorSpaceChannels]?: Channels;
+  readonly [ColorSpaceTraits]?: Trait;
+}
+/**
+ * A polar color space — one carrying the `Polar` trait, so `Color.mix` may take
+ * a `HueInterpolation` after it.
+ *
+ * @since 0.2.0
+ */
+type PolarSpace<Channels = ChannelLeaf<string>> = ColorSpace<Channels, Polar>;
+/**
+ * The `oklch` space: a polar interpolation space, and an `oklch(from ...)`
+ * destination with `Channel.L`/`C`/`H` (and `Alpha`) in scope.
+ *
+ * @since 0.2.0
+ */
+declare const oklch$1: ColorSpace<ChannelLeaf<'l'> | ChannelLeaf<'c'> | ChannelLeaf<'h'> | ChannelLeaf<'alpha'>, Polar>;
+/**
+ * The `srgb` space: a rectangular interpolation space, and a
+ * `color(from ... srgb ...)` destination with `Channel.R`/`G`/`B` (and `Alpha`)
+ * in scope.
+ *
+ * @since 0.2.0
+ */
+declare const srgb$1: ColorSpace<ChannelLeaf<'r'> | ChannelLeaf<'g'> | ChannelLeaf<'b'> | ChannelLeaf<'alpha'>>;
+/**
+ * The `srgb-linear` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const srgbLinear: ColorSpace<never>;
+/**
+ * The `display-p3` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const displayP3: ColorSpace<never>;
+/**
+ * The `a98-rgb` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const a98Rgb: ColorSpace<never>;
+/**
+ * The `prophoto-rgb` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const prophotoRgb: ColorSpace<never>;
+/**
+ * The `rec2020` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const rec2020: ColorSpace<never>;
+/**
+ * The `lab` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const lab: ColorSpace<never>;
+/**
+ * The `oklab` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const oklab: ColorSpace<never>;
+/**
+ * The `xyz` space (rectangular; an alias for `xyz-d65`).
+ *
+ * @since 0.2.0
+ */
+declare const xyz: ColorSpace<never>;
+/**
+ * The `xyz-d50` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const xyzD50: ColorSpace<never>;
+/**
+ * The `xyz-d65` space (rectangular).
+ *
+ * @since 0.2.0
+ */
+declare const xyzD65: ColorSpace<never>;
+/**
+ * The `hsl` space (polar).
+ *
+ * @since 0.2.0
+ */
+declare const hsl: ColorSpace<never, Polar>;
+/**
+ * The `hwb` space (polar).
+ *
+ * @since 0.2.0
+ */
+declare const hwb: ColorSpace<never, Polar>;
+/**
+ * The `lch` space (polar).
+ *
+ * @since 0.2.0
+ */
+declare const lch: ColorSpace<never, Polar>;
+//#endregion
+//#region src/data/colorSpace.internal.d.ts
+declare const ColorSpaceTypeId: unique symbol;
+type ColorSpaceTypeId = typeof ColorSpaceTypeId;
+/**
+ * Phantom key holding a `ColorSpace`'s `Trait` parameter. The runtime value
+ * never has a value here — traits are type-level brands, so a space is
+ * identical at runtime whatever its traits (the curvy trait pattern).
+ *
+ * @internal
+ */
+declare const ColorSpaceTraits: unique symbol;
+type ColorSpaceTraits = typeof ColorSpaceTraits;
+//#endregion
+//#region src/data/hueInterpolation.internal.d.ts
+declare const HueInterpolationTypeId: unique symbol;
+type HueInterpolationTypeId = typeof HueInterpolationTypeId;
+declare namespace hueInterpolation_d_exports {
+  export { HueInterpolation, decreasing, increasing, interpolate, longer, shorter };
+}
+declare const HueInterpolationStrategy: unique symbol;
+/**
+ * A hue-interpolation strategy. The `Strategy` parameter names the specific
+ * one (`'longer'`), letting a position accept a particular strategy where it
+ * matters; `Color.mix` accepts any.
+ *
+ * @since 0.2.0
+ */
+interface HueInterpolation<Strategy extends string = string> {
+  readonly [HueInterpolationTypeId]: HueInterpolationTypeId;
+  readonly [HueInterpolationStrategy]?: Strategy;
+}
+/**
+ * The `shorter` strategy — the short arc between the two hues (the browser
+ * default). Serializes as `shorter hue`.
+ *
+ * @since 0.2.0
+ */
+declare const shorter: HueInterpolation<'shorter'>;
+/**
+ * The `longer` strategy — the long arc between the two hues. Serializes as
+ * `longer hue`.
+ *
+ * @since 0.2.0
+ */
+declare const longer: HueInterpolation<'longer'>;
+/**
+ * The `increasing` strategy — hues traversed in increasing order, wrapping past
+ * `360` if needed. Serializes as `increasing hue`.
+ *
+ * @since 0.2.0
+ */
+declare const increasing: HueInterpolation<'increasing'>;
+/**
+ * The `decreasing` strategy — hues traversed in decreasing order, wrapping past
+ * `0` if needed. Serializes as `decreasing hue`.
+ *
+ * @since 0.2.0
+ */
+declare const decreasing: HueInterpolation<'decreasing'>;
+/**
+ * Builds the hue at `t` along the arc from `from` to `to` under `strategy` — the
+ * JS side of what a polar `Color.mix` emits for the browser. Hues are numbers of
+ * degrees (as an oklch/lch hue channel is), and `from`, `to`, and `t` are each a
+ * number or a `Calc`, so the result is a `Calc` too: fully symbolic when any
+ * argument is, folding to a constant when all are numbers.
+ *
+ * The hue math is the CSS Color 4 fixup, written branchlessly with `mod`: each
+ * strategy is a signed delta added to `from` as `t` runs `0` (at `from`) to `1`
+ * (at `to`). `shorter` and `longer` take the short or long arc between the hues;
+ * `increasing`/`decreasing` force the direction. The result is unwrapped — it may
+ * fall outside `[0, 360)`, which the browser resolves as a hue — and unions the
+ * arguments' references. Drop it straight into a hue channel (`Color.oklch`).
+ *
+ * @param strategy - The traversal strategy (`shorter`, `longer`, ...).
+ * @param from - The start hue, in degrees: a number or a `Calc`.
+ * @param to - The end hue, in degrees: a number or a `Calc`.
+ * @param t - The interpolation parameter, `0` to `1`: a number or a `Calc`.
+ * @returns The interpolated hue in degrees, a `Calc` unioning the arguments' references.
+ * @example
+ * ```ts
+ * const hue = HueInterpolation.interpolate(HueInterpolation.shorter, 30, Calc.ref('to'), Calc.ref('t'))
+ * Calc.serialize(hue) // 'calc(30 + (mod(var(--to) - 30 + 180, 360) - 180) * var(--t))'
+ * Calc.serialize(HueInterpolation.interpolate(HueInterpolation.increasing, 20, 350, 0.5)) // '185'
+ * ```
+ * @since 0.2.0
+ */
+declare const interpolate: <F extends string = never, T extends string = never, P extends string = never>(strategy: HueInterpolation, from: Input<F>, to: Input<T>, t: Input<P>) => Calc<F | T | P>;
+//#endregion
+//#region src/data/keywords.internal.d.ts
+declare const NoneTypeId: unique symbol;
+type NoneTypeId = typeof NoneTypeId;
+declare namespace keywords_d_exports {
+  export { None, isNone, none };
+}
+/**
+ * The type of `none` alone. Naming it lets accepting positions spell
+ * their signatures (`Input<R> | Keyword.None`) and overloads recognize
+ * the keyword.
+ *
+ * @since 0.2.0
+ */
+interface None extends Pipeable {
+  readonly [NoneTypeId]: NoneTypeId;
+}
+/**
+ * The `none` keyword — CSS's missing-component value. Accepted where a
+ * position declares it: color channels today (`oklch(0 0 none)`), other
+ * slots as they arrive.
+ *
+ * @since 0.2.0
+ */
+declare const none: None;
+/**
+ * Checks if a value is the `none` keyword.
+ *
+ * True only for `none` itself, which carries the brand.
+ *
+ * @param u - The value to check.
+ * @returns `true` if the value is `none`, `false` otherwise.
+ * @since 0.2.0
+ */
+declare const isNone: (u: unknown) => u is None;
+//#endregion
+//#region src/data/color.internal.d.ts
+declare const ColorTypeId: unique symbol;
+type ColorTypeId = typeof ColorTypeId;
+declare namespace color_d_exports {
+  export { Color, RelativeChannel, bind, channels, equals, from, isColor, lightDark, mix, named, oklch, ref, refs, serialize, srgb, transparent };
+}
+declare const ColorRefs: unique symbol;
+/**
+ * A CSS color expression whose channels are `Calc` number expressions.
+ *
+ * A color is not a number: it can be bound and serialized, but not
+ * solved. The `Refs` parameter unions the channels' unbound reference
+ * names, exactly as on `Calc`.
+ *
+ * `oklch(...)`, `color(srgb ...)`, `light-dark(...)`, `color-mix(...)`,
+ * relative colors (`oklch(from ...)`, `color(from ...)`), a color-valued
+ * `var(...)`, and named colors are modeled today; other color functions
+ * arrive as a consumer needs them. Channels accept `Keyword.none`, CSS's
+ * missing-component value.
+ *
+ * Construct via `oklch`, `srgb`, `lightDark`, `mix`, `named`, `from`, and
+ * `ref` (or the `transparent` constant).
+ *
+ * @since 0.1.0
+ */
+interface Color<out Refs extends string = string> extends Pipeable {
+  readonly [ColorTypeId]: ColorTypeId;
+  readonly [ColorRefs]?: Refs;
+}
+/**
+ * Checks if a value is a `Color`.
+ *
+ * True only for values built by this module's constructors, which carry
+ * the brand.
+ *
+ * @param u - The value to check.
+ * @returns `true` if the value is a `Color`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isColor: (u: unknown) => u is Color<string>;
+/**
+ * Creates an `oklch(...)` color from three channel expressions: lightness
+ * (`0` to `1`), chroma (`0` upward), and hue (degrees). A channel may be
+ * `Keyword.none` — the missing-component keyword, the conventional hue
+ * for achromatic colors: `oklch(0 0 none)`.
+ *
+ * Each channel serializes independently, wrapped in `calc()` when it is
+ * arithmetic: `oklch(var(--l) calc(var(--c) * 0.5) 220)`.
+ *
+ * @param lightness - The lightness channel.
+ * @param chroma - The chroma channel.
+ * @param hue - The hue channel, in degrees.
+ * @returns A `Color` with the channels' references unioned.
+ * @example
+ * ```ts
+ * const accent = Color.oklch(Calc.ref('lightness'), 0.15, 220)
+ * Color.serialize(accent) // 'oklch(var(--lightness) 0.15 220)'
+ * ```
+ * @since 0.1.0
+ */
+declare const oklch: <L extends string = never, C extends string = never, H extends string = never>(lightness: Input<L> | None, chroma: Input<C> | None, hue: Input<H> | None) => Color<L | C | H>;
+/**
+ * Creates a `color(srgb ...)` color from three channel expressions, each
+ * `0` to `1`. A channel may be `Keyword.none`, the missing-component
+ * keyword.
+ *
+ * Each channel serializes independently, wrapped in `calc()` when it is
+ * arithmetic, inside the `color()` function's `srgb` colorspace:
+ * `color(srgb 0.18 0.34 0.78)`.
+ *
+ * @param red - The red channel.
+ * @param green - The green channel.
+ * @param blue - The blue channel.
+ * @returns A `Color` with the channels' references unioned.
+ * @example
+ * ```ts
+ * const brand = Color.srgb(0.18, 0.34, 0.78)
+ * Color.serialize(brand) // 'color(srgb 0.18 0.34 0.78)'
+ * ```
+ * @since 0.2.0
+ */
+declare const srgb: <R extends string = never, G extends string = never, B extends string = never>(red: Input<R> | None, green: Input<G> | None, blue: Input<B> | None) => Color<R | G | B>;
+/**
+ * Creates a named color, rendered bare: `named('rebeccapurple')`
+ * serializes as `rebeccapurple`. The name is the whole value — a named
+ * color has no channels, contributes no references, and binds nothing.
+ *
+ * That the name is one of the specification's named colors is not
+ * checked, matching the library's posture on identifiers — with one
+ * exception: the CSS-wide keywords (`inherit`, `initial`, ...) are
+ * whole-declaration values, not colors (`light-dark(inherit, ...)` is
+ * invalid CSS), and are rejected.
+ *
+ * @param name - The color name. Must be non-empty and not a CSS-wide keyword.
+ * @returns A `Color<never>`.
+ * @throws `Error` when `name` is empty or a CSS-wide keyword.
+ * @since 0.2.0
+ */
+declare const named: (name: string) => Color<never>;
+/**
+ * The `transparent` named color — `rgb(0 0 0 / 0)` by definition, and
+ * the conventional "no color" value.
+ *
+ * @since 0.2.0
+ */
+declare const transparent: Color<never>;
+/**
+ * Creates a color-valued custom-property reference — `ref('accent')`
+ * serializes as `var(--accent)`. Use it where a whole color is read from a
+ * custom property: as a standalone value, or as the origin of a relative color
+ * (`from`).
+ *
+ * The reference is the whole value, so it carries `name` as its one unbound
+ * reference — a dependency, exactly as an unbound `Calc.ref` does — but has no
+ * channels. `bind` substitutes channel expressions, not whole colors, so it
+ * leaves a color reference in place; the browser resolves it from the cascade.
+ *
+ * @param name - The custom-property name, without the `--` prefix. Must be non-empty.
+ * @returns A `Color` with `name` as its one unbound reference.
+ * @throws `Error` when `name` is empty.
+ * @example
+ * ```ts
+ * Color.serialize(Color.ref('accent')) // 'var(--accent)'
+ * ```
+ * @since 0.2.0
+ */
+declare const ref: <Name extends string>(name: Name) => Color<Name>;
+/**
+ * Creates a scheme-conditional `light-dark(...)` color: the browser uses
+ * the first color under the light scheme and the second under dark.
+ *
+ * The arms are whole colors and positional — `lightDark(a, b)` and
+ * `lightDark(b, a)` are different colors. Any `Color` is accepted,
+ * including another `lightDark` (grammatically an arm is any `<color>`;
+ * nesting is redundant but legal, and simplification is not this type's
+ * job). Note the resolution context: `light-dark()` requires
+ * `color-scheme` to be set — that contract is the consumer's.
+ *
+ * @param light - The color used under the light scheme.
+ * @param dark - The color used under the dark scheme.
+ * @returns A `Color` with both arms' references unioned.
+ * @example
+ * ```ts
+ * const accent = Color.lightDark(Color.srgb(0.85, 0.3, 0.4), Color.srgb(0.95, 0.5, 0.55))
+ * Color.serialize(accent) // 'light-dark(color(srgb 0.85 0.3 0.4), color(srgb 0.95 0.5 0.55))'
+ * ```
+ * @since 0.2.0
+ */
+declare const lightDark: <A extends string = never, B extends string = never>(light: Color<A>, dark: Color<B>) => Color<A | B>;
+type MixArm<C extends string, P extends string> = Color<C> | readonly [Color<C>, number | Calc<P, 'percentage', unknown>];
+/**
+ * Creates a `color-mix(...)`: the browser mixes `color1` and `color2` in the
+ * interpolation `space`. Each arm is a bare `Color` or a `[color, percentage]`
+ * tuple giving its weight — a bare number reads as a percent (`20` is `20%`,
+ * the `<percentage>` convention), a `Percentage` expression an annotated or
+ * computed weight (`Percentage.of(20)`, `Calc.multiply(Percentage.of(50), ...)`);
+ * a plain number-kind `Calc` is rejected, a weight being a `<percentage>`.
+ *
+ * A polar `space` (`ColorSpace.oklch`, `ColorSpace.lch`, ...) may take a
+ * `HueInterpolation` strategy between the space and the colors — the second
+ * overload — for how the hue circle is traversed; omit it and the browser
+ * defaults to `shorter`. A rectangular space has no hue channel, so passing a
+ * strategy is a compile error, mirroring the grammar where
+ * `<hue-interpolation-method>` follows only a polar space.
+ *
+ * Percentages are optional and preserved verbatim — fashionable emits the
+ * authored form and never runs the spec's mixing normalization (omitted weights
+ * defaulting to `50%`, weights off `100%` rescaling with an alpha multiplier),
+ * which is computed-value behavior the browser owns. Like every `Color`, a mix
+ * binds and serializes but does not solve, and each arm and each percentage
+ * contributes its references to the result.
+ *
+ * @param space - The interpolation `ColorSpace`; a polar one may be followed by a `HueInterpolation`.
+ * @param color1 - The first color, or a `[color, percentage]` tuple weighting it.
+ * @param color2 - The second color, or a `[color, percentage]` tuple weighting it.
+ * @returns A `Color` unioning both arms' and both percentages' references.
+ * @example
+ * ```ts
+ * Color.serialize(Color.mix(ColorSpace.oklch, Color.named('red'), Color.named('blue')))
+ * // 'color-mix(in oklch, red, blue)'
+ * Color.serialize(Color.mix(ColorSpace.srgb, [Color.named('white'), 20], Color.named('black')))
+ * // 'color-mix(in srgb, white 20%, black)'
+ * Color.serialize(Color.mix(ColorSpace.oklch, HueInterpolation.longer, Color.named('red'), Color.named('blue')))
+ * // 'color-mix(in oklch longer hue, red, blue)'
+ * ```
+ * @since 0.2.0
+ */
+declare const mix: {
+  <C1 extends string = never, P1 extends string = never, C2 extends string = never, P2 extends string = never>(space: ColorSpace, color1: MixArm<C1, P1>, color2: MixArm<C2, P2>): Color<C1 | P1 | C2 | P2>;
+  <C1 extends string = never, P1 extends string = never, C2 extends string = never, P2 extends string = never>(space: PolarSpace, hue: HueInterpolation, color1: MixArm<C1, P1>, color2: MixArm<C2, P2>): Color<C1 | P1 | C2 | P2>;
+};
+/**
+ * A channel slot of a relative color: a bare number, `Keyword.none`, or a
+ * `Calc` number expression. `Channels` is the set of origin-channel keyword
+ * brands (`Channel`) the expression may read — the space's own channels — so a
+ * keyword from another color space (`Channel.R` in an `oklch` slot) is a
+ * compile error. A plain expression (a constant, a `Calc.ref`, a `clamp`)
+ * carries no channel keyword and fits any slot.
+ *
+ * @since 0.2.0
+ */
+type RelativeChannel<Refs extends string, Channels> = number | None | Calc<Refs, 'number', Channels>;
+type ChannelsOf<Space> = Space extends ColorSpace<infer Channels> ? Channels : never;
+/**
+ * Creates a relative color from an origin and a destination `ColorSpace`:
+ * `Color.from(origin, ColorSpace.oklch, l, c, h)` is `oklch(from origin l c h)`
+ * and `Color.from(origin, ColorSpace.srgb, r, g, b)` is
+ * `color(from origin srgb r g b)`. The browser converts `origin` into the
+ * space and exposes its channels as the `Channel` keywords the space names
+ * (`Channel.L`/`C`/`H` for `oklch`, `Channel.R`/`G`/`B` for `srgb`, `Channel.Alpha`
+ * for both); passing them straight through reproduces the origin, and
+ * arithmetic on them derives a related color.
+ *
+ * The `space` scopes the channel arguments — a keyword the space does not name
+ * is a compile error. Each channel serializes independently, wrapped in
+ * `calc()` when arithmetic and bare when a lone keyword, and may be
+ * `Keyword.none`. A supplied `alpha` renders after a slash
+ * (`/ calc(alpha * 0.5)`); omitted, the origin's alpha carries through. The
+ * origin's own references union into the result; the channel keywords
+ * contribute none, since the browser resolves them from the origin.
+ *
+ * @param origin - The color to derive from — any `Color`, commonly a `ref`.
+ * @param space - The destination `ColorSpace`, fixing the function form and the channels in scope.
+ * @param channel1 - The first channel (`l`/`r`), in the space's order.
+ * @param channel2 - The second channel (`c`/`g`).
+ * @param channel3 - The third channel (`h`/`b`).
+ * @param alpha - The optional alpha channel; omitted, the origin's alpha is kept.
+ * @returns A `Color` unioning the origin's and the channels' references.
+ * @example
+ * ```ts
+ * const hover = Color.from(Color.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+ * Color.serialize(hover) // 'oklch(from var(--accent) calc(l * 0.8) c h)'
+ * const faded = Color.from(Color.ref('brand'), ColorSpace.srgb, Channel.R, Channel.G, Channel.B, Calc.multiply(Channel.Alpha, 0.5))
+ * Color.serialize(faded) // 'color(from var(--brand) srgb r g b / calc(alpha * 0.5))'
+ * ```
+ * @since 0.2.0
+ */
+declare const from: <O extends string = never, Space extends ColorSpace = ColorSpace, C1 extends string = never, C2 extends string = never, C3 extends string = never, A extends string = never>(origin: Color<O>, space: Space, channel1: RelativeChannel<C1, ChannelsOf<Space>>, channel2: RelativeChannel<C2, ChannelsOf<Space>>, channel3: RelativeChannel<C3, ChannelsOf<Space>>, alpha?: RelativeChannel<A, ChannelsOf<Space>>) => Color<O | C1 | C2 | C3 | A>;
+declare const bind: {
+  /**
+   * Returns a function that binds the given names in a color's channels.
+   *
+   * @param bindings - Reference names to values or expressions.
+   * @returns A function replacing bound references in its argument.
+   * @since 0.1.0
+   */
+  <const B extends Bindings>(bindings: B): <Refs extends string>(color: Color<Refs>) => Color<ApplyBindings<Refs, B>>;
+  /**
+   * Replaces references in the color's channels with values or other
+   * expressions, re-folding constant subtrees. Semantics match
+   * `Calc.bind`: unreferenced names and `undefined` values are ignored,
+   * and expression-valued bindings contribute their own references.
+   *
+   * @param color - The color to bind.
+   * @param bindings - Reference names to values or expressions.
+   * @returns The bound color.
+   * @since 0.1.0
+   */
+  <Refs extends string, const B extends Bindings>(color: Color<Refs>, bindings: B): Color<ApplyBindings<Refs, B>>;
+};
+/**
+ * Renders a color as CSS text. Channels render space-separated inside
+ * the color's own function form — `oklch(...)` or `color(srgb ...)` —
+ * each wrapped in `calc()` when it is arithmetic; a `lightDark` renders
+ * both arms in full, comma-separated.
+ *
+ * Options match `Calc.serialize`: partial bindings applied first, and a
+ * precision context for unannotated constants.
+ *
+ * @param color - The color to render.
+ * @param options - Optional bindings and precision context.
+ * @returns Deterministic CSS text.
+ * @example
+ * ```ts
+ * const surface = Color.oklch(Calc.add(Calc.ref('l'), 0.1), 0.04, 250)
+ * Color.serialize(surface) // 'oklch(calc(var(--l) + 0.1) 0.04 250)'
+ * ```
+ * @since 0.1.0
+ */
+declare const serialize: <Refs extends string>(color: Color<Refs>, options?: SerializeOptions<Refs>) => string;
+/**
+ * The color's unbound reference names, unioned across channels.
+ *
+ * @param color - The color to inspect.
+ * @returns The set of unbound reference names.
+ * @since 0.1.0
+ */
+declare const refs: <Refs extends string>(color: Color<Refs>) => ReadonlySet<Refs>;
+/**
+ * The origin-channel keyword tokens the color reads — the `Channel` keywords a
+ * relative color's channels reference (`l`, `c`, `h`, ...), gathered across its
+ * channels and any nested colors. Empty for a color with no relative parts.
+ *
+ * The `Color` companion to `Calc.channels`, and the mirror of `refs`: where
+ * `refs` reports the custom properties a color depends on, `channels` reports
+ * the origin channels a relative color reads. They are disjoint — a channel
+ * keyword is never a reference — so a channel token never appears in `refs` nor
+ * reaches a `Stylesheet`'s dependency report.
+ *
+ * @param color - The color to inspect.
+ * @returns The set of channel-keyword tokens the color reads.
+ * @example
+ * ```ts
+ * const hover = Color.from(Color.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+ * Color.channels(hover) // Set { 'l', 'c', 'h' }
+ * Color.refs(hover) // Set { 'accent' }
+ * ```
+ * @since 0.2.0
+ */
+declare const channels: (color: Color<string>) => ReadonlySet<string>;
+declare const equals: {
+  /**
+   * Returns a function that checks structural equality against `that`.
+   *
+   * @param that - The color to compare against.
+   * @returns A function testing its argument for structural equality with `that`.
+   * @since 0.1.0
+   */
+  (that: Color<string>): (self: Color<string>) => boolean;
+  /**
+   * Structural equality over colors: channel trees compare node for node,
+   * as in `Calc.equals`. Different color functions never compare equal,
+   * even where they would name the same point in color space.
+   *
+   * @param self - The first color.
+   * @param that - The second color.
+   * @returns `true` if the colors are structurally equal.
+   * @since 0.1.0
+   */
+  (self: Color<string>, that: Color<string>): boolean;
+};
+//#endregion
+export { colorSpace_d_exports as a, hueInterpolation_d_exports as i, color_d_exports as n, keywords_d_exports as r, Color as t };
+//# sourceMappingURL=color-BvNJ2YqL.d.mts.map