@shortfuse/materialdesignweb 0.7.6 → 0.9.0

package/types/mixins/TextFieldMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFieldMixin.d.ts","sourceRoot":"","sources":["../../mixins/TextFieldMixin.js"],"names":[],"mappings":"AAIA,0EAA0E;AAE1E;;GAEG;AACH,6CAFW,UAAU,CAAC,0CAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAuuBzD;4BA1uBa,OAAO,0BAA0B,EAAE,OAAO"}

package/types/mixins/ThemableMixin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function ThemableMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]>;
+//# sourceMappingURL=ThemableMixin.d.ts.map

package/types/mixins/ThemableMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemableMixin.d.ts","sourceRoot":"","sources":["../../mixins/ThemableMixin.js"],"names":[],"mappings":"AAwCA;;GAEG;AACH,4CAFW,cAAc,0BAA0B,EAAE,OAAO;;;;UAuF3D"}

package/types/mixins/TooltipTriggerMixin.d.ts

@@ -0,0 +1,106 @@
+/** @typedef {import('../components/Tooltip.js').default} Tooltip */
+/**
+ * @param {ReturnType<import('./StateMixin.js').default>} Base
+ */
+export default function TooltipTriggerMixin(Base: ReturnType<typeof import("./StateMixin.js").default>): typeof import("../index.js").CustomElement & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    TOOLTIP_MOUSE_IDLE_MS: number;
+    TOOLTIP_TOUCH_IDLE_MS: number;
+    /** @type {any} */
+    _idleDebounce: any;
+    /** @type {HTMLElement[]} */
+    _watchedParents: HTMLElement[];
+    /** @type {ResizeObserver} */
+    _resizeObserver: ResizeObserver;
+    /** @type {IntersectionObserver} */
+    _intersectObserver: IntersectionObserver;
+    _parentScrollListener: any;
+    tooltipSlotId: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    tooltip: string;
+    autoTooltip: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    cancelShowTooltip(): void;
+    /** @param {'mouse'|'touch'|'keyboard'} type */
+    scheduleHideTooltip(type: "mouse" | "touch" | "keyboard"): void;
+    /** @param {'mouse'|'touch'|'keyboard'} type */
+    scheduleShowTooltip(type: "mouse" | "touch" | "keyboard"): void;
+    showTooltip(): void;
+    hideTooltip(cancelSchedule?: boolean): void;
+    /**
+     * TODO: Throttle multiple calls
+     * @param {DOMRect} [domRect]
+     * @return {void}
+     */
+    updateTooltipPosition(domRect?: DOMRect): void;
+    recloneTooltip(): void;
+    closeIfNotHovered(): void;
+}, any[]>;
+export type Tooltip = typeof import("../index.js").CustomElement & import("../core/CustomElement.js").Class<{
+    _ariaRole: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    onConnectAriaValues: Map<string, string>;
+    hasFiredConnected: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    readAriaProperty(name: keyof HTMLElement & keyof ElementInternals): string | ShadowRoot;
+    updateAriaProperty(name: keyof HTMLElement & keyof ElementInternals, value: string): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    shapeTop: boolean;
+    shapeBottom: boolean;
+    shapeStart: boolean;
+    shapeEnd: boolean;
+    shapeStyle: string;
+    outlined: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _ariaRole: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    open: boolean;
+}, any[]>;
+//# sourceMappingURL=TooltipTriggerMixin.d.ts.map

package/types/mixins/TooltipTriggerMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipTriggerMixin.d.ts","sourceRoot":"","sources":["../../mixins/TooltipTriggerMixin.js"],"names":[],"mappings":"AAIA,oEAAoE;AAEpE;;GAEG;AACH,kDAFW,UAAU,CAAC,wCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IAOlD,kBAAkB;mBAAP,GAAG;IAEd,4BAA4B;qBAAjB,WAAW,EAAE;IAExB,6BAA6B;qBAAlB,cAAc;IAEzB,mCAAmC;wBAAxB,oBAAoB;;;;;;;;IAoB/B,+CAA+C;8BAAnC,OAAO,GAAC,OAAO,GAAC,UAAU;IAwBtC,+CAA+C;8BAAnC,OAAO,GAAC,OAAO,GAAC,UAAU;;;IAgEtC;;;;OAIG;oCAFQ,OAAO,GACN,IAAI;;;UAyLrB;sBAxTa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA0C"}

package/types/mixins/TouchTargetMixin.d.ts

@@ -0,0 +1,3 @@
+/** @param {typeof import('../core/CustomElement.js').default} Base */
+export default function TouchTargetMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default;
+//# sourceMappingURL=TouchTargetMixin.d.ts.map

package/types/mixins/TouchTargetMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TouchTargetMixin.d.ts","sourceRoot":"","sources":["../../mixins/TouchTargetMixin.js"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,+CADY,cAAc,0BAA0B,EAAE,OAAO,qDAkC5D"}

package/types/mixins/TypographyMixin.d.ts

@@ -0,0 +1,17 @@
+/** @param {typeof import('../core/CustomElement.js').default} Base */
+export default function TypographyMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    delegatesFocus: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    textPadding: string;
+    textPaddingTop: string;
+    textLeading: string;
+    textPaddingBottom: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedTextPaddingTop: string;
+    _computedTextPaddingBottom: string;
+    _computedTextLeading: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _beforeStyle: string;
+    _afterStyle: string;
+}, any[]>;
+//# sourceMappingURL=TypographyMixin.d.ts.map

package/types/mixins/TypographyMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypographyMixin.d.ts","sourceRoot":"","sources":["../../mixins/TypographyMixin.js"],"names":[],"mappings":"AAcA,sEAAsE;AACtE,8CADY,cAAc,0BAA0B,EAAE,OAAO;;;;;;;;;;;;;;UA0G5D"}

package/types/services/rtl.d.ts

@@ -0,0 +1,3 @@
+/** @return {void} */
+export function loadGlobalStyles(): void;
+//# sourceMappingURL=rtl.d.ts.map

package/types/services/rtl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtl.d.ts","sourceRoot":"","sources":["../../services/rtl.js"],"names":[],"mappings":"AAIA,qBAAqB;AACrB,oCADa,IAAI,CAKhB"}

package/types/services/svgAlias.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {string} name
+ * @param {string} path
+ * @param {string} [viewBox]
+ */
+export function addSVGAlias(name: string, path: string, viewBox?: string): void;
+/** @type {Map<string, {path:string, viewBox:string}>} */
+export const svgAliasMap: Map<string, {
+    path: string;
+    viewBox: string;
+}>;
+export const unaliased: Set<any>;
+//# sourceMappingURL=svgAlias.d.ts.map

package/types/services/svgAlias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgAlias.d.ts","sourceRoot":"","sources":["../../services/svgAlias.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,kCAJW,MAAM,QACN,MAAM,YACN,MAAM,QAShB;AAhBD,yDAAyD;AACzD,0BADW,GAAG,CAAC,MAAM,EAAE;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,OAAO,EAAC,MAAM,CAAA;CAAC,CAAC,CAChB;AACrC,iCAAmC"}

package/types/services/theme.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @param {typeof TYPOGRAPHY_DEFAULT} config
+ * @return {string}
+ */
+export function generateTypographyCSS(config?: typeof TYPOGRAPHY_DEFAULT): string;
+/** @return {string} */
+export function generateTypographyGlobalCSS(): string;
+/**
+ * @param {typeof SHAPE_ROUNDED_DEFAULT} [config]
+ * @return {string}
+ */
+export function generateShapeCSS(config?: typeof SHAPE_ROUNDED_DEFAULT): string;
+/**
+ * @param {ThemeOptions} options
+ * @return {string}
+ */
+export function generateColorCSS({ color, custom, lightness }: ThemeOptions): string;
+/**
+ * @param {ThemeOptions} options
+ * @return {void}
+ */
+export function setupTheme({ color, custom, lightness }: ThemeOptions): void;
+/**
+ * @param {URLSearchParams} searchParams
+ * @return {ThemeOptions}
+ */
+export function themeOptionsFromSearchParams(searchParams: URLSearchParams): ThemeOptions;
+/**
+ * @param {ThemeOptions} options
+ * @return {string}
+ */
+export function generateThemeCSS({ color, custom, lightness }: ThemeOptions): string;
+export const PALETTES: string[];
+export const TYPE_STYLES: string[];
+export type ThemeOptions = {
+    color?: string;
+    /**
+     * Map()
+     */
+    custom?: Iterable<[string, string?]>;
+    lightness?: "auto" | "light" | "dark";
+};
+import { TYPOGRAPHY_DEFAULT } from '../constants/typography.js';
+import { SHAPE_ROUNDED_DEFAULT } from '../constants/shapes.js';
+//# sourceMappingURL=theme.d.ts.map

package/types/services/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../services/theme.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,+CAHW,OAAO,kBAAkB,GACxB,MAAM,CAoGjB;AAED,uBAAuB;AACvB,+CADa,MAAM,CAalB;AAED;;;GAGG;AACH,0CAHW,OAAO,qBAAqB,GAC3B,MAAM,CAsBjB;AAaD;;;GAGG;AACH,+DAHW,YAAY,GACX,MAAM,CAWjB;AAED;;;GAGG;AACH,yDAHW,YAAY,GACX,IAAI,CAiBf;AAED;;;GAGG;AACH,2DAHW,eAAe,GACd,YAAY,CAYvB;AAED;;;GAGG;AACH,+DAHW,YAAY,GACX,MAAM,CAqBjB;AA5TD,gCAME;AAEF,mCAME;;YAIQ,MAAM;;;;aACN,QAAQ,CAAC,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC,CAAC;gBAC1B,MAAM,GAAC,OAAO,GAAC,MAAM;;mCAxBI,4BAA4B;sCADzB,wBAAwB"}

package/types/utils/cli.d.ts

@@ -0,0 +1,3 @@
+/** @return {URLSearchParams} */
+export function getSearchParams(): URLSearchParams;
+//# sourceMappingURL=cli.d.ts.map

package/types/utils/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../utils/cli.js"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,mCADa,eAAe,CAU3B"}

package/types/utils/function.d.ts

@@ -0,0 +1,3 @@
+/** @return {void} */
+export function noop(): void;
+//# sourceMappingURL=function.d.ts.map

package/types/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../utils/function.js"],"names":[],"mappings":"AAAA,qBAAqB;AAErB,wBAFa,IAAI,CAEQ"}

package/types/utils/jsx-runtime.d.ts

@@ -0,0 +1,20 @@
+/** eslint-env browser */
+export const Fragment: "$FRAGMENT";
+/**
+ * @param {string} tagName
+ * @param {{ children?: DocumentFragment|string }} attrs
+ * @return {HTMLElement|DocumentFragment}
+ */
+export function jsx(tagName: string, attrs?: {
+    children?: DocumentFragment | string;
+}): HTMLElement | DocumentFragment;
+/**
+ * @param {string} tagName
+ * @param {Record<string, any> & { children: HTMLElement[], style:string|CSSStyleDeclaration }} attrs
+ * @return {HTMLElement|DocumentFragment}
+ */
+export function jsxs(tagName: string, attrs: Record<string, any> & {
+    children: HTMLElement[];
+    style: string | CSSStyleDeclaration;
+}): HTMLElement | DocumentFragment;
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/types/utils/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../utils/jsx-runtime.js"],"names":[],"mappings":"AAAA,yBAAyB;AAEzB,mCAAoC;AAkDpC;;;;GAIG;AACH,6BAJW,MAAM,UACN;IAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAC,MAAM,CAAA;CAAE,GACrC,WAAW,GAAC,gBAAgB,CA0CvC;AA7FD;;;;GAIG;AACH,8BAJW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAC,MAAM,GAAC,mBAAmB,CAAA;CAAE,GAClF,WAAW,GAAC,gBAAgB,CA2CvC"}

package/types/utils/material-color/blend.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Functions for blending in HCT and CAM16.
+ */
+/**
+ * Blend the design color's HCT hue towards the key color's HCT
+ * hue, in a way that leaves the original color recognizable and
+ * recognizably shifted towards the key color.
+ * @param {number} designColor ARGB representation of an arbitrary color.
+ * @param {number} sourceColor ARGB representation of the main theme color.
+ * @return {number} The design color with a hue shifted towards the
+ * system's color, a slightly warmer/cooler variant of the design
+ * color's hue.
+ */
+export function harmonize(designColor: number, sourceColor: number): number;
+/**
+ * Blend in CAM16-UCS space.
+ * @param {number} from ARGB representation of color
+ * @param {number} to ARGB representation of color
+ * @param {number} amount how much blending to perform; 0.0 >= and <= 1.0
+ * @return {number} from, blended towards to. Hue, chroma, and tone will
+ * change.
+ */
+export function cam16Ucs(from: number, to: number, amount: number): number;
+/**
+ * Blends hue from one color into another. The chroma and tone of
+ * the original color are maintained.
+ * @param {number} from ARGB representation of color
+ * @param {number} to ARGB representation of color
+ * @param {number} amount how much blending to perform; 0.0 >= and <= 1.0
+ * @return {number} from, with a hue blended towards to. Chroma and tone
+ * are constant.
+ */
+export function hctHue(from: number, to: number, amount: number): number;
+//# sourceMappingURL=blend.d.ts.map

package/types/utils/material-color/blend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blend.d.ts","sourceRoot":"","sources":["../../../utils/material-color/blend.js"],"names":[],"mappings":"AAsBA;;GAEG;AAEH;;;;;;;;;GASG;AACH,uCANW,MAAM,eACN,MAAM,GACL,MAAM,CAcjB;AAED;;;;;;;GAOG;AACH,+BANW,MAAM,MACN,MAAM,UACN,MAAM,GACL,MAAM,CAgBjB;AAED;;;;;;;;GAQG;AACH,6BANW,MAAM,MACN,MAAM,UACN,MAAM,GACL,MAAM,CAajB"}

package/types/utils/material-color/hct/Cam16.d.ts

@@ -0,0 +1,142 @@
+/**
+ * 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 default class Cam16 {
+    /**
+     * @param {number} argb ARGB representation of a color.
+     * @return {Cam16} CAM16 color, assuming the color was viewed in default viewing
+     *     conditions.
+     */
+    static fromInt(argb: number): Cam16;
+    /**
+     * @param {number} argb ARGB representation of a color.
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     * @return {Cam16} CAM16 color.
+     */
+    static fromIntInViewingConditions(argb: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param {number} j CAM16 lightness
+     * @param {number} c CAM16 chroma
+     * @param {number} h CAM16 hue
+     * @return {Cam16}
+     */
+    static fromJch(j: number, c: number, h: number): Cam16;
+    /**
+     * @param {number} j CAM16 lightness
+     * @param {number} c CAM16 chroma
+     * @param {number} h CAM16 hue
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromJchInViewingConditions(j: number, c: number, h: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param {number} jstar CAM16-UCS lightness.
+     * @param {number} astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param {number} bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @return {Cam16}
+     */
+    static fromUcs(jstar: number, astar: number, bstar: number): Cam16;
+    /**
+     * @param {number} jstar CAM16-UCS lightness.
+     * @param {number} astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param {number} bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromUcsInViewingConditions(jstar: number, astar: number, bstar: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * Given color expressed in XYZ and viewed in [viewingConditions], convert to
+     * CAM16.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {ViewingConditions} viewingConditions
+     * @return {Cam16}
+     */
+    static fromXyzInViewingConditions(x: number, y: number, z: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * 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 {number} hue
+     * @param {number} chroma informally, colorfulness / color intensity. like saturation
+     *     in HSL, except perceptually accurate.
+     * @param {number} j lightness
+     * @param {number} q brightness; ratio of lightness to white point's lightness
+     * @param {number} m colorfulness
+     * @param {number} s saturation; ratio of chroma to white point's chroma
+     * @param {number} jstar CAM16-UCS J coordinate
+     * @param {number} astar CAM16-UCS a coordinate
+     * @param {number} bstar CAM16-UCS b coordinate
+     */
+    constructor(hue: number, chroma: number, j: number, q: number, m: number, s: number, jstar: number, astar: number, bstar: number);
+    /** @readonly */
+    readonly hue: number;
+    /** @readonly */
+    readonly chroma: number;
+    /** @readonly */
+    readonly j: number;
+    /** @readonly */
+    readonly q: number;
+    /** @readonly */
+    readonly m: number;
+    /** @readonly */
+    readonly s: number;
+    /** @readonly */
+    readonly jstar: number;
+    /** @readonly */
+    readonly astar: number;
+    /** @readonly */
+    readonly 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.
+     * @param {Cam16} other
+     * @return {number}
+     */
+    distance(other: Cam16): number;
+    /**
+     *  @return {number} 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} viewingConditions Information about the environment where the color
+     *     will be viewed.
+     * @return {number} ARGB representation of color
+     */
+    viewed(viewingConditions: ViewingConditions): number;
+    /**
+     * XYZ representation of CAM16 seen in [viewingConditions].
+     * @param {ViewingConditions} viewingConditions
+     * @return {number[]}
+     */
+    xyzInViewingConditions(viewingConditions: ViewingConditions): number[];
+}
+import ViewingConditions from './ViewingConditions.js';
+//# sourceMappingURL=Cam16.d.ts.map

package/types/utils/material-color/hct/Cam16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cam16.d.ts","sourceRoot":"","sources":["../../../../utils/material-color/hct/Cam16.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;;;OAIG;IACH,qBAJW,MAAM,GACL,KAAK,CAKhB;IAED;;;;;OAKG;IACH,wCALW,MAAM,qBACN,iBAAiB,GAEhB,KAAK,CA6DhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,KAAK,CAIhB;IAED;;;;;;OAMG;IACH,qCANW,MAAM,KACN,MAAM,KACN,MAAM,qBACN,iBAAiB,SAgB3B;IAED;;;;;;;OAOG;IACH,sBAPW,MAAM,SACN,MAAM,SAEN,MAAM,GAEL,KAAK,CAIhB;IAED;;;;;;;;OAQG;IACH,yCARW,MAAM,SACN,MAAM,SAEN,MAAM,qBAEN,iBAAiB,SAe3B;IAED;;;;;;;;OAQG;IACH,qCANW,MAAM,KACN,MAAM,KACN,MAAM,qBACN,iBAAiB,GAChB,KAAK,CAkEhB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,iBAXW,MAAM,UACN,MAAM,KAEN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,EAqBhB;IAlBC,gBAAgB;IAChB,qBAAc;IACd,gBAAgB;IAChB,wBAAoB;IACpB,gBAAgB;IAChB,mBAAU;IACV,gBAAgB;IAChB,mBAAU;IACV,gBAAgB;IAChB,mBAAU;IACV,gBAAgB;IAChB,mBAAU;IACV,gBAAgB;IAChB,uBAAkB;IAClB,gBAAgB;IAChB,uBAAkB;IAClB,gBAAgB;IAChB,uBAAkB;IAGpB;;;;;;OAMG;IACH,gBAHW,KAAK,GACJ,MAAM,CASjB;IAED;;;;OAIG;IACH,SAJa,MAAM,CAMlB;IAED;;;;OAIG;IACH,0BAJW,iBAAiB,GAEhB,MAAM,CA8CjB;IAED;;;;OAIG;IACH,0CAHW,iBAAiB,GAChB,MAAM,EAAE,CA8CnB;CACF;8BApZ6B,wBAAwB"}

package/types/utils/material-color/hct/Hct.d.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 default class Hct {
+    /**
+     * @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.
+     */
+    /**
+     * @param {number} hue
+     * @param {number} chroma
+     * @param {number} tone
+     * @return {Hct}
+     */
+    static from(hue: number, chroma: number, tone: number): Hct;
+    /**
+     * @param {number} argb ARGB representation of a color.
+     * @return {Hct} HCT representation of a color in default viewing conditions
+     */
+    static fromInt(argb: number): Hct;
+    /** @param {number} argb */
+    constructor(argb: number);
+    /** @type {number} */
+    internalHue: number;
+    /** @type {number} */
+    internalChroma: number;
+    /** @type {number} */
+    internalTone: number;
+    argb: number;
+    /** @return {number} */
+    toInt(): number;
+    /**
+     * @param {number} 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);
+    /**
+     * A number, in degrees, representing ex. red, orange, yellow, etc.
+     * Ranges from 0 <= hue < 360.
+     * @return {number}
+     */
+    get hue(): number;
+    /**
+     * @param {number} newChroma 0 <= newChroma < ?
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set chroma(newChroma: number);
+    /** @return {number} */
+    get chroma(): number;
+    /**
+     * @param {number} 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);
+    /**
+     * Lightness. Ranges from 0 to 100.
+     * @return {number}
+     */
+    get tone(): number;
+    /**
+     * @private
+     * @param {number} argb
+     */
+    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.
+     * @param {ViewingConditions} vc
+     * @return {Hct}
+     */
+    inViewingConditions(vc: ViewingConditions): Hct;
+}
+import ViewingConditions from './ViewingConditions.js';
+//# sourceMappingURL=Hct.d.ts.map

package/types/utils/material-color/hct/Hct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hct.d.ts","sourceRoot":"","sources":["../../../../utils/material-color/hct/Hct.js"],"names":[],"mappings":"AAuCA;;;;GAIG;AACH;IACE;;;;;;;OAOG;IAEH;;;;;OAKG;IACH,iBALW,MAAM,UACN,MAAM,QACN,MAAM,GACL,GAAG,CAId;IAED;;;OAGG;IACH,qBAHW,MAAM,GACL,GAAG,CAId;IAWD,2BAA2B;IAC3B,kBADY,MAAM,EAOjB;IAhBD,qBAAqB;IACrB,aADW,MAAM,CACL;IAEZ,qBAAqB;IACrB,gBADW,MAAM,CACF;IAEf,qBAAqB;IACrB,cADW,MAAM,CACJ;IAQX,aAAgB;IAGlB,uBAAuB;IACvB,SADa,MAAM,CAGlB;IAWD;;;;OAIG;IACH,wBAQC;IAtBD;;;;OAIG;IACH,kBAEC;IAsBD;;;;OAIG;IACH,8BAQC;IAlBD,uBAAuB;IACvB,qBAEC;IAyBD;;;;OAIG;IACH,0BAQC;IArBD;;;OAGG;IACH,mBAEC;IAiBD;;;OAGG;IACH,yBAMC;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAHW,iBAAiB,GAChB,GAAG,CAwBd;CACF;8BAjL6B,wBAAwB"}

package/types/utils/material-color/hct/ViewingConditions.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 default class ViewingConditions {
+    /** 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 {number} 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 {number} backgroundLstar The lightness of the area surrounding the color.
+     *     measured by L* in L*a*b*. default = 50.0
+     * @param {number} 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 {boolean} 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.
+     * @return {ViewingConditions}
+     */
+    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.
+     * @param {number} n
+     * @param {number} aw
+     * @param {number} nbb
+     * @param {number} ncb
+     * @param {number} c
+     * @param {number} nc
+     * @param {number[]} rgbD
+     * @param {number} fl
+     * @param {number} fLRoot
+     * @param {number} z
+     */
+    constructor(n: number, aw: number, nbb: number, ncb: number, c: number, nc: number, rgbD: number[], fl: number, fLRoot: number, z: number);
+    n: number;
+    aw: number;
+    nbb: number;
+    ncb: number;
+    c: number;
+    nc: number;
+    rgbD: number[];
+    fl: number;
+    fLRoot: number;
+    z: number;
+}
+//# sourceMappingURL=ViewingConditions.d.ts.map

package/types/utils/material-color/hct/ViewingConditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewingConditions.d.ts","sourceRoot":"","sources":["../../../../utils/material-color/hct/ViewingConditions.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;GAYG;AACH;IACE,qCAAqC;IACrC,kCAA0C;IAE1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,uDAjBW,MAAM,oBAIN,MAAM,aAEN,MAAM,0BAKN,OAAO,GAIN,iBAAiB,CA+C5B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAXW,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,KACN,MAAM,MACN,MAAM,QACN,MAAM,EAAE,MACR,MAAM,UACN,MAAM,KACN,MAAM,EAahB;IAVC,UAAU;IACV,WAAY;IACZ,YAAc;IACd,YAAc;IACd,UAAU;IACV,WAAY;IACZ,eAAgB;IAChB,WAAY;IACZ,eAAoB;IACpB,UAAU;CAEb"}