@nasser-sw/fabric 7.0.0-beta1

package/debug/konva/src/Util.ts

@@ -0,0 +1,1123 @@
+import { Konva } from './Global.ts';
+import type { Context } from './Context.ts';
+import type { IRect, RGB, Vector2d } from './types.ts';
+
+const NODE_ERROR = `Konva.js unsupported environment.
+
+Looks like you are trying to use Konva.js in Node.js environment. because "document" object is undefined.
+
+To use Konva.js in Node.js environment, you need to use the "canvas-backend" or "skia-backend" module.
+
+bash: npm install canvas
+js: import "konva/canvas-backend";
+
+or
+
+bash: npm install skia-canvas
+js: import "konva/skia-backend";
+`;
+const ensureBrowser = () => {
+  if (typeof document === 'undefined') {
+    throw new Error(NODE_ERROR);
+  }
+};
+
+/*
+ * Last updated November 2011
+ * By Simon Sarris
+ * www.simonsarris.com
+ * sarris@acm.org
+ *
+ * Free to use and distribute at will
+ * So long as you are nice to people, etc
+ */
+/*
+ * The usage of this class was inspired by some of the work done by a forked
+ * project, KineticJS-Ext by Wappworks, which is based on Simon's Transform
+ * class.  Modified by Eric Rowell
+ */
+
+/**
+ * Transform constructor.
+ * In most of the cases you don't need to use it in your app. Because it is for internal usage in Konva core.
+ * But there is a documentation for that class in case you still want
+ * to make some manual calculations.
+ * @constructor
+ * @param {Array} [m] Optional six-element matrix
+ * @memberof Konva
+ */
+export class Transform {
+  m: Array<number>;
+  dirty = false;
+  constructor(m = [1, 0, 0, 1, 0, 0]) {
+    this.m = (m && m.slice()) || [1, 0, 0, 1, 0, 0];
+  }
+  reset() {
+    this.m[0] = 1;
+    this.m[1] = 0;
+    this.m[2] = 0;
+    this.m[3] = 1;
+    this.m[4] = 0;
+    this.m[5] = 0;
+  }
+  /**
+   * Copy Konva.Transform object
+   * @method
+   * @name Konva.Transform#copy
+   * @returns {Konva.Transform}
+   * @example
+   * const tr = shape.getTransform().copy()
+   */
+  copy() {
+    return new Transform(this.m);
+  }
+  copyInto(tr: Transform) {
+    tr.m[0] = this.m[0];
+    tr.m[1] = this.m[1];
+    tr.m[2] = this.m[2];
+    tr.m[3] = this.m[3];
+    tr.m[4] = this.m[4];
+    tr.m[5] = this.m[5];
+  }
+  /**
+   * Transform point
+   * @method
+   * @name Konva.Transform#point
+   * @param {Object} point 2D point(x, y)
+   * @returns {Object} 2D point(x, y)
+   */
+  point(point: Vector2d) {
+    const m = this.m;
+    return {
+      x: m[0] * point.x + m[2] * point.y + m[4],
+      y: m[1] * point.x + m[3] * point.y + m[5],
+    };
+  }
+  /**
+   * Apply translation
+   * @method
+   * @name Konva.Transform#translate
+   * @param {Number} x
+   * @param {Number} y
+   * @returns {Konva.Transform}
+   */
+  translate(x: number, y: number) {
+    this.m[4] += this.m[0] * x + this.m[2] * y;
+    this.m[5] += this.m[1] * x + this.m[3] * y;
+    return this;
+  }
+  /**
+   * Apply scale
+   * @method
+   * @name Konva.Transform#scale
+   * @param {Number} sx
+   * @param {Number} sy
+   * @returns {Konva.Transform}
+   */
+  scale(sx: number, sy: number) {
+    this.m[0] *= sx;
+    this.m[1] *= sx;
+    this.m[2] *= sy;
+    this.m[3] *= sy;
+    return this;
+  }
+  /**
+   * Apply rotation
+   * @method
+   * @name Konva.Transform#rotate
+   * @param {Number} rad  Angle in radians
+   * @returns {Konva.Transform}
+   */
+  rotate(rad: number) {
+    const c = Math.cos(rad);
+    const s = Math.sin(rad);
+    const m11 = this.m[0] * c + this.m[2] * s;
+    const m12 = this.m[1] * c + this.m[3] * s;
+    const m21 = this.m[0] * -s + this.m[2] * c;
+    const m22 = this.m[1] * -s + this.m[3] * c;
+    this.m[0] = m11;
+    this.m[1] = m12;
+    this.m[2] = m21;
+    this.m[3] = m22;
+    return this;
+  }
+  /**
+   * Returns the translation
+   * @method
+   * @name Konva.Transform#getTranslation
+   * @returns {Object} 2D point(x, y)
+   */
+  getTranslation() {
+    return {
+      x: this.m[4],
+      y: this.m[5],
+    };
+  }
+  /**
+   * Apply skew
+   * @method
+   * @name Konva.Transform#skew
+   * @param {Number} sx
+   * @param {Number} sy
+   * @returns {Konva.Transform}
+   */
+  skew(sx: number, sy: number) {
+    const m11 = this.m[0] + this.m[2] * sy;
+    const m12 = this.m[1] + this.m[3] * sy;
+    const m21 = this.m[2] + this.m[0] * sx;
+    const m22 = this.m[3] + this.m[1] * sx;
+    this.m[0] = m11;
+    this.m[1] = m12;
+    this.m[2] = m21;
+    this.m[3] = m22;
+    return this;
+  }
+  /**
+   * Transform multiplication
+   * @method
+   * @name Konva.Transform#multiply
+   * @param {Konva.Transform} matrix
+   * @returns {Konva.Transform}
+   */
+  multiply(matrix: Transform) {
+    const m11 = this.m[0] * matrix.m[0] + this.m[2] * matrix.m[1];
+    const m12 = this.m[1] * matrix.m[0] + this.m[3] * matrix.m[1];
+
+    const m21 = this.m[0] * matrix.m[2] + this.m[2] * matrix.m[3];
+    const m22 = this.m[1] * matrix.m[2] + this.m[3] * matrix.m[3];
+
+    const dx = this.m[0] * matrix.m[4] + this.m[2] * matrix.m[5] + this.m[4];
+    const dy = this.m[1] * matrix.m[4] + this.m[3] * matrix.m[5] + this.m[5];
+
+    this.m[0] = m11;
+    this.m[1] = m12;
+    this.m[2] = m21;
+    this.m[3] = m22;
+    this.m[4] = dx;
+    this.m[5] = dy;
+    return this;
+  }
+  /**
+   * Invert the matrix
+   * @method
+   * @name Konva.Transform#invert
+   * @returns {Konva.Transform}
+   */
+  invert() {
+    const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+    const m0 = this.m[3] * d;
+    const m1 = -this.m[1] * d;
+    const m2 = -this.m[2] * d;
+    const m3 = this.m[0] * d;
+    const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+    const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
+    this.m[0] = m0;
+    this.m[1] = m1;
+    this.m[2] = m2;
+    this.m[3] = m3;
+    this.m[4] = m4;
+    this.m[5] = m5;
+    return this;
+  }
+  /**
+   * return matrix
+   * @method
+   * @name Konva.Transform#getMatrix
+   */
+  getMatrix() {
+    return this.m;
+  }
+  /**
+   * convert transformation matrix back into node's attributes
+   * @method
+   * @name Konva.Transform#decompose
+   * @returns {Konva.Transform}
+   */
+  decompose() {
+    const a = this.m[0];
+    const b = this.m[1];
+    const c = this.m[2];
+    const d = this.m[3];
+    const e = this.m[4];
+    const f = this.m[5];
+
+    const delta = a * d - b * c;
+
+    const result = {
+      x: e,
+      y: f,
+      rotation: 0,
+      scaleX: 0,
+      scaleY: 0,
+      skewX: 0,
+      skewY: 0,
+    };
+
+    // Apply the QR-like decomposition.
+    if (a != 0 || b != 0) {
+      const r = Math.sqrt(a * a + b * b);
+      result.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);
+      result.scaleX = r;
+      result.scaleY = delta / r;
+      result.skewX = (a * c + b * d) / delta;
+      result.skewY = 0;
+    } else if (c != 0 || d != 0) {
+      const s = Math.sqrt(c * c + d * d);
+      result.rotation =
+        Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));
+      result.scaleX = delta / s;
+      result.scaleY = s;
+      result.skewX = 0;
+      result.skewY = (a * c + b * d) / delta;
+    } else {
+      // a = b = c = d = 0
+    }
+
+    result.rotation = Util._getRotation(result.rotation);
+
+    return result;
+  }
+}
+
+// CONSTANTS
+const OBJECT_ARRAY = '[object Array]',
+  OBJECT_NUMBER = '[object Number]',
+  OBJECT_STRING = '[object String]',
+  OBJECT_BOOLEAN = '[object Boolean]',
+  PI_OVER_DEG180 = Math.PI / 180,
+  DEG180_OVER_PI = 180 / Math.PI,
+  HASH = '#',
+  EMPTY_STRING = '',
+  ZERO = '0',
+  KONVA_WARNING = 'Konva warning: ',
+  KONVA_ERROR = 'Konva error: ',
+  RGB_PAREN = 'rgb(',
+  COLORS = {
+    aliceblue: [240, 248, 255],
+    antiquewhite: [250, 235, 215],
+    aqua: [0, 255, 255],
+    aquamarine: [127, 255, 212],
+    azure: [240, 255, 255],
+    beige: [245, 245, 220],
+    bisque: [255, 228, 196],
+    black: [0, 0, 0],
+    blanchedalmond: [255, 235, 205],
+    blue: [0, 0, 255],
+    blueviolet: [138, 43, 226],
+    brown: [165, 42, 42],
+    burlywood: [222, 184, 135],
+    cadetblue: [95, 158, 160],
+    chartreuse: [127, 255, 0],
+    chocolate: [210, 105, 30],
+    coral: [255, 127, 80],
+    cornflowerblue: [100, 149, 237],
+    cornsilk: [255, 248, 220],
+    crimson: [220, 20, 60],
+    cyan: [0, 255, 255],
+    darkblue: [0, 0, 139],
+    darkcyan: [0, 139, 139],
+    darkgoldenrod: [184, 132, 11],
+    darkgray: [169, 169, 169],
+    darkgreen: [0, 100, 0],
+    darkgrey: [169, 169, 169],
+    darkkhaki: [189, 183, 107],
+    darkmagenta: [139, 0, 139],
+    darkolivegreen: [85, 107, 47],
+    darkorange: [255, 140, 0],
+    darkorchid: [153, 50, 204],
+    darkred: [139, 0, 0],
+    darksalmon: [233, 150, 122],
+    darkseagreen: [143, 188, 143],
+    darkslateblue: [72, 61, 139],
+    darkslategray: [47, 79, 79],
+    darkslategrey: [47, 79, 79],
+    darkturquoise: [0, 206, 209],
+    darkviolet: [148, 0, 211],
+    deeppink: [255, 20, 147],
+    deepskyblue: [0, 191, 255],
+    dimgray: [105, 105, 105],
+    dimgrey: [105, 105, 105],
+    dodgerblue: [30, 144, 255],
+    firebrick: [178, 34, 34],
+    floralwhite: [255, 255, 240],
+    forestgreen: [34, 139, 34],
+    fuchsia: [255, 0, 255],
+    gainsboro: [220, 220, 220],
+    ghostwhite: [248, 248, 255],
+    gold: [255, 215, 0],
+    goldenrod: [218, 165, 32],
+    gray: [128, 128, 128],
+    green: [0, 128, 0],
+    greenyellow: [173, 255, 47],
+    grey: [128, 128, 128],
+    honeydew: [240, 255, 240],
+    hotpink: [255, 105, 180],
+    indianred: [205, 92, 92],
+    indigo: [75, 0, 130],
+    ivory: [255, 255, 240],
+    khaki: [240, 230, 140],
+    lavender: [230, 230, 250],
+    lavenderblush: [255, 240, 245],
+    lawngreen: [124, 252, 0],
+    lemonchiffon: [255, 250, 205],
+    lightblue: [173, 216, 230],
+    lightcoral: [240, 128, 128],
+    lightcyan: [224, 255, 255],
+    lightgoldenrodyellow: [250, 250, 210],
+    lightgray: [211, 211, 211],
+    lightgreen: [144, 238, 144],
+    lightgrey: [211, 211, 211],
+    lightpink: [255, 182, 193],
+    lightsalmon: [255, 160, 122],
+    lightseagreen: [32, 178, 170],
+    lightskyblue: [135, 206, 250],
+    lightslategray: [119, 136, 153],
+    lightslategrey: [119, 136, 153],
+    lightsteelblue: [176, 196, 222],
+    lightyellow: [255, 255, 224],
+    lime: [0, 255, 0],
+    limegreen: [50, 205, 50],
+    linen: [250, 240, 230],
+    magenta: [255, 0, 255],
+    maroon: [128, 0, 0],
+    mediumaquamarine: [102, 205, 170],
+    mediumblue: [0, 0, 205],
+    mediumorchid: [186, 85, 211],
+    mediumpurple: [147, 112, 219],
+    mediumseagreen: [60, 179, 113],
+    mediumslateblue: [123, 104, 238],
+    mediumspringgreen: [0, 250, 154],
+    mediumturquoise: [72, 209, 204],
+    mediumvioletred: [199, 21, 133],
+    midnightblue: [25, 25, 112],
+    mintcream: [245, 255, 250],
+    mistyrose: [255, 228, 225],
+    moccasin: [255, 228, 181],
+    navajowhite: [255, 222, 173],
+    navy: [0, 0, 128],
+    oldlace: [253, 245, 230],
+    olive: [128, 128, 0],
+    olivedrab: [107, 142, 35],
+    orange: [255, 165, 0],
+    orangered: [255, 69, 0],
+    orchid: [218, 112, 214],
+    palegoldenrod: [238, 232, 170],
+    palegreen: [152, 251, 152],
+    paleturquoise: [175, 238, 238],
+    palevioletred: [219, 112, 147],
+    papayawhip: [255, 239, 213],
+    peachpuff: [255, 218, 185],
+    peru: [205, 133, 63],
+    pink: [255, 192, 203],
+    plum: [221, 160, 203],
+    powderblue: [176, 224, 230],
+    purple: [128, 0, 128],
+    rebeccapurple: [102, 51, 153],
+    red: [255, 0, 0],
+    rosybrown: [188, 143, 143],
+    royalblue: [65, 105, 225],
+    saddlebrown: [139, 69, 19],
+    salmon: [250, 128, 114],
+    sandybrown: [244, 164, 96],
+    seagreen: [46, 139, 87],
+    seashell: [255, 245, 238],
+    sienna: [160, 82, 45],
+    silver: [192, 192, 192],
+    skyblue: [135, 206, 235],
+    slateblue: [106, 90, 205],
+    slategray: [119, 128, 144],
+    slategrey: [119, 128, 144],
+    snow: [255, 255, 250],
+    springgreen: [0, 255, 127],
+    steelblue: [70, 130, 180],
+    tan: [210, 180, 140],
+    teal: [0, 128, 128],
+    thistle: [216, 191, 216],
+    transparent: [255, 255, 255, 0],
+    tomato: [255, 99, 71],
+    turquoise: [64, 224, 208],
+    violet: [238, 130, 238],
+    wheat: [245, 222, 179],
+    white: [255, 255, 255],
+    whitesmoke: [245, 245, 245],
+    yellow: [255, 255, 0],
+    yellowgreen: [154, 205, 5],
+  },
+  RGB_REGEX = /rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)/;
+let animQueue: Array<Function> = [];
+
+const req =
+  (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame) ||
+  function (f) {
+    setTimeout(f, 60);
+  };
+/**
+ * @namespace Util
+ * @memberof Konva
+ */
+export const Util = {
+  /*
+   * cherry-picked utilities from underscore.js
+   */
+  _isElement(obj: any): obj is Element {
+    return !!(obj && obj.nodeType == 1);
+  },
+  _isFunction(obj: any) {
+    return !!(obj && obj.constructor && obj.call && obj.apply);
+  },
+  _isPlainObject(obj: any) {
+    return !!obj && obj.constructor === Object;
+  },
+  _isArray(obj: any): obj is Array<any> {
+    return Object.prototype.toString.call(obj) === OBJECT_ARRAY;
+  },
+  _isNumber(obj: any): obj is number {
+    return (
+      Object.prototype.toString.call(obj) === OBJECT_NUMBER &&
+      !isNaN(obj) &&
+      isFinite(obj)
+    );
+  },
+  _isString(obj: any): obj is string {
+    return Object.prototype.toString.call(obj) === OBJECT_STRING;
+  },
+  _isBoolean(obj: any): obj is boolean {
+    return Object.prototype.toString.call(obj) === OBJECT_BOOLEAN;
+  },
+  // arrays are objects too
+  isObject(val: any): val is object {
+    return val instanceof Object;
+  },
+  isValidSelector(selector: any) {
+    if (typeof selector !== 'string') {
+      return false;
+    }
+    const firstChar = selector[0];
+    return (
+      firstChar === '#' ||
+      firstChar === '.' ||
+      firstChar === firstChar.toUpperCase()
+    );
+  },
+  _sign(number: number) {
+    if (number === 0) {
+      // that is not what sign usually returns
+      // but that is what we need
+      return 1;
+    }
+    if (number > 0) {
+      return 1;
+    } else {
+      return -1;
+    }
+  },
+
+  requestAnimFrame(callback: Function) {
+    animQueue.push(callback);
+    if (animQueue.length === 1) {
+      req(function () {
+        const queue = animQueue;
+        animQueue = [];
+        queue.forEach(function (cb) {
+          cb();
+        });
+      });
+    }
+  },
+  createCanvasElement() {
+    ensureBrowser();
+    const canvas = document.createElement('canvas');
+    // on some environments canvas.style is readonly
+    try {
+      (canvas as any).style = canvas.style || {};
+    } catch (e) {}
+    return canvas;
+  },
+  createImageElement() {
+    ensureBrowser();
+    return document.createElement('img');
+  },
+  _isInDocument(el: any) {
+    while ((el = el.parentNode)) {
+      if (el == document) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  /*
+   * arg can be an image object or image data
+   */
+  _urlToImage(url: string, callback: Function) {
+    // if arg is a string, then it's a data url
+    const imageObj = Util.createImageElement();
+    imageObj.onload = function () {
+      callback(imageObj);
+    };
+    imageObj.src = url;
+  },
+  _rgbToHex(r: number, g: number, b: number) {
+    return ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+  },
+  _hexToRgb(hex: string): RGB {
+    hex = hex.replace(HASH, EMPTY_STRING);
+    const bigint = parseInt(hex, 16);
+    return {
+      r: (bigint >> 16) & 255,
+      g: (bigint >> 8) & 255,
+      b: bigint & 255,
+    };
+  },
+  /**
+   * return random hex color
+   * @method
+   * @memberof Konva.Util
+   * @example
+   * shape.fill(Konva.Util.getRandomColor());
+   */
+  getRandomColor() {
+    let randColor = ((Math.random() * 0xffffff) << 0).toString(16);
+    while (randColor.length < 6) {
+      randColor = ZERO + randColor;
+    }
+    return HASH + randColor;
+  },
+
+  /**
+   * get RGB components of a color
+   * @method
+   * @memberof Konva.Util
+   * @param {String} color
+   * @example
+   * // each of the following examples return {r:0, g:0, b:255}
+   * var rgb = Konva.Util.getRGB('blue');
+   * var rgb = Konva.Util.getRGB('#0000ff');
+   * var rgb = Konva.Util.getRGB('rgb(0,0,255)');
+   */
+  getRGB(color: string): RGB {
+    let rgb;
+    // color string
+    if (color in COLORS) {
+      rgb = COLORS[color as keyof typeof COLORS];
+      return {
+        r: rgb[0],
+        g: rgb[1],
+        b: rgb[2],
+      };
+    } else if (color[0] === HASH) {
+      // hex
+      return this._hexToRgb(color.substring(1));
+    } else if (color.substr(0, 4) === RGB_PAREN) {
+      // rgb string
+      rgb = RGB_REGEX.exec(color.replace(/ /g, '')) as RegExpExecArray;
+      return {
+        r: parseInt(rgb[1], 10),
+        g: parseInt(rgb[2], 10),
+        b: parseInt(rgb[3], 10),
+      };
+    } else {
+      // default
+      return {
+        r: 0,
+        g: 0,
+        b: 0,
+      };
+    }
+  },
+  // convert any color string to RGBA object
+  // from https://github.com/component/color-parser
+  colorToRGBA(str: string) {
+    str = str || 'black';
+    return (
+      Util._namedColorToRBA(str) ||
+      Util._hex3ColorToRGBA(str) ||
+      Util._hex4ColorToRGBA(str) ||
+      Util._hex6ColorToRGBA(str) ||
+      Util._hex8ColorToRGBA(str) ||
+      Util._rgbColorToRGBA(str) ||
+      Util._rgbaColorToRGBA(str) ||
+      Util._hslColorToRGBA(str)
+    );
+  },
+  // Parse named css color. Like "green"
+  _namedColorToRBA(str: string) {
+    const c = COLORS[str.toLowerCase() as keyof typeof COLORS];
+    if (!c) {
+      return null;
+    }
+    return {
+      r: c[0],
+      g: c[1],
+      b: c[2],
+      a: 1,
+    };
+  },
+  // Parse rgb(n, n, n)
+  _rgbColorToRGBA(str: string) {
+    if (str.indexOf('rgb(') === 0) {
+      str = str.match(/rgb\(([^)]+)\)/)![1];
+      const parts = str.split(/ *, */).map(Number);
+      return {
+        r: parts[0],
+        g: parts[1],
+        b: parts[2],
+        a: 1,
+      };
+    }
+  },
+  // Parse rgba(n, n, n, n)
+  _rgbaColorToRGBA(str: string) {
+    if (str.indexOf('rgba(') === 0) {
+      str = str.match(/rgba\(([^)]+)\)/)![1]!;
+      const parts = str.split(/ *, */).map((n, index) => {
+        if (n.slice(-1) === '%') {
+          return index === 3 ? parseInt(n) / 100 : (parseInt(n) / 100) * 255;
+        }
+        return Number(n);
+      });
+      return {
+        r: parts[0],
+        g: parts[1],
+        b: parts[2],
+        a: parts[3],
+      };
+    }
+  },
+  // Parse #nnnnnnnn
+  _hex8ColorToRGBA(str: string) {
+    if (str[0] === '#' && str.length === 9) {
+      return {
+        r: parseInt(str.slice(1, 3), 16),
+        g: parseInt(str.slice(3, 5), 16),
+        b: parseInt(str.slice(5, 7), 16),
+        a: parseInt(str.slice(7, 9), 16) / 0xff,
+      };
+    }
+  },
+  // Parse #nnnnnn
+  _hex6ColorToRGBA(str: string) {
+    if (str[0] === '#' && str.length === 7) {
+      return {
+        r: parseInt(str.slice(1, 3), 16),
+        g: parseInt(str.slice(3, 5), 16),
+        b: parseInt(str.slice(5, 7), 16),
+        a: 1,
+      };
+    }
+  },
+  // Parse #nnnn
+  _hex4ColorToRGBA(str: string) {
+    if (str[0] === '#' && str.length === 5) {
+      return {
+        r: parseInt(str[1] + str[1], 16),
+        g: parseInt(str[2] + str[2], 16),
+        b: parseInt(str[3] + str[3], 16),
+        a: parseInt(str[4] + str[4], 16) / 0xff,
+      };
+    }
+  },
+  // Parse #nnn
+  _hex3ColorToRGBA(str: string) {
+    if (str[0] === '#' && str.length === 4) {
+      return {
+        r: parseInt(str[1] + str[1], 16),
+        g: parseInt(str[2] + str[2], 16),
+        b: parseInt(str[3] + str[3], 16),
+        a: 1,
+      };
+    }
+  },
+  // Code adapted from https://github.com/Qix-/color-convert/blob/master/conversions.js#L244
+  _hslColorToRGBA(str: string) {
+    // Check hsl() format
+    if (/hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.test(str)) {
+      // Extract h, s, l
+      const [_, ...hsl] = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(str)!;
+
+      const h = Number(hsl[0]) / 360;
+      const s = Number(hsl[1]) / 100;
+      const l = Number(hsl[2]) / 100;
+
+      let t2;
+      let t3;
+      let val;
+
+      if (s === 0) {
+        val = l * 255;
+        return {
+          r: Math.round(val),
+          g: Math.round(val),
+          b: Math.round(val),
+          a: 1,
+        };
+      }
+
+      if (l < 0.5) {
+        t2 = l * (1 + s);
+      } else {
+        t2 = l + s - l * s;
+      }
+
+      const t1 = 2 * l - t2;
+
+      const rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++) {
+        t3 = h + (1 / 3) * -(i - 1);
+        if (t3 < 0) {
+          t3++;
+        }
+
+        if (t3 > 1) {
+          t3--;
+        }
+
+        if (6 * t3 < 1) {
+          val = t1 + (t2 - t1) * 6 * t3;
+        } else if (2 * t3 < 1) {
+          val = t2;
+        } else if (3 * t3 < 2) {
+          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+        } else {
+          val = t1;
+        }
+
+        rgb[i] = val * 255;
+      }
+
+      return {
+        r: Math.round(rgb[0]),
+        g: Math.round(rgb[1]),
+        b: Math.round(rgb[2]),
+        a: 1,
+      };
+    }
+  },
+  /**
+   * check intersection of two client rectangles
+   * @method
+   * @memberof Konva.Util
+   * @param {Object} r1 - { x, y, width, height } client rectangle
+   * @param {Object} r2 - { x, y, width, height } client rectangle
+   * @example
+   * const overlapping = Konva.Util.haveIntersection(shape1.getClientRect(), shape2.getClientRect());
+   */
+  haveIntersection(r1: IRect, r2: IRect) {
+    return !(
+      r2.x > r1.x + r1.width ||
+      r2.x + r2.width < r1.x ||
+      r2.y > r1.y + r1.height ||
+      r2.y + r2.height < r1.y
+    );
+  },
+  cloneObject<Any>(obj: Any): Any {
+    const retObj: any = {};
+    for (const key in obj) {
+      if (this._isPlainObject(obj[key])) {
+        retObj[key] = this.cloneObject(obj[key]);
+      } else if (this._isArray(obj[key])) {
+        retObj[key] = this.cloneArray(obj[key] as Array<any>);
+      } else {
+        retObj[key] = obj[key];
+      }
+    }
+    return retObj;
+  },
+  cloneArray(arr: Array<any>) {
+    return arr.slice(0);
+  },
+  degToRad(deg: number) {
+    return deg * PI_OVER_DEG180;
+  },
+  radToDeg(rad: number) {
+    return rad * DEG180_OVER_PI;
+  },
+  _degToRad(deg: number) {
+    Util.warn(
+      'Util._degToRad is removed. Please use public Util.degToRad instead.'
+    );
+    return Util.degToRad(deg);
+  },
+  _radToDeg(rad: number) {
+    Util.warn(
+      'Util._radToDeg is removed. Please use public Util.radToDeg instead.'
+    );
+    return Util.radToDeg(rad);
+  },
+  _getRotation(radians: number) {
+    return Konva.angleDeg ? Util.radToDeg(radians) : radians;
+  },
+  _capitalize(str: string) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  },
+  throw(str: string) {
+    throw new Error(KONVA_ERROR + str);
+  },
+  error(str: string) {
+    console.error(KONVA_ERROR + str);
+  },
+  warn(str: string) {
+    if (!Konva.showWarnings) {
+      return;
+    }
+    console.warn(KONVA_WARNING + str);
+  },
+  each(obj: object, func: Function) {
+    for (const key in obj) {
+      func(key, obj[key as keyof typeof obj]);
+    }
+  },
+  _inRange(val: number, left: number, right: number) {
+    return left <= val && val < right;
+  },
+  _getProjectionToSegment(x1, y1, x2, y2, x3, y3) {
+    let x, y, dist;
+
+    const pd2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
+    if (pd2 == 0) {
+      x = x1;
+      y = y1;
+      dist = (x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2);
+    } else {
+      const u = ((x3 - x1) * (x2 - x1) + (y3 - y1) * (y2 - y1)) / pd2;
+      if (u < 0) {
+        x = x1;
+        y = y1;
+        dist = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
+      } else if (u > 1.0) {
+        x = x2;
+        y = y2;
+        dist = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
+      } else {
+        x = x1 + u * (x2 - x1);
+        y = y1 + u * (y2 - y1);
+        dist = (x - x3) * (x - x3) + (y - y3) * (y - y3);
+      }
+    }
+    return [x, y, dist];
+  },
+  // line as array of points.
+  // line might be closed
+  _getProjectionToLine(pt: Vector2d, line: Array<Vector2d>, isClosed: boolean) {
+    const pc = Util.cloneObject(pt);
+    let dist = Number.MAX_VALUE;
+    line.forEach(function (p1, i) {
+      if (!isClosed && i === line.length - 1) {
+        return;
+      }
+      const p2 = line[(i + 1) % line.length];
+      const proj = Util._getProjectionToSegment(
+        p1.x,
+        p1.y,
+        p2.x,
+        p2.y,
+        pt.x,
+        pt.y
+      );
+      const px = proj[0],
+        py = proj[1],
+        pdist = proj[2];
+      if (pdist < dist) {
+        pc.x = px;
+        pc.y = py;
+        dist = pdist;
+      }
+    });
+    return pc;
+  },
+  _prepareArrayForTween(startArray, endArray, isClosed) {
+    const start: Vector2d[] = [],
+      end: Vector2d[] = [];
+    if (startArray.length > endArray.length) {
+      const temp = endArray;
+      endArray = startArray;
+      startArray = temp;
+    }
+    for (let n = 0; n < startArray.length; n += 2) {
+      start.push({
+        x: startArray[n],
+        y: startArray[n + 1],
+      });
+    }
+    for (let n = 0; n < endArray.length; n += 2) {
+      end.push({
+        x: endArray[n],
+        y: endArray[n + 1],
+      });
+    }
+
+    const newStart: number[] = [];
+    end.forEach(function (point) {
+      const pr = Util._getProjectionToLine(point, start, isClosed);
+      newStart.push(pr.x);
+      newStart.push(pr.y);
+    });
+    return newStart;
+  },
+  _prepareToStringify<T>(obj: any): T | null {
+    let desc;
+
+    obj.visitedByCircularReferenceRemoval = true;
+
+    for (const key in obj) {
+      if (
+        !(obj.hasOwnProperty(key) && obj[key] && typeof obj[key] == 'object')
+      ) {
+        continue;
+      }
+      desc = Object.getOwnPropertyDescriptor(obj, key);
+      if (
+        obj[key].visitedByCircularReferenceRemoval ||
+        Util._isElement(obj[key])
+      ) {
+        if (desc.configurable) {
+          delete obj[key];
+        } else {
+          return null;
+        }
+      } else if (Util._prepareToStringify(obj[key]) === null) {
+        if (desc.configurable) {
+          delete obj[key];
+        } else {
+          return null;
+        }
+      }
+    }
+
+    delete obj.visitedByCircularReferenceRemoval;
+
+    return obj;
+  },
+  // very simplified version of Object.assign
+  _assign<T, U>(target: T, source: U) {
+    for (const key in source) {
+      (target as any)[key] = source[key];
+    }
+    return target as T & U;
+  },
+  _getFirstPointerId(evt) {
+    if (!evt.touches) {
+      // try to use pointer id or fake id
+      return evt.pointerId || 999;
+    } else {
+      return evt.changedTouches[0].identifier;
+    }
+  },
+  releaseCanvas(...canvases: HTMLCanvasElement[]) {
+    if (!Konva.releaseCanvasOnDestroy) return;
+
+    canvases.forEach((c) => {
+      c.width = 0;
+      c.height = 0;
+    });
+  },
+  drawRoundedRectPath(
+    context: Context,
+    width: number,
+    height: number,
+    cornerRadius: number | number[]
+  ) {
+    // if negative dimensions, abs width/height and move rectangle
+    let xOrigin = width < 0 ? width : 0;
+    let yOrigin = height < 0 ? height : 0;
+    width = Math.abs(width);
+    height = Math.abs(height);
+    let topLeft = 0;
+    let topRight = 0;
+    let bottomLeft = 0;
+    let bottomRight = 0;
+    if (typeof cornerRadius === 'number') {
+      topLeft =
+        topRight =
+        bottomLeft =
+        bottomRight =
+          Math.min(cornerRadius, width / 2, height / 2);
+    } else {
+      topLeft = Math.min(cornerRadius[0] || 0, width / 2, height / 2);
+      topRight = Math.min(cornerRadius[1] || 0, width / 2, height / 2);
+      bottomRight = Math.min(cornerRadius[2] || 0, width / 2, height / 2);
+      bottomLeft = Math.min(cornerRadius[3] || 0, width / 2, height / 2);
+    }
+    context.moveTo(xOrigin + topLeft, yOrigin);
+    context.lineTo(xOrigin + width - topRight, yOrigin);
+    context.arc(
+      xOrigin + width - topRight,
+      yOrigin + topRight,
+      topRight,
+      (Math.PI * 3) / 2,
+      0,
+      false
+    );
+    context.lineTo(xOrigin + width, yOrigin + height - bottomRight);
+    context.arc(
+      xOrigin + width - bottomRight,
+      yOrigin + height - bottomRight,
+      bottomRight,
+      0,
+      Math.PI / 2,
+      false
+    );
+    context.lineTo(xOrigin + bottomLeft, yOrigin + height);
+    context.arc(
+      xOrigin + bottomLeft,
+      yOrigin + height - bottomLeft,
+      bottomLeft,
+      Math.PI / 2,
+      Math.PI,
+      false
+    );
+    context.lineTo(xOrigin, yOrigin + topLeft);
+    context.arc(
+      xOrigin + topLeft,
+      yOrigin + topLeft,
+      topLeft,
+      Math.PI,
+      (Math.PI * 3) / 2,
+      false
+    );
+  },
+  drawRoundedPolygonPath(
+    context: Context,
+    points: Vector2d[],
+    sides: number,
+    radius: number,
+    cornerRadius: number | number[]
+  ) {
+    radius = Math.abs(radius);
+    for (let i = 0; i < sides; i++) {
+      const prev = points[(i - 1 + sides) % sides];
+      const curr = points[i];
+      const next = points[(i + 1) % sides];
+      const vec1 = { x: curr.x - prev.x, y: curr.y - prev.y };
+      const vec2 = { x: next.x - curr.x, y: next.y - curr.y };
+      const len1 = Math.hypot(vec1.x, vec1.y);
+      const len2 = Math.hypot(vec2.x, vec2.y);
+      let currCornerRadius;
+      if (typeof cornerRadius === 'number') {
+        currCornerRadius = cornerRadius;
+      } else {
+        currCornerRadius = i < cornerRadius.length ? cornerRadius[i] : 0;
+      }
+      const maxCornerRadius = radius * Math.cos(Math.PI / sides);
+      // cornerRadius creates perfect circle at 1/2 radius
+      currCornerRadius =
+        maxCornerRadius * Math.min(1, (currCornerRadius / radius) * 2);
+      const normalVec1 = { x: vec1.x / len1, y: vec1.y / len1 };
+      const normalVec2 = { x: vec2.x / len2, y: vec2.y / len2 };
+      const p1 = {
+        x: curr.x - normalVec1.x * currCornerRadius,
+        y: curr.y - normalVec1.y * currCornerRadius,
+      };
+      const p2 = {
+        x: curr.x + normalVec2.x * currCornerRadius,
+        y: curr.y + normalVec2.y * currCornerRadius,
+      };
+      if (i === 0) {
+        context.moveTo(p1.x, p1.y);
+      } else {
+        context.lineTo(p1.x, p1.y);
+      }
+      context.arcTo(curr.x, curr.y, p2.x, p2.y, currCornerRadius);
+    }
+  },
+};