fashionable 0.0.0 → 0.2.0

package/dist/data/index.mjs

@@ -0,0 +1,696 @@
+import { t as __exportAll } from "../shared/rolldown-runtime-D7D4PA-g.mjs";
+import { d as ident, u as dimension } from "../shared/calc-Cih4o2r7.mjs";
+import { A as oklab$1, C as shorter$1, D as hwb$1, E as hsl$1, F as srgbLinear$1, I as xyz$1, L as xyzD50$1, M as prophotoRgb$1, N as rec2020$1, O as lab$1, P as srgb$3, R as xyzD65$1, S as longer$1, T as displayP3$1, _ as isNone$1, a as isColor$1, b as increasing$1, c as named$1, d as refs$1, g as of$1, h as transparent$1, i as from$1, j as oklch$3, k as lch$1, l as oklch$2, m as srgb$2, n as channels$1, o as lightDark$1, p as serialize$1, r as equals$1, s as mix$1, t as bind$1, u as ref$1, v as none$1, w as a98Rgb$1, x as interpolate$1, y as decreasing$1 } from "../shared/color.internal-Dts5ycTm.mjs";
+//#region src/data/angle.internal.ts
+/** @internal */
+const rad$1 = (value, precision) => dimension(value, "rad", "angle", precision);
+/** @internal */
+const deg$1 = (value, precision) => dimension(value, "deg", "angle", precision);
+//#endregion
+//#region src/data/angle.ts
+var angle_exports = /* @__PURE__ */ __exportAll({
+	deg: () => deg,
+	rad: () => rad
+});
+/**
+* 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
+*/
+const rad = rad$1;
+/**
+* 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
+*/
+const deg = deg$1;
+//#endregion
+//#region src/data/channels.internal.ts
+/** @internal */
+const L$1 = ident("l");
+/** @internal */
+const C$1 = ident("c");
+/** @internal */
+const H$1 = ident("h");
+/** @internal */
+const R$1 = ident("r");
+/** @internal */
+const G$1 = ident("g");
+/** @internal */
+const B$1 = ident("b");
+/** @internal */
+const Alpha$1 = ident("alpha");
+//#endregion
+//#region src/data/channels.ts
+var channels_exports = /* @__PURE__ */ __exportAll({
+	Alpha: () => Alpha,
+	B: () => B,
+	C: () => C,
+	G: () => G,
+	H: () => H,
+	L: () => L,
+	R: () => R
+});
+/**
+* The `l` origin channel — lightness in `oklch`. Serializes bare as `l`.
+*
+* @since 0.2.0
+*/
+const L = L$1;
+/**
+* The `c` origin channel — chroma in `oklch`. Serializes bare as `c`.
+*
+* @since 0.2.0
+*/
+const C = C$1;
+/**
+* The `h` origin channel — hue in `oklch`, in degrees. Serializes bare as `h`.
+*
+* @since 0.2.0
+*/
+const H = H$1;
+/**
+* The `r` origin channel — red in `color(srgb ...)`. Serializes bare as `r`.
+*
+* @since 0.2.0
+*/
+const R = R$1;
+/**
+* The `g` origin channel — green in `color(srgb ...)`. Serializes bare as `g`.
+*
+* @since 0.2.0
+*/
+const G = G$1;
+/**
+* The `b` origin channel — blue in `color(srgb ...)`. Serializes bare as `b`.
+*
+* @since 0.2.0
+*/
+const B = B$1;
+/**
+* The `alpha` origin channel — the opacity of the `from` origin, in `oklch`
+* and `color(srgb ...)` alike. Serializes bare as `alpha`.
+*
+* @since 0.2.0
+*/
+const Alpha = Alpha$1;
+//#endregion
+//#region src/data/color.ts
+var color_exports = /* @__PURE__ */ __exportAll({
+	bind: () => bind,
+	channels: () => channels,
+	equals: () => equals,
+	from: () => from,
+	isColor: () => isColor,
+	lightDark: () => lightDark,
+	mix: () => mix,
+	named: () => named,
+	oklch: () => oklch$1,
+	ref: () => ref,
+	refs: () => refs,
+	serialize: () => serialize,
+	srgb: () => srgb$1,
+	transparent: () => transparent
+});
+/**
+* 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
+*/
+const isColor = isColor$1;
+/**
+* Creates an `oklch(...)` color from three channel expressions: lightness
+* (`0` to `1`), chroma (`0` upward), and hue (degrees). A channel may be
+* `Keyword.none` — the missing-component keyword, the conventional hue
+* for achromatic colors: `oklch(0 0 none)`.
+*
+* Each channel serializes independently, wrapped in `calc()` when it is
+* arithmetic: `oklch(var(--l) calc(var(--c) * 0.5) 220)`.
+*
+* @param lightness - The lightness channel.
+* @param chroma - The chroma channel.
+* @param hue - The hue channel, in degrees.
+* @returns A `Color` with the channels' references unioned.
+* @example
+* ```ts
+* const accent = Color.oklch(Calc.ref('lightness'), 0.15, 220)
+* Color.serialize(accent) // 'oklch(var(--lightness) 0.15 220)'
+* ```
+* @since 0.1.0
+*/
+const oklch$1 = oklch$2;
+/**
+* Creates a `color(srgb ...)` color from three channel expressions, each
+* `0` to `1`. A channel may be `Keyword.none`, the missing-component
+* keyword.
+*
+* Each channel serializes independently, wrapped in `calc()` when it is
+* arithmetic, inside the `color()` function's `srgb` colorspace:
+* `color(srgb 0.18 0.34 0.78)`.
+*
+* @param red - The red channel.
+* @param green - The green channel.
+* @param blue - The blue channel.
+* @returns A `Color` with the channels' references unioned.
+* @example
+* ```ts
+* const brand = Color.srgb(0.18, 0.34, 0.78)
+* Color.serialize(brand) // 'color(srgb 0.18 0.34 0.78)'
+* ```
+* @since 0.2.0
+*/
+const srgb$1 = srgb$2;
+/**
+* Creates a named color, rendered bare: `named('rebeccapurple')`
+* serializes as `rebeccapurple`. The name is the whole value — a named
+* color has no channels, contributes no references, and binds nothing.
+*
+* That the name is one of the specification's named colors is not
+* checked, matching the library's posture on identifiers — with one
+* exception: the CSS-wide keywords (`inherit`, `initial`, ...) are
+* whole-declaration values, not colors (`light-dark(inherit, ...)` is
+* invalid CSS), and are rejected.
+*
+* @param name - The color name. Must be non-empty and not a CSS-wide keyword.
+* @returns A `Color<never>`.
+* @throws `Error` when `name` is empty or a CSS-wide keyword.
+* @since 0.2.0
+*/
+const named = named$1;
+/**
+* The `transparent` named color — `rgb(0 0 0 / 0)` by definition, and
+* the conventional "no color" value.
+*
+* @since 0.2.0
+*/
+const transparent = transparent$1;
+/**
+* Creates a color-valued custom-property reference — `ref('accent')`
+* serializes as `var(--accent)`. Use it where a whole color is read from a
+* custom property: as a standalone value, or as the origin of a relative color
+* (`from`).
+*
+* The reference is the whole value, so it carries `name` as its one unbound
+* reference — a dependency, exactly as an unbound `Calc.ref` does — but has no
+* channels. `bind` substitutes channel expressions, not whole colors, so it
+* leaves a color reference in place; the browser resolves it from the cascade.
+*
+* @param name - The custom-property name, without the `--` prefix. Must be non-empty.
+* @returns A `Color` with `name` as its one unbound reference.
+* @throws `Error` when `name` is empty.
+* @example
+* ```ts
+* Color.serialize(Color.ref('accent')) // 'var(--accent)'
+* ```
+* @since 0.2.0
+*/
+const ref = ref$1;
+/**
+* Creates a scheme-conditional `light-dark(...)` color: the browser uses
+* the first color under the light scheme and the second under dark.
+*
+* The arms are whole colors and positional — `lightDark(a, b)` and
+* `lightDark(b, a)` are different colors. Any `Color` is accepted,
+* including another `lightDark` (grammatically an arm is any `<color>`;
+* nesting is redundant but legal, and simplification is not this type's
+* job). Note the resolution context: `light-dark()` requires
+* `color-scheme` to be set — that contract is the consumer's.
+*
+* @param light - The color used under the light scheme.
+* @param dark - The color used under the dark scheme.
+* @returns A `Color` with both arms' references unioned.
+* @example
+* ```ts
+* const accent = Color.lightDark(Color.srgb(0.85, 0.3, 0.4), Color.srgb(0.95, 0.5, 0.55))
+* Color.serialize(accent) // 'light-dark(color(srgb 0.85 0.3 0.4), color(srgb 0.95 0.5 0.55))'
+* ```
+* @since 0.2.0
+*/
+const lightDark = lightDark$1;
+/**
+* Creates a `color-mix(...)`: the browser mixes `color1` and `color2` in the
+* interpolation `space`. Each arm is a bare `Color` or a `[color, percentage]`
+* tuple giving its weight — a bare number reads as a percent (`20` is `20%`,
+* the `<percentage>` convention), a `Percentage` expression an annotated or
+* computed weight (`Percentage.of(20)`, `Calc.multiply(Percentage.of(50), ...)`);
+* a plain number-kind `Calc` is rejected, a weight being a `<percentage>`.
+*
+* A polar `space` (`ColorSpace.oklch`, `ColorSpace.lch`, ...) may take a
+* `HueInterpolation` strategy between the space and the colors — the second
+* overload — for how the hue circle is traversed; omit it and the browser
+* defaults to `shorter`. A rectangular space has no hue channel, so passing a
+* strategy is a compile error, mirroring the grammar where
+* `<hue-interpolation-method>` follows only a polar space.
+*
+* Percentages are optional and preserved verbatim — fashionable emits the
+* authored form and never runs the spec's mixing normalization (omitted weights
+* defaulting to `50%`, weights off `100%` rescaling with an alpha multiplier),
+* which is computed-value behavior the browser owns. Like every `Color`, a mix
+* binds and serializes but does not solve, and each arm and each percentage
+* contributes its references to the result.
+*
+* @param space - The interpolation `ColorSpace`; a polar one may be followed by a `HueInterpolation`.
+* @param color1 - The first color, or a `[color, percentage]` tuple weighting it.
+* @param color2 - The second color, or a `[color, percentage]` tuple weighting it.
+* @returns A `Color` unioning both arms' and both percentages' references.
+* @example
+* ```ts
+* Color.serialize(Color.mix(ColorSpace.oklch, Color.named('red'), Color.named('blue')))
+* // 'color-mix(in oklch, red, blue)'
+* Color.serialize(Color.mix(ColorSpace.srgb, [Color.named('white'), 20], Color.named('black')))
+* // 'color-mix(in srgb, white 20%, black)'
+* Color.serialize(Color.mix(ColorSpace.oklch, HueInterpolation.longer, Color.named('red'), Color.named('blue')))
+* // 'color-mix(in oklch longer hue, red, blue)'
+* ```
+* @since 0.2.0
+*/
+const mix = mix$1;
+/**
+* Creates a relative color from an origin and a destination `ColorSpace`:
+* `Color.from(origin, ColorSpace.oklch, l, c, h)` is `oklch(from origin l c h)`
+* and `Color.from(origin, ColorSpace.srgb, r, g, b)` is
+* `color(from origin srgb r g b)`. The browser converts `origin` into the
+* space and exposes its channels as the `Channel` keywords the space names
+* (`Channel.L`/`C`/`H` for `oklch`, `Channel.R`/`G`/`B` for `srgb`, `Channel.Alpha`
+* for both); passing them straight through reproduces the origin, and
+* arithmetic on them derives a related color.
+*
+* The `space` scopes the channel arguments — a keyword the space does not name
+* is a compile error. Each channel serializes independently, wrapped in
+* `calc()` when arithmetic and bare when a lone keyword, and may be
+* `Keyword.none`. A supplied `alpha` renders after a slash
+* (`/ calc(alpha * 0.5)`); omitted, the origin's alpha carries through. The
+* origin's own references union into the result; the channel keywords
+* contribute none, since the browser resolves them from the origin.
+*
+* @param origin - The color to derive from — any `Color`, commonly a `ref`.
+* @param space - The destination `ColorSpace`, fixing the function form and the channels in scope.
+* @param channel1 - The first channel (`l`/`r`), in the space's order.
+* @param channel2 - The second channel (`c`/`g`).
+* @param channel3 - The third channel (`h`/`b`).
+* @param alpha - The optional alpha channel; omitted, the origin's alpha is kept.
+* @returns A `Color` unioning the origin's and the channels' references.
+* @example
+* ```ts
+* const hover = Color.from(Color.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+* Color.serialize(hover) // 'oklch(from var(--accent) calc(l * 0.8) c h)'
+* const faded = Color.from(Color.ref('brand'), ColorSpace.srgb, Channel.R, Channel.G, Channel.B, Calc.multiply(Channel.Alpha, 0.5))
+* Color.serialize(faded) // 'color(from var(--brand) srgb r g b / calc(alpha * 0.5))'
+* ```
+* @since 0.2.0
+*/
+const from = from$1;
+const bind = bind$1;
+/**
+* Renders a color as CSS text. Channels render space-separated inside
+* the color's own function form — `oklch(...)` or `color(srgb ...)` —
+* each wrapped in `calc()` when it is arithmetic; a `lightDark` renders
+* both arms in full, comma-separated.
+*
+* Options match `Calc.serialize`: partial bindings applied first, and a
+* precision context for unannotated constants.
+*
+* @param color - The color to render.
+* @param options - Optional bindings and precision context.
+* @returns Deterministic CSS text.
+* @example
+* ```ts
+* const surface = Color.oklch(Calc.add(Calc.ref('l'), 0.1), 0.04, 250)
+* Color.serialize(surface) // 'oklch(calc(var(--l) + 0.1) 0.04 250)'
+* ```
+* @since 0.1.0
+*/
+const serialize = serialize$1;
+/**
+* The color's unbound reference names, unioned across channels.
+*
+* @param color - The color to inspect.
+* @returns The set of unbound reference names.
+* @since 0.1.0
+*/
+const refs = refs$1;
+/**
+* The origin-channel keyword tokens the color reads — the `Channel` keywords a
+* relative color's channels reference (`l`, `c`, `h`, ...), gathered across its
+* channels and any nested colors. Empty for a color with no relative parts.
+*
+* The `Color` companion to `Calc.channels`, and the mirror of `refs`: where
+* `refs` reports the custom properties a color depends on, `channels` reports
+* the origin channels a relative color reads. They are disjoint — a channel
+* keyword is never a reference — so a channel token never appears in `refs` nor
+* reaches a `Stylesheet`'s dependency report.
+*
+* @param color - The color to inspect.
+* @returns The set of channel-keyword tokens the color reads.
+* @example
+* ```ts
+* const hover = Color.from(Color.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+* Color.channels(hover) // Set { 'l', 'c', 'h' }
+* Color.refs(hover) // Set { 'accent' }
+* ```
+* @since 0.2.0
+*/
+const channels = channels$1;
+const equals = equals$1;
+//#endregion
+//#region src/data/colorSpace.ts
+var colorSpace_exports = /* @__PURE__ */ __exportAll({
+	a98Rgb: () => a98Rgb,
+	displayP3: () => displayP3,
+	hsl: () => hsl,
+	hwb: () => hwb,
+	lab: () => lab,
+	lch: () => lch,
+	oklab: () => oklab,
+	oklch: () => oklch,
+	prophotoRgb: () => prophotoRgb,
+	rec2020: () => rec2020,
+	srgb: () => srgb,
+	srgbLinear: () => srgbLinear,
+	xyz: () => xyz,
+	xyzD50: () => xyzD50,
+	xyzD65: () => xyzD65
+});
+/**
+* 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
+*/
+const oklch = oklch$3;
+/**
+* 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
+*/
+const srgb = srgb$3;
+/**
+* The `srgb-linear` space (rectangular).
+*
+* @since 0.2.0
+*/
+const srgbLinear = srgbLinear$1;
+/**
+* The `display-p3` space (rectangular).
+*
+* @since 0.2.0
+*/
+const displayP3 = displayP3$1;
+/**
+* The `a98-rgb` space (rectangular).
+*
+* @since 0.2.0
+*/
+const a98Rgb = a98Rgb$1;
+/**
+* The `prophoto-rgb` space (rectangular).
+*
+* @since 0.2.0
+*/
+const prophotoRgb = prophotoRgb$1;
+/**
+* The `rec2020` space (rectangular).
+*
+* @since 0.2.0
+*/
+const rec2020 = rec2020$1;
+/**
+* The `lab` space (rectangular).
+*
+* @since 0.2.0
+*/
+const lab = lab$1;
+/**
+* The `oklab` space (rectangular).
+*
+* @since 0.2.0
+*/
+const oklab = oklab$1;
+/**
+* The `xyz` space (rectangular; an alias for `xyz-d65`).
+*
+* @since 0.2.0
+*/
+const xyz = xyz$1;
+/**
+* The `xyz-d50` space (rectangular).
+*
+* @since 0.2.0
+*/
+const xyzD50 = xyzD50$1;
+/**
+* The `xyz-d65` space (rectangular).
+*
+* @since 0.2.0
+*/
+const xyzD65 = xyzD65$1;
+/**
+* The `hsl` space (polar).
+*
+* @since 0.2.0
+*/
+const hsl = hsl$1;
+/**
+* The `hwb` space (polar).
+*
+* @since 0.2.0
+*/
+const hwb = hwb$1;
+/**
+* The `lch` space (polar).
+*
+* @since 0.2.0
+*/
+const lch = lch$1;
+//#endregion
+//#region src/data/hueInterpolation.ts
+var hueInterpolation_exports = /* @__PURE__ */ __exportAll({
+	decreasing: () => decreasing,
+	increasing: () => increasing,
+	interpolate: () => interpolate,
+	longer: () => longer,
+	shorter: () => shorter
+});
+/**
+* The `shorter` strategy — the short arc between the two hues (the browser
+* default). Serializes as `shorter hue`.
+*
+* @since 0.2.0
+*/
+const shorter = shorter$1;
+/**
+* The `longer` strategy — the long arc between the two hues. Serializes as
+* `longer hue`.
+*
+* @since 0.2.0
+*/
+const longer = longer$1;
+/**
+* The `increasing` strategy — hues traversed in increasing order, wrapping past
+* `360` if needed. Serializes as `increasing hue`.
+*
+* @since 0.2.0
+*/
+const increasing = increasing$1;
+/**
+* The `decreasing` strategy — hues traversed in decreasing order, wrapping past
+* `0` if needed. Serializes as `decreasing hue`.
+*
+* @since 0.2.0
+*/
+const decreasing = decreasing$1;
+/**
+* Builds the hue at `t` along the arc from `from` to `to` under `strategy` — the
+* JS side of what a polar `Color.mix` emits for the browser. Hues are numbers of
+* degrees (as an oklch/lch hue channel is), and `from`, `to`, and `t` are each a
+* number or a `Calc`, so the result is a `Calc` too: fully symbolic when any
+* argument is, folding to a constant when all are numbers.
+*
+* The hue math is the CSS Color 4 fixup, written branchlessly with `mod`: each
+* strategy is a signed delta added to `from` as `t` runs `0` (at `from`) to `1`
+* (at `to`). `shorter` and `longer` take the short or long arc between the hues;
+* `increasing`/`decreasing` force the direction. The result is unwrapped — it may
+* fall outside `[0, 360)`, which the browser resolves as a hue — and unions the
+* arguments' references. Drop it straight into a hue channel (`Color.oklch`).
+*
+* @param strategy - The traversal strategy (`shorter`, `longer`, ...).
+* @param from - The start hue, in degrees: a number or a `Calc`.
+* @param to - The end hue, in degrees: a number or a `Calc`.
+* @param t - The interpolation parameter, `0` to `1`: a number or a `Calc`.
+* @returns The interpolated hue in degrees, a `Calc` unioning the arguments' references.
+* @example
+* ```ts
+* const hue = HueInterpolation.interpolate(HueInterpolation.shorter, 30, Calc.ref('to'), Calc.ref('t'))
+* Calc.serialize(hue) // 'calc(30 + (mod(var(--to) - 30 + 180, 360) - 180) * var(--t))'
+* Calc.serialize(HueInterpolation.interpolate(HueInterpolation.increasing, 20, 350, 0.5)) // '185'
+* ```
+* @since 0.2.0
+*/
+const interpolate = interpolate$1;
+//#endregion
+//#region src/data/keywords.ts
+var keywords_exports = /* @__PURE__ */ __exportAll({
+	isNone: () => isNone,
+	none: () => none
+});
+/**
+* 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
+*/
+const none = none$1;
+/**
+* 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
+*/
+const isNone = isNone$1;
+//#endregion
+//#region src/data/length.internal.ts
+/** @internal */
+const px$1 = (value, precision) => dimension(value, "px", "length", precision);
+/** @internal */
+const rem$1 = (value, precision) => dimension(value, "rem", "length", precision);
+/** @internal */
+const em$1 = (value, precision) => dimension(value, "em", "length", precision);
+/** @internal */
+const vw$1 = (value, precision) => dimension(value, "vw", "length", precision);
+/** @internal */
+const vh$1 = (value, precision) => dimension(value, "vh", "length", precision);
+/** @internal */
+const vmin$1 = (value, precision) => dimension(value, "vmin", "length", precision);
+/** @internal */
+const vmax$1 = (value, precision) => dimension(value, "vmax", "length", precision);
+//#endregion
+//#region src/data/length.ts
+var length_exports = /* @__PURE__ */ __exportAll({
+	em: () => em,
+	px: () => px,
+	rem: () => rem,
+	vh: () => vh,
+	vmax: () => vmax,
+	vmin: () => vmin,
+	vw: () => vw
+});
+/**
+* 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
+*/
+const px = px$1;
+/**
+* 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
+*/
+const rem = rem$1;
+/**
+* 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
+*/
+const em = em$1;
+/**
+* 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
+*/
+const vw = vw$1;
+/**
+* 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
+*/
+const vh = vh$1;
+/**
+* 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
+*/
+const vmin = vmin$1;
+/**
+* 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
+*/
+const vmax = vmax$1;
+//#endregion
+//#region src/data/percentage.ts
+var percentage_exports = /* @__PURE__ */ __exportAll({ of: () => of });
+/**
+* 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%'
+* ```
+* @since 0.2.0
+*/
+const of = of$1;
+//#endregion
+//#region src/data/units.ts
+var units_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+export { angle_exports as Angle, channels_exports as Channel, color_exports as Color, colorSpace_exports as ColorSpace, hueInterpolation_exports as HueInterpolation, keywords_exports as Keyword, length_exports as Length, percentage_exports as Percentage, units_exports as Unit };
+
+//# sourceMappingURL=index.mjs.map