@mkbabb/value.js 0.4.5 → 0.4.6

package/dist/src/units/color/gamut.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Analytical sRGB gamut mapping based on Bjorn Ottosson's ok_color.h
+ * https://bottosson.github.io/posts/gamutclipping/
+ *
+ * Strategy: adaptive L0 (alpha=0.05) — deterministic, zero-iteration,
+ * perceptually correct in OKLab with exact hue preservation.
+ *
+ * MIT License — Copyright (c) 2021 Bjorn Ottosson
+ */
+export declare const DELTA_E_OK_JND = 0.02;
+export declare function deltaEOK(L1: number, a1: number, b1: number, L2: number, a2: number, b2: number): number;
+/**
+ * Direct OKLab→linear sRGB conversion (no XYZ intermediate).
+ * L ∈ [0,1], a,b ∈ [-0.4,0.4] (raw OKLab, NOT normalized).
+ */
+export declare function oklabToLinearSRGB(L: number, a: number, b: number): [number, number, number];
+/** Check if linear sRGB values are within the [0,1]³ gamut. */
+export declare function isInSRGBGamut(r: number, g: number, b: number): boolean;
+/**
+ * Compute the maximum saturation S = C/L for a given hue direction (a_, b_)
+ * where a_² + b_² ≈ 1. Uses a polynomial initial guess refined by one
+ * Halley's method step for cubic convergence.
+ */
+export declare function computeMaxSaturation(a_: number, b_: number): number;
+/**
+ * Find the cusp (L_cusp, C_cusp) — the point of maximum chroma on the
+ * gamut boundary for a given hue direction.
+ */
+export declare function findCusp(a_: number, b_: number): {
+    L: number;
+    C: number;
+};
+/**
+ * Find the parameter t where the ray from (L0, 0) through (L1, C1)
+ * intersects the sRGB gamut boundary. Returns t ∈ [0,1].
+ *
+ * Lower half uses closed-form; upper half uses one Halley's method step.
+ */
+export declare function findGamutIntersection(a_: number, b_: number, L1: number, C1: number, L0: number, cusp: {
+    L: number;
+    C: number;
+}): number;
+/**
+ * Core gamut mapping in raw OKLab space.
+ * Adaptive L0 strategy (alpha=0.05) — preserves hue exactly.
+ *
+ * Input/output: raw OKLab (L ∈ [0,1], a,b ∈ [-0.4,0.4]).
+ * Returns the mapped (L, a, b) tuple.
+ */
+export declare function gamutMapOKLab(L: number, a: number, b: number): [number, number, number];
+/**
+ * Convert sRGB (possibly out-of-gamut) to raw OKLab.
+ * Uses the direct linear sRGB → LMS path.
+ */
+export declare function srgbToOKLab(r: number, g: number, b: number): [number, number, number];
+/**
+ * Map an sRGB color (components may be outside [0,1]) to in-gamut sRGB.
+ * Returns clamped sRGB [0,1]³.
+ */
+export declare function gamutMapSRGB(r: number, g: number, b: number): [number, number, number];

package/dist/src/units/color/index.d.ts

@@ -0,0 +1,171 @@
+import { ColorSpace, WhitePoint } from './constants';
+export declare abstract class Color<T = number> {
+    readonly colorSpace: ColorSpace;
+    alpha: T;
+    [key: string]: any;
+    protected components: Map<string, T>;
+    constructor(colorSpace: ColorSpace, alpha?: T);
+    toString(): string;
+    toFormattedString(digits?: number): string;
+    valueOf(): T[];
+    toJSON(): Record<string, T>;
+    clone(): this;
+    keys(): string[];
+    values(): T[];
+    entries(): [string, T][];
+    protected getComponent(key: string): T | undefined;
+    protected setComponent(key: string, value: T): void;
+}
+declare class WhitePointColor<T = number> extends Color<T> {
+    whitePoint: WhitePoint;
+    constructor(colorSpace: ColorSpace, alpha: T, whitePoint: WhitePoint);
+}
+export declare class RGBColor<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class HSLColor<T = number> extends Color<T> {
+    constructor(h: T, s: T, l: T, alpha?: T);
+    get h(): T;
+    set h(value: T);
+    get s(): T;
+    set s(value: T);
+    get l(): T;
+    set l(value: T);
+}
+export declare class HSVColor<T = number> extends Color<T> {
+    constructor(h: T, s: T, v: T, alpha?: T);
+    get h(): T;
+    set h(value: T);
+    get s(): T;
+    set s(value: T);
+    get v(): T;
+    set v(value: T);
+}
+export declare class HWBColor<T = number> extends Color<T> {
+    constructor(h: T, w: T, b: T, alpha?: T);
+    get h(): T;
+    set h(value: T);
+    get w(): T;
+    set w(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class LABColor<T = number> extends WhitePointColor<T> {
+    constructor(l: T, a: T, b: T, alpha?: T);
+    get l(): T;
+    set l(value: T);
+    get a(): T;
+    set a(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class LCHColor<T = number> extends Color<T> {
+    constructor(l: T, c: T, h: T, alpha?: T);
+    get l(): T;
+    set l(value: T);
+    get c(): T;
+    set c(value: T);
+    get h(): T;
+    set h(value: T);
+}
+export declare class OKLABColor<T = number> extends WhitePointColor<T> {
+    constructor(l: T, a: T, b: T, alpha?: T);
+    get l(): T;
+    set l(value: T);
+    get a(): T;
+    set a(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class OKLCHColor<T = number> extends Color<T> {
+    constructor(l: T, c: T, h: T, alpha?: T);
+    get l(): T;
+    set l(value: T);
+    get c(): T;
+    set c(value: T);
+    get h(): T;
+    set h(value: T);
+}
+export declare class XYZColor<T = number> extends WhitePointColor<T> {
+    constructor(x: T, y: T, z: T, alpha?: T);
+    get x(): T;
+    set x(value: T);
+    get y(): T;
+    set y(value: T);
+    get z(): T;
+    set z(value: T);
+}
+export declare class KelvinColor<T = number> extends Color<T> {
+    constructor(kelvin: T, alpha?: T);
+    get kelvin(): T;
+    set kelvin(value: T);
+}
+export declare class LinearSRGBColor<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class DisplayP3Color<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class AdobeRGBColor<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class ProPhotoRGBColor<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export declare class Rec2020Color<T = number> extends Color<T> {
+    constructor(r: T, g: T, b: T, alpha?: T);
+    get r(): T;
+    set r(value: T);
+    get g(): T;
+    set g(value: T);
+    get b(): T;
+    set b(value: T);
+}
+export type ColorSpaceMap<T> = {
+    rgb: RGBColor<T>;
+    hsl: HSLColor<T>;
+    hsv: HSVColor<T>;
+    hwb: HWBColor<T>;
+    lab: LABColor<T>;
+    lch: LCHColor<T>;
+    oklab: OKLABColor<T>;
+    oklch: OKLCHColor<T>;
+    kelvin: KelvinColor<T>;
+    xyz: XYZColor<T>;
+    "srgb-linear": LinearSRGBColor<T>;
+    "display-p3": DisplayP3Color<T>;
+    "a98-rgb": AdobeRGBColor<T>;
+    "prophoto-rgb": ProPhotoRGBColor<T>;
+    rec2020: Rec2020Color<T>;
+};
+export {};

package/dist/src/units/color/matrix.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal 3×3 matrix and 3-element vector math.
+ * Replaces gl-matrix dependency — uses native number[] for full f64 precision
+ * (gl-matrix uses Float32Array).
+ *
+ * Mat3 is stored in row-major order:
+ *   [m00, m01, m02, m10, m11, m12, m20, m21, m22]
+ */
+export type Vec3 = [number, number, number];
+export type Mat3 = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/** Multiply a Mat3 (row-major) by a Vec3: result = M * v */
+export declare function transformMat3(v: Vec3, m: Mat3): Vec3;
+/** Transpose a Mat3 (row-major → row-major transpose) */
+export declare function transposeMat3(m: Mat3): Mat3;
+/** Multiply two Mat3 matrices (row-major): result = A × B */
+export declare function multiplyMat3(a: Mat3, b: Mat3): Mat3;
+/** Invert a 3×3 matrix via cofactor expansion. Returns the inverse. */
+export declare function invertMat3(m: Mat3): Mat3;

package/dist/src/units/color/normalize.d.ts

@@ -0,0 +1,10 @@
+import { Color, ColorSpaceMap } from '.';
+import { ValueUnit } from '..';
+import { ColorSpace } from './constants';
+import { HueInterpolationMethod } from './utils';
+export type { HueInterpolationMethod };
+export declare const normalizeColorUnitComponent: (v: number, unit: string, colorSpace: ColorSpace, component: string, inverse?: boolean) => ValueUnit<number, string>;
+export declare const normalizeColor: (color: Color<ValueUnit<number> | number>, inverse?: boolean) => Color<ValueUnit<number>>;
+export declare const normalizeColorUnit: (color: ValueUnit<Color<ValueUnit<number>>, "color">, inverse?: boolean, inplace?: boolean) => ValueUnit<Color<ValueUnit<number>>, "color">;
+export declare const colorUnit2: <C extends ColorSpace>(color: ValueUnit<Color<ValueUnit<number>>, "color">, to?: C | null, normalized?: boolean, inverse?: boolean, inplace?: boolean) => ValueUnit<ColorSpaceMap<ValueUnit<number>>[C], "color">;
+export declare const normalizeColorUnits: (a: ValueUnit<Color<ValueUnit<number>>, "color">, b: ValueUnit<Color<ValueUnit<number>>, "color">, to?: ColorSpace, normalized?: boolean, inverse?: boolean, inplace?: boolean, hueMethod?: HueInterpolationMethod) => readonly [ValueUnit<import('.').RGBColor<ValueUnit<number, string | undefined>> | import('.').HSLColor<ValueUnit<number, string | undefined>> | import('.').HSVColor<ValueUnit<number, string | undefined>> | import('.').HWBColor<ValueUnit<number, string | undefined>> | import('.').LABColor<ValueUnit<number, string | undefined>> | import('.').LCHColor<ValueUnit<number, string | undefined>> | import('.').OKLABColor<ValueUnit<number, string | undefined>> | import('.').OKLCHColor<ValueUnit<number, string | undefined>> | import('.').XYZColor<ValueUnit<number, string | undefined>> | import('.').KelvinColor<ValueUnit<number, string | undefined>> | import('.').LinearSRGBColor<ValueUnit<number, string | undefined>> | import('.').DisplayP3Color<ValueUnit<number, string | undefined>> | import('.').AdobeRGBColor<ValueUnit<number, string | undefined>> | import('.').ProPhotoRGBColor<ValueUnit<number, string | undefined>> | import('.').Rec2020Color<ValueUnit<number, string | undefined>>, "color">, ValueUnit<import('.').RGBColor<ValueUnit<number, string | undefined>> | import('.').HSLColor<ValueUnit<number, string | undefined>> | import('.').HSVColor<ValueUnit<number, string | undefined>> | import('.').HWBColor<ValueUnit<number, string | undefined>> | import('.').LABColor<ValueUnit<number, string | undefined>> | import('.').LCHColor<ValueUnit<number, string | undefined>> | import('.').OKLABColor<ValueUnit<number, string | undefined>> | import('.').OKLCHColor<ValueUnit<number, string | undefined>> | import('.').XYZColor<ValueUnit<number, string | undefined>> | import('.').KelvinColor<ValueUnit<number, string | undefined>> | import('.').LinearSRGBColor<ValueUnit<number, string | undefined>> | import('.').DisplayP3Color<ValueUnit<number, string | undefined>> | import('.').AdobeRGBColor<ValueUnit<number, string | undefined>> | import('.').ProPhotoRGBColor<ValueUnit<number, string | undefined>> | import('.').Rec2020Color<ValueUnit<number, string | undefined>>, "color">, HueInterpolationMethod | undefined];

package/dist/src/units/color/utils.d.ts

@@ -0,0 +1,77 @@
+import { AdobeRGBColor, Color, DisplayP3Color, HSLColor, HSVColor, HWBColor, KelvinColor, LABColor, LCHColor, LinearSRGBColor, OKLABColor, OKLCHColor, ProPhotoRGBColor, RGBColor, Rec2020Color, XYZColor, ColorSpaceMap } from '.';
+import { ColorSpace, WhitePoint } from './constants';
+export declare const getFormattedColorSpaceRange: <T extends ColorSpace>(colorSpace: T) => ColorSpaceMap<{
+    min: string;
+    max: string;
+}>[T];
+export declare const hex2rgb: (hex: string) => RGBColor;
+export declare const rgb2hex: ({ r, g, b, alpha }: RGBColor) => string;
+export declare const kelvin2rgb: ({ kelvin, alpha }: KelvinColor) => RGBColor;
+export declare const rgb2kelvin: ({ r, g, b, alpha }: RGBColor) => KelvinColor;
+export declare const hsv2hsl: ({ h, s, v, alpha }: HSVColor) => HSLColor;
+export declare const hsl2hsv: ({ h, s, l, alpha }: HSLColor) => HSVColor;
+export declare const hwb2hsl: ({ h, w, b, alpha }: HWBColor) => HSLColor;
+export declare const hsl2hwb: ({ h, s, l, alpha }: HSLColor) => HWBColor;
+export declare const rgb2hsl: ({ r, g, b, alpha }: RGBColor) => HSLColor;
+export declare function hsl2rgb({ h, s, l, alpha }: HSLColor): RGBColor;
+export declare function xyz2lab(xyz: XYZColor, toWhitePoint?: WhitePoint): LABColor;
+export declare function lab2xyz(lab: LABColor): XYZColor;
+export declare function srgbToLinear(channel: number): number;
+export declare function linearToSrgb(channel: number): number;
+export declare function rgb2xyz({ r, g, b, alpha }: RGBColor): XYZColor;
+export declare const xyz2rgb: ({ x, y, z, alpha }: XYZColor, correctGamut?: boolean) => RGBColor;
+export declare function lch2lab({ l, c, h, alpha }: LCHColor): LABColor;
+export declare function lab2lch({ l, a, b, alpha }: LABColor): LCHColor;
+export declare function oklab2xyz({ l, a, b, alpha }: OKLABColor): XYZColor;
+export declare function xyz2oklab(xyz: XYZColor): OKLABColor;
+export declare function oklab2lab(oklab: OKLABColor): LABColor;
+export declare function lab2oklab(lab: LABColor): OKLABColor;
+export declare function oklab2oklch({ l, a, b, alpha }: OKLABColor): OKLCHColor;
+export declare function oklch2oklab({ l, c, h, alpha }: OKLCHColor): OKLABColor;
+export declare function oklch2lab(oklch: OKLCHColor): LABColor;
+export declare function lab2oklch(lab: LABColor): OKLCHColor;
+export declare function hsl2xyz(hsl: HSLColor): XYZColor<number>;
+export declare function xyz2hsl(xyz: XYZColor): HSLColor<number>;
+export declare function hsv2xyz(hsv: HSVColor): XYZColor;
+export declare function xyz2hsv(xyz: XYZColor): HSVColor;
+export declare function hwb2xyz(hwb: HWBColor): XYZColor;
+export declare function xyz2hwb(xyz: XYZColor): HWBColor;
+export declare function lch2xyz(lch: LCHColor): XYZColor;
+export declare function xyz2lch(xyz: XYZColor): LCHColor;
+export declare function oklch2xyz(oklch: OKLCHColor): XYZColor;
+export declare function xyz2oklch(xyz: XYZColor): OKLCHColor;
+export declare function kelvin2xyz(kelvin: KelvinColor): XYZColor;
+export declare function xyz2kelvin(xyz: XYZColor): KelvinColor;
+export declare function adobeRgbToLinear(c: number): number;
+export declare function linearToAdobeRgb(c: number): number;
+export declare function proPhotoToLinear(c: number): number;
+export declare function linearToProPhoto(c: number): number;
+export declare function rec2020ToLinear(c: number): number;
+export declare function linearToRec2020(c: number): number;
+export declare function linearSrgb2xyz({ r, g, b, alpha }: LinearSRGBColor): XYZColor;
+export declare function xyz2linearSrgb({ x, y, z, alpha }: XYZColor): LinearSRGBColor;
+export declare function displayP32xyz({ r, g, b, alpha }: DisplayP3Color): XYZColor;
+export declare function xyz2displayP3({ x, y, z, alpha }: XYZColor): DisplayP3Color;
+export declare function adobeRgb2xyz({ r, g, b, alpha }: AdobeRGBColor): XYZColor;
+export declare function xyz2adobeRgb({ x, y, z, alpha }: XYZColor): AdobeRGBColor;
+export declare function proPhoto2xyz({ r, g, b, alpha }: ProPhotoRGBColor): XYZColor;
+export declare function xyz2proPhoto({ x, y, z, alpha }: XYZColor): ProPhotoRGBColor;
+export declare function rec20202xyz({ r, g, b, alpha }: Rec2020Color): XYZColor;
+export declare function xyz2rec2020({ x, y, z, alpha }: XYZColor): Rec2020Color;
+export declare function color2<T, C extends ColorSpace>(color: Color<T>, to: C): Color<T>;
+export { deltaEOK, isInSRGBGamut, DELTA_E_OK_JND } from './gamut';
+export declare function gamutMap<C extends Color>(color: C): C;
+export type HueInterpolationMethod = "shorter" | "longer" | "increasing" | "decreasing";
+export declare const CYLINDRICAL_HUE_COMPONENT: Partial<Record<ColorSpace, string>>;
+/**
+ * Interpolate between two hue values using the given method.
+ * Hues are in [0, 1] (normalized). Returns an interpolated hue in [0, 1].
+ * Handles NaN (CSS `none`): if one hue is NaN, the other's value is used.
+ */
+export declare function interpolateHue(h1: number, h2: number, t: number, method?: HueInterpolationMethod): number;
+/**
+ * Mix two colors per CSS color-mix() specification.
+ * Both colors should be normalized (components in [0, 1]).
+ * Percentages p1, p2 are in [0, 1] (e.g. 0.5 = 50%).
+ */
+export declare function mixColors(col1: Color, col2: Color, p1: number, p2: number, space?: ColorSpace, hueMethod?: HueInterpolationMethod): Color;

package/dist/src/units/constants.d.ts

@@ -0,0 +1,33 @@
+export declare const ABSOLUTE_LENGTH_UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt"];
+export declare const RELATIVE_LENGTH_UNITS: readonly ["em", "ex", "ch", "cap", "ic", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "svi", "svb", "svmin", "svmax", "lvw", "lvh", "lvi", "lvb", "lvmin", "lvmax", "dvw", "dvh", "dvi", "dvb", "dvmin", "dvmax", "cqw", "cqh", "cqi", "cqb", "cqmin", "cqmax"];
+export declare const LENGTH_UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt", "em", "ex", "ch", "cap", "ic", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "svi", "svb", "svmin", "svmax", "lvw", "lvh", "lvi", "lvb", "lvmin", "lvmax", "dvw", "dvh", "dvi", "dvb", "dvmin", "dvmax", "cqw", "cqh", "cqi", "cqb", "cqmin", "cqmax"];
+export declare const TIME_UNITS: readonly ["s", "ms"];
+export declare const ANGLE_UNITS: readonly ["deg", "rad", "grad", "turn"];
+export declare const PERCENTAGE_UNITS: readonly ["%"];
+export declare const FREQUENCY_UNITS: readonly ["Hz", "kHz"];
+export declare const RESOLUTION_UNITS: readonly ["dpi", "dpcm", "dppx"];
+export declare const FLEX_UNITS: readonly ["fr"];
+export declare const COMPUTED_UNITS: readonly ["var", "calc"];
+export declare const STRING_UNITS: readonly ["string"];
+export declare const COLOR_UNITS: readonly ["color"];
+export declare const UNITS: readonly ["px", "cm", "mm", "Q", "in", "pc", "pt", "em", "ex", "ch", "cap", "ic", "rem", "lh", "rlh", "vw", "vh", "vmin", "vmax", "vb", "vi", "svw", "svh", "svi", "svb", "svmin", "svmax", "lvw", "lvh", "lvi", "lvb", "lvmin", "lvmax", "dvw", "dvh", "dvi", "dvb", "dvmin", "dvmax", "cqw", "cqh", "cqi", "cqb", "cqmin", "cqmax", "s", "ms", "deg", "rad", "grad", "turn", "%", "Hz", "kHz", "dpi", "dpcm", "dppx", "fr", "var", "calc", "string", "color", "", undefined];
+export declare const BLACKLISTED_COALESCE_UNITS: readonly ["string", "var", "calc"];
+export interface MatrixValues {
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    skewX: number;
+    skewY: number;
+    skewZ: number;
+    translateX: number;
+    translateY: number;
+    translateZ: number;
+    rotateX: number;
+    rotateY: number;
+    rotateZ: number;
+    perspectiveX: number;
+    perspectiveY: number;
+    perspectiveZ: number;
+    perspectiveW: number;
+}
+export declare const STYLE_NAMES: readonly ["accentColor", "additiveSymbols", "alignContent", "alignItems", "alignSelf", "alignmentBaseline", "all", "anchorName", "animation", "animationComposition", "animationDelay", "animationDirection", "animationDuration", "animationFillMode", "animationIterationCount", "animationName", "animationPlayState", "animationRange", "animationRangeEnd", "animationRangeStart", "animationTimeline", "animationTimingFunction", "appRegion", "appearance", "ascentOverride", "aspectRatio", "backdropFilter", "backfaceVisibility", "background", "backgroundAttachment", "backgroundBlendMode", "backgroundClip", "backgroundColor", "backgroundImage", "backgroundOrigin", "backgroundPosition", "backgroundPositionX", "backgroundPositionY", "backgroundRepeat", "backgroundSize", "basePalette", "baselineShift", "baselineSource", "blockSize", "border", "borderBlock", "borderBlockColor", "borderBlockEnd", "borderBlockEndColor", "borderBlockEndStyle", "borderBlockEndWidth", "borderBlockStart", "borderBlockStartColor", "borderBlockStartStyle", "borderBlockStartWidth", "borderBlockStyle", "borderBlockWidth", "borderBottom", "borderBottomColor", "borderBottomLeftRadius", "borderBottomRightRadius", "borderBottomStyle", "borderBottomWidth", "borderCollapse", "borderColor", "borderEndEndRadius", "borderEndStartRadius", "borderImage", "borderImageOutset", "borderImageRepeat", "borderImageSlice", "borderImageSource", "borderImageWidth", "borderInline", "borderInlineColor", "borderInlineEnd", "borderInlineEndColor", "borderInlineEndStyle", "borderInlineEndWidth", "borderInlineStart", "borderInlineStartColor", "borderInlineStartStyle", "borderInlineStartWidth", "borderInlineStyle", "borderInlineWidth", "borderLeft", "borderLeftColor", "borderLeftStyle", "borderLeftWidth", "borderRadius", "borderRight", "borderRightColor", "borderRightStyle", "borderRightWidth", "borderSpacing", "borderStartEndRadius", "borderStartStartRadius", "borderStyle", "borderTop", "borderTopColor", "borderTopLeftRadius", "borderTopRightRadius", "borderTopStyle", "borderTopWidth", "borderWidth", "bottom", "boxShadow", "boxSizing", "breakAfter", "breakBefore", "breakInside", "bufferedRendering", "captionSide", "caretColor", "clear", "clip", "clipPath", "clipRule", "color", "colorInterpolation", "colorInterpolationFilters", "colorRendering", "colorScheme", "columnCount", "columnFill", "columnGap", "columnRule", "columnRuleColor", "columnRuleStyle", "columnRuleWidth", "columnSpan", "columnWidth", "columns", "contain", "containIntrinsicBlockSize", "containIntrinsicHeight", "containIntrinsicInlineSize", "containIntrinsicSize", "containIntrinsicWidth", "container", "containerName", "containerType", "content", "contentVisibility", "counterIncrement", "counterReset", "counterSet", "cursor", "cx", "cy", "d", "descentOverride", "direction", "display", "dominantBaseline", "emptyCells", "fallback", "fieldSizing", "fill", "fillOpacity", "fillRule", "filter", "flex", "flexBasis", "flexDirection", "flexFlow", "flexGrow", "flexShrink", "flexWrap", "float", "floodColor", "floodOpacity", "font", "fontDisplay", "fontFamily", "fontFeatureSettings", "fontKerning", "fontOpticalSizing", "fontPalette", "fontSize", "fontStretch", "fontStyle", "fontSynthesis", "fontSynthesisSmallCaps", "fontSynthesisStyle", "fontSynthesisWeight", "fontVariant", "fontVariantAlternates", "fontVariantCaps", "fontVariantEastAsian", "fontVariantLigatures", "fontVariantNumeric", "fontVariantPosition", "fontVariationSettings", "fontWeight", "forcedColorAdjust", "gap", "grid", "gridArea", "gridAutoColumns", "gridAutoFlow", "gridAutoRows", "gridColumn", "gridColumnEnd", "gridColumnGap", "gridColumnStart", "gridGap", "gridRow", "gridRowEnd", "gridRowGap", "gridRowStart", "gridTemplate", "gridTemplateAreas", "gridTemplateColumns", "gridTemplateRows", "height", "hyphenateCharacter", "hyphenateLimitChars", "hyphens", "imageOrientation", "imageRendering", "inherits", "initialLetter", "initialValue", "inlineSize", "inset", "insetArea", "insetBlock", "insetBlockEnd", "insetBlockStart", "insetInline", "insetInlineEnd", "insetInlineStart", "isolation", "justifyContent", "justifyItems", "justifySelf", "left", "letterSpacing", "lightingColor", "lineBreak", "lineGapOverride", "lineHeight", "listStyle", "listStyleImage", "listStylePosition", "listStyleType", "margin", "marginBlock", "marginBlockEnd", "marginBlockStart", "marginBottom", "marginInline", "marginInlineEnd", "marginInlineStart", "marginLeft", "marginRight", "marginTop", "marker", "markerEnd", "markerMid", "markerStart", "mask", "maskClip", "maskComposite", "maskImage", "maskMode", "maskOrigin", "maskPosition", "maskRepeat", "maskSize", "maskType", "mathDepth", "mathShift", "mathStyle", "maxBlockSize", "maxHeight", "maxInlineSize", "maxWidth", "minBlockSize", "minHeight", "minInlineSize", "minWidth", "mixBlendMode", "navigation", "negative", "objectFit", "objectPosition", "objectViewBox", "offset", "offsetAnchor", "offsetDistance", "offsetPath", "offsetPosition", "offsetRotate", "opacity", "order", "orphans", "outline", "outlineColor", "outlineOffset", "outlineStyle", "outlineWidth", "overflow", "overflowAnchor", "overflowClipMargin", "overflowWrap", "overflowX", "overflowY", "overlay", "overrideColors", "overscrollBehavior", "overscrollBehaviorBlock", "overscrollBehaviorInline", "overscrollBehaviorX", "overscrollBehaviorY", "pad", "padding", "paddingBlock", "paddingBlockEnd", "paddingBlockStart", "paddingBottom", "paddingInline", "paddingInlineEnd", "paddingInlineStart", "paddingLeft", "paddingRight", "paddingTop", "page", "pageBreakAfter", "pageBreakBefore", "pageBreakInside", "pageOrientation", "paintOrder", "perspective", "perspectiveOrigin", "placeContent", "placeItems", "placeSelf", "pointerEvents", "position", "positionAnchor", "positionTry", "positionTryOptions", "positionTryOrder", "positionVisibility", "prefix", "quotes", "r", "range", "resize", "right", "rotate", "rowGap", "rubyPosition", "rx", "ry", "scale", "scrollBehavior", "scrollMargin", "scrollMarginBlock", "scrollMarginBlockEnd", "scrollMarginBlockStart", "scrollMarginBottom", "scrollMarginInline", "scrollMarginInlineEnd", "scrollMarginInlineStart", "scrollMarginLeft", "scrollMarginRight", "scrollMarginTop", "scrollPadding", "scrollPaddingBlock", "scrollPaddingBlockEnd", "scrollPaddingBlockStart", "scrollPaddingBottom", "scrollPaddingInline", "scrollPaddingInlineEnd", "scrollPaddingInlineStart", "scrollPaddingLeft", "scrollPaddingRight", "scrollPaddingTop", "scrollSnapAlign", "scrollSnapStop", "scrollSnapType", "scrollTimeline", "scrollTimelineAxis", "scrollTimelineName", "scrollbarColor", "scrollbarGutter", "scrollbarWidth", "shapeImageThreshold", "shapeMargin", "shapeOutside", "shapeRendering", "size", "sizeAdjust", "speak", "speakAs", "src", "stopColor", "stopOpacity", "stroke", "strokeDasharray", "strokeDashoffset", "strokeLinecap", "strokeLinejoin", "strokeMiterlimit", "strokeOpacity", "strokeWidth", "suffix", "symbols", "syntax", "system", "tabSize", "tableLayout", "textAlign", "textAlignLast", "textAnchor", "textCombineUpright", "textDecoration", "textDecorationColor", "textDecorationLine", "textDecorationSkipInk", "textDecorationStyle", "textDecorationThickness", "textEmphasis", "textEmphasisColor", "textEmphasisPosition", "textEmphasisStyle", "textIndent", "textOrientation", "textOverflow", "textRendering", "textShadow", "textSizeAdjust", "textSpacingTrim", "textTransform", "textUnderlineOffset", "textUnderlinePosition", "textWrap", "timelineScope", "top", "touchAction", "transform", "transformBox", "transformOrigin", "transformStyle", "transition", "transitionBehavior", "transitionDelay", "transitionDuration", "transitionProperty", "transitionTimingFunction", "translate", "types", "unicodeBidi", "unicodeRange", "userSelect", "vectorEffect", "verticalAlign", "viewTimeline", "viewTimelineAxis", "viewTimelineInset", "viewTimelineName", "viewTransitionClass", "viewTransitionName", "visibility", "webkitAlignContent", "webkitAlignItems", "webkitAlignSelf", "webkitAnimation", "webkitAnimationDelay", "webkitAnimationDirection", "webkitAnimationDuration", "webkitAnimationFillMode", "webkitAnimationIterationCount", "webkitAnimationName", "webkitAnimationPlayState", "webkitAnimationTimingFunction", "webkitAppRegion", "webkitAppearance", "webkitBackfaceVisibility", "webkitBackgroundClip", "webkitBackgroundOrigin", "webkitBackgroundSize", "webkitBorderAfter", "webkitBorderAfterColor", "webkitBorderAfterStyle", "webkitBorderAfterWidth", "webkitBorderBefore", "webkitBorderBeforeColor", "webkitBorderBeforeStyle", "webkitBorderBeforeWidth", "webkitBorderBottomLeftRadius", "webkitBorderBottomRightRadius", "webkitBorderEnd", "webkitBorderEndColor", "webkitBorderEndStyle", "webkitBorderEndWidth", "webkitBorderHorizontalSpacing", "webkitBorderImage", "webkitBorderRadius", "webkitBorderStart", "webkitBorderStartColor", "webkitBorderStartStyle", "webkitBorderStartWidth", "webkitBorderTopLeftRadius", "webkitBorderTopRightRadius", "webkitBorderVerticalSpacing", "webkitBoxAlign", "webkitBoxDecorationBreak", "webkitBoxDirection", "webkitBoxFlex", "webkitBoxOrdinalGroup", "webkitBoxOrient", "webkitBoxPack", "webkitBoxReflect", "webkitBoxShadow", "webkitBoxSizing", "webkitClipPath", "webkitColumnBreakAfter", "webkitColumnBreakBefore", "webkitColumnBreakInside", "webkitColumnCount", "webkitColumnGap", "webkitColumnRule", "webkitColumnRuleColor", "webkitColumnRuleStyle", "webkitColumnRuleWidth", "webkitColumnSpan", "webkitColumnWidth", "webkitColumns", "webkitFilter", "webkitFlex", "webkitFlexBasis", "webkitFlexDirection", "webkitFlexFlow", "webkitFlexGrow", "webkitFlexShrink", "webkitFlexWrap", "webkitFontFeatureSettings", "webkitFontSmoothing", "webkitHyphenateCharacter", "webkitJustifyContent", "webkitLineBreak", "webkitLineClamp", "webkitLocale", "webkitLogicalHeight", "webkitLogicalWidth", "webkitMarginAfter", "webkitMarginBefore", "webkitMarginEnd", "webkitMarginStart", "webkitMask", "webkitMaskBoxImage", "webkitMaskBoxImageOutset", "webkitMaskBoxImageRepeat", "webkitMaskBoxImageSlice", "webkitMaskBoxImageSource", "webkitMaskBoxImageWidth", "webkitMaskClip", "webkitMaskComposite", "webkitMaskImage", "webkitMaskOrigin", "webkitMaskPosition", "webkitMaskPositionX", "webkitMaskPositionY", "webkitMaskRepeat", "webkitMaskSize", "webkitMaxLogicalHeight", "webkitMaxLogicalWidth", "webkitMinLogicalHeight", "webkitMinLogicalWidth", "webkitOpacity", "webkitOrder", "webkitPaddingAfter", "webkitPaddingBefore", "webkitPaddingEnd", "webkitPaddingStart", "webkitPerspective", "webkitPerspectiveOrigin", "webkitPerspectiveOriginX", "webkitPerspectiveOriginY", "webkitPrintColorAdjust", "webkitRtlOrdering", "webkitRubyPosition", "webkitShapeImageThreshold", "webkitShapeMargin", "webkitShapeOutside", "webkitTapHighlightColor", "webkitTextCombine", "webkitTextDecorationsInEffect", "webkitTextEmphasis", "webkitTextEmphasisColor", "webkitTextEmphasisPosition", "webkitTextEmphasisStyle", "webkitTextFillColor", "webkitTextOrientation", "webkitTextSecurity", "webkitTextSizeAdjust", "webkitTextStroke", "webkitTextStrokeColor", "webkitTextStrokeWidth", "webkitTransform", "webkitTransformOrigin", "webkitTransformOriginX", "webkitTransformOriginY", "webkitTransformOriginZ", "webkitTransformStyle", "webkitTransition", "webkitTransitionDelay", "webkitTransitionDuration", "webkitTransitionProperty", "webkitTransitionTimingFunction", "webkitUserDrag", "webkitUserModify", "webkitUserSelect", "webkitWritingMode", "whiteSpace", "whiteSpaceCollapse", "widows", "width", "willChange", "wordBreak", "wordSpacing", "wordWrap", "writingMode", "x", "y", "zIndex", "zoom"];

package/dist/src/units/index.d.ts

@@ -0,0 +1,51 @@
+import { UNITS } from './constants';
+export { registerColorNames, clearCustomColorNames, getCustomColorNames } from '../parsing/color';
+export declare class ValueUnit<T = any, U = (typeof UNITS)[number] | string> {
+    value: T;
+    unit?: U | undefined;
+    superType?: string[] | undefined;
+    subProperty?: string | undefined;
+    property?: string | undefined;
+    targets?: HTMLElement[] | undefined;
+    constructor(value: T, unit?: U | undefined, superType?: string[] | undefined, subProperty?: string | undefined, property?: string | undefined, targets?: HTMLElement[] | undefined);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    valueOf(): T;
+    setValue(value: T): void;
+    toString(): string;
+    toJSON(): T;
+    toFixed(fractionDigits?: number): string;
+    clone(): ValueUnit<T, U>;
+    coalesce(right?: ValueUnit, inplace?: boolean): ValueUnit<any, any>;
+}
+export declare class FunctionValue<T = any, N extends string = string> {
+    name: N;
+    values: Array<ValueUnit<T> | FunctionValue<T>>;
+    constructor(name: N, values: Array<ValueUnit<T> | FunctionValue<T>>);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    setValue(value: T, index?: number): void;
+    valueOf(): any[];
+    toString(): string;
+    toJSON(): Record<string, any[]>;
+    clone(): FunctionValue<T>;
+}
+export declare class ValueArray<T = any> extends Array<ValueUnit<T> | FunctionValue<T>> {
+    constructor(...args: Array<ValueUnit<T> | FunctionValue<T>>);
+    setSubProperty(subProperty: any): void;
+    setProperty(property: any): void;
+    setTargets(targets: HTMLElement[]): void;
+    setValue(value: T, index?: number): void;
+    valueOf(): (any[] | T)[];
+    toString(): string;
+    toJSON(): (Record<string, any[]> | T)[];
+    clone(): ValueArray<T>;
+}
+export type InterpolatedVar<T> = {
+    start: ValueUnit<T>;
+    stop: ValueUnit<T>;
+    value: ValueUnit<T>;
+    computed: boolean;
+};

package/dist/src/units/normalize.d.ts

@@ -0,0 +1,9 @@
+import { ValueUnit, InterpolatedVar } from '.';
+export declare const getComputedValue: ((value: ValueUnit, target: HTMLElement) => ValueUnit<any, any>) & {
+    cache: Map<string, {
+        value: ValueUnit<any, any>;
+        timestamp: number;
+    }>;
+};
+export declare const normalizeNumericUnits: (a: ValueUnit, b: ValueUnit, inplace?: boolean) => [ValueUnit, ValueUnit];
+export declare function normalizeValueUnits(left: ValueUnit, right: ValueUnit): InterpolatedVar<any>;

package/dist/src/units/utils.d.ts

@@ -0,0 +1,17 @@
+import { FunctionValue, ValueUnit } from '.';
+import { Color } from './color';
+import { ABSOLUTE_LENGTH_UNITS, ANGLE_UNITS, FREQUENCY_UNITS, PERCENTAGE_UNITS, RELATIVE_LENGTH_UNITS, RESOLUTION_UNITS, STYLE_NAMES, TIME_UNITS, UNITS, MatrixValues } from './constants';
+export declare function isColorUnit(value: ValueUnit<Color<ValueUnit>>): value is ValueUnit<Color<ValueUnit>>;
+export declare const flattenObject: (obj: any) => Record<string, any>;
+export declare const unflattenObject: (flatObj: Record<string, any[]>) => any;
+export declare const unflattenObjectToString: (flatObj: Record<string, any[]>) => Record<string, string>;
+export declare function isCSSStyleName(value: any): value is (typeof STYLE_NAMES)[number];
+export declare const unpackMatrixValues: (value: FunctionValue) => MatrixValues;
+export declare function convertAbsoluteUnitToPixels(value: number, unit: string): number;
+export declare function convertToPixels(value: number, unit: (typeof ABSOLUTE_LENGTH_UNITS)[number] | (typeof RELATIVE_LENGTH_UNITS)[number] | (typeof PERCENTAGE_UNITS)[number], element?: HTMLElement, property?: string): number;
+export declare function convertToMs(value: number, unit: (typeof TIME_UNITS)[number]): number;
+export declare function convertToDegrees(value: number, unit: (typeof ANGLE_UNITS)[number]): number;
+export declare function convertToHz(value: number, unit: (typeof FREQUENCY_UNITS)[number]): number;
+export declare function convertToDPI(value: number, unit: (typeof RESOLUTION_UNITS)[number]): number;
+declare function convert2(value: number, from: (typeof UNITS)[number], to: (typeof UNITS)[number], target?: HTMLElement): number;
+export { convert2 };

package/dist/src/utils.d.ts

@@ -0,0 +1,28 @@
+export declare const FRAME_RATE: number;
+export declare const isObject: (value: any) => boolean;
+export declare function clone(obj: any): any;
+export declare const arrayEquals: (a: any[], b: any[]) => boolean;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function waitUntil(condition: () => boolean, delay?: number): Promise<void>;
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, immediate?: boolean): ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+};
+export declare function createHash(algorithm: string, data: string): Promise<string>;
+export interface MemoizeOptions<T extends (...args: any[]) => any = (...args: any[]) => any> {
+    maxCacheSize?: number;
+    ttl?: number;
+    keyFn?: (...args: any[]) => string;
+    /** When provided, the result is only cached if this returns true. */
+    shouldCache?: (result: ReturnType<T>, ...args: Parameters<T>) => boolean;
+}
+export declare function memoize<T extends (...args: any[]) => any>(func: T, options?: MemoizeOptions<T>): T & {
+    cache: Map<string, {
+        value: ReturnType<T>;
+        timestamp: number;
+    }>;
+};
+export declare const hyphenToCamelCase: (str: string) => string;
+export declare function camelCaseToHyphen(str: string): string;
+export declare function seekPreviousValue<T>(ix: number, values: T[], pred: (f: T) => boolean): number | undefined;
+export declare function requestAnimationFrame(callback: FrameRequestCallback): number | NodeJS.Timeout;
+export declare function cancelAnimationFrame(handle: number | undefined | null | any): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mkbabb/value.js",
-    "version": "0.4.5",
+    "version": "0.4.6",
     "description": "CSS value units for color, length, angles, & c.",
     "license": "GPL-3.0-only",
     "keywords": [