fashionable 0.1.0 → 0.2.0

package/dist/data/index.d.mts

@@ -0,0 +1,208 @@
+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