@dxyl/utils 1.0.0 → 1.1.0

package/types/antv-util/color/torgb.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 将颜色转换到 rgb 的格式
+ * @param {color} color 颜色
+ * @return 将颜色转换到 '#ffffff' 的格式
+ */
+export declare function toRGB(color: string): string;

package/types/antv-util/helper/index.d.ts

@@ -0,0 +1,2 @@
+export { mod } from './mod';
+export { toRadian } from './to-radian';

package/types/antv-util/helper/mod.d.ts

@@ -0,0 +1 @@
+export declare function mod(n: number, m: number): number;

package/types/antv-util/helper/to-radian.d.ts

@@ -0,0 +1 @@
+export declare function toRadian(degree: number): number;

package/types/antv-util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './color';
+export * from './matrix';
+export * from './path';

package/types/antv-util/matrix/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 根据 actions 来做 transform
+ * @param m
+ * @param actions
+ */
+export declare function transform(m: number[], actions: any[][]): number[];
+/**
+ * 向量 v1 到 向量 v2 夹角的方向
+ * @param  {Array} v1 向量
+ * @param  {Array} v2 向量
+ * @return {Boolean} >= 0 顺时针 < 0 逆时针
+ */
+export declare function direction(v1: number[], v2: number[]): number;
+/**
+ * 二维向量 v1 到 v2 的夹角
+ * @param v1
+ * @param v2
+ * @param direct
+ */
+export declare function angleTo(v1: [number, number], v2: [number, number], direct?: boolean): number;
+/**
+ * 计算二维向量的垂直向量
+ * @param out
+ * @param v
+ * @param flag
+ */
+export declare function vertical(out: number[], v: number[], flag: boolean): number[];

package/types/antv-util/path/convert/path-2-absolute.d.ts

@@ -0,0 +1,2 @@
+import { PathArray, AbsoluteArray } from '../types';
+export declare function path2Absolute(pathInput: string | PathArray): AbsoluteArray;

package/types/antv-util/path/convert/path-2-curve.d.ts

@@ -0,0 +1,2 @@
+import { CurveArray, PathArray } from '../types';
+export declare function path2Curve(pathInput: string | PathArray, needZCommandIndexes?: boolean): CurveArray | [CurveArray, number[]];

package/types/antv-util/path/convert/path-2-string.d.ts

@@ -0,0 +1,6 @@
+import { PathArray } from '../types';
+/**
+ * Returns a valid `d` attribute string value created
+ * by rounding values and concatenating the `pathArray` segments.
+ */
+export declare function path2String(path: PathArray, round?: number | 'off'): string;

package/types/antv-util/path/index.d.ts

@@ -0,0 +1,17 @@
+export { path2String } from './convert/path-2-string';
+export { path2Curve } from './convert/path-2-curve';
+export { path2Absolute } from './convert/path-2-absolute';
+export { clonePath } from './process/clone-path';
+export { normalizePath } from './process/normalize-path';
+export { reverseCurve } from './process/reverse-curve';
+export { getPathBBox } from './util/get-path-bbox';
+export { getTotalLength } from './util/get-total-length';
+export { getPathBBoxTotalLength } from './util/get-path-bbox-total-length';
+export { getRotatedCurve } from './util/get-rotated-curve';
+export { getPathArea } from './util/get-path-area';
+export { getDrawDirection } from './util/get-draw-direction';
+export { getPointAtLength } from './util/get-point-at-length';
+export { isPointInStroke } from './util/is-point-in-stroke';
+export { distanceSquareRoot } from './util/distance-square-root';
+export { equalizeSegments } from './util/equalize-segments';
+export * from './types';

package/types/antv-util/path/parser/finalize-segment.d.ts

@@ -0,0 +1,5 @@
+import { PathParser } from './path-parser';
+/**
+ * Breaks the parsing of a pathString once a segment is finalized.
+ */
+export declare function finalizeSegment(path: PathParser): void;

package/types/antv-util/path/parser/is-arc-command.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if the character is an A (arc-to) path command.
+ */
+export declare function isArcCommand(code: number): boolean;

package/types/antv-util/path/parser/is-digit-start.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if the character is or belongs to a number.
+ * [0-9]|+|-|.
+ */
+export declare function isDigitStart(code: number): boolean;
+export declare function isDigit(code: number): boolean;

package/types/antv-util/path/parser/is-path-command.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if the character is a path command.
+ */
+export declare function isPathCommand(code: number): boolean;

package/types/antv-util/path/parser/is-space.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if the character is a space.
+ */
+export declare function isSpace(ch: number): boolean;

package/types/antv-util/path/parser/params-count.d.ts

@@ -0,0 +1,13 @@
+export declare const paramsCount: {
+    a: number;
+    c: number;
+    h: number;
+    l: number;
+    m: number;
+    r: number;
+    q: number;
+    s: number;
+    t: number;
+    v: number;
+    z: number;
+};

package/types/antv-util/path/parser/params-parser.d.ts

@@ -0,0 +1,10 @@
+export declare const paramsParser: {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+    qx: null;
+    qy: null;
+};

package/types/antv-util/path/parser/parse-path-string.d.ts

@@ -0,0 +1,6 @@
+import { PathArray } from '../types';
+/**
+ * Parses a path string value and returns an array
+ * of segments we like to call `pathArray`.
+ */
+export declare function parsePathString(pathInput: PathArray | string): PathArray | string;

package/types/antv-util/path/parser/path-parser.d.ts

@@ -0,0 +1,16 @@
+import { PathArray } from '../types';
+/**
+ * The `PathParser` is used by the `parsePathString` static method
+ * to generate a `pathArray`.
+ */
+export declare class PathParser {
+    pathValue: string;
+    segments: PathArray;
+    max: number;
+    index: number;
+    param: number;
+    segmentStart: number;
+    data: any;
+    err: string;
+    constructor(pathString: string);
+}

package/types/antv-util/path/parser/scan-flag.d.ts

@@ -0,0 +1,6 @@
+import { PathParser } from './path-parser';
+/**
+ * Validates an A (arc-to) specific path command value.
+ * Usually a `large-arc-flag` or `sweep-flag`.
+ */
+export declare function scanFlag(path: PathParser): void;

package/types/antv-util/path/parser/scan-param.d.ts

@@ -0,0 +1,6 @@
+import { PathParser } from './path-parser';
+/**
+ * Validates every character of the path string,
+ * every path command, negative numbers or floating point numbers.
+ */
+export declare function scanParam(path: PathParser): void;

package/types/antv-util/path/parser/scan-segment.d.ts

@@ -0,0 +1,6 @@
+import { PathParser } from './path-parser';
+/**
+ * Scans every character in the path string to determine
+ * where a segment starts and where it ends.
+ */
+export declare function scanSegment(path: PathParser): void;

package/types/antv-util/path/parser/skip-spaces.d.ts

@@ -0,0 +1,7 @@
+import { PathParser } from './path-parser';
+/**
+ * Points the parser to the next character in the
+ * path string every time it encounters any kind of
+ * space character.
+ */
+export declare function skipSpaces(path: PathParser): void;

package/types/antv-util/path/process/arc-2-cubic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts A (arc-to) segments to C (cubic-bezier-to).
+ *
+ * For more information of where this math came from visit:
+ * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
+ */
+export declare function arcToCubic(X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, recursive: number[]): any;

package/types/antv-util/path/process/clone-path.d.ts

@@ -0,0 +1,2 @@
+import { PathArray, PathSegment } from '../types';
+export declare function clonePath(path: PathArray | PathSegment): PathArray;

package/types/antv-util/path/process/fix-arc.d.ts

@@ -0,0 +1,2 @@
+import { PathArray } from '../types';
+export declare function fixArc(pathArray: PathArray, allPathCommands: string[], i: number): void;

package/types/antv-util/path/process/line-2-cubic.d.ts

@@ -0,0 +1 @@
+export declare function lineToCubic(x1: number, y1: number, x2: number, y2: number): number[];

package/types/antv-util/path/process/normalize-path.d.ts

@@ -0,0 +1,8 @@
+import { PathArray, NormalArray } from '../types';
+/**
+ * @example
+ * const path = 'M0 0 H50';
+ * const normalizedPath = SVGPathCommander.normalizePath(path);
+ * // result => [['M', 0, 0], ['L', 50, 0]]
+ */
+export declare function normalizePath(pathInput: string | PathArray): NormalArray;

package/types/antv-util/path/process/normalize-segment.d.ts

@@ -0,0 +1,6 @@
+import { PathSegment, NormalSegment } from '../types';
+/**
+ * Normalizes a single segment of a `PathArray` object.
+ * eg. H/V -> L, T -> Q
+ */
+export declare function normalizeSegment(segment: PathSegment, params: any): NormalSegment;

package/types/antv-util/path/process/quad-2-cubic.d.ts

@@ -0,0 +1 @@
+export declare function quadToCubic(x1: number, y1: number, qx: number, qy: number, x2: number, y2: number): number[];

package/types/antv-util/path/process/reverse-curve.d.ts

@@ -0,0 +1,2 @@
+import { CurveArray } from '../types';
+export declare function reverseCurve(pathArray: CurveArray): CurveArray;

package/types/antv-util/path/process/round-path.d.ts

@@ -0,0 +1,6 @@
+import { PathArray } from '../types';
+/**
+ * Rounds the values of a `PathArray` instance to
+ * a specified amount of decimals and returns it.
+ */
+export declare function roundPath(path: PathArray, round: number | 'off'): PathArray;

package/types/antv-util/path/process/segment-2-cubic.d.ts

@@ -0,0 +1,2 @@
+import { PathSegment, ParserParams, CSegment, MSegment } from '../types';
+export declare function segmentToCubic(segment: PathSegment, params: ParserParams): CSegment | MSegment;

package/types/antv-util/path/types.d.ts

@@ -0,0 +1,122 @@
+export type Point = {
+    x: number;
+    y: number;
+};
+export type MCommand = 'M';
+export type mCommand = 'm';
+export type LCommand = 'L';
+export type lCommand = 'l';
+export type VCommand = 'V';
+export type vCommand = 'v';
+export type HCommand = 'H';
+export type hCommand = 'h';
+export type ZCommand = 'Z';
+export type zCommand = 'z';
+export type CCommand = 'C';
+export type cCommand = 'c';
+export type SCommand = 'S';
+export type sCommand = 's';
+export type QCommand = 'Q';
+export type qCommand = 'q';
+export type TCommand = 'T';
+export type tCommand = 't';
+export type ACommand = 'A';
+export type aCommand = 'a';
+export type AbsoluteCommand = MCommand | LCommand | VCommand | HCommand | ZCommand | CCommand | SCommand | QCommand | TCommand | ACommand;
+export type RelativeCommand = mCommand | lCommand | vCommand | hCommand | zCommand | cCommand | sCommand | qCommand | tCommand | aCommand;
+export type PathCommand = AbsoluteCommand | RelativeCommand;
+export type MSegment = [MCommand, number, number];
+export type mSegment = [mCommand, number, number];
+export type MoveSegment = MSegment | mSegment;
+export type LSegment = [LCommand, number, number];
+export type lSegment = [lCommand, number, number];
+export type LineSegment = LSegment | lSegment;
+export type VSegment = [VCommand, number];
+export type vSegment = [vCommand, number];
+export type VertLineSegment = vSegment | VSegment;
+export type HSegment = [HCommand, number];
+export type hSegment = [hCommand, number];
+export type HorLineSegment = HSegment | hSegment;
+export type ZSegment = [ZCommand];
+export type zSegment = [zCommand];
+export type CloseSegment = ZSegment | zSegment;
+export type CSegment = [CCommand, number, number, number, number, number, number];
+export type cSegment = [cCommand, number, number, number, number, number, number];
+export type CubicSegment = CSegment | cSegment;
+export type SSegment = [SCommand, number, number, number, number];
+export type sSegment = [sCommand, number, number, number, number];
+export type ShortCubicSegment = SSegment | sSegment;
+export type QSegment = [QCommand, number, number, number, number];
+export type qSegment = [qCommand, number, number, number, number];
+export type QuadSegment = QSegment | qSegment;
+export type TSegment = [TCommand, number, number];
+export type tSegment = [tCommand, number, number];
+export type ShortQuadSegment = TSegment | tSegment;
+export type ASegment = [ACommand, number, number, number, number, number, number, number];
+export type aSegment = [aCommand, number, number, number, number, number, number, number];
+export type ArcSegment = ASegment | aSegment;
+export type PathSegment = MoveSegment | LineSegment | VertLineSegment | HorLineSegment | CloseSegment | CubicSegment | ShortCubicSegment | QuadSegment | ShortQuadSegment | ArcSegment;
+export interface SegmentProperties {
+    /** the segment */
+    segment: PathSegment;
+    /** the segment index */
+    index: number;
+    /** the segment length */
+    length: number;
+    /** the length including the segment length */
+    lengthAtSegment: number;
+    [key: string]: any;
+}
+export type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment;
+export type AbsoluteSegment = MSegment | LSegment | VSegment | HSegment | CSegment | SSegment | QSegment | TSegment | ASegment | ZSegment;
+export type RelativeSegment = mSegment | lSegment | vSegment | hSegment | cSegment | sSegment | qSegment | tSegment | aSegment | zSegment;
+export type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment;
+export type PathArray = [MSegment | mSegment, ...PathSegment[]];
+export type AbsoluteArray = [MSegment, ...AbsoluteSegment[]];
+export type RelativeArray = [MSegment, ...RelativeSegment[]];
+export type NormalArray = [MSegment, ...NormalSegment[]];
+export type CurveArray = [MSegment, ...CSegment[]];
+export type PolygonArray = [MSegment, ...LSegment[], ZSegment];
+export type PolylineArray = [MSegment, ...LSegment[]];
+export interface ParserParams {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+    qx: number | null;
+    qy: number | null;
+}
+export interface PathBBox {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    x2: number;
+    y2: number;
+    cx: number;
+    cy: number;
+    cz: number;
+}
+export interface PathBBoxTotalLength extends PathBBox {
+    length: number;
+}
+export interface SegmentLimits {
+    min: Point;
+    max: Point;
+}
+export interface PointProperties {
+    closest: {
+        x: number;
+        y: number;
+    };
+    distance: number;
+    segment?: SegmentProperties;
+}
+export interface LengthFactory {
+    length: number;
+    point: Point;
+    min: Point;
+    max: Point;
+}

package/types/antv-util/path/util/distance-square-root.d.ts

@@ -0,0 +1 @@
+export declare function distanceSquareRoot(a: [number, number], b: [number, number]): number;

package/types/antv-util/path/util/equalize-segments.d.ts

@@ -0,0 +1,2 @@
+import { CurveArray, PathArray } from '../types';
+export declare function equalizeSegments(path1: PathArray, path2: PathArray, TL?: number): CurveArray[];

package/types/antv-util/path/util/get-draw-direction.d.ts

@@ -0,0 +1,2 @@
+import { PathArray } from '../types';
+export declare function getDrawDirection(pathArray: PathArray): boolean;

package/types/antv-util/path/util/get-path-area.d.ts

@@ -0,0 +1,8 @@
+import { PathArray } from '../types';
+/**
+ * Returns the area of a shape.
+ * @author Jürg Lehni & Jonathan Puckey
+ *
+ * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js
+ */
+export declare function getPathArea(path: PathArray): number;

package/types/antv-util/path/util/get-path-bbox-total-length.d.ts

@@ -0,0 +1,5 @@
+import { PathArray, PathBBoxTotalLength } from '../types';
+/**
+ * Returns the bounding box of a shape.
+ */
+export declare function getPathBBoxTotalLength(path: PathArray): PathBBoxTotalLength;

package/types/antv-util/path/util/get-path-bbox.d.ts

@@ -0,0 +1,5 @@
+import { PathArray, PathBBox } from '../types';
+/**
+ * Returns the bounding box of a shape.
+ */
+export declare function getPathBBox(path: string | PathArray): PathBBox;

package/types/antv-util/path/util/get-point-at-length.d.ts

@@ -0,0 +1,5 @@
+import { PathArray } from '../types';
+/**
+ * Returns [x,y] coordinates of a point at a given length of a shape.
+ */
+export declare function getPointAtLength(pathInput: string | PathArray, distance: number): import('..').Point;

package/types/antv-util/path/util/get-properties-at-length.d.ts

@@ -0,0 +1,6 @@
+import { PathArray, SegmentProperties } from '../types';
+/**
+ * Returns the segment, its index and length as well as
+ * the length to that segment at a given length in a path.
+ */
+export declare function getPropertiesAtLength(pathInput: string | PathArray, distance?: number): SegmentProperties;

package/types/antv-util/path/util/get-properties-at-point.d.ts

@@ -0,0 +1,7 @@
+import { Point, PathArray, PointProperties } from '../types';
+/**
+ * Returns the point and segment in path closest to a given point as well as
+ * the distance to the path stroke.
+ * @see https://bl.ocks.org/mbostock/8027637
+ */
+export declare function getPropertiesAtPoint(pathInput: string | PathArray, point: Point): PointProperties;

package/types/antv-util/path/util/get-rotated-curve.d.ts

@@ -0,0 +1,2 @@
+import { CurveArray } from '../types';
+export declare function getRotatedCurve(a: CurveArray, b: CurveArray): (string[] | import('..').MSegment | import('..').CSegment)[];

package/types/antv-util/path/util/get-total-length.d.ts

@@ -0,0 +1,8 @@
+import { PathArray } from '../types';
+/**
+ * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
+ *
+ * The `normalizePath` version is lighter, faster, more efficient and more accurate
+ * with paths that are not `curveArray`.
+ */
+export declare function getTotalLength(pathInput: string | PathArray): number;

package/types/antv-util/path/util/is-absolute-array.d.ts

@@ -0,0 +1,6 @@
+import { PathArray, AbsoluteArray } from '../types';
+/**
+ * Iterates an array to check if it's a `PathArray`
+ * with all absolute values.
+ */
+export declare function isAbsoluteArray(path: string | PathArray): path is AbsoluteArray;

package/types/antv-util/path/util/is-curve-array.d.ts

@@ -0,0 +1,9 @@
+import { PathArray } from '../types';
+/**
+ * Iterates an array to check if it's a `PathArray`
+ * with all C (cubic bezier) segments.
+ *
+ * @param {string | PathArray} path the `Array` to be checked
+ * @returns {boolean} iteration result
+ */
+export declare function isCurveArray(path: string | PathArray): path is PathArray;

package/types/antv-util/path/util/is-normalized-array.d.ts

@@ -0,0 +1,7 @@
+import { PathArray } from '../types';
+/**
+ * Iterates an array to check if it's a `PathArray`
+ * with all segments are in non-shorthand notation
+ * with absolute values.
+ */
+export declare function isNormalizedArray(path: string | PathArray): path is PathArray;

package/types/antv-util/path/util/is-path-array.d.ts

@@ -0,0 +1,5 @@
+import { PathArray } from '../types';
+/**
+ * Iterates an array to check if it's an actual `PathArray`.
+ */
+export declare function isPathArray(path: string | PathArray): path is PathArray;

package/types/antv-util/path/util/is-point-in-stroke.d.ts

@@ -0,0 +1,5 @@
+import { Point, PathArray } from '../types';
+/**
+ * Checks if a given point is in the stroke of a path.
+ */
+export declare function isPointInStroke(pathInput: string | PathArray, point: Point): boolean;

package/types/antv-util/path/util/mid-point.d.ts

@@ -0,0 +1 @@
+export declare function midPoint(a: number[], b: number[], t: number): number[];

package/types/antv-util/path/util/path-length-factory.d.ts

@@ -0,0 +1,7 @@
+import { PathArray, LengthFactory } from '../types';
+/**
+ * Returns a {x,y} point at a given length
+ * of a shape, the shape total length and
+ * the shape minimum and maximum {x,y} coordinates.
+ */
+export declare function pathLengthFactory(pathInput: string | PathArray, distance?: number): LengthFactory;

package/types/antv-util/path/util/rotate-vector.d.ts

@@ -0,0 +1,4 @@
+export declare function rotateVector(x: number, y: number, rad: number): {
+    x: number;
+    y: number;
+};

package/types/antv-util/path/util/segment-arc-factory.d.ts

@@ -0,0 +1,6 @@
+import { LengthFactory } from '../types';
+/**
+ * Returns a {x,y} point at a given length, the total length and
+ * the shape minimum and maximum {x,y} coordinates of an A (arc-to) segment.
+ */
+export declare function segmentArcFactory(X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, distance: number): LengthFactory;

package/types/antv-util/path/util/segment-cubic-factory.d.ts

@@ -0,0 +1,6 @@
+import { LengthFactory } from '../types';
+/**
+ * Returns the length of a C (cubic-bezier) segment
+ * or an {x,y} point at a given length.
+ */
+export declare function segmentCubicFactory(x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number, distance: number): LengthFactory;

package/types/antv-util/path/util/segment-line-factory.d.ts

@@ -0,0 +1,6 @@
+import { LengthFactory } from '../types';
+/**
+ * Returns a {x,y} point at a given length, the total length and
+ * the minimum and maximum {x,y} coordinates of a line (L,V,H,Z) segment.
+ */
+export declare function segmentLineFactory(x1: number, y1: number, x2: number, y2: number, distance: number): LengthFactory;

package/types/antv-util/path/util/segment-quad-factory.d.ts

@@ -0,0 +1,6 @@
+import { LengthFactory } from '../types';
+/**
+ * Returns a {x,y} point at a given length, the total length and
+ * the minimum and maximum {x,y} coordinates of a Q (quadratic-bezier) segment.
+ */
+export declare function segmentQuadFactory(x1: number, y1: number, qx: number, qy: number, x2: number, y2: number, distance: number): LengthFactory;

package/types/callbacks.d.ts

@@ -0,0 +1,30 @@
+type CallbacksOptions = {
+    once?: boolean;
+    memory?: boolean;
+    unique?: boolean;
+    stopOnFalse?: boolean;
+};
+type ListHandle<Args extends any[] = any> = (...args: Args) => any;
+export declare class Callbacks<Args extends any[] = any, Context extends any = any> {
+    firing: boolean;
+    memory: any;
+    fired: boolean;
+    locked: boolean;
+    list: ListHandle<Args>[];
+    queue: any[];
+    firingIndex: number;
+    destroyedList: boolean;
+    options: Required<CallbacksOptions>;
+    constructor(options?: CallbacksOptions);
+    private _fire;
+    add(...args: (ListHandle<Args> | ListHandle<Args>[])[]): this;
+    remove(...args: ListHandle[]): this;
+    has(fn: ListHandle): boolean;
+    empty(): this;
+    disable(): this;
+    disabled(): boolean;
+    lock(): this;
+    fireWith(context: Context, args: Args): this;
+    fire(...args: Args): this;
+}
+export {};

package/types/color/colord/src/colorModels/cmyk.d.ts

@@ -0,0 +1,23 @@
+import { RgbaColor, InputObject, CmykaColor } from '../types';
+/**
+ * Clamps the CMYK color object values.
+ */
+export declare const clampCmyka: (cmyka: CmykaColor) => CmykaColor;
+/**
+ * Rounds the CMYK color object values.
+ */
+export declare const roundCmyka: (cmyka: CmykaColor) => CmykaColor;
+/**
+ * Transforms the CMYK color object to RGB.
+ * https://www.rapidtables.com/convert/color/cmyk-to-rgb.html
+ */
+export declare function cmykaToRgba(cmyka: CmykaColor): RgbaColor;
+/**
+ * Convert RGB Color Model object to CMYK.
+ * https://www.rapidtables.com/convert/color/rgb-to-cmyk.html
+ */
+export declare function rgbaToCmyka(rgba: RgbaColor): CmykaColor;
+/**
+ * Parses the CMYK color object into RGB.
+ */
+export declare function parseCmyka({ c, m, y, k, a }: InputObject): RgbaColor | null;

package/types/color/colord/src/colorModels/cmykString.d.ts

@@ -0,0 +1,7 @@
+import { RgbaColor } from '../types';
+/**
+ * Parses a valid CMYK CSS color function/string
+ * https://www.w3.org/TR/css-color-4/#device-cmyk
+ */
+export declare const parseCmykaString: (input: string) => RgbaColor | null;
+export declare function rgbaToCmykaString(rgb: RgbaColor): string;

package/types/color/colord/src/colorModels/hex.d.ts

@@ -0,0 +1,5 @@
+import { RgbaColor } from '../types';
+/** Parses any valid Hex3, Hex4, Hex6 or Hex8 string and converts it to an RGBA object */
+export declare const parseHex: (hex: string) => RgbaColor | null;
+/** Converts RGBA object to Hex6 or (if it has alpha channel) Hex8 string */
+export declare const rgbaToHex: (rgba: RgbaColor) => string;

package/types/color/colord/src/colorModels/hsl.d.ts

@@ -0,0 +1,8 @@
+import { InputObject, RgbaColor, HslaColor, HsvaColor } from '../types';
+export declare const clampHsla: (hsla: HslaColor) => HslaColor;
+export declare const roundHsla: (hsla: HslaColor) => HslaColor;
+export declare const parseHsla: ({ h, s, l, a }: InputObject) => RgbaColor | null;
+export declare const hslaToHsva: ({ h, s, l, a }: HslaColor) => HsvaColor;
+export declare const hsvaToHsla: ({ h, s, v, a }: HsvaColor) => HslaColor;
+export declare const hslaToRgba: (hsla: HslaColor) => RgbaColor;
+export declare const rgbaToHsla: (rgba: RgbaColor) => HslaColor;