fashionable 0.2.0 → 0.4.0

package/dist/shared/index-D-hVWDgZ.d.mts

@@ -0,0 +1,2289 @@
+import { t as Pipeable } from "./utils-DpN6qr94.mjs";
+//#region src/calc/precision.internal.d.ts
+declare const PrecisionTypeId: unique symbol;
+type PrecisionTypeId = typeof PrecisionTypeId;
+declare namespace precision_d_exports {
+  export { Precision, decimals, isPrecision, significant };
+}
+/**
+ * A number-formatting precision, attached to constants at construction
+ * (`Calc.of`) or supplied as a serialization context default
+ * (`Calc.serialize`'s `precision` option).
+ *
+ * Two modes exist. `decimals` fixes the count of digits after the decimal
+ * point (`toFixed` semantics); `significant` fixes the count of significant
+ * digits (`toPrecision` semantics). Both render plain decimal text with
+ * trailing zeros trimmed — CSS never accepts exponent notation.
+ *
+ * A precision annotated on a constant overrides the serialization context.
+ * When constant folding combines annotated constants, the result carries
+ * the highest-fidelity annotation among the operands: any `significant`
+ * outranks any `decimals`, and more digits outrank fewer.
+ *
+ * @since 0.1.0
+ */
+interface Precision extends Pipeable {
+  readonly [PrecisionTypeId]: PrecisionTypeId;
+  /**
+   * The formatting mode: digits after the decimal point (`decimals`) or
+   * significant digits (`significant`).
+   */
+  readonly mode: 'decimals' | 'significant';
+  /**
+   * The digit count the mode fixes.
+   */
+  readonly digits: number;
+}
+/**
+ * Checks if a value is a `Precision`.
+ *
+ * True only for values built by `decimals` or `significant`, which carry
+ * the brand.
+ *
+ * @param u - The value to check.
+ * @returns `true` if the value is a `Precision`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isPrecision: (u: unknown) => u is Precision;
+/**
+ * Creates a `Precision` fixing the count of digits after the decimal
+ * point. The library default for unannotated constants is `decimals(5)`.
+ *
+ * @param digits - Digits after the decimal point. Must be an integer in `[0, 100]`.
+ * @returns A `Precision` in `decimals` mode.
+ * @throws `Error` when `digits` is not an integer in `[0, 100]`.
+ * @example
+ * ```ts
+ * Calc.serialize(Calc.of(1 / 3), { precision: Precision.decimals(2) }) // '0.33'
+ * ```
+ * @since 0.1.0
+ */
+declare const decimals: (digits: number) => Precision;
+/**
+ * Creates a `Precision` fixing the count of significant digits. Use it for
+ * unit-free constants whose error is amplified downstream — solved curve
+ * coefficients, for example — where fixed decimal places would truncate.
+ *
+ * @param digits - Significant digits. Must be an integer in `[1, 100]`.
+ * @returns A `Precision` in `significant` mode.
+ * @throws `Error` when `digits` is not an integer in `[1, 100]`.
+ * @example
+ * ```ts
+ * const k = Calc.of(0.8377580409572781, Precision.significant(10))
+ * Calc.serialize(k) // '0.837758041'
+ * ```
+ * @since 0.1.0
+ */
+declare const significant: (digits: number) => Precision;
+//#endregion
+//#region src/var/var.internal.d.ts
+declare const VarTypeId: unique symbol;
+type VarTypeId = typeof VarTypeId;
+//#endregion
+//#region src/calc/calc.internal.d.ts
+declare const CalcTypeId: unique symbol;
+type CalcTypeId = typeof CalcTypeId;
+declare namespace unit_d_exports {
+  export { AbsoluteLength, Angle$1 as Angle, Any$1 as Any, ContextFree, Deg, Em, Family, Length$1 as Length, LengthPercentage$1 as LengthPercentage, None$1 as None, Percent, Percentage$1 as Percentage, Px, Rad, Relative, Rem, Token, UnitContext, Vh, Vmax, Vmin, Vw };
+}
+/**
+ * The unit vocabulary: the brands `Calc` carries in both its `Result` and
+ * `Requires` parameters. Each unit is a distinct nominal type carrying its CSS
+ * token, keyed by a per-dimension `unique symbol` so a length unit and an
+ * angle unit never unify — that nominal split is what lets `solve` demand a
+ * ratio for viewport-relative units while leaving absolute ones alone.
+ *
+ * You rarely name a unit type directly — `Length.px(10)` and `Angle.rad(2)`
+ * stamp them — but they surface in `Calc<Vars, Result, Requires>` hovers: the
+ * `Result` side as the units the expression's value is composed from
+ * (`Unit.Px | Unit.Vw` for a mixed sum, `Unit.None` for a `<number>`), the
+ * `Requires` side as the ratios `solve` may need.
+ *
+ * Units share the `Requires` parameter with the other requirement brand,
+ * `Calc.Ident` — the bare-identifier tokens supplied by value through the
+ * `idents` section of the solve options, where a unit is supplied by ratio
+ * through `units`.
+ *
+ * @since 0.2.0
+ */
+declare const LengthUnitId: unique symbol;
+declare const AngleUnitId: unique symbol;
+declare const PercentageUnitId: unique symbol;
+declare const NoneUnitId: unique symbol;
+/**
+ * The `px` unit (absolute length).
+ *
+ * @since 0.2.0
+ */
+interface Px {
+  readonly [LengthUnitId]: 'px';
+}
+/**
+ * The `rem` unit (length relative to the root font size).
+ *
+ * @since 0.2.0
+ */
+interface Rem {
+  readonly [LengthUnitId]: 'rem';
+}
+/**
+ * The `em` unit (length relative to the element font size).
+ *
+ * @since 0.2.0
+ */
+interface Em {
+  readonly [LengthUnitId]: 'em';
+}
+/**
+ * The `vw` unit (length relative to 1% of viewport width).
+ *
+ * @since 0.2.0
+ */
+interface Vw {
+  readonly [LengthUnitId]: 'vw';
+}
+/**
+ * The `vh` unit (length relative to 1% of viewport height).
+ *
+ * @since 0.2.0
+ */
+interface Vh {
+  readonly [LengthUnitId]: 'vh';
+}
+/**
+ * The `vmin` unit (length relative to 1% of the smaller viewport axis).
+ *
+ * @since 0.2.0
+ */
+interface Vmin {
+  readonly [LengthUnitId]: 'vmin';
+}
+/**
+ * The `vmax` unit (length relative to 1% of the larger viewport axis).
+ *
+ * @since 0.2.0
+ */
+interface Vmax {
+  readonly [LengthUnitId]: 'vmax';
+}
+/**
+ * The `rad` unit (angle in radians).
+ *
+ * @since 0.2.0
+ */
+interface Rad {
+  readonly [AngleUnitId]: 'rad';
+}
+/**
+ * The `deg` unit (angle in degrees). Degrees lower to radians at solve
+ * (`180deg` is `pi`), a fixed ratio, so like `rad` a degree needs no context.
+ *
+ * @since 0.2.0
+ */
+interface Deg {
+  readonly [AngleUnitId]: 'deg';
+}
+/**
+ * The `%` unit (percentage). Keyed by its own dimension symbol, so a
+ * percentage never unifies with a length or an angle — a `<percentage>`
+ * is its own `Calc` kind, not a length that happens to be relative.
+ *
+ * @since 0.2.0
+ */
+interface Percent {
+  readonly [PercentageUnitId]: '%';
+}
+/**
+ * Any `<length>` unit.
+ *
+ * @since 0.2.0
+ */
+type Length$1 = Px | Rem | Em | Vw | Vh | Vmin | Vmax;
+/**
+ * Any `<angle>` unit.
+ *
+ * @since 0.2.0
+ */
+type Angle$1 = Rad | Deg;
+/**
+ * Any `<percentage>` unit. There is only one (`%`); the alias exists for
+ * symmetry with `Length` and `Angle`, so `Calc<never, Unit.Percentage, ...>`
+ * reads uniformly.
+ *
+ * @since 0.2.0
+ */
+type Percentage$1 = Percent;
+/**
+ * The absent unit: the `Result` of a `<number>` expression. A brand rather
+ * than a bare marker so it slots into the same algebra as the real units —
+ * `Family<None>` is `None`, and a `None`-result operand is what `multiply`
+ * and `pow` mean by "a number."
+ *
+ * @since 0.4.0
+ */
+interface None$1 {
+  readonly [NoneUnitId]: 'none';
+}
+/**
+ * Any `<length-percentage>` unit: the length units plus `%`. The Result of
+ * a mixed expression (`calc(100% - 24px)`) and the family a declared
+ * `<length-percentage>` variable reads as. Mixing requires the anchor: the
+ * algebra admits a length or a percentage operand beside a
+ * length-percentage expression, while a bare `px + %` sum (no anchor
+ * naming the destination type) stays a type error.
+ *
+ * @since 0.4.0
+ */
+type LengthPercentage$1 = Length$1 | Percentage$1;
+/**
+ * The whole `Result` domain: every unit, plus `None` for numbers. The top of
+ * the parameter — `Calc.Top` and the widest signatures use it where they once
+ * used `Kind`.
+ *
+ * @since 0.4.0
+ */
+type Any$1 = Length$1 | Angle$1 | Percentage$1 | None$1;
+/**
+ * A unit widened to its dimension family — `Family<Unit.Px>` is
+ * `Unit.Length`, `Family<Unit.None>` is `Unit.None`. This is the
+ * specification's own type algebra as a projection of `Result`: CSS
+ * type-checks `calc()` at the dimension level, so the same-dimension operand
+ * constraints compare families, never single units. Distributes over unions
+ * (`Family<Unit.Px | Unit.Vw>` is `Unit.Length`).
+ *
+ * @since 0.4.0
+ */
+type Family<U> = U extends Length$1 ? Length$1 : U extends Angle$1 ? Angle$1 : U extends Percentage$1 ? Percentage$1 : None$1;
+/**
+ * The context-dependent length units — those whose pixel ratio depends on the
+ * viewport or a font size, so `solve` requires a `units` entry for each.
+ *
+ * @since 0.2.0
+ */
+type Relative = Rem | Em | Vw | Vh | Vmin | Vmax;
+/**
+ * The absolute length units, whose pixel ratio is fixed (`px` is `1`). The
+ * `units` section of the solve options may override them but need not supply
+ * them.
+ *
+ * @since 0.2.0
+ */
+type AbsoluteLength = Px;
+/**
+ * The requirements that are all pre-satisfied: absolute lengths (fixed
+ * ratio) and angles (radians are already numbers, degrees a fixed ratio of
+ * them). An expression whose `Requires` stays inside this set solves with
+ * no options.
+ *
+ * These units ride the `Requires` channel even though they demand nothing —
+ * deliberately, and load-bearing: division cancellation may discharge a
+ * requirement only when eager folding guarantees the division folds before
+ * evaluation needs a ratio, and foldability is a property of every unit in
+ * the tree, defaults included (see `docs/result-calc.md`).
+ *
+ * @since 0.2.0
+ */
+type ContextFree = AbsoluteLength | Angle$1;
+/**
+ * The CSS token of a unit brand (`Unit.Px` -> `'px'`), used to key the
+ * `units` section of the solve options and to render the unit suffix.
+ *
+ * @since 0.2.0
+ */
+type Token<U> = U extends {
+  readonly [LengthUnitId]: infer T;
+} ? T : U extends {
+  readonly [AngleUnitId]: infer T;
+} ? T : U extends {
+  readonly [PercentageUnitId]: infer T;
+} ? T : never;
+/**
+ * The `units` section of `Calc.SolveOptions`: the ratios that lower an
+ * expression with the requirements `R` to a number. Each context-dependent
+ * unit present is a required pixels-per-unit ratio — `vw` is
+ * `sampleWidth / 100`, and `%` is `basis / 100`, per-hundred alike — while
+ * absolute lengths (`px`) are optional overrides and angle units never
+ * appear (radians are already numeric, degrees a fixed ratio). An expression
+ * whose requirements are all pre-satisfied needs no entries at all.
+ *
+ * @since 0.2.0
+ */
+type UnitContext<R> = { readonly [K in Token<Extract<R, Relative | Percent>> & string]: number; } & { readonly [K in Token<Extract<R, AbsoluteLength>> & string]?: number; };
+declare namespace channels_d_exports {
+  export { Alpha, B, C, ChannelIdent, G, H, L, R$1 as R };
+}
+declare const ChannelId: unique symbol;
+/**
+ * The leaf brand of an origin-channel keyword: the refinement of `Calc.Ident`
+ * the `Channel` keywords carry. The extra brand is what scopes relative-color
+ * slots — a `ColorSpace` names the `ChannelIdent`s it admits, so a bare
+ * identifier from some other construct never satisfies a channel slot even if
+ * its token collides — while everything generic over identifiers (`solve`'s
+ * `idents` section, `Calc.idents`) keys on the `Ident` base and needs no
+ * special case.
+ *
+ * @since 0.2.0
+ */
+interface ChannelIdent<Name extends string> extends Ident<Name> {
+  readonly [ChannelId]: Name;
+}
+/**
+ * The `l` origin channel — lightness in `oklch`. Serializes bare as `l`.
+ *
+ * @since 0.2.0
+ */
+declare const L: Calc<never, None$1, ChannelIdent<'l'>>;
+/**
+ * The `c` origin channel — chroma in `oklch`. Serializes bare as `c`.
+ *
+ * @since 0.2.0
+ */
+declare const C: Calc<never, None$1, ChannelIdent<'c'>>;
+/**
+ * The `h` origin channel — hue in `oklch`, in degrees. Serializes bare as `h`.
+ *
+ * @since 0.2.0
+ */
+declare const H: Calc<never, None$1, ChannelIdent<'h'>>;
+/**
+ * The `r` origin channel — red in `color(srgb ...)`. Serializes bare as `r`.
+ *
+ * @since 0.2.0
+ */
+declare const R$1: Calc<never, None$1, ChannelIdent<'r'>>;
+/**
+ * The `g` origin channel — green in `color(srgb ...)`. Serializes bare as `g`.
+ *
+ * @since 0.2.0
+ */
+declare const G: Calc<never, None$1, ChannelIdent<'g'>>;
+/**
+ * The `b` origin channel — blue in `color(srgb ...)`. Serializes bare as `b`.
+ *
+ * @since 0.2.0
+ */
+declare const B: Calc<never, None$1, ChannelIdent<'b'>>;
+/**
+ * The `alpha` origin channel — the opacity of the `from` origin, in `oklch`
+ * and `color(srgb ...)` alike. Serializes bare as `alpha`.
+ *
+ * @since 0.2.0
+ */
+declare const Alpha: Calc<never, None$1, ChannelIdent<'alpha'>>;
+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 = ChannelIdent<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 = ChannelIdent<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<ChannelIdent<'l'> | ChannelIdent<'c'> | ChannelIdent<'h'> | ChannelIdent<'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<ChannelIdent<'r'> | ChannelIdent<'g'> | ChannelIdent<'b'> | ChannelIdent<'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' variables. 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' variables.
+ * @example
+ * ```ts
+ * const hue = HueInterpolation.interpolate(HueInterpolation.shorter, 30, Calc.var('to'), Calc.var('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 Any = never, T extends Any = never, P extends Any = 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$1 as bind, channels, equals$2 as equals, from, isColor, lightDark, mix, named, oklch, serialize$1 as serialize, srgb, transparent, _var$1 as var, vars$2 as vars };
+}
+declare const ColorVars: 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 `Vars` parameter unions the channels' unbound variable
+ * 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
+ * `var` (or the `transparent` constant).
+ *
+ * @since 0.1.0
+ */
+interface Color<out Vars extends Any = Any> extends Pipeable {
+  readonly [ColorTypeId]: ColorTypeId;
+  readonly [ColorVars]?: Vars;
+}
+/**
+ * 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<Any>;
+/**
+ * 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' variables unioned.
+ * @example
+ * ```ts
+ * const accent = Color.oklch(Calc.var('lightness'), 0.15, 220)
+ * Color.serialize(accent) // 'oklch(var(--lightness) 0.15 220)'
+ * ```
+ * @since 0.1.0
+ */
+declare const oklch: <L extends Any = never, C extends Any = never, H extends Any = 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' variables 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 Any = never, G extends Any = never, B extends Any = 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 variables, 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>;
+type ReadVars$1<V> = V extends Var<infer N, infer T, infer F> ? Var<N, T> | ReadFallbackVars$1<F> : never;
+type ReadFallbackVars$1<F> = F extends Color<infer W> ? W : F extends Any ? ReadVars$1<F> : never;
+type ReadGuard$1<V> = V extends Var<string, infer T, infer F> ? [unknown] extends [T] ? FallbackGuard$1<F> : T extends Color<Any> ? FallbackGuard$1<F> : 'this read is declared inside calc: a numeric read lifts with Calc.var' : never;
+type FallbackGuard$1<F> = [F] extends [undefined] ? unknown : F extends string ? unknown : F extends Color<Any> ? unknown : F extends Var<string, infer T2, infer F2> ? [unknown] extends [T2] ? FallbackGuard$1<F2> : T2 extends Color<Any> ? FallbackGuard$1<F2> : 'a calc-declared read cannot fall back inside a color' : 'a color fallback is a Color, color text, or a Var read';
+declare const _var$1: {
+  /**
+   * Creates a color-valued read of a CSS variable — `Color.var('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`). Exported as `var` (`Color.var('accent')`)
+   * because `var` is reserved in declaration position.
+   *
+   * The read is the whole value, so it carries `name` as its one unbound
+   * variable — a dependency, exactly as an unbound `Calc.var` is — but has
+   * no channels. `bind` substitutes channel expressions, not whole colors,
+   * so it leaves a color variable in place; the browser resolves it from
+   * the cascade.
+   *
+   * Sugar for the read overload: `Color.var('accent')` is
+   * `Color.var(Var.of('accent'))`.
+   *
+   * @param name - The variable name, without the `--` prefix. Must be non-empty.
+   * @returns A `Color` with `name` as its one unbound variable.
+   * @throws `Error` when `name` is empty.
+   * @example
+   * ```ts
+   * Color.serialize(Color.var('accent')) // 'var(--accent)'
+   * ```
+   * @since 0.2.0
+   */
+  <Name extends string>(name: Name): Color<Var<Name>>;
+  /**
+   * Lifts a `Var` read into a color-valued expression. A fallback-carrying
+   * read renders its fallback (`var(--accent, red)`), which must be
+   * color-valued here — a `Color`, literal color text, or another such
+   * read, recursively. Anything else is a type error at this lift, backed
+   * by a runtime check.
+   *
+   * The returned color's `Vars` unions the read's identity with its
+   * fallback chain's, flattened, and every name joins the dependency
+   * report. As with the bare form, `bind` leaves the read itself in place
+   * (channel substitution cannot produce a whole color), though it does
+   * substitute inside a fallback's channels.
+   *
+   * @param read - The read to lift, from `Var.of` or `Var.color` (optionally through `Var.fallback`).
+   * @returns A `Color` reading the read's name, with its fallback chain's reads unioned in.
+   * @throws `Error` when the read is calc-declared, or its fallback chain holds anything but colors, color text, and reads.
+   * @example
+   * ```ts
+   * const accent = Var.of('accent')
+   * Color.serialize(Color.var(accent.pipe(Var.fallback('rebeccapurple'))))
+   * // 'var(--accent, rebeccapurple)'
+   * ```
+   * @since 0.4.0
+   */
+  <V extends Any>(read: V & ReadGuard$1<V>): Color<ReadVars$1<V>>;
+};
+/**
+ * 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' variables 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 Any = never, B extends Any = never>(light: Color<A>, dark: Color<B>) => Color<A | B>;
+type MixArm<C extends Any, P extends Any> = Color<C> | readonly [Color<C>, number | Calc<P, Percentage$1, 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 variables 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' variables.
+ * @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 Any = never, P1 extends Any = never, C2 extends Any = never, P2 extends Any = never>(space: ColorSpace, color1: MixArm<C1, P1>, color2: MixArm<C2, P2>): Color<C1 | P1 | C2 | P2>;
+  <C1 extends Any = never, P1 extends Any = never, C2 extends Any = never, P2 extends Any = 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 (`ChannelIdent`) 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.var`, a `clamp`)
+ * carries no channel keyword and fits any slot.
+ *
+ * @since 0.2.0
+ */
+type RelativeChannel<Vars extends Any, Channels> = number | None | Calc<Vars, None$1, 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 variables 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 `var`.
+ * @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' variables.
+ * @example
+ * ```ts
+ * const hover = Color.from(Color.var('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.var('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 Any = never, Space extends ColorSpace = ColorSpace, C1 extends Any = never, C2 extends Any = never, C3 extends Any = never, A extends Any = 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$1: {
+  /**
+   * Returns a function that binds the given names in a color's channels.
+   *
+   * @param bindings - Variable names to values or expressions.
+   * @returns A function replacing bound variables in its argument.
+   * @since 0.1.0
+   */
+  <const B extends Bindings>(bindings: B): <Vars extends Any>(color: Color<Vars>) => Color<ApplyBindings<Vars, B>>;
+  /**
+   * Replaces variables in the color's channels with values or other
+   * expressions, re-folding constant subtrees. Semantics match
+   * `Calc.bind`: unread names and `undefined` values are ignored, and
+   * expression-valued bindings contribute their own variables.
+   *
+   * @param color - The color to bind.
+   * @param bindings - Variable names to values or expressions.
+   * @returns The bound color.
+   * @since 0.1.0
+   */
+  <Vars extends Any, const B extends PartialBindings<Vars>>(color: Color<Vars>, bindings: B): Color<ApplyBindings<Vars, 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.var('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$1: <Vars extends Any>(color: Color<Vars>, options?: SerializeOptions<Vars>) => string;
+/**
+ * The color's unbound variable names, unioned across channels.
+ *
+ * @param color - The color to inspect.
+ * @returns The set of unbound variable names.
+ * @since 0.1.0
+ */
+declare const vars$2: <Vars extends Any>(color: Color<Vars>) => ReadonlySet<Name<Vars>>;
+/**
+ * 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.idents`, and the mirror of `vars`: where
+ * `vars` 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 variable — so a channel token never appears in `vars` 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.var('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+ * Color.channels(hover) // Set { 'l', 'c', 'h' }
+ * Color.vars(hover) // Set { 'accent' }
+ * ```
+ * @since 0.2.0
+ */
+declare const channels: (color: Color<Any>) => ReadonlySet<string>;
+declare const equals$2: {
+  /**
+   * 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<Any>): (self: Color<Any>) => 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<Any>, that: Color<Any>): boolean;
+};
+declare namespace length_d_exports {
+  export { Length, em, px, rem, vh, vmax, vmin, vw };
+}
+/**
+ * A `<length>` expression: a `Calc` of length kind, in any length unit. Names
+ * the dimension without spelling `Calc<Vars, Unit.Length, unknown>` —
+ * `Length.px(16)` produces one, and it composes with every `Calc` combinator
+ * (adding two lengths is a length, dividing one by another is a number). `Vars`
+ * unions the unbound variable names, as on `Calc`.
+ *
+ * The result is the widened `Unit.Length` and the requirements stay open, so
+ * a mixed-unit sum (`Calc.add(Length.px(16), Length.vw(2))`) and every
+ * single-unit length are alike assignable to it. Declared as an
+ * interface so the name survives inference — the shape a typed `Var`'s
+ * `Type` slot displays.
+ *
+ * @since 0.2.0
+ */
+interface Length<out Vars extends Any = Any> extends Calc<Vars, Length$1, unknown> {}
+/**
+ * A length in `px` (absolute pixels).
+ *
+ * @param value - The pixel count.
+ * @param precision - Optional serialization precision.
+ * @returns A `px` length expression.
+ * @example
+ * ```ts
+ * Calc.serialize(Length.px(16)) // '16px'
+ * ```
+ * @since 0.2.0
+ */
+declare const px: (value: number, precision?: Precision) => Calc<never, Px, Px>;
+/**
+ * A length in `rem` (relative to the root font size).
+ *
+ * @param value - The multiple of the root font size.
+ * @param precision - Optional serialization precision.
+ * @returns A `rem` length expression.
+ * @since 0.2.0
+ */
+declare const rem: (value: number, precision?: Precision) => Calc<never, Rem, Rem>;
+/**
+ * A length in `em` (relative to the element font size).
+ *
+ * @param value - The multiple of the element font size.
+ * @param precision - Optional serialization precision.
+ * @returns An `em` length expression.
+ * @since 0.2.0
+ */
+declare const em: (value: number, precision?: Precision) => Calc<never, Em, Em>;
+/**
+ * A length in `vw` (1% of the viewport width).
+ *
+ * @param value - The percentage of viewport width.
+ * @param precision - Optional serialization precision.
+ * @returns A `vw` length expression.
+ * @since 0.2.0
+ */
+declare const vw: (value: number, precision?: Precision) => Calc<never, Vw, Vw>;
+/**
+ * A length in `vh` (1% of the viewport height).
+ *
+ * @param value - The percentage of viewport height.
+ * @param precision - Optional serialization precision.
+ * @returns A `vh` length expression.
+ * @since 0.2.0
+ */
+declare const vh: (value: number, precision?: Precision) => Calc<never, Vh, Vh>;
+/**
+ * A length in `vmin` (1% of the smaller viewport axis).
+ *
+ * @param value - The percentage of the smaller viewport axis.
+ * @param precision - Optional serialization precision.
+ * @returns A `vmin` length expression.
+ * @since 0.2.0
+ */
+declare const vmin: (value: number, precision?: Precision) => Calc<never, Vmin, Vmin>;
+/**
+ * A length in `vmax` (1% of the larger viewport axis).
+ *
+ * @param value - The percentage of the larger viewport axis.
+ * @param precision - Optional serialization precision.
+ * @returns A `vmax` length expression.
+ * @since 0.2.0
+ */
+declare const vmax: (value: number, precision?: Precision) => Calc<never, Vmax, Vmax>;
+declare namespace lengthPercentage_d_exports {
+  export { LengthPercentage, of$3 as of };
+}
+/**
+ * A `<length-percentage>` expression: a `Calc` whose Result spans the
+ * length and percentage families. Every plain length and every percentage
+ * is assignable to it; anchoring an operation on one admits operands from
+ * both families, and the sum stays a `<length-percentage>`.
+ *
+ * Declared as an interface rather than a type alias so the name survives
+ * inference — the shape a `Var.lengthPercentage` handle's `Type` slot
+ * displays.
+ *
+ * @since 0.4.0
+ */
+interface LengthPercentage<out Vars extends Any = Any> extends Calc<Vars, LengthPercentage$1, unknown> {}
+type VarsOf$1<A> = A extends Calc<infer V, Any$1, unknown> ? V : never;
+type RequiresOf$1<A> = A extends Calc<Any, Any$1, infer Q> ? Q : never;
+/**
+ * Widens a length or percentage expression to a `<length-percentage>` —
+ * the identity at runtime, an anchor at the type level. Widening is what
+ * unlocks mixing: the combinators key their operand family on the first
+ * argument, so `Calc.subtract(LengthPercentage.of(Percentage.of(100)),
+ * Length.px(24))` builds `calc(100% - 24px)` where the unwidened spelling
+ * is a cross-family type error.
+ *
+ * A `<length-percentage>` read (`Calc.var(Var.lengthPercentage('inset'))`)
+ * is already this wide; `of` serves values built from concrete units.
+ *
+ * @param value - A length, percentage, or already-mixed expression.
+ * @returns The same expression, typed as a `<length-percentage>`.
+ * @example
+ * ```ts
+ * const inset = LengthPercentage.of(Percentage.of(100))
+ * Calc.serialize(Calc.subtract(inset, Length.px(24))) // 'calc(100% - 24px)'
+ * ```
+ * @since 0.4.0
+ */
+declare const of$3: <A extends Calc<Any, LengthPercentage$1, unknown>>(value: A) => Calc<VarsOf$1<A>, LengthPercentage$1, RequiresOf$1<A>>;
+declare namespace numeric_d_exports {
+  export { Numeric };
+}
+/**
+ * A `<number>` expression: a `Calc` of number result, in no unit. Names the
+ * dimension without spelling `Calc<Vars, Unit.None, unknown>` — `Calc.of(4)`
+ * produces one, as does any combinator whose operands cancel to a number.
+ * `Vars` unions the unbound variable names, as on `Calc`.
+ *
+ * The requirements stay open: a number-result expression can still carry
+ * requirements (a relative-color channel ident, or the units of a
+ * `vw / px` ratio), so no signature may assume number-result means
+ * requirement-free.
+ *
+ * Declared as an interface rather than a type alias so the name survives
+ * inference — this is the shape the `Type` slot of a typed `Var` displays,
+ * and an alias would expand to its `Calc` spelling there.
+ *
+ * @since 0.4.0
+ */
+interface Numeric<out Vars extends Any = Any> extends Calc<Vars, None$1, unknown> {}
+declare namespace percentage_d_exports {
+  export { Percentage, of$2 as of };
+}
+/**
+ * A `<percentage>` expression: a `Calc` of percentage kind. Names the dimension
+ * without spelling `Calc<Vars, Unit.Percentage, unknown>` —
+ * `Percentage.of(40)` produces one, and it composes with every `Calc`
+ * combinator (adding two percentages is a percentage, one over another is a
+ * number). `Vars` unions the unbound variable names, as on `Calc`.
+ *
+ * @since 0.2.0
+ */
+interface Percentage<out Vars extends Any = Any> extends Calc<Vars, Percentage$1, unknown> {}
+/**
+ * A percentage — a number rendered with a trailing `%`. `Percentage.of(40)`
+ * serializes as `40%`. The value passes through unrounded; the optional
+ * `Precision` pins serialization exactly as `Calc.of` does.
+ *
+ * @param value - The percentage magnitude (`40` for `40%`, not `0.4`).
+ * @param precision - Optional serialization precision.
+ * @returns A `<percentage>` expression.
+ * @example
+ * ```ts
+ * Calc.serialize(Percentage.of(40)) // '40%'
+ * Calc.serialize(Calc.add(Percentage.of(20), Percentage.of(5))) // '25%'
+ * Calc.solve(Percentage.of(50), { units: { '%': 320 / 100 } }) // 160
+ * ```
+ * @since 0.2.0
+ */
+declare const of$2: (value: number, precision?: Precision) => Calc<never, Percent, Percent>;
+declare namespace var_d_exports {
+  export { Any, Fallback, Identity, Name, Type, Var, angle, color, equals$1 as equals, fallback, isVar, length, lengthPercentage, name, number, of$1 as of, percentage, vars$1 as vars };
+}
+declare const VarVariance: unique symbol;
+/**
+ * A read of a CSS custom property: one `var()` invocation, modeled as a
+ * value. A bare read (`Var.of('gap')`) doubles as the property's canonical
+ * handle — the one value a consumer exports for a property — and
+ * site-specific reads derive from it through `fallback` without disturbing
+ * it.
+ *
+ * Three type parameters track the read:
+ *
+ * - `Name` — the property name, without the `--` prefix. This is the
+ *   read's identity: it is what the `Vars` parameter of `Calc`, `Color`,
+ *   and the containers unions, and what the runtime `vars()` reports list.
+ * - `Type` — the declared value type, `unknown` while undeclared. The
+ *   vocabulary is the data types themselves: `length('gap')` is a
+ *   `Var<'gap', Length>`, `color('accent')` a `Var<'accent', Color>`. A
+ *   declared type gives the read a Result at the lift, types its
+ *   bindings, and drives `PropertyRule.make`'s syntax derivation; an
+ *   undeclared read lifts as a `<number>` with unconstrained bindings.
+ * - `Fallback` — the fallback value, `undefined` on a bare read. The slot
+ *   is generic here: what a fallback may be depends on where the read
+ *   lands, and each admitting context (`Declaration.Value`, `Calc.var`,
+ *   `Color.var`) constrains it there.
+ *
+ * A read is not itself an expression. `Calc.var` and `Color.var` lift it
+ * into their worlds, and a declaration accepts it directly as a whole
+ * value (`Declaration.make('font-family', stack)` renders
+ * `font-family: var(--stack)`).
+ *
+ * Values are immutable and structurally comparable via `equals` — two
+ * reads of the same property with different fallbacks are different
+ * values that report the same dependency.
+ *
+ * @since 0.4.0
+ */
+interface Var<out Name extends string = string, out Type = unknown, out Fallback = undefined> extends Pipeable {
+  readonly [VarTypeId]: VarTypeId;
+  readonly [VarVariance]?: {
+    readonly name: Name;
+    readonly type: Type;
+    readonly fallback: Fallback;
+  };
+}
+/**
+ * The widest read — any name, any declared type, any fallback. The
+ * supertype every read extends, used to constrain a parameter before its
+ * facets are extracted.
+ *
+ * @since 0.4.0
+ */
+type Any = Var<string, unknown, unknown>;
+/**
+ * The property name a read carries — `Name<Var<'gap'>>` is `'gap'`.
+ * Distributes over unions, so applying it to a `Vars` phantom recovers the
+ * name union the runtime `vars()` sets mirror.
+ *
+ * @since 0.4.0
+ */
+type Name<V extends Any> = V extends Var<infer N, unknown, unknown> ? N : never;
+/**
+ * The declared value type a read carries — `unknown` while undeclared.
+ *
+ * @since 0.4.0
+ */
+type Type<V extends Any> = V extends Var<string, infer T, unknown> ? T : never;
+/**
+ * The fallback value a read carries — `undefined` on a bare read.
+ *
+ * @since 0.4.0
+ */
+type Fallback<V extends Any> = V extends Var<string, unknown, infer F> ? F : never;
+/**
+ * A read stripped to its identity: the name-and-type pair, fallback slot
+ * cleared. This is what phantoms union — `Calc.var` on
+ * `var(--x, var(--y))` returns a `Calc<Var<'x'> | Var<'y'>>`, identities
+ * flattened, never a nested read.
+ *
+ * @since 0.4.0
+ */
+type Identity<V extends Any> = V extends Var<infer N, infer T, unknown> ? Var<N, T> : never;
+/**
+ * Checks if a value is a `Var`.
+ *
+ * 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 `Var`, `false` otherwise.
+ * @since 0.4.0
+ */
+declare const isVar: (u: unknown) => u is Any;
+/**
+ * Creates a bare read of a custom property — the property's canonical
+ * handle. Accepted wherever a read is: as a declaration value, lifted by
+ * `Calc.var` or `Color.var`, and (as sugar) both lifts also take the bare
+ * name directly, so `Calc.var('gap')` and `Calc.var(Var.of('gap'))` are
+ * the same expression.
+ *
+ * The read is undeclared: it lifts as a `<number>` and its bindings are
+ * unconstrained. The typed constructors (`number`, `length`, `angle`,
+ * `percentage`, `color`) declare a value type instead.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare undeclared read of `--name`.
+ * @throws `Error` when `name` is empty.
+ * @example
+ * ```ts
+ * const gap = Var.of('gap')
+ * Calc.serialize(Calc.var(gap)) // 'var(--gap)'
+ * ```
+ * @since 0.4.0
+ */
+declare const of$1: <Name extends string>(name: Name) => Var<Name>;
+/**
+ * Creates a read declared `<number>`. The declaration types the channel
+ * end to end: the read lifts as a number-result expression (as an
+ * undeclared read does), `bind` and `solve` accept only number-family
+ * values for the name, and `PropertyRule.make` derives the `<number>`
+ * syntax from the handle.
+ *
+ * Repeated calls with the same name return the same instance; a
+ * differently-declared read of the same name is a different value (one
+ * name, one type is the consumer's contract — see `docs/vars.md`).
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<number>`.
+ * @throws `Error` when `name` is empty.
+ * @since 0.4.0
+ */
+declare const number: <Name extends string>(name: Name) => Var<Name, Numeric>;
+/**
+ * Creates a read declared `<length>`. The read lifts as a length-family
+ * expression — `Calc.add(Calc.var(gap), Length.px(4))` composes through
+ * the ordinary dimension algebra — its bindings take length-family
+ * values, and `PropertyRule.make` derives the `<length>` syntax.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<length>`.
+ * @throws `Error` when `name` is empty.
+ * @example
+ * ```ts
+ * const gap = Var.length('gap')
+ * Calc.serialize(Calc.add(Calc.var(gap), Length.px(4))) // 'calc(var(--gap) + 4px)'
+ * ```
+ * @since 0.4.0
+ */
+declare const length: <Name extends string>(name: Name) => Var<Name, Length>;
+/**
+ * Creates a read declared `<length-percentage>`. The read lifts spanning
+ * both families — the anchor that admits length and percentage operands
+ * beside it, so `Calc.subtract(Calc.var(inset), Length.px(24))` and a
+ * percentage subtrahend both compose — its bindings take either family
+ * (or a mix), and `PropertyRule.make` derives the `<length-percentage>`
+ * syntax.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<length-percentage>`.
+ * @throws `Error` when `name` is empty.
+ * @example
+ * ```ts
+ * const inset = Var.lengthPercentage('inset')
+ * Calc.serialize(Calc.subtract(Calc.var(inset), Length.px(24)))
+ * // 'calc(var(--inset) - 24px)'
+ * ```
+ * @since 0.4.0
+ */
+declare const lengthPercentage: <Name extends string>(name: Name) => Var<Name, LengthPercentage>;
+/**
+ * Creates a read declared `<angle>`: an angle-family read at the lift,
+ * angle-family bindings, the `<angle>` syntax under `PropertyRule.make`.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<angle>`.
+ * @throws `Error` when `name` is empty.
+ * @since 0.4.0
+ */
+declare const angle: <Name extends string>(name: Name) => Var<Name, Angle>;
+/**
+ * Creates a read declared `<percentage>`: a percentage-family read at the
+ * lift, percentage-family bindings, the `<percentage>` syntax under
+ * `PropertyRule.make`.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<percentage>`.
+ * @throws `Error` when `name` is empty.
+ * @since 0.4.0
+ */
+declare const percentage: <Name extends string>(name: Name) => Var<Name, Percentage>;
+/**
+ * Creates a read declared `<color>`. A color does not participate in calc,
+ * and the type says so: the read lifts through `Color.var` (never
+ * `Calc.var`), and `PropertyRule.make` derives the `<color>` syntax.
+ *
+ * Repeated calls with the same name return the same instance.
+ *
+ * @param name - The property name, without the `--` prefix. Must be non-empty.
+ * @returns A bare read of `--name`, declared `<color>`.
+ * @throws `Error` when `name` is empty.
+ * @example
+ * ```ts
+ * const accent = Var.color('accent')
+ * Color.serialize(Color.var(accent)) // 'var(--accent)'
+ * ```
+ * @since 0.4.0
+ */
+declare const color: <Name extends string>(name: Name) => Var<Name, Color>;
+declare const fallback: {
+  /**
+   * Returns a function that derives a read carrying `fb` as its fallback.
+   *
+   * @param fb - The fallback value.
+   * @returns A function that takes a read and returns the same property's read with `fb` as its fallback.
+   * @since 0.4.0
+   */
+  <const F>(fb: F): <V extends Any>(v: V) => Var<Name<V>, Type<V>, F>;
+  /**
+   * Derives a read of the same property carrying a fallback — the second
+   * argument of the rendered `var()`, used by the browser when the
+   * property is unset. The original read is untouched: fallback is a
+   * property of the read site, not the variable, so one canonical handle
+   * derives as many site-specific reads as needed.
+   *
+   * The fallback is held opaquely here. What it may be is constrained
+   * where the read is used: a declaration value accepts any declaration
+   * value (nested reads included), `Calc.var` accepts numeric fallbacks,
+   * `Color.var` color-valued ones.
+   *
+   * A fallback joins the dependency report (`var(--x, var(--y))` reads
+   * both names) but is discarded by `bind` when its read's own name is
+   * bound, and does not reduce what `solve` requires — see `docs/vars.md`.
+   *
+   * @param v - The read to derive from.
+   * @param fb - The fallback value. Must not be `undefined`.
+   * @returns A read of the same property with `fb` as its fallback.
+   * @throws `Error` when `fb` is `undefined`.
+   * @example
+   * ```ts
+   * const gap = Var.of('gap')
+   * Calc.serialize(Calc.var(gap.pipe(Var.fallback(8)))) // 'var(--gap, 8)'
+   * ```
+   * @since 0.4.0
+   */
+  <V extends Any, const F>(v: V, fb: F): Var<Name<V>, Type<V>, F>;
+};
+/**
+ * The property name a read carries, without the `--` prefix.
+ *
+ * @param v - The read to inspect.
+ * @returns The bare property name.
+ * @since 0.4.0
+ */
+declare const name: <V extends Any>(v: V) => Name<V>;
+/**
+ * The names a read reads: its own, plus everything its fallback chain
+ * reads (`var(--x, var(--y))` reads `x` and `y`). The runtime mirror of
+ * the identities the read contributes to a `Vars` phantom when lifted.
+ *
+ * @param v - The read to inspect.
+ * @returns The set of property names read.
+ * @since 0.4.0
+ */
+declare const vars$1: (v: Any) => ReadonlySet<string>;
+declare const equals$1: {
+  /**
+   * Returns a function that checks structural equality against `that`.
+   *
+   * @param that - The read to compare against.
+   * @returns A function testing its argument for structural equality with `that`.
+   * @since 0.4.0
+   */
+  (that: Any): (self: Any) => boolean;
+  /**
+   * Structural equality: names compare as text, declared types as data
+   * (`Var.length('x')` never equals `Var.of('x')`), and fallbacks by
+   * their own structural equality (expression fallbacks as expression
+   * trees, primitive fallbacks by value). A bare read never equals a
+   * fallback-carrying one.
+   *
+   * @param self - The first read.
+   * @param that - The second read.
+   * @returns `true` if the reads are structurally equal.
+   * @since 0.4.0
+   */
+  (self: Any, that: Any): boolean;
+};
+declare namespace angle_d_exports {
+  export { Angle, deg, rad };
+}
+/**
+ * An `<angle>` expression: a `Calc` of angle kind, in any angle unit. Names the
+ * dimension without spelling `Calc<Vars, Unit.Angle, unknown>` — `Angle.rad(2)`
+ * produces one, and it composes with every `Calc` combinator (subtracting two
+ * angles is an angle, scaling by a number stays an angle). `Vars` unions the
+ * unbound variable names, as on `Calc`.
+ *
+ * The result is the widened `Unit.Angle`, so every specific angle expression
+ * is assignable to it; a constructor narrows it (`Angle.rad` carries `Unit.Rad`). Declared as an
+ * interface so the name survives inference — the shape a typed `Var`'s
+ * `Type` slot displays.
+ *
+ * @since 0.2.0
+ */
+interface Angle<out Vars extends Any = Any> extends Calc<Vars, Angle$1, unknown> {}
+/**
+ * An angle in `rad` (radians). Radians are the numeric measure of an angle, so
+ * a radian-only expression solves with no unit context.
+ *
+ * @param value - The angle in radians.
+ * @param precision - Optional serialization precision.
+ * @returns A `rad` angle expression.
+ * @example
+ * ```ts
+ * Calc.serialize(Angle.rad(1.5708)) // '1.5708rad'
+ * ```
+ * @since 0.2.0
+ */
+declare const rad: (value: number, precision?: Precision) => Calc<never, Rad, Rad>;
+/**
+ * An angle in `deg` (degrees). Degrees lower to radians at solve (`180deg` is
+ * `pi`), a fixed ratio, so a degree-only expression solves with no unit context.
+ *
+ * @param value - The angle in degrees.
+ * @param precision - Optional serialization precision.
+ * @returns A `deg` angle expression.
+ * @example
+ * ```ts
+ * Calc.serialize(Angle.deg(45)) // '45deg'
+ * ```
+ * @since 0.2.0
+ */
+declare const deg: (value: number, precision?: Precision) => Calc<never, Deg, Deg>;
+declare namespace calc_d_exports {
+  export { ApplyBindings, BindingRequires, Bindings, Calc, DeclaredType, Ident, IdentValues, Input, Kind, PartialBindings, ReadResult, SerializeOptions, SolveOptions, Top, abs, acos, add, atan2, bind, clamp, cos, divide, equals, idents, isCalc, lerp, max, min, mod, multiply, of, pow, serialize, sign, signedPow, sin, solve, subtract, tan, units, _var as var, vars };
+}
+declare const CalcVariance: unique symbol;
+declare const IdentId: unique symbol;
+/**
+ * The CSS dimension vocabulary: `<number>`, `<length>`, `<angle>`, or
+ * `<percentage>`. The algebra itself runs on `Result` unit brands compared by
+ * `Unit.Family` — CSS type-checks `calc()` at this dimension level, and the
+ * family comparison implements exactly that — so `Kind` remains as the prose
+ * and runtime vocabulary: dimensioned constants carry it, and the docs speak
+ * it. A `<percentage>` is its own dimension, not a length: it adds only to
+ * another percentage — unless the expression is anchored on a
+ * `<length-percentage>` value (a `Var.lengthPercentage` read, or
+ * `LengthPercentage.of`), which admits both families (see `docs/design.md`).
+ *
+ * @since 0.2.0
+ */
+type Kind = 'number' | 'length' | 'angle' | 'percentage';
+/**
+ * The leaf brand of a bare CSS identifier — a token like a relative color's
+ * `l` that serializes as itself and is resolved by the CSS construct around
+ * it, not read from the cascade. It rides the `Requires` parameter of `Calc`,
+ * so `solve` demands a value for the token through the `idents` section of
+ * its options, the way a relative unit demands a ratio through `units`.
+ *
+ * Constructs that introduce identifiers refine this brand: the `Channel`
+ * keywords (`Channel.L`, ...) carry a subtype scoped to their color space,
+ * and `Color.from` admits them by that subtype. Generic machinery — the
+ * solve options, `idents` — keys on this base, so every identifier source
+ * is covered without new plumbing.
+ *
+ * @since 0.2.0
+ */
+interface Ident<Name extends string = string> {
+  readonly [IdentId]: Name;
+}
+/**
+ * A CSS value expression: a tree of constants, unbound variables, and math
+ * operations that can be solved to a number, serialized to CSS `calc()`
+ * text, or partially bound and passed along.
+ *
+ * Three type parameters track the expression structurally:
+ *
+ * - `Vars` — the identities of the custom-property reads still unbound,
+ *   as `Var` values from `fashionable/var`: `var('u')` is a
+ *   `Calc<Var<'u'>>`. Combining expressions unions their reads; `bind`
+ *   subtracts the names it binds. A fully bound (or constant) expression
+ *   is a `Calc<never>`. Names stay the value-level currency — binding
+ *   records are keyed by bare name, and `vars` reports names — while the
+ *   phantom carries the identities.
+ * - `Result` — what the expression produces, as a set of `Unit` brands:
+ *   `Unit.Px` for a pure pixel length, `Unit.Px | Unit.Vw` for a mixed sum
+ *   (a composition, not an uncertainty), `Unit.None` for a `<number>`. The
+ *   algebra enforces the CSS dimension rules through it — same-family
+ *   addition, family-merging multiplication, same-family division producing
+ *   `Unit.None` — so a `<length>` plus a `<number>` is a type error.
+ * - `Requires` — what stands between the expression and a number: the unit
+ *   ratios and identifier values the matching sections of `solve`'s options
+ *   must supply (`never` when nothing is needed). Absolute units ride it
+ *   with default supplies — `px`, `rad`, and `deg` demand no entry.
+ *
+ * Values are immutable and structurally comparable via `equals`.
+ * Construction folds constant subtrees eagerly: `add(1, 2)` is the
+ * constant `3`, and binding every variable of a tree collapses it to a
+ * constant.
+ *
+ * An unbound variable serializes as `var(--name)` — the read side of a CSS
+ * custom property.
+ *
+ * Construct via `of`, `var`, the `Length`/`Angle` constructors in
+ * `fashionable/data`, and the math combinators.
+ *
+ * @since 0.1.0
+ */
+interface Calc<out Vars extends Any = Any, out Result = None$1, out Requires = never> extends Pipeable {
+  readonly [CalcTypeId]: CalcTypeId;
+  readonly [CalcVariance]?: {
+    readonly vars: Vars;
+    readonly result: Result;
+    readonly requires: Requires;
+  };
+}
+/**
+ * The widest `Calc` — the supertype every expression extends, used to
+ * constrain a combinator operand before its facets are extracted.
+ *
+ * @since 0.2.0
+ */
+type Top = Calc<Any, Any$1, unknown>;
+/** Any operand a combinator accepts: an expression of any dimension, or a bare number. */
+type In = Top | number;
+type VarsOf<A> = A extends Calc<infer X, Any$1, unknown> ? X : never;
+type ResultOf<A> = A extends Calc<Any, infer R, unknown> ? R : None$1;
+type RequiresOf<A> = A extends Calc<Any, Any$1, infer Q> ? Q : never;
+/** An operand constrained to number-result (or a bare number). */
+type NumberIn = number | Calc<Any, None$1, unknown>;
+/** An operand accepted by `sin`/`cos`: a plain number (radians) or an angle. */
+type NumberOrAngleIn = number | Calc<Any, None$1 | Angle$1, unknown>;
+/**
+ * An operand constrained to `A`'s dimension family — a bare number only when
+ * `A` is number-result, so `add(length, 1)` is rejected while
+ * `add(length, length)` holds.
+ */
+type SameKindIn<A> = Calc<Any, Family<ResultOf<A>>, unknown> | (Family<ResultOf<A>> extends None$1 ? number : never);
+type VarsOfAll<T extends ReadonlyArray<unknown>> = { [K in keyof T]: VarsOf<T[K]>; }[number];
+type ResultOfAll<T extends ReadonlyArray<unknown>> = { [K in keyof T]: ResultOf<T[K]>; }[number];
+type RequiresOfAll<T extends ReadonlyArray<unknown>> = { [K in keyof T]: RequiresOf<T[K]>; }[number];
+type IsUnion<T, U = T> = [T] extends [never] ? false : T extends T ? [U] extends [T] ? false : true : never;
+type Singleton<T> = [T] extends [never] ? false : IsUnion<T> extends true ? false : true;
+type LeafFn<X> = <T>() => T extends X ? 1 : 2;
+type LeafEqual<A, B> = LeafFn<A> extends LeafFn<B> ? true : false;
+type SameSingleton<A, B> = LeafEqual<A, B> extends true ? Singleton<A> : false;
+type DivRequires<A, B> = Family<ResultOf<B>> extends None$1 ? RequiresOf<A> | RequiresOf<B> : SameSingleton<RequiresOf<A>, RequiresOf<B>> extends true ? [Extract<RequiresOf<A>, Ident<string>>] extends [never] ? never : RequiresOf<A> | RequiresOf<B> : RequiresOf<A> | RequiresOf<B>;
+/**
+ * A value accepted where an expression is expected: an existing `Calc` or
+ * a bare number, which is coerced to an unannotated constant.
+ *
+ * @since 0.1.0
+ */
+type Input<Vars extends Any = Any> = Calc<Vars> | number;
+/**
+ * The declared type of the read named `N` in `Vars` — the identity's
+ * `Type` slot, recovered per name. `unknown` while the name is undeclared;
+ * a union when a name is declared twice (a violation of the one-name,
+ * one-type contract, met leniently).
+ *
+ * @since 0.4.0
+ */
+type DeclaredType<Vars extends Any, N extends string> = Type<Extract<Vars, Var<N, unknown, unknown>>>;
+type BindingValue<T> = [unknown] extends [T] ? Input : T extends Calc<Any, infer R, unknown> ? Calc<Any, Family<R>, unknown> | ([Family<R>] extends [None$1] ? number : never) : Input;
+/**
+ * A bindings record: bare variable names to the values that replace them.
+ * A value may itself be an expression, whose own reads join the result.
+ *
+ * Keys are names, not `Var` values — names are the value-level currency
+ * of the variables channel; the identities live in the `Vars` phantom the
+ * record is derived from (mapped over `Var.Name<Vars>`). A declared name
+ * types its value: a `Var.length` read binds only to length-family
+ * expressions, while undeclared names accept any `Input`.
+ *
+ * @since 0.1.0
+ */
+type Bindings<Vars extends Any = Any> = { readonly [N in Name<Vars>]: BindingValue<DeclaredType<Vars, N>>; };
+type ValueVars<V> = V extends Calc<infer R> ? R : never;
+type BindingVars<T> = T extends Record<string, infer V> ? ValueVars<V> : never;
+/**
+ * The read identities remaining after applying the bindings `B` to an
+ * expression with reads `Vars`: identities whose names are bound are
+ * removed, and the reads of any expression-valued bindings are added.
+ *
+ * @since 0.1.0
+ */
+type ApplyBindings<Vars extends Any, B> = (Vars extends unknown ? (Name<Vars> extends keyof B ? never : Vars) : never) | BindingVars<Pick<B, Extract<keyof B, Name<Vars>>>>;
+type ValueRequires<V> = V extends Calc<Any, Any$1, infer Q> ? Q : never;
+type RecordRequires<T> = T extends Record<string, infer V> ? ValueRequires<V> : never;
+/**
+ * What `bind` accepts for an expression with reads `Vars`: `Bindings`
+ * with every name optional (binding may be partial), intersected with a
+ * wide index signature so a record sharing no names with the expression
+ * stays legal — unread names are ignored, and without the index signature
+ * the all-optional record would be a weak type that rejects exactly the
+ * spread-a-wider-object usage the contract promises. Present names still
+ * check against their declared types through the `Bindings` half.
+ *
+ * @since 0.4.0
+ */
+type PartialBindings<Vars extends Any> = Partial<Bindings<Vars>> & {
+  readonly [name: string]: Calc<Any, Any$1, unknown> | number | undefined;
+};
+/**
+ * The requirements the bindings `B` contribute to an expression with reads
+ * `Vars`: the union of the bound values' own `Requires`, over the names
+ * the expression actually reads. This is `bind`'s side of the split with
+ * `solve` — `bind` is partial evaluation, so a bound `Length.vw(2)` may
+ * carry its `vw` requirement into the result, where `solve` is total and
+ * accepts only pre-satisfied values (see `docs/vars.md`).
+ *
+ * @since 0.4.0
+ */
+type BindingRequires<Vars extends Any, B> = RecordRequires<Pick<B, Extract<keyof B, Name<Vars>>>>;
+/**
+ * Options for `serialize`.
+ *
+ * @since 0.1.0
+ */
+interface SerializeOptions<Vars extends Any = Any> {
+  /**
+   * Bindings applied before rendering. May be partial: variables left
+   * unbound render as `var(--name)`.
+   */
+  readonly bindings?: Partial<Bindings<Vars>>;
+  /**
+   * The precision for constants that carry no annotation of their own.
+   * Defaults to `Precision.decimals(5)`.
+   */
+  readonly precision?: Precision;
+}
+type IdentName<I> = I extends Ident<infer Name> ? Name : never;
+/**
+ * The `idents` section of `SolveOptions`: a numeric value for each
+ * bare-identifier token in the requirements `R`. The value is the token's
+ * own — read directly, not multiplied as a ratio — so `{ l: 0.62 }` supplies
+ * the relative-color `l` keyword.
+ *
+ * @since 0.4.0
+ */
+type IdentValues<R> = { readonly [K in IdentName<Extract<R, Ident<string>>> & string]: number; };
+/**
+ * Options for `solve`: the environments that satisfy an expression's
+ * dependency channels. Each section is required exactly when the
+ * expression's type demands it — `bindings` while unbound variables remain,
+ * `units` while a relative unit or percentage is present, `idents` while a
+ * bare identifier is — and optional otherwise.
+ *
+ * - `bindings` — a closed value (a number or a `Calc<never>`) for every
+ *   unbound variable. Substitution, as in `bind`, but total: a value
+ *   carrying its own unbound variables is a type error here, since nothing
+ *   later could close it.
+ * - `units` — a pixels-per-unit ratio for every context-dependent unit:
+ *   `vw` is `sampleWidth / 100`, `%` is `basis / 100`. Absolute lengths
+ *   default (`px` is `1`) unless overridden; angles never appear (radians
+ *   and degrees lower on their own).
+ * - `idents` — the value each bare-identifier token stands for
+ *   (`{ l: 0.62 }`).
+ *
+ * @since 0.4.0
+ */
+type SolveBindingValue<T> = [unknown] extends [T] ? Input<never> : T extends Calc<Any, infer R, unknown> ? Calc<never, Family<R>, ContextFree> | ([Family<R>] extends [None$1] ? number : never) : Input<never>;
+type SolveOptions<Vars extends Any, R> = ([Vars] extends [never] ? {
+  readonly bindings?: Record<string, Input<never>>;
+} : {
+  readonly bindings: { readonly [N in Name<Vars>]: SolveBindingValue<DeclaredType<Vars, N>>; };
+}) & ([Exclude<R, ContextFree | Ident<string>>] extends [never] ? {
+  readonly units?: UnitContext<R>;
+} : {
+  readonly units: UnitContext<R>;
+}) & ([Extract<R, Ident<string>>] extends [never] ? {
+  readonly idents?: IdentValues<R>;
+} : {
+  readonly idents: IdentValues<R>;
+});
+/**
+ * Checks if a value is a `Calc`.
+ *
+ * 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 `Calc`, `false` otherwise.
+ * @since 0.1.0
+ */
+declare const isCalc: (u: unknown) => u is Calc<Any, Any$1, unknown>;
+/**
+ * Creates a constant expression, optionally annotated with a serialization
+ * precision that overrides the context default wherever the constant lands
+ * — including in constants produced by folding it with others (the
+ * highest-fidelity operand annotation wins).
+ *
+ * Bare numbers passed to combinators become unannotated constants; `of`
+ * exists to name a value or pin its precision.
+ *
+ * @param value - The constant value. Must be finite.
+ * @param precision - Optional precision annotation.
+ * @returns A constant `Calc<never>`.
+ * @throws `Error` when `value` is not finite.
+ * @example
+ * ```ts
+ * const k = Calc.of(0.8377580409572781, Precision.significant(10))
+ * Calc.serialize(Calc.multiply(k, Calc.var('t'))) // 'calc(0.837758041 * var(--t))'
+ * ```
+ * @since 0.1.0
+ */
+declare const of: (value: number, precision?: Precision) => Calc<never>;
+/**
+ * The Result a lifted read produces: its declared type's Result when the
+ * declaration is calc-shaped — the trait is the `Result` parameter itself,
+ * read structurally — and `Unit.None` while the read is undeclared.
+ *
+ * @since 0.4.0
+ */
+type ReadResult<T> = T extends Calc<Any, infer R, unknown> ? R : None$1;
+type ReadVars<V> = V extends Var<infer N, infer T, infer F> ? Var<N, T> | ReadFallbackVars<F> : never;
+type ReadFallbackVars<F> = F extends Calc<infer W, Any$1, unknown> ? W : F extends Any ? ReadVars<F> : never;
+type ReadGuard<V> = V extends Var<string, infer T, infer F> ? [unknown] extends [T] ? FallbackGuard<F, None$1> : T extends Calc<Any, Any$1, unknown> ? FallbackGuard<F, Family<ReadResult<T>>> : 'this read is declared outside calc: a color-typed read lifts with Color.var' : never;
+type FallbackGuard<F, Fam> = [F] extends [undefined] ? unknown : F extends number ? [Fam] extends [None$1] ? unknown : 'a bare-number fallback fits only a number-result read' : F extends Calc<Any, infer R, unknown> ? [Family<R>] extends [Fam] ? unknown : "this fallback's family does not match the read's declared type" : F extends Var<string, infer T2, infer F2> ? [unknown] extends [T2] ? [None$1] extends [Fam] ? FallbackGuard<F2, Fam> : "an undeclared nested read is number-result; declare it to match the outer read's family" : T2 extends Calc<Any, Any$1, unknown> ? [Family<ReadResult<T2>>] extends [Fam] ? FallbackGuard<F2, Fam> : "a nested read's declared family must match the outer read's" : 'a color-typed read cannot fall back inside calc' : 'a calc fallback is a number, a Calc expression, or a Var read';
+declare const _var: {
+  /**
+   * Creates a read of a CSS variable (custom property): `var('width')`
+   * serializes as `var(--width)`. Variables are the substitutable
+   * dependency channel — `bind` replaces them with values or other
+   * expressions, and an expression's `Vars` parameter tracks the reads
+   * still unbound. Exported as `var` (`Calc.var('width')`) because `var`
+   * is reserved in declaration position.
+   *
+   * Sugar for the read overload: `Calc.var('width')` is
+   * `Calc.var(Var.of('width'))`. Repeated calls with the same name return
+   * the same instance.
+   *
+   * @param name - The variable name, without the `--` prefix. Must be non-empty.
+   * @returns A `Calc` reading `name`, its one unbound variable.
+   * @throws `Error` when `name` is empty.
+   * @example
+   * ```ts
+   * Calc.serialize(Calc.var('width')) // 'var(--width)'
+   * ```
+   * @since 0.1.0
+   */
+  <Name extends string>(name: Name): Calc<Var<Name>>;
+  /**
+   * Lifts a `Var` read into an expression. The read's declared type sets
+   * the expression's Result: a `Var.length` read is a length-family
+   * expression that composes through the ordinary dimension algebra, an
+   * undeclared read is a `<number>` as before, and a color-typed read is
+   * rejected — it lifts with `Color.var`.
+   *
+   * A fallback-carrying read renders its fallback (`var(--gap, 8)`),
+   * which must land in the read's family: a bare number only under a
+   * number-result read, a `Calc` of the declared family (rendered under
+   * the normal rules, so arithmetic gets a nested `calc()` wrapper), or
+   * another read of the same family, recursively. Anything else is a type
+   * error at this lift, backed by a runtime check on the world (family
+   * fidelity within calc is the type level's job alone, as everywhere
+   * else in the algebra).
+   *
+   * The returned expression's `Vars` unions the read's identity with its
+   * fallback chain's, flattened — `var(--x, var(--y))` is a
+   * `Calc<Var<'x'> | Var<'y'>>`, and both names join the dependency
+   * report. Binding the read's own name replaces the whole read and
+   * discards the fallback; a fallback never reduces what `solve`
+   * requires (see `docs/vars.md`).
+   *
+   * @param read - The read to lift, from `Var.of` or a typed constructor (optionally through `Var.fallback`).
+   * @returns A `Calc` of the read's declared family, with its fallback chain's reads unioned in.
+   * @throws `Error` when the read is color-declared, or its fallback chain holds anything but numbers, `Calc` expressions, and reads.
+   * @example
+   * ```ts
+   * const gap = Var.length('gap')
+   * Calc.serialize(Calc.add(Calc.var(gap), Length.px(4))) // 'calc(var(--gap) + 4px)'
+   * ```
+   * @since 0.4.0
+   */
+  <V extends Any>(read: V & ReadGuard<V>): Calc<ReadVars<V>, ReadResult<Type<V>>, never>;
+};
+/**
+ * Adds expressions. Constant operands fold at construction.
+ *
+ * Serializes as `a + b + ...` inside a `calc()` wrapper; negative constant
+ * terms (and products led by a negative constant) render subtractively:
+ * `a + (-2)` serializes as `a - 2`.
+ *
+ * @param a - The first operand.
+ * @param b - The second operand, sharing `a`'s dimension.
+ * @returns The sum, with the operands' variables, results, and requirements unioned.
+ * @example
+ * ```ts
+ * Calc.serialize(Calc.add(Calc.var('x'), 10)) // 'calc(var(--x) + 10)'
+ * ```
+ * @since 0.1.0
+ */
+declare const add: <A extends In, B extends SameKindIn<A>, Rest extends ReadonlyArray<SameKindIn<A>>>(a: A, b: B, ...rest: Rest) => Calc<VarsOf<A> | VarsOf<B> | VarsOfAll<Rest>, ResultOf<A> | ResultOf<B> | ResultOfAll<Rest>, RequiresOf<A> | RequiresOf<B> | RequiresOfAll<Rest>>;
+/**
+ * Subtracts `right` from `left`. Constant operands fold at construction.
+ *
+ * @param left - The minuend.
+ * @param right - The subtrahend, sharing `left`'s dimension.
+ * @returns The difference, with the operands' variables, results, and requirements unioned.
+ * @since 0.1.0
+ */
+declare const subtract: <A extends In, B extends SameKindIn<A>>(left: A, right: B) => Calc<VarsOf<A> | VarsOf<B>, ResultOf<A> | ResultOf<B>, RequiresOf<A> | RequiresOf<B>>;
+/**
+ * The CSS `mod()` of `dividend` and `divisor` — the remainder that takes the
+ * sign of the divisor (the floored modulo), so `mod(x, 360)` lands in
+ * `[0, 360)` for a positive divisor. Same-dimension operands, as `subtract`;
+ * constant operands fold at construction.
+ *
+ * @param dividend - The value to reduce.
+ * @param divisor - The modulus, sharing `dividend`'s dimension.
+ * @returns The modulo, with the operands' variables, results, and requirements unioned.
+ * @example
+ * ```ts
+ * Calc.serialize(Calc.mod(Calc.var('h'), 360)) // 'mod(var(--h), 360)'
+ * ```
+ * @since 0.2.0
+ */
+declare const mod: <A extends In, B extends SameKindIn<A>>(dividend: A, divisor: B) => Calc<VarsOf<A> | VarsOf<B>, ResultOf<A> | ResultOf<B>, RequiresOf<A> | RequiresOf<B>>;
+/**
+ * Multiplies expressions. One factor must be a `<number>`; the dimensioned
+ * factor's result rides through. Constant operands fold at construction.
+ *
+ * Addition and subtraction operands are parenthesized when serialized
+ * under a product: `(a + b) * c`.
+ *
+ * @param left - The first factor.
+ * @param right - The second factor.
+ * @returns The product, carrying the dimensioned factor's result and both operands' variables and requirements.
+ * @since 0.1.0
+ */
+declare const multiply: {
+  <A extends NumberIn, B extends In>(left: A, right: B): Calc<VarsOf<A> | VarsOf<B>, ResultOf<B>, RequiresOf<A> | RequiresOf<B>>;
+  <A extends In, B extends NumberIn>(left: A, right: B): Calc<VarsOf<A> | VarsOf<B>, ResultOf<A>, RequiresOf<A> | RequiresOf<B>>;
+};
+/**
+ * Divides `left` by `right`. Constant operands fold at construction.
+ *
+ * Dividing by a `<number>` keeps the dividend's result; dividing two
+ * same-dimension expressions produces a `<number>` (`Unit.None`) — the
+ * units cancel. The requirements discharge only where folding guarantees
+ * they can: a same-single-unit division always folds once bound, so its
+ * requirement drops; anything mixed keeps both operands'.
+ *
+ * @param left - The dividend.
+ * @param right - The divisor: a number, or an expression sharing `left`'s dimension.
+ * @returns The quotient, with the operands' variables unioned.
+ * @since 0.1.0
+ */
+declare const divide: {
+  <A extends In, B extends NumberIn>(left: A, right: B): Calc<VarsOf<A> | VarsOf<B>, ResultOf<A>, DivRequires<A, B>>;
+  <A extends In, B extends SameKindIn<A>>(left: A, right: B): Calc<VarsOf<A> | VarsOf<B>, None$1, DivRequires<A, B>>;
+};
+/**
+ * Raises `base` to `exponent`. Serializes as the CSS `pow()` function,
+ * whose operands are `<number>`s — so both take number-result expressions,
+ * which may carry identifier requirements (`pow(l, 2.2)` gamma-adjusts a
+ * relative-color channel).
+ *
+ * @param base - The base.
+ * @param exponent - The exponent.
+ * @returns The power, a `<number>`, with the operands' variables and requirements unioned.
+ * @since 0.1.0
+ */
+declare const pow: <A extends NumberIn, B extends NumberIn>(base: A, exponent: B) => Calc<VarsOf<A> | VarsOf<B>, None$1, RequiresOf<A> | RequiresOf<B>>;
+/**
+ * Sign-preserving power: `abs(base) ^ exponent * sign(base)`. Unlike
+ * `pow`, well-defined for negative bases with fractional exponents.
+ * Serializes as `pow(abs(base), exponent) * sign(base)`.
+ *
+ * @param base - The base.
+ * @param exponent - The exponent.
+ * @returns The signed power, a `<number>`, with the operands' variables and requirements unioned.
+ * @since 0.1.0
+ */
+declare const signedPow: <A extends NumberIn, B extends NumberIn>(base: A, exponent: B) => Calc<VarsOf<A> | VarsOf<B>, None$1, RequiresOf<A> | RequiresOf<B>>;
+/**
+ * The minimum of the operands. Serializes as the CSS `min()` function.
+ *
+ * @param a - The first operand.
+ * @param b - The second operand, sharing `a`'s dimension.
+ * @returns The minimum, with the operands' variables, results, and requirements unioned.
+ * @since 0.1.0
+ */
+declare const min: <A extends In, B extends SameKindIn<A>, Rest extends ReadonlyArray<SameKindIn<A>>>(a: A, b: B, ...rest: Rest) => Calc<VarsOf<A> | VarsOf<B> | VarsOfAll<Rest>, ResultOf<A> | ResultOf<B> | ResultOfAll<Rest>, RequiresOf<A> | RequiresOf<B> | RequiresOfAll<Rest>>;
+/**
+ * The maximum of the operands. Serializes as the CSS `max()` function.
+ *
+ * @param a - The first operand.
+ * @param b - The second operand, sharing `a`'s dimension.
+ * @returns The maximum, with the operands' variables, results, and requirements unioned.
+ * @since 0.1.0
+ */
+declare const max: <A extends In, B extends SameKindIn<A>, Rest extends ReadonlyArray<SameKindIn<A>>>(a: A, b: B, ...rest: Rest) => Calc<VarsOf<A> | VarsOf<B> | VarsOfAll<Rest>, ResultOf<A> | ResultOf<B> | ResultOfAll<Rest>, RequiresOf<A> | RequiresOf<B> | RequiresOfAll<Rest>>;
+/**
+ * Clamps `value` between `minimum` and `maximum`. Serializes as the CSS
+ * `clamp()` function, with the CSS argument order `(min, value, max)`.
+ *
+ * @param minimum - The lower bound.
+ * @param value - The value to clamp, sharing `minimum`'s dimension.
+ * @param maximum - The upper bound, likewise.
+ * @returns The clamped expression, with the operands' variables, results, and requirements unioned.
+ * @example
+ * ```ts
+ * Calc.serialize(Calc.clamp(-1, Calc.var('u'), 1)) // 'clamp(-1, var(--u), 1)'
+ * ```
+ * @since 0.1.0
+ */
+declare const clamp: <A extends In, B extends SameKindIn<A>, C extends SameKindIn<A>>(minimum: A, value: B, maximum: C) => Calc<VarsOf<A> | VarsOf<B> | VarsOf<C>, ResultOf<A> | ResultOf<B> | ResultOf<C>, RequiresOf<A> | RequiresOf<B> | RequiresOf<C>>;
+/**
+ * Linear interpolation from `a` to `b` by `t`. This is sugar, not a node:
+ * it desugars to `(1 - t) * a + t * b`, and serializes as that expanded
+ * form. `t` contributes its variables and requirements but never the
+ * result — the endpoints alone fix the dimension.
+ *
+ * @param a - The value at `t = 0`.
+ * @param b - The value at `t = 1`, sharing `a`'s dimension.
+ * @param t - The interpolation parameter, a `<number>`.
+ * @returns The interpolated expression, with the operands' variables unioned.
+ * @since 0.1.0
+ */
+declare const lerp: {
+  <A extends In, B extends SameKindIn<A>, T extends NumberIn>(a: A, b: B, t: T): Calc<VarsOf<A> | VarsOf<B> | VarsOf<T>, ResultOf<A> | ResultOf<B>, RequiresOf<A> | RequiresOf<B> | RequiresOf<T>>;
+};
+/**
+ * The absolute value. Serializes as the CSS `abs()` function.
+ *
+ * @param argument - The operand.
+ * @returns The absolute value expression, preserving the operand's result.
+ * @since 0.1.0
+ */
+declare const abs: {
+  <A extends In>(argument: A): Calc<VarsOf<A>, ResultOf<A>, RequiresOf<A>>;
+};
+/**
+ * The sign (`-1`, `0`, or `1`). Serializes as the CSS `sign()` function,
+ * which accepts a calculation of any dimension and returns a `<number>` —
+ * so any operand is accepted here.
+ *
+ * @param argument - The operand, of any dimension.
+ * @returns The sign, a `<number>`, carrying the operand's requirements.
+ * @since 0.1.0
+ */
+declare const sign: {
+  <A extends In>(argument: A): Calc<VarsOf<A>, None$1, RequiresOf<A>>;
+};
+/**
+ * The sine of its argument. Serializes as the CSS `sin()` function, which
+ * accepts an `<angle>` or a plain number treated as radians — so this takes
+ * either an angle expression or a number, and returns a number.
+ *
+ * @param argument - An angle, or a plain number in radians.
+ * @returns The sine, a `<number>`, carrying the argument's requirements.
+ * @since 0.1.0
+ */
+declare const sin: {
+  <A extends NumberOrAngleIn>(argument: A): Calc<VarsOf<A>, None$1, RequiresOf<A>>;
+};
+/**
+ * The cosine of its argument. Serializes as the CSS `cos()` function, which
+ * accepts an `<angle>` or a plain number treated as radians — so this takes
+ * either an angle expression or a number, and returns a number.
+ *
+ * @param argument - An angle, or a plain number in radians.
+ * @returns The cosine, a `<number>`, carrying the argument's requirements.
+ * @since 0.1.0
+ */
+declare const cos: {
+  <A extends NumberOrAngleIn>(argument: A): Calc<VarsOf<A>, None$1, RequiresOf<A>>;
+};
+/**
+ * The tangent of its argument. Serializes as the CSS `tan()` function, which
+ * accepts an `<angle>` or a plain number treated as radians. Paired with
+ * `atan2`, `tan(atan2(a, b))` divides two same-dimension expressions to a
+ * `<number>` — the length ratio that works where `a / b` does not, since
+ * Firefox does not yet support `<length> / <length>` in `calc()`.
+ *
+ * @param argument - An angle, or a plain number in radians.
+ * @returns The tangent, a `<number>`, carrying the argument's requirements.
+ * @since 0.2.0
+ */
+declare const tan: {
+  <A extends NumberOrAngleIn>(argument: A): Calc<VarsOf<A>, None$1, RequiresOf<A>>;
+};
+/**
+ * The arccosine of a value in `[-1, 1]`, an `<angle>` in radians — the
+ * result is `Unit.Rad`, matching what solving evaluates (`Math.acos`) and
+ * what constant folding emits (`rad` constants); CSS's `acos()` returns an
+ * `<angle>` and serialization is unchanged.
+ *
+ * Because the result is an angle, it composes only with other angles: divide
+ * or scale it by a number, and add or subtract an `Angle.rad(...)` phase. A
+ * plain number added to it is a type error — supply the phase as an angle.
+ *
+ * @param argument - The cosine value, in `[-1, 1]`.
+ * @returns The arccosine in radians, carrying the argument's requirements.
+ * @example
+ * ```ts
+ * const phase = Angle.rad(2.0943951)
+ * Calc.serialize(Calc.cos(Calc.subtract(Calc.divide(Calc.acos(Calc.var('u')), 3), phase)))
+ * // 'cos(acos(var(--u)) / 3 - 2.0944rad)'
+ * ```
+ * @since 0.1.0
+ */
+declare const acos: {
+  <A extends NumberIn>(argument: A): Calc<VarsOf<A>, Rad, RequiresOf<A>>;
+};
+/**
+ * The angle, in radians, of the vector from the origin to `(x, y)` — CSS's
+ * `atan2()`, which returns an `<angle>`; the result is `Unit.Rad`, as
+ * `acos`. The operands must share a dimension (two numbers, two lengths,
+ * two angles); their units cancel in the ratio, so `tan(atan2(a, b))`
+ * recovers `a / b` as a `<number>` and is the portable way to divide two
+ * `<length>`s.
+ *
+ * @param y - The vertical component.
+ * @param x - The horizontal component, sharing `y`'s dimension.
+ * @returns The angle in radians, with the operands' variables and requirements unioned.
+ * @example
+ * ```ts
+ * const ratio = Calc.tan(Calc.atan2(Calc.subtract(Length.vw(100), Length.px(320)), Length.px(160)))
+ * Calc.serialize(ratio) // 'tan(atan2(100vw - 320px, 160px))'
+ * ```
+ * @since 0.2.0
+ */
+declare const atan2: {
+  <A extends In, B extends SameKindIn<A>>(y: A, x: B): Calc<VarsOf<A> | VarsOf<B>, Rad, RequiresOf<A> | RequiresOf<B>>;
+};
+declare const bind: {
+  /**
+   * Returns a function that binds the given names in an expression.
+   *
+   * The data-last form cannot see its eventual expression, so the
+   * per-name declared-type checking rides the data-first overload only;
+   * requirement threading works in both.
+   *
+   * @param bindings - Variable names to values or expressions. Names the expression does not read are ignored, as are `undefined` values.
+   * @returns A function replacing bound variables in its argument, preserving its result and joining the bound values' requirements to its own.
+   * @since 0.1.0
+   */
+  <const B extends Bindings>(bindings: B): <A extends Top>(expr: A) => Calc<ApplyBindings<VarsOf<A>, B>, ResultOf<A>, RequiresOf<A> | BindingRequires<VarsOf<A>, B>>;
+  /**
+   * Replaces variables with values or other expressions. Binding is
+   * partial evaluation: substituted subtrees re-fold, so binding every
+   * variable collapses the tree to a constant. The expression's result is
+   * preserved — binding touches only the variable channel — and the bound
+   * values' own requirements join the expression's, so a `Length.vw(2)`
+   * binding carries its `vw` ratio demand into the result for `solve` to
+   * collect later.
+   *
+   * A declared name types its value: binding a `Var.length` read to a
+   * bare number (or any non-length) is a type error, the check the
+   * declaration exists for. Undeclared names accept any `Input`.
+   *
+   * Names the expression does not read are ignored (spreading a wider
+   * bindings object is fine), as are `undefined` values. Binding a
+   * variable to another expression composes trees; the bound expression's
+   * own variables join the result, tracked in the return type by
+   * `ApplyBindings`.
+   *
+   * @param expr - The expression to bind.
+   * @param bindings - Variable names to values or expressions, typed per name by its declared type. May be partial: unbound names stay in the result.
+   * @returns The bound expression.
+   * @example
+   * ```ts
+   * const half = Calc.bind(Calc.divide(Calc.var('x'), 2), { x: Calc.var('width') })
+   * Calc.serialize(half) // 'calc(var(--width) / 2)'
+   * Calc.solve(Calc.bind(half, { width: 100 })) // 50
+   * ```
+   * @since 0.1.0
+   */
+  <A extends Top, const B extends PartialBindings<VarsOf<A>>>(expr: A, bindings: B): Calc<ApplyBindings<VarsOf<A>, B>, ResultOf<A>, RequiresOf<A> | BindingRequires<VarsOf<A>, B>>;
+};
+declare const solve: {
+  /**
+   * Evaluates a closed expression to a number. Absolute lengths (`px`) and
+   * angles (radians and degrees) lower with no options; an unbound
+   * variable, a relative unit, a percentage, or a bare identifier needs the
+   * options overload.
+   *
+   * @param expr - The expression. No unbound variables, only pre-satisfied requirements.
+   * @returns The numeric value.
+   * @throws `Error` when unbound variables or unresolvable requirements remain at runtime.
+   * @since 0.1.0
+   */
+  (expr: Calc<never, Any$1, ContextFree>): number;
+  /**
+   * Applies bindings, lowers each unit and identifier through the matching
+   * options section, then evaluates to a number. `SolveOptions` requires
+   * each section exactly when the expression's type demands it: `bindings`
+   * while variables are unbound, `units` while a relative unit or
+   * percentage is present, `idents` while a bare identifier is.
+   *
+   * @param expr - The expression to evaluate.
+   * @param options - The bindings, unit ratios, and identifier values the expression needs.
+   * @returns The numeric value.
+   * @throws `Error` when unbound variables remain after binding, or a unit or identifier has no entry at runtime.
+   * @example
+   * ```ts
+   * Calc.solve(Calc.lerp(Calc.var('a'), Calc.var('b'), 0.5), { bindings: { a: 0, b: 10 } }) // 5
+   * const position = Calc.divide(Calc.subtract(Length.vw(100), Length.px(320)), Length.px(160))
+   * Calc.solve(position, { units: { vw: 1280 / 100 } }) // 6
+   * Calc.solve(Calc.multiply(Channel.L, 0.8), { idents: { l: 0.62 } }) // 0.496
+   * ```
+   * @since 0.1.0
+   */
+  <Vars extends Any, R>(expr: Calc<Vars, Any$1, R>, options: SolveOptions<Vars, R>): number;
+};
+/**
+ * Renders an expression as CSS text. Arithmetic gets a `calc()` wrapper;
+ * function forms (`min`, `clamp`, `sin`, ...) and leaves stand alone.
+ * Variables render as `var(--name)`.
+ *
+ * Bindings in `options` are applied first and may be partial — this is
+ * the serialize half of the solve/serialize duality, and unbound
+ * variables are the values left for the browser. Constants render with
+ * their annotated precision, or the context `precision` option (default
+ * `Precision.decimals(5)`). Constants equal to pi render as the CSS
+ * constant `pi` where a math function surrounds them.
+ *
+ * @param expr - The expression to render.
+ * @param options - Optional bindings and precision context.
+ * @returns Deterministic CSS text.
+ * @example
+ * ```ts
+ * const fluid = Calc.add(10, Calc.var('runtime'))
+ * Calc.serialize(fluid) // 'calc(10 + var(--runtime))'
+ * Calc.serialize(fluid, { bindings: { runtime: 4 } }) // '14'
+ * ```
+ * @since 0.1.0
+ */
+declare const serialize: <Vars extends Any>(expr: Calc<Vars, Any$1, unknown>, options?: SerializeOptions<Vars>) => string;
+/**
+ * The expression's unbound variable names — bare names, the value-level
+ * mirror of the read identities in `Vars`. A fallback chain's names are
+ * included: `var(--x, var(--y))` reads both.
+ *
+ * @param expr - The expression to inspect.
+ * @returns The set of unbound variable names.
+ * @since 0.1.0
+ */
+declare const vars: <Vars extends Any>(expr: Calc<Vars, Any$1, unknown>) => ReadonlySet<Name<Vars>>;
+/**
+ * The bare-identifier tokens the expression reads — leaves that serialize
+ * as themselves (`l`, not `var(--l)`) and are resolved by the CSS construct
+ * around them, the `Channel` keywords being the only source today. Empty
+ * for an expression with none.
+ *
+ * The runtime mirror of the `Ident` brands in `Requires`: it reports which
+ * values the `idents` section of `solve`'s options must supply, exactly as
+ * `vars` reports what `bindings` must — and, unlike the type parameter, it
+ * survives on a `Calc<Vars, Unit.Any, unknown>` whose requirements have
+ * been erased. Identifiers are not variables, so `vars` never lists them
+ * and they never reach a `Stylesheet`'s dependency report.
+ *
+ * @param expr - The expression to inspect.
+ * @returns The set of bare-identifier tokens the expression reads.
+ * @example
+ * ```ts
+ * Calc.idents(Calc.multiply(Channel.L, 0.8)) // Set { 'l' }
+ * Calc.idents(Calc.var('x')) // Set {}
+ * ```
+ * @since 0.2.0
+ */
+declare const idents: (expr: Calc<Any, Any$1, unknown>) => ReadonlySet<string>;
+/**
+ * The unit tokens the expression's dimensioned constants carry (`'vw'`,
+ * `'px'`, `'%'`). Empty for a unit-free expression.
+ *
+ * The runtime mirror of the `Unit` brands in `Requires`: it reports which
+ * ratios the `units` section of `solve`'s options may need to supply, and —
+ * unlike the type parameter — it survives on a `Calc<Vars, Unit.Any, unknown>`
+ * whose requirements have been erased. Pre-satisfied units (`px`, `rad`,
+ * `deg`) are reported too; they lower with no entry.
+ *
+ * @param expr - The expression to inspect.
+ * @returns The set of unit tokens the expression's constants carry.
+ * @example
+ * ```ts
+ * Calc.units(Calc.subtract(Length.vw(100), Length.px(320))) // Set { 'vw', 'px' }
+ * ```
+ * @since 0.4.0
+ */
+declare const units: (expr: Calc<Any, Any$1, unknown>) => ReadonlySet<string>;
+declare const equals: {
+  /**
+   * Returns a function that checks structural equality against `that`.
+   *
+   * @param that - The expression to compare against.
+   * @returns A function testing its argument for structural equality with `that`.
+   * @since 0.1.0
+   */
+  (that: Calc<Any, Any$1, unknown>): (self: Calc<Any, Any$1, unknown>) => boolean;
+  /**
+   * Structural equality over expression trees. Two expressions are equal
+   * when their trees match node for node — including constant units and
+   * precision annotations, which affect serialization. Expression trees are
+   * ordered syntax: `add(a, b)` and `add(b, a)` are not equal.
+   *
+   * @param self - The first expression.
+   * @param that - The second expression.
+   * @returns `true` if the expressions are structurally equal.
+   * @since 0.1.0
+   */
+  (self: Calc<Any, Any$1, unknown>, that: Calc<Any, Any$1, unknown>): boolean;
+};
+//#endregion
+export { precision_d_exports as A, Any$1 as C, Percentage$1 as D, None$1 as E, unit_d_exports as O, Angle$1 as S, Length$1 as T, keywords_d_exports as _, calc_d_exports as a, channels_d_exports as b, Name as c, percentage_d_exports as d, numeric_d_exports as f, color_d_exports as g, Color as h, PartialBindings as i, Precision as k, Var as l, length_d_exports as m, Bindings as n, angle_d_exports as o, lengthPercentage_d_exports as p, Calc as r, Any as s, ApplyBindings as t, var_d_exports as u, hueInterpolation_d_exports as v, Family as w, AbsoluteLength as x, colorSpace_d_exports as y };
+//# sourceMappingURL=index-D-hVWDgZ.d.mts.map