yuyeon 0.3.4-beta.12 → 0.3.4-beta.13

package/types/src/util/color/apca.d.ts

@@ -0,0 +1,29 @@
+/** @preserve
+ /////    SAPC APCA - Advanced Perceptual Contrast Algorithm
+ /////           Beta 0.1.9 W3 • contrast function only
+ /////           DIST: W3 • Revision date: July 3, 2022
+ /////    Function to parse color values and determine Lc contrast
+ /////    Copyright © 2019-2022 by Andrew Somers. All Rights Reserved.
+ /////    LICENSE: W3 LICENSE
+ /////    CONTACT: Please use the ISSUES or DISCUSSIONS tab at:
+ /////    https://github.com/Myndex/SAPC-APCA/
+ /////
+ ///////////////////////////////////////////////////////////////////////////////
+ /////
+ /////    MINIMAL IMPORTS:
+ /////      import { APCAcontrast, sRGBtoY, displayP3toY,
+/////               calcAPCA, fontLookupAPCA } from 'apca-w3';
+ /////      import { colorParsley } from 'colorparsley';
+ /////
+ /////    FORWARD CONTRAST USAGE:
+ /////      Lc = APCAcontrast( sRGBtoY( TEXTcolor ) , sRGBtoY( BACKGNDcolor ) );
+ /////    Where the colors are sent as an rgba array [255,255,255,1]
+ /////
+ /////    Retrieving an array of font sizes for the contrast:
+ /////      fontArray = fontLookupAPCA(Lc);
+ /////
+ /////    Live Demonstrator at https://www.myndex.com/APCA/
+ // */
+export declare function sRGBtoY(rgb?: number[]): number;
+export declare function APCAcontrast(txtY: number, bgY: number, places?: number): string | number;
+export declare function alphaBlend(rgbaFG?: number[], rgbBG?: number[], round?: boolean): (number | boolean)[];

package/types/src/util/color/const.d.ts

@@ -0,0 +1,5 @@
+export declare const RGBA_REGEX: RegExp;
+export declare const HEX_COLOR_REGEX: RegExp;
+export declare const SRGB_TO_XYZ: number[][];
+export declare const XYZ_TO_SRGB: number[][];
+export declare const WHITE_POINT_D65: number[];

package/types/src/util/color/contrast/contrast.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Utility methods for calculating contrast given two colors, or calculating a
+ * color given one color and a contrast ratio.
+ *
+ * Contrast ratio is calculated using XYZ's Y. When linearized to match human
+ * perception, Y becomes HCT's tone and L*a*b*'s' L*. Informally, this is the
+ * lightness of a color.
+ *
+ * Methods refer to tone, T in the the HCT color space.
+ * Tone is equivalent to L* in the L*a*b* color space, or L in the LCH color
+ * space.
+ */
+export declare class Contrast {
+    /**
+     * Returns a contrast ratio, which ranges from 1 to 21.
+     *
+     * @param toneA Tone between 0 and 100. Values outside will be clamped.
+     * @param toneB Tone between 0 and 100. Values outside will be clamped.
+     */
+    static ratioOfTones(toneA: number, toneB: number): number;
+    static ratioOfYs(y1: number, y2: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns -1 if ratio cannot be achieved with tone parameter.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in -1 being returned.
+     * @param ratio Contrast ratio of return value and tone.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static lighter(tone: number, ratio: number): number;
+    /**
+     * Returns a tone <= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns -1 if ratio cannot be achieved with tone parameter.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in -1 being returned.
+     * @param ratio Contrast ratio of return value and tone.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static darker(tone: number, ratio: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns 100 if ratio cannot be achieved with tone parameter.
+     *
+     * This method is unsafe because the returned value is guaranteed to be in
+     * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+     * the ratio with tone. For example, there is no color lighter than T100.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in 100 being returned.
+     * @param ratio Desired contrast ratio of return value and tone parameter.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static lighterUnsafe(tone: number, ratio: number): number;
+    /**
+     * Returns a tone >= tone parameter that ensures ratio parameter.
+     * Return value is between 0 and 100.
+     * Returns 100 if ratio cannot be achieved with tone parameter.
+     *
+     * This method is unsafe because the returned value is guaranteed to be in
+     * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+     * the [ratio with [tone]. For example, there is no color darker than T0.
+     *
+     * @param tone Tone return value must contrast with.
+     * Range is 0 to 100. Invalid values will result in 0 being returned.
+     * @param ratio Desired contrast ratio of return value and tone parameter.
+     * Range is 1 to 21, invalid values have undefined behavior.
+     */
+    static darkerUnsafe(tone: number, ratio: number): number;
+}

package/types/src/util/color/conversion.d.ts

@@ -0,0 +1,131 @@
+import { Rgba } from './types';
+
+export declare function rgbFromHex(color: string): number[] | undefined;
+export declare function hexFromRgb(red: number, green: number, blue: number): string;
+export declare function hexFromArgb(argb: number): string;
+/**
+ * Converts a color from RGB components to ARGB format.
+ */
+export declare function argbFromRgb(red: number, green: number, blue: number): number;
+/**
+ * Converts a color from linear RGB components to ARGB format.
+ */
+export declare function argbFromLinrgb(linrgb: number[]): number;
+/**
+ * Returns the alpha component of a color in ARGB format.
+ */
+export declare function alphaFromArgb(argb: number): number;
+/**
+ * Returns the red component of a color in ARGB format.
+ */
+export declare function redFromArgb(argb: number): number;
+/**
+ * Returns the green component of a color in ARGB format.
+ */
+export declare function greenFromArgb(argb: number): number;
+/**
+ * Returns the blue component of a color in ARGB format.
+ */
+export declare function blueFromArgb(argb: number): number;
+/**
+ * Returns whether a color in ARGB format is opaque.
+ */
+export declare function isOpaque(argb: number): boolean;
+/**
+ * Converts a color from ARGB to XYZ.
+ */
+export declare function argbFromXyz(x: number, y: number, z: number): number;
+/**
+ * Converts a color from XYZ to ARGB.
+ */
+export declare function xyzFromArgb(argb: number): number[];
+/**
+ * Converts a color represented in Lab color space into an ARGB
+ * integer.
+ */
+export declare function argbFromLab(l: number, a: number, b: number): number;
+/**
+ * Converts a color from ARGB representation to L*a*b*
+ * representation.
+ *
+ * @param argb the ARGB representation of a color
+ * @return a Lab object representing the color
+ */
+export declare function labFromArgb(argb: number): number[];
+/**
+ * Converts an L* value to an ARGB representation.
+ *
+ * @param lstar L* in L*a*b*
+ * @return ARGB representation of grayscale color with lightness
+ * matching L*
+ */
+export declare function argbFromLstar(lstar: number): number;
+/**
+ * Computes the L* value of a color in ARGB representation.
+ *
+ * @param argb ARGB representation of a color
+ * @return L*, from L*a*b*, coordinate of the color
+ */
+export declare function lstarFromArgb(argb: number): number;
+/**
+ * Converts an L* value to a Y value.
+ *
+ * L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
+ *
+ * L* measures perceptual luminance, a linear scale. Y in XYZ
+ * measures relative luminance, a logarithmic scale.
+ *
+ * @param lstar L* in L*a*b*
+ * @return Y in XYZ
+ */
+export declare function yFromLstar(lstar: number): number;
+/**
+ * Converts a Y value to an L* value.
+ *
+ * L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
+ *
+ * L* measures perceptual luminance, a linear scale. Y in XYZ
+ * measures relative luminance, a logarithmic scale.
+ *
+ * @param y Y in XYZ
+ * @return L* in L*a*b*
+ */
+export declare function lstarFromY(y: number): number;
+/**
+ * Linearizes an RGB component.
+ *
+ * @param rgbComponent 0 <= rgb_component <= 255, represents R/G/B
+ * channel
+ * @return 0.0 <= output <= 100.0, color channel converted to
+ * linear RGB space
+ */
+export declare function linearized(rgbComponent: number): number;
+/**
+ * Delinearizes an RGB component.
+ *
+ * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+ * linear R/G/B channel
+ * @return 0 <= output <= 255, color channel converted to regular
+ * RGB space
+ */
+export declare function delinearized(rgbComponent: number): number;
+/**
+ * Returns the standard white point; white on a sunny day.
+ *
+ * @return The white point
+ */
+export declare function whitePointD65(): number[];
+/**
+ * Return RGBA from a given int32 color
+ *
+ * @param argb ARGB representation of a int32 color.
+ * @return RGBA representation of a int32 color.
+ */
+export declare function rgbaFromArgb(argb: number): Rgba;
+/**
+ * Return int32 color from a given RGBA component
+ *
+ * @param rgba RGBA representation of a int32 color.
+ * @returns ARGB representation of a int32 color.
+ */
+export declare function argbFromRgba({ r, g, b, a }: Rgba): number;

package/types/src/util/color/hct/cam16.d.ts

@@ -0,0 +1,116 @@
+import { ViewingConditions } from './viewing-conditions';
+
+/**
+ * CAM16, a color appearance model. Colors are not just defined by their hex
+ * code, but rather, a hex code and viewing conditions.
+ *
+ * CAM16 instances also have coordinates in the CAM16-UCS space, called J*, a*,
+ * b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+ * specification, and should be used when measuring distances between colors.
+ *
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ */
+export declare class Cam16 {
+    readonly hue: number;
+    readonly chroma: number;
+    readonly j: number;
+    readonly q: number;
+    readonly m: number;
+    readonly s: number;
+    readonly jstar: number;
+    readonly astar: number;
+    readonly bstar: number;
+    /**
+     * All of the CAM16 dimensions can be calculated from 3 of the dimensions, in
+     * the following combinations:
+     *      -  {j or q} and {c, m, or s} and hue
+     *      - jstar, astar, bstar
+     * Prefer using a static method that constructs from 3 of those dimensions.
+     * This constructor is intended for those methods to use to return all
+     * possible dimensions.
+     *
+     * @param hue
+     * @param chroma informally, colorfulness / color intensity. like saturation
+     *     in HSL, except perceptually accurate.
+     * @param j lightness
+     * @param q brightness; ratio of lightness to white point's lightness
+     * @param m colorfulness
+     * @param s saturation; ratio of chroma to white point's chroma
+     * @param jstar CAM16-UCS J coordinate
+     * @param astar CAM16-UCS a coordinate
+     * @param bstar CAM16-UCS b coordinate
+     */
+    constructor(hue: number, chroma: number, j: number, q: number, m: number, s: number, jstar: number, astar: number, bstar: number);
+    /**
+     * CAM16 instances also have coordinates in the CAM16-UCS space, called J*,
+     * a*, b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+     * specification, and is used to measure distances between colors.
+     */
+    distance(other: Cam16): number;
+    /**
+     * @param argb ARGB representation of a color.
+     * @return CAM16 color, assuming the color was viewed in default viewing
+     *     conditions.
+     */
+    static fromInt(argb: number): Cam16;
+    /**
+     * @param argb ARGB representation of a color.
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     * @return CAM16 color.
+     */
+    static fromIntInViewingConditions(argb: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param j CAM16 lightness
+     * @param c CAM16 chroma
+     * @param h CAM16 hue
+     */
+    static fromJch(j: number, c: number, h: number): Cam16;
+    /**
+     * @param j CAM16 lightness
+     * @param c CAM16 chroma
+     * @param h CAM16 hue
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromJchInViewingConditions(j: number, c: number, h: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param jstar CAM16-UCS lightness.
+     * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     */
+    static fromUcs(jstar: number, astar: number, bstar: number): Cam16;
+    /**
+     * @param jstar CAM16-UCS lightness.
+     * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromUcsInViewingConditions(jstar: number, astar: number, bstar: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     *  @return ARGB representation of color, assuming the color was viewed in
+     *     default viewing conditions, which are near-identical to the default
+     *     viewing conditions for sRGB.
+     */
+    toInt(): number;
+    /**
+     * @param viewingConditions Information about the environment where the color
+     *     will be viewed.
+     * @return ARGB representation of color
+     */
+    viewed(viewingConditions: ViewingConditions): number;
+    static fromXyzInViewingConditions(x: number, y: number, z: number, viewingConditions: ViewingConditions): Cam16;
+    xyzInViewingConditions(viewingConditions: ViewingConditions): number[];
+}

package/types/src/util/color/hct/hct-solver.d.ts

@@ -0,0 +1,131 @@
+import { Cam16 } from './cam16';
+
+/**
+ * A class that solves the HCT equation.
+ */
+export declare class HctSolver {
+    static SCALED_DISCOUNT_FROM_LINRGB: number[][];
+    static LINRGB_FROM_SCALED_DISCOUNT: number[][];
+    static Y_FROM_LINRGB: number[];
+    static CRITICAL_PLANES: number[];
+    /**
+     * Sanitizes a small enough angle in radians.
+     *
+     * @param angle An angle in radians; must not deviate too much
+     * from 0.
+     * @return A coterminal angle between 0 and 2pi.
+     */
+    private static sanitizeRadians;
+    /**
+     * Delinearizes an RGB component, returning a floating-point
+     * number.
+     *
+     * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+     * linear R/G/B channel
+     * @return 0.0 <= output <= 255.0, color channel converted to
+     * regular RGB space
+     */
+    private static trueDelinearized;
+    private static chromaticAdaptation;
+    /**
+     * Returns the hue of a linear RGB color in CAM16.
+     *
+     * @param linrgb The linear RGB coordinates of a color.
+     * @return The hue of the color in CAM16, in radians.
+     */
+    private static hueOf;
+    private static areInCyclicOrder;
+    /**
+     * Solves the lerp equation.
+     *
+     * @param source The starting number.
+     * @param mid The number in the middle.
+     * @param target The ending number.
+     * @return A number t such that lerp(source, target, t) = mid.
+     */
+    private static intercept;
+    private static lerpPoint;
+    /**
+     * Intersects a segment with a plane.
+     *
+     * @param source The coordinates of point A.
+     * @param coordinate The R-, G-, or B-coordinate of the plane.
+     * @param target The coordinates of point B.
+     * @param axis The axis the plane is perpendicular with. (0: R, 1:
+     * G, 2: B)
+     * @return The intersection point of the segment AB with the plane
+     * R=coordinate, G=coordinate, or B=coordinate
+     */
+    private static setCoordinate;
+    private static isBounded;
+    /**
+     * Returns the nth possible vertex of the polygonal intersection.
+     *
+     * @param y The Y value of the plane.
+     * @param n The zero-based index of the point. 0 <= n <= 11.
+     * @return The nth possible vertex of the polygonal intersection
+     * of the y plane and the RGB cube, in linear RGB coordinates, if
+     * it exists. If this possible vertex lies outside of the cube,
+     * [-1.0, -1.0, -1.0] is returned.
+     */
+    private static nthVertex;
+    /**
+     * Finds the segment containing the desired color.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return A list of two sets of linear RGB coordinates, each
+     * corresponding to an endpoint of the segment containing the
+     * desired color.
+     */
+    private static bisectToSegment;
+    private static midpoint;
+    private static criticalPlaneBelow;
+    private static criticalPlaneAbove;
+    /**
+     * Finds a color with the given Y and hue on the boundary of the
+     * cube.
+     *
+     * @param y The Y value of the color.
+     * @param targetHue The hue of the color.
+     * @return The desired color, in linear RGB coordinates.
+     */
+    private static bisectToLimit;
+    private static inverseChromaticAdaptation;
+    /**
+     * Finds a color with the given hue, chroma, and Y.
+     *
+     * @param hueRadians The desired hue in radians.
+     * @param chroma The desired chroma.
+     * @param y The desired Y.
+     * @return The desired color as a hexadecimal integer, if found; 0
+     * otherwise.
+     */
+    private static findResultByJ;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return A hexadecimal representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToInt(hueDegrees: number, chroma: number, lstar: number): number;
+    /**
+     * Finds an sRGB color with the given hue, chroma, and L*, if
+     * possible.
+     *
+     * @param hueDegrees The desired hue, in degrees.
+     * @param chroma The desired chroma.
+     * @param lstar The desired L*.
+     * @return An CAM16 object representing the sRGB color. The color
+     * has sufficiently close hue, chroma, and L* to the desired
+     * values, if possible; otherwise, the hue and L* will be
+     * sufficiently close, and chroma will be maximized.
+     */
+    static solveToCam(hueDegrees: number, chroma: number, lstar: number): Cam16;
+}

package/types/src/util/color/hct/hct.d.ts

@@ -0,0 +1,71 @@
+import { ViewingConditions } from './viewing-conditions';
+
+/**
+ * HCT, hue, chroma, and tone. A color system that provides a perceptually
+ * accurate color measurement system that can also accurately render what colors
+ * will appear as in different lighting environments.
+ */
+export declare class Hct {
+    private argb;
+    /**
+     * @param hue 0 <= hue < 360; invalid values are corrected.
+     * @param chroma 0 <= chroma < ?; Informally, colorfulness. The color
+     *     returned may be lower than the requested chroma. Chroma has a different
+     *     maximum for any given hue and tone.
+     * @param tone 0 <= tone <= 100; invalid values are corrected.
+     * @return HCT representation of a color in default viewing conditions.
+     */
+    internalHue: number;
+    internalChroma: number;
+    internalTone: number;
+    static from(hue: number, chroma: number, tone: number): Hct;
+    /**
+     * @param argb ARGB representation of a color.
+     * @return HCT representation of a color in default viewing conditions
+     */
+    static fromInt(argb: number): Hct;
+    toInt(): number;
+    /**
+     * A number, in degrees, representing ex. red, orange, yellow, etc.
+     * Ranges from 0 <= hue < 360.
+     */
+    get hue(): number;
+    /**
+     * @param newHue 0 <= newHue < 360; invalid values are corrected.
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set hue(newHue: number);
+    get chroma(): number;
+    /**
+     * @param newChroma 0 <= newChroma < ?
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set chroma(newChroma: number);
+    /** Lightness. Ranges from 0 to 100. */
+    get tone(): number;
+    /**
+     * @param newTone 0 <= newTone <= 100; invalid valids are corrected.
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set tone(newTone: number);
+    private constructor();
+    private setInternalState;
+    /**
+     * Translates a color into different [ViewingConditions].
+     *
+     * Colors change appearance. They look different with lights on versus off,
+     * the same color, as in hex code, on white looks different when on black.
+     * This is called color relativity, most famously explicated by Josef Albers
+     * in Interaction of Color.
+     *
+     * In color science, color appearance models can account for this and
+     * calculate the appearance of a color in different settings. HCT is based on
+     * CAM16, a color appearance model, and uses it to make these calculations.
+     *
+     * See [ViewingConditions.make] for parameters affecting color appearance.
+     */
+    inViewingConditions(vc: ViewingConditions): Hct;
+}

package/types/src/util/color/hct/viewing-conditions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ *
+ * This class caches intermediate values of the CAM16 conversion process that
+ * depend only on viewing conditions, enabling speed ups.
+ */
+export declare class ViewingConditions {
+    n: number;
+    aw: number;
+    nbb: number;
+    ncb: number;
+    c: number;
+    nc: number;
+    rgbD: number[];
+    fl: number;
+    fLRoot: number;
+    z: number;
+    /** sRGB-like viewing conditions.  */
+    static DEFAULT: ViewingConditions;
+    /**
+     * Create ViewingConditions from a simple, physically relevant, set of
+     * parameters.
+     *
+     * @param whitePoint White point, measured in the XYZ color space.
+     *     default = D65, or sunny day afternoon
+     * @param adaptingLuminance The luminance of the adapting field. Informally,
+     *     how bright it is in the room where the color is viewed. Can be
+     *     calculated from lux by multiplying lux by 0.0586. default = 11.72,
+     *     or 200 lux.
+     * @param backgroundLstar The lightness of the area surrounding the color.
+     *     measured by L* in L*a*b*. default = 50.0
+     * @param surround A general description of the lighting surrounding the
+     *     color. 0 is pitch dark, like watching a movie in a theater. 1.0 is a
+     *     dimly light room, like watching TV at home at night. 2.0 means there
+     *     is no difference between the lighting on the color and around it.
+     *     default = 2.0
+     * @param discountingIlluminant Whether the eye accounts for the tint of the
+     *     ambient lighting, such as knowing an apple is still red in green light.
+     *     default = false, the eye does not perform this process on
+     *       self-luminous objects like displays.
+     */
+    static make(whitePoint?: number[], adaptingLuminance?: number, backgroundLstar?: number, surround?: number, discountingIlluminant?: boolean): ViewingConditions;
+    /**
+     * Parameters are intermediate values of the CAM16 conversion process. Their
+     * names are shorthand for technical color science terminology, this class
+     * would not benefit from documenting them individually. A brief overview
+     * is available in the CAM16 specification, and a complete overview requires
+     * a color science textbook, such as Fairchild's Color Appearance Models.
+     */
+    private constructor();
+}

package/types/src/util/color/index.d.ts

@@ -0,0 +1,5 @@
+export declare function isColorValue(value: string): boolean;
+export declare function colorRgb(color: string): string;
+export declare function isTextColorIsLight(r: number, g: number, b: number): boolean;
+export * from './const';
+export * from './conversion';

package/types/src/util/color/palettes/core-palette.d.ts

@@ -0,0 +1,44 @@
+import { TonalPalette } from './tonal-palette';
+
+/**
+ * Set of colors to generate a [CorePalette] from
+ */
+export interface CorePaletteColors {
+    primary: number;
+    secondary?: number;
+    tertiary?: number;
+    neutral?: number;
+    neutralVariant?: number;
+    error?: number;
+}
+/**
+ * An intermediate concept between the key color for a UI theme, and a full
+ * color scheme. 5 sets of tones are generated, all except one use the same hue
+ * as the key color, and all vary in chroma.
+ */
+export declare class CorePalette {
+    a1: TonalPalette;
+    a2: TonalPalette;
+    a3: TonalPalette;
+    n1: TonalPalette;
+    n2: TonalPalette;
+    error: TonalPalette;
+    /**
+     * @param argb ARGB representation of a color
+     */
+    static of(argb: number): CorePalette;
+    /**
+     * @param argb ARGB representation of a color
+     */
+    static contentOf(argb: number): CorePalette;
+    /**
+     * Create a [CorePalette] from a set of colors
+     */
+    static fromColors(colors: CorePaletteColors): CorePalette;
+    /**
+     * Create a content [CorePalette] from a set of colors
+     */
+    static contentFromColors(colors: CorePaletteColors): CorePalette;
+    private static createPaletteFromColors;
+    private constructor();
+}