fabric 6.2.0 → 6.3.0

package/dist-extensions/src/canvas/StaticCanvasOptions.d.ts

@@ -0,0 +1,153 @@
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import type { TFiller, TMat2D, TOptions } from '../typedefs';
+interface CanvasDrawableOptions {
+    /**
+     * if set to false background image is not affected by viewport transform
+     * @since 1.6.3
+     * @type Boolean
+     * @todo we should really find a different way to do this
+     * @default
+     */
+    backgroundVpt: boolean;
+    /**
+     * Background color of canvas instance.
+     * @type {(String|TFiller)}
+     * @default
+     */
+    backgroundColor: TFiller | string;
+    /**
+     * Background image of canvas instance.
+     * since 2.4.0 image caching is active, please when putting an image as background, add to the
+     * canvas property a reference to the canvas it is on. Otherwise the image cannot detect the zoom
+     * vale. As an alternative you can disable image objectCaching
+     * @type FabricObject
+     * @default
+     */
+    backgroundImage?: FabricObject;
+    /**
+     * if set to false overlay image is not affected by viewport transform
+     * @since 1.6.3
+     * @type Boolean
+     * @todo we should really find a different way to do this
+     * @default
+     */
+    overlayVpt: boolean;
+    /**
+     * Overlay color of canvas instance.
+     * @since 1.3.9
+     * @type {(String|TFiller)}
+     * @default
+     */
+    overlayColor: TFiller | string;
+    /**
+     * Overlay image of canvas instance.
+     * since 2.4.0 image caching is active, please when putting an image as overlay, add to the
+     * canvas property a reference to the canvas it is on. Otherwise the image cannot detect the zoom
+     * vale. As an alternative you can disable image objectCaching
+     * @type FabricObject
+     * @default
+     */
+    overlayImage?: FabricObject;
+}
+interface CanvasRenderingOptions {
+    /**
+     * Indicates whether {@link StaticCanvas#add}, {@link StaticCanvas#insertAt} and {@link StaticCanvas#remove},
+     * {@link StaticCanvas#moveTo}, {@link StaticCanvas#clear} and many more, should also re-render canvas.
+     * Disabling this option will not give a performance boost when adding/removing a lot of objects to/from canvas at once
+     * since the renders are queued and executed one per frame.
+     * Disabling is suggested anyway and managing the renders of the app manually is not a big effort ( canvas.requestRenderAll() )
+     * Left default to true to do not break documentation and old app, fiddles.
+     * @type Boolean
+     * @default
+     */
+    renderOnAddRemove: boolean;
+    /**
+     * Based on vptCoords and object.aCoords, skip rendering of objects that
+     * are not included in current viewport.
+     * May greatly help in applications with crowded canvas and use of zoom/pan
+     * If One of the corner of the bounding box of the object is on the canvas
+     * the objects get rendered.
+     * @type Boolean
+     * @default true
+     */
+    skipOffscreen: boolean;
+    /**
+     * When true, canvas is scaled by devicePixelRatio for better rendering on retina screens
+     * @type Boolean
+     * @default
+     */
+    enableRetinaScaling: boolean;
+    /**
+     * Indicates whether this canvas will use image smoothing, this is on by default in browsers
+     * @type Boolean
+     * @default
+     */
+    imageSmoothingEnabled: boolean;
+    /**
+     * a fabricObject that, without stroke define a clipping area with their shape. filled in black
+     * the clipPath object gets used when the canvas has rendered, and the context is placed in the
+     * top left corner of the canvas.
+     * clipPath will clip away controls, if you do not want this to happen use controlsAboveOverlay = true
+     * @type FabricObject
+     */
+    clipPath?: FabricObject;
+}
+export interface CanvasExportOptions {
+    /**
+     * Indicates whether toObject/toDatalessObject should include default values
+     * if set to false, takes precedence over the object value.
+     * @type Boolean
+     * @default
+     */
+    includeDefaultValues: boolean;
+    /**
+     * When true, getSvgTransform() will apply the StaticCanvas.viewportTransform to the SVG transformation. When true,
+     * a zoomed canvas will then produce zoomed SVG output.
+     * @type Boolean
+     * @default
+     */
+    svgViewportTransformation: boolean;
+}
+export interface StaticCanvasOptions extends CanvasDrawableOptions, CanvasRenderingOptions, CanvasExportOptions {
+    /**
+     * Width in virtual/logical pixels of the canvas.
+     * The canvas can be larger than width if retina scaling is active
+     * @type number
+     */
+    width: number;
+    /**
+     * Height in virtual/logical pixels of the canvas.
+     * The canvas can be taller than width if retina scaling is active
+     * @type height
+     */
+    height: number;
+    /**
+     * Indicates whether object controls (borders/controls) are rendered above overlay image
+     * @type Boolean
+     * @default
+     *
+     * @todo move to Canvas
+     */
+    controlsAboveOverlay: boolean;
+    /**
+     * Indicates whether the browser can be scrolled when using a touchscreen and dragging on the canvas
+     * @type Boolean
+     * @default
+     *
+     * @todo move to Canvas
+     */
+    allowTouchScrolling: boolean;
+    /**
+     * The transformation (a Canvas 2D API transform matrix) which focuses the viewport
+     * @type Array
+     * @example <caption>Default transform</caption>
+     * canvas.viewportTransform = [1, 0, 0, 1, 0, 0];
+     * @example <caption>Scale by 70% and translate toward bottom-right by 50, without skewing</caption>
+     * canvas.viewportTransform = [0.7, 0, 0, 0.7, 50, 50];
+     * @default
+     */
+    viewportTransform: TMat2D;
+}
+export declare const staticCanvasDefaults: TOptions<StaticCanvasOptions>;
+export {};
+//# sourceMappingURL=StaticCanvasOptions.d.ts.map

package/dist-extensions/src/canvas/StaticCanvasOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticCanvasOptions.d.ts","sourceRoot":"","sources":["../../../src/canvas/StaticCanvasOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE7D,UAAU,qBAAqB;IAC7B;;;;;;OAMG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,eAAe,EAAE,OAAO,GAAG,MAAM,CAAC;IAElC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,YAAY,CAAC;IAE/B;;;;;;OAMG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,GAAG,MAAM,CAAC;IAE/B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,UAAU,sBAAsB;IAC9B;;;;;;;;;OASG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAE3B;;;;;;;;OAQG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAE7B;;;;OAIG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAE/B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAE9B;;;;;OAKG;IACH,yBAAyB,EAAE,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,mBACf,SAAQ,qBAAqB,EAC3B,sBAAsB,EACtB,mBAAmB;IACrB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAE9B;;;;;;OAMG;IACH,mBAAmB,EAAE,OAAO,CAAC;IAE7B;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,mBAAmB,CAwB9D,CAAC"}

package/dist-extensions/src/canvas/TextEditingManager.d.ts

@@ -0,0 +1,21 @@
+import type { TPointerEvent } from '../EventTypeDefs';
+import type { ITextBehavior } from '../shapes/IText/ITextBehavior';
+import type { Canvas } from './Canvas';
+/**
+ * In charge of synchronizing all interactive text instances of a canvas
+ */
+export declare class TextEditingManager {
+    private targets;
+    private target?;
+    private __disposer;
+    constructor(canvas: Canvas);
+    exitTextEditing(): void;
+    add(target: ITextBehavior): void;
+    remove(target: ITextBehavior): void;
+    register(target: ITextBehavior): void;
+    unregister(target: ITextBehavior): void;
+    onMouseMove(e: TPointerEvent): void;
+    clear(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=TextEditingManager.d.ts.map

package/dist-extensions/src/canvas/TextEditingManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextEditingManager.d.ts","sourceRoot":"","sources":["../../../src/canvas/TextEditingManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAuB;IACtC,QAAgB,MAAM,CAAC,CAAgB;IACvC,OAAO,CAAC,UAAU,CAAe;gBAErB,MAAM,EAAE,MAAM;IAW1B,eAAe;IASf,GAAG,CAAC,MAAM,EAAE,aAAa;IAIzB,MAAM,CAAC,MAAM,EAAE,aAAa;IAK5B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAI9B,UAAU,CAAC,MAAM,EAAE,aAAa;IAMhC,WAAW,CAAC,CAAC,EAAE,aAAa;IAI5B,KAAK;IAKL,OAAO;CAMR"}

package/dist-extensions/src/color/Color.d.ts

@@ -0,0 +1,162 @@
+import type { TRGBAColorSource, TColorArg } from './typedefs';
+/**
+ * @class Color common color operations
+ * @tutorial {@link http://fabricjs.com/fabric-intro-part-2/#colors colors}
+ */
+export declare class Color {
+    private _source;
+    isUnrecognised: boolean;
+    /**
+     *
+     * @param {string} [color] optional in hex or rgb(a) or hsl format or from known color list
+     */
+    constructor(color?: TColorArg);
+    /**
+     * @private
+     * @param {string} [color] Color value to parse
+     * @returns {TRGBAColorSource}
+     */
+    protected _tryParsingColor(color: string): TRGBAColorSource;
+    /**
+     * Returns source of this color (where source is an array representation; ex: [200, 200, 100, 1])
+     * @return {TRGBAColorSource}
+     */
+    getSource(): TRGBAColorSource;
+    /**
+     * Sets source of this color (where source is an array representation; ex: [200, 200, 100, 1])
+     * @param {TRGBAColorSource} source
+     */
+    setSource(source: TRGBAColorSource): void;
+    /**
+     * Returns color representation in RGB format
+     * @return {String} ex: rgb(0-255,0-255,0-255)
+     */
+    toRgb(): string;
+    /**
+     * Returns color representation in RGBA format
+     * @return {String} ex: rgba(0-255,0-255,0-255,0-1)
+     */
+    toRgba(): string;
+    /**
+     * Returns color representation in HSL format
+     * @return {String} ex: hsl(0-360,0%-100%,0%-100%)
+     */
+    toHsl(): string;
+    /**
+     * Returns color representation in HSLA format
+     * @return {String} ex: hsla(0-360,0%-100%,0%-100%,0-1)
+     */
+    toHsla(): string;
+    /**
+     * Returns color representation in HEX format
+     * @return {String} ex: FF5555
+     */
+    toHex(): string;
+    /**
+     * Returns color representation in HEXA format
+     * @return {String} ex: FF5555CC
+     */
+    toHexa(): string;
+    /**
+     * Gets value of alpha channel for this color
+     * @return {Number} 0-1
+     */
+    getAlpha(): number;
+    /**
+     * Sets value of alpha channel for this color
+     * @param {Number} alpha Alpha value 0-1
+     * @return {Color} thisArg
+     */
+    setAlpha(alpha: number): this;
+    /**
+     * Transforms color to its grayscale representation
+     * @return {Color} thisArg
+     */
+    toGrayscale(): this;
+    /**
+     * Transforms color to its black and white representation
+     * @param {Number} threshold
+     * @return {Color} thisArg
+     */
+    toBlackWhite(threshold: number): this;
+    /**
+     * Overlays color with another color
+     * @param {String|Color} otherColor
+     * @return {Color} thisArg
+     */
+    overlayWith(otherColor: string | Color): this;
+    /**
+     * Returns new color object, when given a color in RGB format
+     * @memberOf Color
+     * @param {String} color Color value ex: rgb(0-255,0-255,0-255)
+     * @return {Color}
+     */
+    static fromRgb(color: string): Color;
+    /**
+     * Returns new color object, when given a color in RGBA format
+     * @static
+     * @function
+     * @memberOf Color
+     * @param {String} color
+     * @return {Color}
+     */
+    static fromRgba(color: string): Color;
+    /**
+     * Returns array representation (ex: [100, 100, 200, 1]) of a color that's in RGB or RGBA format
+     * @memberOf Color
+     * @param {String} color Color value ex: rgb(0-255,0-255,0-255), rgb(0%-100%,0%-100%,0%-100%)
+     * @return {TRGBAColorSource | undefined} source
+     */
+    static sourceFromRgb(color: string): TRGBAColorSource | undefined;
+    /**
+     * Returns new color object, when given a color in HSL format
+     * @param {String} color Color value ex: hsl(0-260,0%-100%,0%-100%)
+     * @memberOf Color
+     * @return {Color}
+     */
+    static fromHsl(color: string): Color;
+    /**
+     * Returns new color object, when given a color in HSLA format
+     * @static
+     * @function
+     * @memberOf Color
+     * @param {String} color
+     * @return {Color}
+     */
+    static fromHsla(color: string): Color;
+    /**
+     * Returns array representation (ex: [100, 100, 200, 1]) of a color that's in HSL or HSLA format.
+     * Adapted from <a href="https://rawgithub.com/mjijackson/mjijackson.github.com/master/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript.html">https://github.com/mjijackson</a>
+     * @memberOf Color
+     * @param {String} color Color value ex: hsl(0-360,0%-100%,0%-100%) or hsla(0-360,0%-100%,0%-100%, 0-1)
+     * @return {TRGBAColorSource | undefined} source
+     * @see http://http://www.w3.org/TR/css3-color/#hsl-color
+     */
+    static sourceFromHsl(color: string): TRGBAColorSource | undefined;
+    /**
+     * Returns new color object, when given a color in HEX format
+     * @static
+     * @memberOf Color
+     * @param {String} color Color value ex: FF5555
+     * @return {Color}
+     */
+    static fromHex(color: string): Color;
+    /**
+     * Returns array representation (ex: [100, 100, 200, 1]) of a color that's in HEX format
+     * @static
+     * @memberOf Color
+     * @param {String} color ex: FF5555 or FF5544CC (RGBa)
+     * @return {TRGBAColorSource | undefined} source
+     */
+    static sourceFromHex(color: string): TRGBAColorSource | undefined;
+    /**
+     * Converts a string that could be any angle notation (50deg, 0.5turn, 2rad)
+     * into degrees without the 'deg' suffix
+     * @static
+     * @memberOf Color
+     * @param {String} value ex: 0deg, 0.5turn, 2rad
+     * @return {Number} number in degrees or NaN if inputs are invalid
+     */
+    static parseAngletoDegrees(value: string): number;
+}
+//# sourceMappingURL=Color.d.ts.map

package/dist-extensions/src/color/Color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Color.d.ts","sourceRoot":"","sources":["../../../src/color/Color.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAS9D;;;GAGG;AACH,qBAAa,KAAK;IAChB,QAAgB,OAAO,CAAmB;IAC1C,cAAc,UAAS;IAEvB;;;OAGG;gBACS,KAAK,CAAC,EAAE,SAAS;IAc7B;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM;IAexC;;;OAGG;IACH,SAAS;IAIT;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,gBAAgB;IAIlC;;;OAGG;IACH,KAAK;IAKL;;;OAGG;IACH,MAAM;IAIN;;;OAGG;IACH,KAAK;IAKL;;;OAGG;IACH,MAAM;IAKN;;;OAGG;IACH,KAAK;IAKL;;;OAGG;IACH,MAAM;IAKN;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM;IAKtB;;;OAGG;IACH,WAAW;IAKX;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM;IAO9B;;;;OAIG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK;IAgBtC;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAIpC;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAIrC;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAajE;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAIpC;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAIrC;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IA+BjE;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAIpC;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAiBjE;;;;;;;OAOG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAelD"}

package/dist-extensions/src/color/color_map.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Map of the 148 color names with HEX code
+ * @see: https://www.w3.org/TR/css3-color/#svg-color
+ */
+export declare const ColorNameMap: {
+    aliceblue: string;
+    antiquewhite: string;
+    aqua: string;
+    aquamarine: string;
+    azure: string;
+    beige: string;
+    bisque: string;
+    black: string;
+    blanchedalmond: string;
+    blue: string;
+    blueviolet: string;
+    brown: string;
+    burlywood: string;
+    cadetblue: string;
+    chartreuse: string;
+    chocolate: string;
+    coral: string;
+    cornflowerblue: string;
+    cornsilk: string;
+    crimson: string;
+    cyan: string;
+    darkblue: string;
+    darkcyan: string;
+    darkgoldenrod: string;
+    darkgray: string;
+    darkgrey: string;
+    darkgreen: string;
+    darkkhaki: string;
+    darkmagenta: string;
+    darkolivegreen: string;
+    darkorange: string;
+    darkorchid: string;
+    darkred: string;
+    darksalmon: string;
+    darkseagreen: string;
+    darkslateblue: string;
+    darkslategray: string;
+    darkslategrey: string;
+    darkturquoise: string;
+    darkviolet: string;
+    deeppink: string;
+    deepskyblue: string;
+    dimgray: string;
+    dimgrey: string;
+    dodgerblue: string;
+    firebrick: string;
+    floralwhite: string;
+    forestgreen: string;
+    fuchsia: string;
+    gainsboro: string;
+    ghostwhite: string;
+    gold: string;
+    goldenrod: string;
+    gray: string;
+    grey: string;
+    green: string;
+    greenyellow: string;
+    honeydew: string;
+    hotpink: string;
+    indianred: string;
+    indigo: string;
+    ivory: string;
+    khaki: string;
+    lavender: string;
+    lavenderblush: string;
+    lawngreen: string;
+    lemonchiffon: string;
+    lightblue: string;
+    lightcoral: string;
+    lightcyan: string;
+    lightgoldenrodyellow: string;
+    lightgray: string;
+    lightgrey: string;
+    lightgreen: string;
+    lightpink: string;
+    lightsalmon: string;
+    lightseagreen: string;
+    lightskyblue: string;
+    lightslategray: string;
+    lightslategrey: string;
+    lightsteelblue: string;
+    lightyellow: string;
+    lime: string;
+    limegreen: string;
+    linen: string;
+    magenta: string;
+    maroon: string;
+    mediumaquamarine: string;
+    mediumblue: string;
+    mediumorchid: string;
+    mediumpurple: string;
+    mediumseagreen: string;
+    mediumslateblue: string;
+    mediumspringgreen: string;
+    mediumturquoise: string;
+    mediumvioletred: string;
+    midnightblue: string;
+    mintcream: string;
+    mistyrose: string;
+    moccasin: string;
+    navajowhite: string;
+    navy: string;
+    oldlace: string;
+    olive: string;
+    olivedrab: string;
+    orange: string;
+    orangered: string;
+    orchid: string;
+    palegoldenrod: string;
+    palegreen: string;
+    paleturquoise: string;
+    palevioletred: string;
+    papayawhip: string;
+    peachpuff: string;
+    peru: string;
+    pink: string;
+    plum: string;
+    powderblue: string;
+    purple: string;
+    rebeccapurple: string;
+    red: string;
+    rosybrown: string;
+    royalblue: string;
+    saddlebrown: string;
+    salmon: string;
+    sandybrown: string;
+    seagreen: string;
+    seashell: string;
+    sienna: string;
+    silver: string;
+    skyblue: string;
+    slateblue: string;
+    slategray: string;
+    slategrey: string;
+    snow: string;
+    springgreen: string;
+    steelblue: string;
+    tan: string;
+    teal: string;
+    thistle: string;
+    tomato: string;
+    turquoise: string;
+    violet: string;
+    wheat: string;
+    white: string;
+    whitesmoke: string;
+    yellow: string;
+    yellowgreen: string;
+};
+//# sourceMappingURL=color_map.d.ts.map

package/dist-extensions/src/color/color_map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color_map.d.ts","sourceRoot":"","sources":["../../../src/color/color_map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqJxB,CAAC"}

package/dist-extensions/src/color/constants.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Regex matching color in RGB or RGBA formats (ex: `rgb(0, 0, 0)`, `rgba(255, 100, 10, 0.5)`, `rgba( 255 , 100 , 10 , 0.5 )`, `rgb(1,1,1)`, `rgba(100%, 60%, 10%, 0.5)`)
+ * Also matching rgba(r g b / a) as per new specs
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb
+ * Formal syntax at the time of writing:
+ * <rgb()> =
+ *  rgb( [ <percentage> | none ]{3} [ / [ <alpha-value> | none ] ]? )  |
+ *  rgb( [ <number> | none ]{3} [ / [ <alpha-value> | none ] ]? )
+ * <alpha-value> = <number> | <percentage>
+ *
+ * For learners this is how you can read this regex
+ * Regular expression for matching an rgba or rgb CSS color value
+ *
+ * /^          # Beginning of the string
+ * rgba?       # "rgb" or "rgba"
+ * \(\s*       # Opening parenthesis and optional whitespace
+ * (\d{0,3}    # 0 to three digits R channel
+ *  (?:\.\d+)? # Optional decimal with one or more digits
+ * )           # End of capturing group for the first color component
+ * %?          # Optional percent sign after the first color component
+ * \s*         # Optional whitespace
+ * [\s|,]      # Separator between color components can be a space or comma
+ * \s*         # Optional whitespace
+ * (\d{0,3}    # 0 to three digits G channel
+ *  (?:\.\d+)? # Optional decimal with one or more digits
+ * )           # End of capturing group for the second color component
+ * %?          # Optional percent sign after the second color component
+ * \s*         # Optional whitespace
+ * [\s|,]      # Separator between color components can be a space or comma
+ * \s*         # Optional whitespace
+ * (\d{0,3}    # 0 to three digits B channel
+ *  (?:\.\d+)? # Optional decimal with one or more digits
+ * )           # End of capturing group for the third color component
+ * %?          # Optional percent sign after the third color component
+ * \s*         # Optional whitespace
+ * (?:         # Beginning of non-capturing group for alpha value
+ *  \s*        # Optional whitespace
+ *  [,/]       # Comma or slash separator for alpha value
+ *  \s*        # Optional whitespace
+ *  (\d{0,3}   # Zero to three digits
+ *    (?:\.\d+)? # Optional decimal with one or more digits
+ *  )          # End of capturing group for alpha value
+ *  %?         # Optional percent sign after alpha value
+ *  \s*        # Optional whitespace
+ * )?          # End of non-capturing group for alpha value (optional)
+ * \)          # Closing parenthesis
+ * $           # End of the string
+ *
+ * The alpha channel can be in the format 0.4 .7 or 1 or 73%
+ *
+ * WARNING this regex doesn't fail on off spec colors. it matches everything that could be a color.
+ * So the spec does not allow for `rgba(30 , 45%  35, 49%)` but this will work anyways for us
+ */
+export declare const reRGBa: () => RegExp;
+/**
+ * Regex matching color in HSL or HSLA formats (ex: hsl(0, 0, 0), rgba(255, 100, 10, 0.5), rgba( 255 , 100 , 10 , 0.5 ), rgb(1,1,1), rgba(100%, 60%, 10%, 0.5))
+ * Also matching rgba(r g b / a) as per new specs
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/hsl
+ * Formal syntax at the time of writing:
+ * <hsl()> =
+ *   hsl( [ <hue> | none ] [ <percentage> | none ] [ <percentage> | none ] [ / [ <alpha-value> | none ] ]? )
+ *
+ * <hue> =
+ *   <number>  |
+ *   <angle>
+ *
+ * <alpha-value> =
+ *   <number>      |
+ *   <percentage>
+ *
+ * For learners this is how you can read this regex
+ * Regular expression for matching an hsla or hsl CSS color value
+ *
+ * /^hsla?\(         // Matches the beginning of the string and the opening parenthesis of "hsl" or "hsla"
+ * \s*               // Matches any whitespace characters (space, tab, etc.) zero or more times
+ * (\d{0,3}          // Hue: 0 to three digits - start capture in a group
+ * (?:\.\d+)?        // Hue: Optional (non capture group) decimal with one or more digits.
+ * (?:deg|turn|rad)? // Hue: Optionally include suffix deg or turn or rad
+ * )                 // Hue: End capture group
+ * \s*               // Matches any whitespace characters zero or more times
+ * [\s|,]            // Matches a space, tab or comma
+ * \s*               // Matches any whitespace characters zero or more times
+ * (\d{0,3}          // Saturation: 0 to three digits - start capture in a group
+ * (?:\.\d+)?        // Saturation: Optional decimal with one or more digits in a non-capturing group
+ * %?)               // Saturation: match optional % character and end capture group
+ * \s*               // Matches any whitespace characters zero or more times
+ * [\s|,]            // Matches a space, tab or comma
+ * \s*               // Matches any whitespace characters zero or more times
+ * (\d{0,3}          // Lightness: 0 to three digits - start capture in a group
+ * (?:\.\d+)?        // Lightness: Optional decimal with one or more digits in a non-capturing group
+ * %?)                // Lightness: match % character and end capture group
+ * \s*               // Matches any whitespace characters zero or more times
+ * (?:               // Alpha: Begins a non-capturing group for the alpha value
+ *   \s*             // Matches any whitespace characters zero or more times
+ *   [,/]            // Matches a comma or forward slash
+ *   \s*             // Matches any whitespace characters zero or more times
+ *   (\d*(?:\.\d+)?%?) // Matches zero or more digits, optionally followed by a decimal point and one or more digits, followed by an optional percentage sign and captures it in a group
+ *   \s*             // Matches any whitespace characters zero or more times
+ * )?                // Makes the alpha value group optional
+ * \)                // Matches the closing parenthesis
+ * $/i               // Matches the end of the string and sets the regular expression to case-insensitive mode
+ *
+ * WARNING this regex doesn't fail on off spec colors. It matches everything that could be a color.
+ * So the spec does not allow `hsl(30 , 45%  35, 49%)` but this will work anyways for us.
+ */
+export declare const reHSLa: () => RegExp;
+/**
+ * Regex matching color in HEX format (ex: #FF5544CC, #FF5555, 010155, aff)
+ */
+export declare const reHex: () => RegExp;
+//# sourceMappingURL=constants.d.ts.map

package/dist-extensions/src/color/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/color/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,MAAM,cACiI,CAAC;AAErJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,MAAM,cACiJ,CAAC;AAErK;;GAEG;AACH,eAAO,MAAM,KAAK,cAAoD,CAAC"}

package/dist-extensions/src/color/typedefs.d.ts

@@ -0,0 +1,16 @@
+import type { Color } from './Color';
+/**
+ * RGB format
+ */
+export type TRGBColorSource = [red: number, green: number, blue: number];
+/**
+ * RGBA format
+ */
+export type TRGBAColorSource = [
+    red: number,
+    green: number,
+    blue: number,
+    alpha: number
+];
+export type TColorArg = string | TRGBColorSource | TRGBAColorSource | Color;
+//# sourceMappingURL=typedefs.d.ts.map

package/dist-extensions/src/color/typedefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedefs.d.ts","sourceRoot":"","sources":["../../../src/color/typedefs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM;IACX,KAAK,EAAE,MAAM;IACb,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,MAAM;CACd,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,eAAe,GAAG,gBAAgB,GAAG,KAAK,CAAC"}

package/dist-extensions/src/color/util.d.ts

@@ -0,0 +1,27 @@
+import type { TRGBAColorSource } from './typedefs';
+/**
+ * @param {Number} p
+ * @param {Number} q
+ * @param {Number} t
+ * @return {Number}
+ */
+export declare const hue2rgb: (p: number, q: number, t: number) => number;
+/**
+ * Adapted from {@link https://gist.github.com/mjackson/5311256 https://gist.github.com/mjackson}
+ * @param {Number} r Red color value
+ * @param {Number} g Green color value
+ * @param {Number} b Blue color value
+ * @param {Number} a Alpha color value pass through
+ * @return {TRGBColorSource} Hsl color
+ */
+export declare const rgb2Hsl: (r: number, g: number, b: number, a: number) => TRGBAColorSource;
+export declare const fromAlphaToFloat: (value?: string) => number;
+/**
+ * Convert a value in the inclusive range [0, 255] to hex
+ */
+export declare const hexify: (value: number) => string;
+/**
+ * Calculate the grey average value for rgb and pass through alpha
+ */
+export declare const greyAverage: ([r, g, b, a,]: TRGBAColorSource) => TRGBAColorSource;
+//# sourceMappingURL=util.d.ts.map

package/dist-extensions/src/color/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/color/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,MAAO,MAAM,KAAK,MAAM,KAAK,MAAM,KAAG,MAiBzD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,MACf,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACR,gBA8BF,CAAC;AAEF,eAAO,MAAM,gBAAgB,4BACwB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,WAC0C,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,WAAW,kBAKrB,gBAAgB,KAAG,gBAGrB,CAAC"}