@udixio/theme 0.0.1

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@udixio/theme",
+  "version": "0.0.1",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "dependencies": {
+    "awilix": "^12.0.5",
+    "@material/material-color-utilities": "^0.3.0",
+    "replace-in-file": "^8.3.0",
+    "tailwindcss": "^4.1.11"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Udixio/UI.git"
+  },
+  "types": "./index.d.ts"
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/index';

package/src/lib/API.d.ts

@@ -0,0 +1,13 @@
+import { ColorApi } from './color';
+import { ThemeApi } from './theme';
+import { PluginApi } from './plugin/pluginApi';
+export declare class API {
+    colors: ColorApi;
+    themes: ThemeApi;
+    plugins: PluginApi;
+    constructor({ colorApi, themeApi, pluginApi, }: {
+        colorApi: ColorApi;
+        themeApi: ThemeApi;
+        pluginApi: PluginApi;
+    });
+}

package/src/lib/app.container.d.ts

@@ -0,0 +1,5 @@
+import { AwilixContainer, BuildResolver, DisposableResolver } from 'awilix';
+export type Module = Record<string, BuildResolver<any> & DisposableResolver<any>>;
+export declare function importContainer(container: AwilixContainer, services: Module[]): AwilixContainer<any>;
+declare const AppContainer: AwilixContainer<any>;
+export default AppContainer;

package/src/lib/app.module.d.ts

@@ -0,0 +1,2 @@
+import { Module } from './app.container';
+export declare const AppModule: Module;

package/src/lib/color/color.api.d.ts

@@ -0,0 +1,38 @@
+import { ColorOptions, ConfigurableColor } from './configurable-color';
+import { ColorManager } from './color.manager';
+import { DynamicColorKey } from './color.utils';
+export type AddColors = {
+    colors?: Record<DynamicColorKey | string, (Partial<ColorOptions> & {
+        alias?: never;
+    }) | {
+        alias: string;
+        palette?: never;
+        tone?: never;
+    }>;
+    fromPalettes?: string[] | string;
+};
+export type AddColorsOptions = AddColors | ((colorService: ColorApi) => AddColors);
+export declare class ColorApi {
+    private readonly colorManager;
+    constructor({ colorManager }: {
+        colorManager: ColorManager;
+    });
+    getColors(): ReadonlyMap<string, ConfigurableColor>;
+    addColor(key: string, color: (Partial<ColorOptions> & {
+        alias?: never;
+    }) | {
+        alias: string;
+        palette?: never;
+        tone?: never;
+    }): ConfigurableColor;
+    addColors(args: AddColorsOptions | AddColorsOptions[]): void;
+    getColor(key: DynamicColorKey | string): ConfigurableColor;
+    removeColor(key: string): boolean;
+    updateColor(key: string, newColor: (Partial<ColorOptions> & {
+        alias?: never;
+    }) | {
+        alias: string;
+        palette?: never;
+        tone?: never;
+    }): ConfigurableColor;
+}

package/src/lib/color/color.manager.d.ts

@@ -0,0 +1,23 @@
+import { DynamicColor } from '../material-color-utilities';
+import { Scheme, SchemeManager } from '../theme';
+import { ColorOptions, ConfigurableColor } from './configurable-color';
+import { ColorApi } from './color.api';
+export declare const highestSurface: (s: Scheme, colorService: ColorManager | ColorApi) => DynamicColor;
+export declare class ColorManager {
+    private colorMap;
+    private readonly schemeManager;
+    constructor({ schemeManager }: {
+        schemeManager: SchemeManager;
+    });
+    createOrUpdate(key: string, args: (Partial<ColorOptions> & {
+        alias?: never;
+    }) | {
+        alias: string;
+        palette?: never;
+        tone?: never;
+    }): ConfigurableColor;
+    remove(key: string): boolean;
+    get(key: string): ConfigurableColor;
+    getAll(): ReadonlyMap<string, ConfigurableColor>;
+    addFromPalette(key: string): void;
+}

package/src/lib/color/color.module.d.ts

@@ -0,0 +1,2 @@
+import { Module } from '@udixio/theme';
+export declare const ColorModule: Module;

package/src/lib/color/color.utils.d.ts

@@ -0,0 +1,7 @@
+import { TonalPalette } from '@material/material-color-utilities';
+import { ContrastCurve } from '../material-color-utilities/contrastCurve';
+export type DynamicColorKey = 'background' | 'onBackground' | 'surface' | 'surfaceDim' | 'surfaceBright' | 'surfaceContainerLowest' | 'surfaceContainerLow' | 'surfaceContainer' | 'surfaceContainerHigh' | 'surfaceContainerHighest' | 'onSurface' | 'surfaceVariant' | 'onSurfaceVariant' | 'inverseSurface' | 'inverseOnSurface' | 'outline' | 'outlineVariant' | 'surfaceTint' | 'primary' | 'primaryDim' | 'onPrimary' | 'primaryContainer' | 'onPrimaryContainer' | 'inversePrimary' | 'secondary' | 'secondaryDim' | 'onSecondary' | 'secondaryContainer' | 'onSecondaryContainer' | 'tertiary' | 'tertiaryDim' | 'onTertiary' | 'tertiaryContainer' | 'onTertiaryContainer' | 'error' | 'errorDim' | 'onError' | 'errorContainer' | 'onErrorContainer' | 'primaryFixed' | 'primaryFixedDim' | 'onPrimaryFixed' | 'onPrimaryFixedVariant' | 'secondaryFixed' | 'secondaryFixedDim' | 'onSecondaryFixed' | 'onSecondaryFixedVariant' | 'tertiaryFixed' | 'tertiaryFixedDim' | 'onTertiaryFixed' | 'onTertiaryFixedVariant';
+export declare function getCurve(defaultContrast: number): ContrastCurve;
+export declare function tMaxC(palette: TonalPalette, lowerBound?: number, upperBound?: number, chromaMultiplier?: number): number;
+export declare function tMinC(palette: TonalPalette, lowerBound?: number, upperBound?: number): number;
+export declare function findBestToneForChroma(hue: number, chroma: number, tone: number, byDecreasingTone: boolean): number;

package/src/lib/color/configurable-color.d.ts

@@ -0,0 +1,30 @@
+import { SchemeManager } from '../theme';
+import { DynamicColor, FromPaletteOptions } from '../material-color-utilities';
+import { ColorManager } from './color.manager';
+export type ColorOptions = ((FromPaletteOptions & {
+    alias?: string;
+}) | (Partial<FromPaletteOptions> & {
+    alias: string;
+    palette?: never;
+})) & {
+    name: string;
+};
+export declare class ConfigurableColor {
+    private option;
+    private schemeService;
+    private colorService;
+    private dynamicColor;
+    constructor(option: ColorOptions, schemeService: SchemeManager, colorService: ColorManager);
+    update(args: Partial<ColorOptions & {
+        name: string;
+    }>): void;
+    getHex(): string;
+    getArgb(): number;
+    getRgb(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    getName(): string;
+    getMaterialColor(): DynamicColor;
+}

package/src/lib/color/default-color.d.ts

@@ -0,0 +1,2 @@
+import { AddColorsOptions } from './color.api';
+export declare const defaultColors: AddColorsOptions;

package/src/lib/color/index.d.ts

@@ -0,0 +1,5 @@
+export * from './color.api';
+export * from './color.manager';
+export * from './color.module';
+export * from './configurable-color';
+export * from './default-color';

package/src/lib/config/config.interface.d.ts

@@ -0,0 +1,13 @@
+import { AddColorsOptions } from '../color';
+import { Variant } from '../theme';
+import { PluginAbstract } from '../plugin';
+export interface ConfigInterface {
+    sourceColor: string;
+    contrastLevel?: number;
+    isDark?: boolean;
+    variant?: Variant;
+    colors?: AddColorsOptions | AddColorsOptions[];
+    useDefaultColors?: boolean;
+    palettes?: Record<string, string>;
+    plugins?: PluginAbstract<any, any>[];
+}

package/src/lib/config/config.module.d.ts

@@ -0,0 +1,2 @@
+import { Module } from '../app.container';
+export declare const ConfigModule: Module;

package/src/lib/config/config.service.d.ts

@@ -0,0 +1,12 @@
+import { ConfigInterface } from './config.interface';
+import { API } from '../API';
+export declare function defineConfig(configObject: ConfigInterface): ConfigInterface;
+export declare class ConfigService {
+    configPath: string;
+    private readonly api;
+    constructor({ api }: {
+        api: API;
+    });
+    loadConfig(config?: ConfigInterface): void;
+    private getConfig;
+}

package/src/lib/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config.interface';
+export * from './config.module';
+export * from './config.service';

package/src/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { default as AppContainer } from './app.container';
+export * from './app.container';
+export * from './app.module';
+export * from './API';
+export * from './color';
+export * from './config';
+export * from './main';
+export * from './material-color-utilities';
+export * from './plugin';
+export * from './plugins/font';
+export * from './plugins/tailwind';
+export * from './theme';

package/src/lib/main.d.ts

@@ -0,0 +1,7 @@
+import { API } from './API';
+import { ConfigInterface } from './config';
+export declare function bootstrap(): API;
+export declare function bootstrapFromConfig(args?: {
+    path?: string;
+    config?: ConfigInterface;
+}): API;

package/src/lib/material-color-utilities/contrastCurve.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A class containing a value that changes with the contrast level.
+ *
+ * Usually represents the contrast requirements for a dynamic color on its
+ * background. The four values correspond to values for contrast levels -1.0,
+ * 0.0, 0.5, and 1.0, respectively.
+ */
+export declare class ContrastCurve {
+    readonly low: number;
+    readonly normal: number;
+    readonly medium: number;
+    readonly high: number;
+    /**
+     * Creates a `ContrastCurve` object.
+     *
+     * @param low Value for contrast level -1.0
+     * @param normal Value for contrast level 0.0
+     * @param medium Value for contrast level 0.5
+     * @param high Value for contrast level 1.0
+     */
+    constructor(low: number, normal: number, medium: number, high: number);
+    /**
+     * Returns the value at a given contrast level.
+     *
+     * @param contrastLevel The contrast level. 0.0 is the default (normal); -1.0
+     *     is the lowest; 1.0 is the highest.
+     * @return The value. For contrast ratios, a number between 1.0 and 21.0.
+     */
+    get(contrastLevel: number): number;
+}

package/src/lib/material-color-utilities/dynamic_color.d.ts

@@ -0,0 +1,199 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { TonalPalette } from '@material/material-color-utilities';
+import { ContrastCurve } from './contrastCurve';
+import { ToneDeltaPair } from './toneDeltaPair';
+import { Scheme } from '../theme/scheme';
+import { Hct } from './htc';
+/**
+ * @param name The name of the dynamic color. Defaults to empty.
+ * @param palette Function that provides a TonalPalette given DynamicScheme. A
+ *     TonalPalette is defined by a hue and chroma, so this replaces the need to
+ *     specify hue/chroma. By providing a tonal palette, when contrast
+ *     adjustments are made, intended chroma can be preserved.
+ * @param tone Function that provides a tone given DynamicScheme. When not
+ *     provided, the tone is same as the background tone or 50, when no
+ *     background is provided.
+ * @param chromaMultiplier A factor that multiplies the chroma for this color.
+ *     Default to 1.
+ * @param isBackground Whether this dynamic color is a background, with some
+ *     other color as the foreground. Defaults to false.
+ * @param background The background of the dynamic color (as a function of a
+ *     `DynamicScheme`), if it exists.
+ * @param secondBackground A second background of the dynamic color (as a
+ *     function of a `DynamicScheme`), if it exists.
+ * @param contrastCurve A `ContrastCurve` object specifying how its contrast
+ *     against its background should behave in various contrast levels options.
+ *     Must used together with `background`. When not provided or resolved as
+ *     undefined, the contrast curve is calculated based on other constraints.
+ * @param toneDeltaPair A `ToneDeltaPair` object specifying a tone delta
+ *     constraint between two colors. One of them must be the color being
+ *     constructed. When not provided or resolved as undefined, the tone is
+ *     calculated based on other constraints.
+ */
+export interface FromPaletteOptions {
+    name?: string;
+    palette: (scheme: Scheme) => TonalPalette;
+    tone?: (scheme: Scheme) => number;
+    chromaMultiplier?: (scheme: Scheme) => number;
+    isBackground?: boolean;
+    background?: (scheme: Scheme) => DynamicColor | undefined;
+    secondBackground?: (scheme: Scheme) => DynamicColor | undefined;
+    contrastCurve?: (scheme: Scheme) => ContrastCurve | undefined;
+    toneDeltaPair?: (scheme: Scheme) => ToneDeltaPair | undefined;
+}
+/**
+ * Returns a new DynamicColor that is the same as the original color, but with
+ * the extended dynamic color's constraints for the given spec version.
+ *
+ * @param originlColor The original color.
+ * @param specVersion The spec version to extend.
+ * @param extendedColor The color with the values to extend.
+ */
+export declare function extendSpecVersion(originlColor: DynamicColor, extendedColor: DynamicColor): DynamicColor;
+/**
+ * A color that adjusts itself based on UI state provided by DynamicScheme.
+ *
+ * Colors without backgrounds do not change tone when contrast changes. Colors
+ * with backgrounds become closer to their background as contrast lowers, and
+ * further when contrast increases.
+ *
+ * Prefer static constructors. They require either a hexcode, a palette and
+ * tone, or a hue and chroma. Optionally, they can provide a background
+ * DynamicColor.
+ */
+export declare class DynamicColor {
+    readonly name: string;
+    readonly palette: (scheme: Scheme) => TonalPalette;
+    readonly tone: (scheme: Scheme) => number;
+    readonly isBackground: boolean;
+    readonly chromaMultiplier?: ((scheme: Scheme) => number) | undefined;
+    readonly background?: ((scheme: Scheme) => DynamicColor | undefined) | undefined;
+    readonly secondBackground?: ((scheme: Scheme) => DynamicColor | undefined) | undefined;
+    readonly contrastCurve?: ((scheme: Scheme) => ContrastCurve | undefined) | undefined;
+    readonly toneDeltaPair?: ((scheme: Scheme) => ToneDeltaPair | undefined) | undefined;
+    private readonly hctCache;
+    /**
+     * The base constructor for DynamicColor.
+     *
+     * _Strongly_ prefer using one of the convenience constructors. This class is
+     * arguably too flexible to ensure it can support any scenario. Functional
+     * arguments allow  overriding without risks that come with subclasses.
+     *
+     * For example, the default behavior of adjust tone at max contrast
+     * to be at a 7.0 ratio with its background is principled and
+     * matches accessibility guidance. That does not mean it's the desired
+     * approach for _every_ design system, and every color pairing,
+     * always, in every case.
+     *
+     * @param name The name of the dynamic color. Defaults to empty.
+     * @param palette Function that provides a TonalPalette given DynamicScheme. A
+     *     TonalPalette is defined by a hue and chroma, so this replaces the need
+     *     to specify hue/chroma. By providing a tonal palette, when contrast
+     *     adjustments are made, intended chroma can be preserved.
+     * @param tone Function that provides a tone, given a DynamicScheme.
+     * @param isBackground Whether this dynamic color is a background, with some
+     *     other color as the foreground. Defaults to false.
+     * @param chromaMultiplier A factor that multiplies the chroma for this color.
+     * @param background The background of the dynamic color (as a function of a
+     *     `DynamicScheme`), if it exists.
+     * @param secondBackground A second background of the dynamic color (as a
+     *     function of a `DynamicScheme`), if it exists.
+     * @param contrastCurve A `ContrastCurve` object specifying how its contrast
+     *     against its background should behave in various contrast levels
+     *     options.
+     * @param toneDeltaPair A `ToneDeltaPair` object specifying a tone delta
+     *     constraint between two colors. One of them must be the color being
+     *     constructed.
+     */
+    constructor(name: string, palette: (scheme: Scheme) => TonalPalette, tone: (scheme: Scheme) => number, isBackground: boolean, chromaMultiplier?: ((scheme: Scheme) => number) | undefined, background?: ((scheme: Scheme) => DynamicColor | undefined) | undefined, secondBackground?: ((scheme: Scheme) => DynamicColor | undefined) | undefined, contrastCurve?: ((scheme: Scheme) => ContrastCurve | undefined) | undefined, toneDeltaPair?: ((scheme: Scheme) => ToneDeltaPair | undefined) | undefined);
+    /**
+     * Create a DynamicColor defined by a TonalPalette and HCT tone.
+     *
+     * @param args Functions with DynamicScheme as input. Must provide a palette
+     *     and tone. May provide a background DynamicColor and ToneDeltaPair.
+     */
+    static fromPalette(args: FromPaletteOptions): DynamicColor;
+    static getInitialToneFromBackground(background?: (scheme: Scheme) => DynamicColor | undefined): (scheme: Scheme) => number;
+    /**
+     * Given a background tone, finds a foreground tone, while ensuring they reach
+     * a contrast ratio that is as close to [ratio] as possible.
+     *
+     * @param bgTone Tone in HCT. Range is 0 to 100, undefined behavior when it
+     *     falls outside that range.
+     * @param ratio The contrast ratio desired between bgTone and the return
+     *     value.
+     */
+    static foregroundTone(bgTone: number, ratio: number): number;
+    /**
+     * Returns whether [tone] prefers a light foreground.
+     *
+     * People prefer white foregrounds on ~T60-70. Observed over time, and also
+     * by Andrew Somers during research for APCA.
+     *
+     * T60 used as to create the smallest discontinuity possible when skipping
+     * down to T49 in order to ensure light foregrounds.
+     * Since `tertiaryContainer` in dark monochrome scheme requires a tone of
+     * 60, it should not be adjusted. Therefore, 60 is excluded here.
+     */
+    static tonePrefersLightForeground(tone: number): boolean;
+    /**
+     * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
+     * color.
+     */
+    static toneAllowsLightForeground(tone: number): boolean;
+    /**
+     * Adjusts a tone such that white has 4.5 contrast, if the tone is
+     * reasonably close to supporting it.
+     */
+    static enableLightForeground(tone: number): number;
+    /**
+     * Returns a deep copy of this DynamicColor.
+     */
+    clone(): DynamicColor;
+    /**
+     * Clears the cache of HCT values for this color. For testing or debugging
+     * purposes.
+     */
+    clearCache(): void;
+    /**
+     * Returns a ARGB integer (i.e. a hex code).
+     *
+     * @param scheme Defines the conditions of the user interface, for example,
+     *     whether or not it is dark mode or light mode, and what the desired
+     *     contrast level is.
+     */
+    getArgb(scheme: Scheme): number;
+    /**
+     * Returns a color, expressed in the HCT color space, that this
+     * DynamicColor is under the conditions in scheme.
+     *
+     * @param scheme Defines the conditions of the user interface, for example,
+     *     whether or not it is dark mode or light mode, and what the desired
+     *     contrast level is.
+     */
+    getHct(scheme: Scheme): Hct;
+    /**
+     * Returns a tone, T in the HCT color space, that this DynamicColor is under
+     * the conditions in scheme.
+     *
+     * @param scheme Defines the conditions of the user interface, for example,
+     *     whether or not it is dark mode or light mode, and what the desired
+     *     contrast level is.
+     */
+    getTone(scheme: Scheme): number;
+}

package/src/lib/material-color-utilities/hct_solver.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Cam16 } from '@material/material-color-utilities';
+/**
+ * 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[];
+    /**
+     * 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;
+    /**
+     * 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;
+}