fashionable 0.2.0 → 0.4.0

package/dist/calc/index.d.mts

@@ -1,2 +1,2 @@
-import { l as precision_d_exports, s as calc_d_exports } from "../shared/index-BvtwY4FQ.mjs";
+import { A as precision_d_exports, a as calc_d_exports } from "../shared/index-D-hVWDgZ.mjs";
 export { calc_d_exports as Calc, precision_d_exports as Precision };

package/dist/calc/index.mjs

@@ -1,2 +1,2 @@
-import { r as calc_exports, t as precision_exports } from "../shared/calc-Cih4o2r7.mjs";
+import { r as calc_exports, t as precision_exports } from "../shared/calc-Uwbxd7CS.mjs";
 export { calc_exports as Calc, precision_exports as Precision };

package/dist/data/index.d.mts

@@ -1,208 +1,2 @@
-import { C as Vmin, S as Vmax, T as units_d_exports, _ as Percentage$1, b as Rem, c as Precision, d as Angle$1, f as ChannelLeaf, g as Percent, h as Length$1, m as Em, p as Deg, r as Calc, v as Px, w as Vw, x as Vh, y as Rad } from "../shared/index-BvtwY4FQ.mjs";
-import { a as colorSpace_d_exports, i as hueInterpolation_d_exports, n as color_d_exports, r as keywords_d_exports } from "../shared/color-BvNJ2YqL.mjs";
-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<Refs, 'angle', Unit.Angle>` — `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). `Refs` unions the
- * unbound reference names, as on `Calc`.
- *
- * The leaf is the widened `Unit.Angle`, so every specific angle expression is
- * assignable to it; a constructor narrows it (`Angle.rad` carries `Unit.Rad`).
- *
- * @since 0.2.0
- */
-type Angle<Refs extends string = string> = Calc<Refs, 'angle', Angle$1>;
-/**
- * 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, 'angle', 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, 'angle', Deg>;
-declare namespace channels_d_exports {
-  export { Alpha, B, C, G, H, L, R };
-}
-/**
- * The `l` origin channel — lightness in `oklch`. Serializes bare as `l`.
- *
- * @since 0.2.0
- */
-declare const L: Calc<never, 'number', ChannelLeaf<'l'>>;
-/**
- * The `c` origin channel — chroma in `oklch`. Serializes bare as `c`.
- *
- * @since 0.2.0
- */
-declare const C: Calc<never, 'number', ChannelLeaf<'c'>>;
-/**
- * The `h` origin channel — hue in `oklch`, in degrees. Serializes bare as `h`.
- *
- * @since 0.2.0
- */
-declare const H: Calc<never, 'number', ChannelLeaf<'h'>>;
-/**
- * The `r` origin channel — red in `color(srgb ...)`. Serializes bare as `r`.
- *
- * @since 0.2.0
- */
-declare const R: Calc<never, 'number', ChannelLeaf<'r'>>;
-/**
- * The `g` origin channel — green in `color(srgb ...)`. Serializes bare as `g`.
- *
- * @since 0.2.0
- */
-declare const G: Calc<never, 'number', ChannelLeaf<'g'>>;
-/**
- * The `b` origin channel — blue in `color(srgb ...)`. Serializes bare as `b`.
- *
- * @since 0.2.0
- */
-declare const B: Calc<never, 'number', ChannelLeaf<'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, 'number', ChannelLeaf<'alpha'>>;
-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<Refs, 'length', Unit.Length>` —
- * `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). `Refs`
- * unions the unbound reference names, as on `Calc`.
- *
- * The leaf is the widened `Unit.Length`, so a mixed-unit sum
- * (`Calc.add(Length.px(16), Length.vw(2))`) and every single-unit length are
- * alike assignable to it.
- *
- * @since 0.2.0
- */
-type Length<Refs extends string = string> = Calc<Refs, 'length', Length$1>;
-/**
- * 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, 'length', 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, 'length', 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, 'length', 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, 'length', 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, 'length', 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, 'length', 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, 'length', Vmax>;
-declare namespace percentage_d_exports {
-  export { Percentage, of };
-}
-/**
- * A `<percentage>` expression: a `Calc` of percentage kind. Names the dimension
- * without spelling `Calc<Refs, 'percentage', Unit.Percentage>` —
- * `Percentage.of(40)` produces one, and it composes with every `Calc`
- * combinator (adding two percentages is a percentage, one over another is a
- * number). `Refs` unions the unbound reference names, as on `Calc`.
- *
- * @since 0.2.0
- */
-type Percentage<Refs extends string = string> = Calc<Refs, 'percentage', Percentage$1>;
-/**
- * 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
- */
-declare const of: (value: number, precision?: Precision) => Calc<never, 'percentage', Percent>;
-//#endregion
-export { angle_d_exports as Angle, channels_d_exports as Channel, color_d_exports as Color, colorSpace_d_exports as ColorSpace, hueInterpolation_d_exports as HueInterpolation, keywords_d_exports as Keyword, length_d_exports as Length, percentage_d_exports as Percentage, units_d_exports as Unit };
-//# sourceMappingURL=index.d.mts.map
+import { O as unit_d_exports, _ as keywords_d_exports, b as channels_d_exports, d as percentage_d_exports, f as numeric_d_exports, g as color_d_exports, m as length_d_exports, o as angle_d_exports, p as lengthPercentage_d_exports, v as hueInterpolation_d_exports, y as colorSpace_d_exports } from "../shared/index-D-hVWDgZ.mjs";
+export { angle_d_exports as Angle, channels_d_exports as Channel, color_d_exports as Color, colorSpace_d_exports as ColorSpace, hueInterpolation_d_exports as HueInterpolation, keywords_d_exports as Keyword, length_d_exports as Length, lengthPercentage_d_exports as LengthPercentage, numeric_d_exports as Numeric, percentage_d_exports as Percentage, unit_d_exports as Unit };

package/dist/data/index.mjs

@@ -1,6 +1,6 @@
 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";
+import { d as ident, u as dimension } from "../shared/calc-Uwbxd7CS.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, g as of$3, 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, v as none$1, w as a98Rgb$1, x as interpolate$1, y as decreasing$1 } from "../shared/color.internal-CxjlaRqR.mjs";
 //#region src/data/angle.internal.ts
 /** @internal */
 const rad$1 = (value, precision) => dimension(value, "rad", "angle", precision);
@@ -122,11 +122,11 @@ var color_exports = /* @__PURE__ */ __exportAll({
 	mix: () => mix,
 	named: () => named,
 	oklch: () => oklch$1,
-	ref: () => ref,
-	refs: () => refs,
 	serialize: () => serialize,
 	srgb: () => srgb$1,
-	transparent: () => transparent
+	transparent: () => transparent,
+	var: () => _var,
+	vars: () => vars
 });
 /**
 * Checks if a value is a `Color`.
@@ -151,10 +151,10 @@ const isColor = isColor$1;
 * @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.
+* @returns A `Color` with the channels' variables unioned.
 * @example
 * ```ts
-* const accent = Color.oklch(Calc.ref('lightness'), 0.15, 220)
+* const accent = Color.oklch(Calc.var('lightness'), 0.15, 220)
 * Color.serialize(accent) // 'oklch(var(--lightness) 0.15 220)'
 * ```
 * @since 0.1.0
@@ -172,7 +172,7 @@ const oklch$1 = oklch$2;
 * @param red - The red channel.
 * @param green - The green channel.
 * @param blue - The blue channel.
-* @returns A `Color` with the channels' references unioned.
+* @returns A `Color` with the channels' variables unioned.
 * @example
 * ```ts
 * const brand = Color.srgb(0.18, 0.34, 0.78)
@@ -184,7 +184,7 @@ 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.
+* 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
@@ -205,27 +205,7 @@ const named = named$1;
 * @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;
+const _var = ref;
 /**
 * Creates a scheme-conditional `light-dark(...)` color: the browser uses
 * the first color under the light scheme and the second under dark.
@@ -239,7 +219,7 @@ const ref = ref$1;
 *
 * @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.
+* @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))
@@ -268,12 +248,12 @@ const lightDark = lightDark$1;
 * 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.
+* 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' references.
+* @returns A `Color` unioning both arms' and both percentages' variables.
 * @example
 * ```ts
 * Color.serialize(Color.mix(ColorSpace.oklch, Color.named('red'), Color.named('blue')))
@@ -301,21 +281,21 @@ const mix = mix$1;
 * `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
+* 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 `ref`.
+* @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' references.
+* @returns A `Color` unioning the origin's and the channels' variables.
 * @example
 * ```ts
-* const hover = Color.from(Color.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+* 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.ref('brand'), ColorSpace.srgb, Channel.R, Channel.G, Channel.B, Calc.multiply(Channel.Alpha, 0.5))
+* 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
@@ -336,38 +316,38 @@ const bind = bind$1;
 * @returns Deterministic CSS text.
 * @example
 * ```ts
-* const surface = Color.oklch(Calc.add(Calc.ref('l'), 0.1), 0.04, 250)
+* 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
 */
 const serialize = serialize$1;
 /**
-* The color's unbound reference names, unioned across channels.
+* The color's unbound variable names, unioned across channels.
 *
 * @param color - The color to inspect.
-* @returns The set of unbound reference names.
+* @returns The set of unbound variable names.
 * @since 0.1.0
 */
-const refs = refs$1;
+const vars = refs;
 /**
 * The origin-channel keyword tokens the color reads — the `Channel` keywords a
 * relative color's channels reference (`l`, `c`, `h`, ...), gathered across its
 * channels and any nested colors. Empty for a color with no relative parts.
 *
-* The `Color` companion to `Calc.channels`, and the mirror of `refs`: where
-* `refs` reports the custom properties a color depends on, `channels` reports
+* The `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 reference — so a channel token never appears in `refs` nor
+* 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.ref('accent'), ColorSpace.oklch, Calc.multiply(Channel.L, 0.8), Channel.C, Channel.H)
+* 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.refs(hover) // Set { 'accent' }
+* Color.vars(hover) // Set { 'accent' }
 * ```
 * @since 0.2.0
 */
@@ -534,16 +514,16 @@ const decreasing = decreasing$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`).
+* 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' references.
+* @returns The interpolated hue in degrees, a `Calc` unioning the arguments' variables.
 * @example
 * ```ts
-* const hue = HueInterpolation.interpolate(HueInterpolation.shorter, 30, Calc.ref('to'), Calc.ref('t'))
+* 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'
 * ```
@@ -669,6 +649,44 @@ const vmin = vmin$1;
 */
 const vmax = vmax$1;
 //#endregion
+//#region src/data/lengthPercentage.internal.ts
+/**
+* The runtime is the identity: widening is a type-level anchor, and the
+* expression tree already carries its units structurally. The bottom
+* return is the usual widening discipline; the public signature carries
+* the real vars/requires threading.
+*
+* @internal
+*/
+const of$2 = (value) => value;
+//#endregion
+//#region src/data/lengthPercentage.ts
+var lengthPercentage_exports = /* @__PURE__ */ __exportAll({ of: () => of$1 });
+/**
+* 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
+*/
+const of$1 = of$2;
+//#endregion
+//#region src/data/numeric.ts
+var numeric_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
 //#region src/data/percentage.ts
 var percentage_exports = /* @__PURE__ */ __exportAll({ of: () => of });
 /**
@@ -683,14 +701,15 @@ var percentage_exports = /* @__PURE__ */ __exportAll({ of: () => of });
 * ```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
 */
-const of = of$1;
+const of = of$3;
 //#endregion
-//#region src/data/units.ts
-var units_exports = /* @__PURE__ */ __exportAll({});
+//#region src/data/unit.ts
+var unit_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 };
+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, lengthPercentage_exports as LengthPercentage, numeric_exports as Numeric, percentage_exports as Percentage, unit_exports as Unit };
 
 //# sourceMappingURL=index.mjs.map