Initial commit

node_modules/konva/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Original work Copyright (C) 2011 - 2013 by Eric Rowell (KineticJS)
+Modified work Copyright (C) 2014 - present by Anton Lavrenov (Konva)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/konva/README.md

@@ -0,0 +1,194 @@
+<p align="center">
+  <img src="https://konvajs.org/android-chrome-192x192.png" alt="Konva logo" height="180" />
+</p>
+
+<h1 align="center">Konva</h1>
+
+[![Financial Contributors on Open Collective](https://opencollective.com/konva/all/badge.svg?label=financial+contributors)](https://opencollective.com/konva)
+[![npm version](https://badge.fury.io/js/konva.svg)](http://badge.fury.io/js/konva)
+[![Build Status](https://github.com/konvajs/konva/actions/workflows/test-browser.yml/badge.svg)](https://github.com/konvajs/konva/actions/workflows/test-browser.ym)
+[![Build Status](https://github.com/konvajs/konva/actions/workflows/test-node.yml/badge.svg)](https://github.com/konvajs/konva/actions/workflows/test-node.ym)[![CDNJS version](https://img.shields.io/cdnjs/v/konva.svg)](https://cdnjs.com/libraries/konva)
+
+Konva is an HTML5 Canvas JavaScript framework that enables high performance animations, transitions, node nesting, layering, filtering, caching, event handling for desktop and mobile applications, and much more.
+
+You can draw things onto the stage, add event listeners to them, move them, scale them, and rotate them independently from other shapes to support high performance animations, even if your application uses thousands of shapes. Served hot with a side of awesomeness.
+
+This repository began as a GitHub fork of [ericdrowell/KineticJS](https://github.com/ericdrowell/KineticJS).
+
+- **Visit:** The [Home Page](http://konvajs.org/) and follow on [Twitter](https://twitter.com/lavrton)
+- **Discover:** [Tutorials](http://konvajs.org/docs), [API Documentation](http://konvajs.org/api)
+- **Help:** [StackOverflow](http://stackoverflow.com/questions/tagged/konvajs), [Discord Chat](https://discord.gg/8FqZwVT)
+
+# Quick Look
+
+```html
+<script src="https://unpkg.com/konva@8/konva.min.js"></script>
+<div id="container"></div>
+<script>
+  var stage = new Konva.Stage({
+    container: 'container',
+    width: window.innerWidth,
+    height: window.innerHeight,
+  });
+
+  // add canvas element
+  var layer = new Konva.Layer();
+  stage.add(layer);
+
+  // create shape
+  var box = new Konva.Rect({
+    x: 50,
+    y: 50,
+    width: 100,
+    height: 50,
+    fill: '#00D2FF',
+    stroke: 'black',
+    strokeWidth: 4,
+    draggable: true,
+  });
+  layer.add(box);
+
+  // add cursor styling
+  box.on('mouseover', function () {
+    document.body.style.cursor = 'pointer';
+  });
+  box.on('mouseout', function () {
+    document.body.style.cursor = 'default';
+  });
+</script>
+```
+
+# Browsers support
+
+Konva works in all modern mobile and desktop browsers. A browser need to be capable to run javascript code from ES2015 spec. For older browsers you may need polyfills for missing functions.
+
+At the current moment `Konva` doesn't work in IE11 directly. To make it work you just need to provide some polyfills such as `Array.prototype.find`, `String.prototype.trimLeft`, `String.prototype.trimRight`, `Array.from`.
+
+# Loading and installing Konva
+
+Konva supports UMD loading. So you can use all possible variants to load the framework into your project:
+
+### Load Konva via classical `<script>` tag from CDN:
+
+```html
+<script src="https://unpkg.com/konva@8/konva.min.js"></script>
+```
+
+### Install with npm:
+
+```bash
+npm install konva --save
+```
+
+```javascript
+// The modern way (e.g. an ES6-style import for webpack, parcel)
+import Konva from 'konva';
+```
+
+#### Typescript usage
+
+Add DOM definitions into your `tsconfig.json`:
+
+```
+{
+  "compilerOptions": {
+    "lib": [
+        "es6",
+        "dom"
+    ]
+  }
+}
+```
+
+### 3 Minimal bundle
+
+```javascript
+import Konva from 'konva/lib/Core';
+// Now you have a Konva object with Stage, Layer, FastLayer, Group, Shape and some additional utils function.
+// Also core currently already have support for drag&drop and animations.
+// BUT there are no shapes (rect, circle, etc), no filters.
+
+// but you can simply add anything you need:
+import { Rect } from 'konva/lib/shapes/Rect';
+// importing a shape will automatically inject it into Konva object
+
+var rect1 = new Rect();
+// or:
+var shape = new Konva.Rect();
+
+// for filters you can use this:
+import { Blur } from 'konva/lib/filters/Blur';
+```
+
+### 4 NodeJS env
+
+In order to run `konva` in nodejs environment you also need to install `canvas` package manually. Konva will use it for 2d canvas API.
+
+```bash
+npm install konva canvas
+```
+
+### CommonJS modules
+
+By default `Konva` is delivered as ES modules. Some environments may automatically take CommonJS version of `Konva`. If it doesn't work for you, try to use `cmj` version explicitly:
+
+```js
+const Konva = require('konva/cmj').default;
+```
+
+# Backers
+
+- [myposter GmbH](https://www.myposter.de/)
+- [queue.gg](https://queue.gg/)
+
+# Change log
+
+See [CHANGELOG.md](https://github.com/konvajs/konva/blob/master/CHANGELOG.md).
+
+## Building the Konva Framework
+
+To make a full build run `npm run build`. The command will compile all typescript files, combine then into one bundle and run minifier.
+
+## Testing
+
+Konva uses Mocha for testing.
+
+- If you need run test only one time run `npm run test`.
+- While developing it is easy to use `npm start`. Just run it and go to [http://localhost:8080/test/runner.html](http://localhost:8080/test/runner.html). The watcher will rebuild the bundle on any change.
+
+Konva is covered with hundreds of tests and well over a thousand assertions.
+Konva uses TDD (test driven development) which means that every new feature or bug fix is accompanied with at least one new test.
+
+## Generate documentation
+
+Run `npx gulp api` which will build the documentation files and place them in the `api` folder.
+
+# Pull Requests
+
+I'd be happy to review any pull requests that may better the Konva project,
+in particular if you have a bug fix, enhancement, or a new shape (see `src/shapes` for examples). Before doing so, please first make sure that all of the tests pass (`gulp lint test`).
+
+## Contributors
+
+### Financial Contributors
+
+Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/konva/contribute)]
+
+#### Individuals
+
+<a href="https://opencollective.com/konva"><img src="https://opencollective.com/konva/individuals.svg?width=890"></a>
+
+#### Organizations
+
+Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/konva/contribute)]
+
+<a href="https://opencollective.com/konva/organization/0/website"><img src="https://opencollective.com/konva/organization/0/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/1/website"><img src="https://opencollective.com/konva/organization/1/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/2/website"><img src="https://opencollective.com/konva/organization/2/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/3/website"><img src="https://opencollective.com/konva/organization/3/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/4/website"><img src="https://opencollective.com/konva/organization/4/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/5/website"><img src="https://opencollective.com/konva/organization/5/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/6/website"><img src="https://opencollective.com/konva/organization/6/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/7/website"><img src="https://opencollective.com/konva/organization/7/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/8/website"><img src="https://opencollective.com/konva/organization/8/avatar.svg"></a>
+<a href="https://opencollective.com/konva/organization/9/website"><img src="https://opencollective.com/konva/organization/9/avatar.svg"></a>

node_modules/konva/cmj/Animation.d.ts

@@ -0,0 +1,24 @@
+import { Layer } from './Layer';
+import { IFrame, AnimationFn } from './types';
+export declare class Animation {
+    func: AnimationFn;
+    id: number;
+    layers: Layer[];
+    frame: IFrame;
+    constructor(func: AnimationFn, layers?: any);
+    setLayers(layers: any): this;
+    getLayers(): Layer[];
+    addLayer(layer: any): boolean;
+    isRunning(): boolean;
+    start(): this;
+    stop(): this;
+    _updateFrameObject(time: any): void;
+    static animations: any[];
+    static animIdCounter: number;
+    static animRunning: boolean;
+    static _addAnimation(anim: any): void;
+    static _removeAnimation(anim: any): void;
+    static _runFrames(): void;
+    static _animationLoop(): void;
+    static _handleAnimation(): void;
+}

node_modules/konva/cmj/Animation.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animation = void 0;
+const Global_1 = require("./Global");
+const Util_1 = require("./Util");
+var now = (function () {
+    if (Global_1.glob.performance && Global_1.glob.performance.now) {
+        return function () {
+            return Global_1.glob.performance.now();
+        };
+    }
+    return function () {
+        return new Date().getTime();
+    };
+})();
+class Animation {
+    constructor(func, layers) {
+        this.id = Animation.animIdCounter++;
+        this.frame = {
+            time: 0,
+            timeDiff: 0,
+            lastTime: now(),
+            frameRate: 0,
+        };
+        this.func = func;
+        this.setLayers(layers);
+    }
+    setLayers(layers) {
+        var lays = [];
+        if (!layers) {
+            lays = [];
+        }
+        else if (layers.length > 0) {
+            lays = layers;
+        }
+        else {
+            lays = [layers];
+        }
+        this.layers = lays;
+        return this;
+    }
+    getLayers() {
+        return this.layers;
+    }
+    addLayer(layer) {
+        var layers = this.layers, len = layers.length, n;
+        for (n = 0; n < len; n++) {
+            if (layers[n]._id === layer._id) {
+                return false;
+            }
+        }
+        this.layers.push(layer);
+        return true;
+    }
+    isRunning() {
+        var a = Animation, animations = a.animations, len = animations.length, n;
+        for (n = 0; n < len; n++) {
+            if (animations[n].id === this.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    start() {
+        this.stop();
+        this.frame.timeDiff = 0;
+        this.frame.lastTime = now();
+        Animation._addAnimation(this);
+        return this;
+    }
+    stop() {
+        Animation._removeAnimation(this);
+        return this;
+    }
+    _updateFrameObject(time) {
+        this.frame.timeDiff = time - this.frame.lastTime;
+        this.frame.lastTime = time;
+        this.frame.time += this.frame.timeDiff;
+        this.frame.frameRate = 1000 / this.frame.timeDiff;
+    }
+    static _addAnimation(anim) {
+        this.animations.push(anim);
+        this._handleAnimation();
+    }
+    static _removeAnimation(anim) {
+        var id = anim.id, animations = this.animations, len = animations.length, n;
+        for (n = 0; n < len; n++) {
+            if (animations[n].id === id) {
+                this.animations.splice(n, 1);
+                break;
+            }
+        }
+    }
+    static _runFrames() {
+        var layerHash = {}, animations = this.animations, anim, layers, func, n, i, layersLen, layer, key, needRedraw;
+        for (n = 0; n < animations.length; n++) {
+            anim = animations[n];
+            layers = anim.layers;
+            func = anim.func;
+            anim._updateFrameObject(now());
+            layersLen = layers.length;
+            if (func) {
+                needRedraw = func.call(anim, anim.frame) !== false;
+            }
+            else {
+                needRedraw = true;
+            }
+            if (!needRedraw) {
+                continue;
+            }
+            for (i = 0; i < layersLen; i++) {
+                layer = layers[i];
+                if (layer._id !== undefined) {
+                    layerHash[layer._id] = layer;
+                }
+            }
+        }
+        for (key in layerHash) {
+            if (!layerHash.hasOwnProperty(key)) {
+                continue;
+            }
+            layerHash[key].batchDraw();
+        }
+    }
+    static _animationLoop() {
+        var Anim = Animation;
+        if (Anim.animations.length) {
+            Anim._runFrames();
+            Util_1.Util.requestAnimFrame(Anim._animationLoop);
+        }
+        else {
+            Anim.animRunning = false;
+        }
+    }
+    static _handleAnimation() {
+        if (!this.animRunning) {
+            this.animRunning = true;
+            Util_1.Util.requestAnimFrame(this._animationLoop);
+        }
+    }
+}
+exports.Animation = Animation;
+Animation.animations = [];
+Animation.animIdCounter = 0;
+Animation.animRunning = false;

node_modules/konva/cmj/Canvas.d.ts

@@ -0,0 +1,32 @@
+import { Context } from './Context';
+interface ICanvasConfig {
+    width?: number;
+    height?: number;
+    pixelRatio?: number;
+}
+export declare class Canvas {
+    pixelRatio: number;
+    _canvas: HTMLCanvasElement;
+    context: Context;
+    width: number;
+    height: number;
+    isCache: boolean;
+    constructor(config: ICanvasConfig);
+    getContext(): Context;
+    getPixelRatio(): number;
+    setPixelRatio(pixelRatio: any): void;
+    setWidth(width: any): void;
+    setHeight(height: any): void;
+    getWidth(): number;
+    getHeight(): number;
+    setSize(width: any, height: any): void;
+    toDataURL(mimeType: any, quality: any): string;
+}
+export declare class SceneCanvas extends Canvas {
+    constructor(config?: ICanvasConfig);
+}
+export declare class HitCanvas extends Canvas {
+    hitCanvas: boolean;
+    constructor(config?: ICanvasConfig);
+}
+export {};

node_modules/konva/cmj/Canvas.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitCanvas = exports.SceneCanvas = exports.Canvas = void 0;
+const Util_1 = require("./Util");
+const Context_1 = require("./Context");
+const Global_1 = require("./Global");
+const Factory_1 = require("./Factory");
+const Validators_1 = require("./Validators");
+var _pixelRatio;
+function getDevicePixelRatio() {
+    if (_pixelRatio) {
+        return _pixelRatio;
+    }
+    var canvas = Util_1.Util.createCanvasElement();
+    var context = canvas.getContext('2d');
+    _pixelRatio = (function () {
+        var devicePixelRatio = Global_1.Konva._global.devicePixelRatio || 1, backingStoreRatio = context.webkitBackingStorePixelRatio ||
+            context.mozBackingStorePixelRatio ||
+            context.msBackingStorePixelRatio ||
+            context.oBackingStorePixelRatio ||
+            context.backingStorePixelRatio ||
+            1;
+        return devicePixelRatio / backingStoreRatio;
+    })();
+    return _pixelRatio;
+}
+class Canvas {
+    constructor(config) {
+        this.pixelRatio = 1;
+        this.width = 0;
+        this.height = 0;
+        this.isCache = false;
+        var conf = config || {};
+        var pixelRatio = conf.pixelRatio || Global_1.Konva.pixelRatio || getDevicePixelRatio();
+        this.pixelRatio = pixelRatio;
+        this._canvas = Util_1.Util.createCanvasElement();
+        this._canvas.style.padding = '0';
+        this._canvas.style.margin = '0';
+        this._canvas.style.border = '0';
+        this._canvas.style.background = 'transparent';
+        this._canvas.style.position = 'absolute';
+        this._canvas.style.top = '0';
+        this._canvas.style.left = '0';
+    }
+    getContext() {
+        return this.context;
+    }
+    getPixelRatio() {
+        return this.pixelRatio;
+    }
+    setPixelRatio(pixelRatio) {
+        var previousRatio = this.pixelRatio;
+        this.pixelRatio = pixelRatio;
+        this.setSize(this.getWidth() / previousRatio, this.getHeight() / previousRatio);
+    }
+    setWidth(width) {
+        this.width = this._canvas.width = width * this.pixelRatio;
+        this._canvas.style.width = width + 'px';
+        var pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+        _context.scale(pixelRatio, pixelRatio);
+    }
+    setHeight(height) {
+        this.height = this._canvas.height = height * this.pixelRatio;
+        this._canvas.style.height = height + 'px';
+        var pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+        _context.scale(pixelRatio, pixelRatio);
+    }
+    getWidth() {
+        return this.width;
+    }
+    getHeight() {
+        return this.height;
+    }
+    setSize(width, height) {
+        this.setWidth(width || 0);
+        this.setHeight(height || 0);
+    }
+    toDataURL(mimeType, quality) {
+        try {
+            return this._canvas.toDataURL(mimeType, quality);
+        }
+        catch (e) {
+            try {
+                return this._canvas.toDataURL();
+            }
+            catch (err) {
+                Util_1.Util.error('Unable to get data URL. ' +
+                    err.message +
+                    ' For more info read https://konvajs.org/docs/posts/Tainted_Canvas.html.');
+                return '';
+            }
+        }
+    }
+}
+exports.Canvas = Canvas;
+Factory_1.Factory.addGetterSetter(Canvas, 'pixelRatio', undefined, (0, Validators_1.getNumberValidator)());
+class SceneCanvas extends Canvas {
+    constructor(config = { width: 0, height: 0 }) {
+        super(config);
+        this.context = new Context_1.SceneContext(this);
+        this.setSize(config.width, config.height);
+    }
+}
+exports.SceneCanvas = SceneCanvas;
+class HitCanvas extends Canvas {
+    constructor(config = { width: 0, height: 0 }) {
+        super(config);
+        this.hitCanvas = true;
+        this.context = new Context_1.HitContext(this);
+        this.setSize(config.width, config.height);
+    }
+}
+exports.HitCanvas = HitCanvas;

node_modules/konva/cmj/Container.d.ts

@@ -0,0 +1,47 @@
+import { Node, NodeConfig } from './Node';
+import { GetSet, IRect } from './types';
+import { HitCanvas, SceneCanvas } from './Canvas';
+import { SceneContext } from './Context';
+export interface ContainerConfig extends NodeConfig {
+    clearBeforeDraw?: boolean;
+    clipFunc?: (ctx: SceneContext) => void;
+    clipX?: number;
+    clipY?: number;
+    clipWidth?: number;
+    clipHeight?: number;
+}
+export declare abstract class Container<ChildType extends Node = Node> extends Node<ContainerConfig> {
+    children: Array<ChildType> | undefined;
+    getChildren(filterFunc?: (item: Node) => boolean): ChildType[];
+    hasChildren(): boolean;
+    removeChildren(): this;
+    destroyChildren(): this;
+    abstract _validateAdd(node: Node): void;
+    add(...children: ChildType[]): this;
+    destroy(): this;
+    find<ChildNode extends Node = Node>(selector: any): Array<ChildNode>;
+    findOne<ChildNode extends Node = Node>(selector: string | Function): ChildNode;
+    _generalFind<ChildNode extends Node = Node>(selector: string | Function, findOne: boolean): ChildNode[];
+    private _descendants;
+    toObject(): any;
+    isAncestorOf(node: Node): boolean;
+    clone(obj?: any): this;
+    getAllIntersections(pos: any): any[];
+    _clearSelfAndDescendantCache(attr?: string): void;
+    _setChildrenIndices(): void;
+    drawScene(can?: SceneCanvas, top?: Node): this;
+    drawHit(can?: HitCanvas, top?: Node): this;
+    _drawChildren(drawMethod: any, canvas: any, top: any): void;
+    getClientRect(config?: {
+        skipTransform?: boolean;
+        skipShadow?: boolean;
+        skipStroke?: boolean;
+        relativeTo?: Container<Node>;
+    }): IRect;
+    clip: GetSet<IRect, this>;
+    clipX: GetSet<number, this>;
+    clipY: GetSet<number, this>;
+    clipWidth: GetSet<number, this>;
+    clipHeight: GetSet<number, this>;
+    clipFunc: GetSet<(ctx: CanvasRenderingContext2D, shape: Container<ChildType>) => void, this>;
+}

node_modules/konva/cmj/Container.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+const Factory_1 = require("./Factory");
+const Node_1 = require("./Node");
+const Validators_1 = require("./Validators");
+class Container extends Node_1.Node {
+    constructor() {
+        super(...arguments);
+        this.children = [];
+    }
+    getChildren(filterFunc) {
+        if (!filterFunc) {
+            return this.children || [];
+        }
+        const children = this.children || [];
+        var results = [];
+        children.forEach(function (child) {
+            if (filterFunc(child)) {
+                results.push(child);
+            }
+        });
+        return results;
+    }
+    hasChildren() {
+        return this.getChildren().length > 0;
+    }
+    removeChildren() {
+        this.getChildren().forEach((child) => {
+            child.parent = null;
+            child.index = 0;
+            child.remove();
+        });
+        this.children = [];
+        this._requestDraw();
+        return this;
+    }
+    destroyChildren() {
+        this.getChildren().forEach((child) => {
+            child.parent = null;
+            child.index = 0;
+            child.destroy();
+        });
+        this.children = [];
+        this._requestDraw();
+        return this;
+    }
+    add(...children) {
+        if (arguments.length > 1) {
+            for (var i = 0; i < arguments.length; i++) {
+                this.add(arguments[i]);
+            }
+            return this;
+        }
+        var child = children[0];
+        if (child.getParent()) {
+            child.moveTo(this);
+            return this;
+        }
+        this._validateAdd(child);
+        child.index = this.getChildren().length;
+        child.parent = this;
+        child._clearCaches();
+        this.getChildren().push(child);
+        this._fire('add', {
+            child: child,
+        });
+        this._requestDraw();
+        return this;
+    }
+    destroy() {
+        if (this.hasChildren()) {
+            this.destroyChildren();
+        }
+        super.destroy();
+        return this;
+    }
+    find(selector) {
+        return this._generalFind(selector, false);
+    }
+    findOne(selector) {
+        var result = this._generalFind(selector, true);
+        return result.length > 0 ? result[0] : undefined;
+    }
+    _generalFind(selector, findOne) {
+        var retArr = [];
+        this._descendants((node) => {
+            const valid = node._isMatch(selector);
+            if (valid) {
+                retArr.push(node);
+            }
+            if (valid && findOne) {
+                return true;
+            }
+            return false;
+        });
+        return retArr;
+    }
+    _descendants(fn) {
+        let shouldStop = false;
+        const children = this.getChildren();
+        for (const child of children) {
+            shouldStop = fn(child);
+            if (shouldStop) {
+                return true;
+            }
+            if (!child.hasChildren()) {
+                continue;
+            }
+            shouldStop = child._descendants(fn);
+            if (shouldStop) {
+                return true;
+            }
+        }
+        return false;
+    }
+    toObject() {
+        var obj = Node_1.Node.prototype.toObject.call(this);
+        obj.children = [];
+        this.getChildren().forEach((child) => {
+            obj.children.push(child.toObject());
+        });
+        return obj;
+    }
+    isAncestorOf(node) {
+        var parent = node.getParent();
+        while (parent) {
+            if (parent._id === this._id) {
+                return true;
+            }
+            parent = parent.getParent();
+        }
+        return false;
+    }
+    clone(obj) {
+        var node = Node_1.Node.prototype.clone.call(this, obj);
+        this.getChildren().forEach(function (no) {
+            node.add(no.clone());
+        });
+        return node;
+    }
+    getAllIntersections(pos) {
+        var arr = [];
+        this.find('Shape').forEach(function (shape) {
+            if (shape.isVisible() && shape.intersects(pos)) {
+                arr.push(shape);
+            }
+        });
+        return arr;
+    }
+    _clearSelfAndDescendantCache(attr) {
+        var _a;
+        super._clearSelfAndDescendantCache(attr);
+        if (this.isCached()) {
+            return;
+        }
+        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (node) {
+            node._clearSelfAndDescendantCache(attr);
+        });
+    }
+    _setChildrenIndices() {
+        var _a;
+        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child, n) {
+            child.index = n;
+        });
+        this._requestDraw();
+    }
+    drawScene(can, top) {
+        var layer = this.getLayer(), canvas = can || (layer && layer.getCanvas()), context = canvas && canvas.getContext(), cachedCanvas = this._getCanvasCache(), cachedSceneCanvas = cachedCanvas && cachedCanvas.scene;
+        var caching = canvas && canvas.isCache;
+        if (!this.isVisible() && !caching) {
+            return this;
+        }
+        if (cachedSceneCanvas) {
+            context.save();
+            var m = this.getAbsoluteTransform(top).getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            this._drawCachedSceneCanvas(context);
+            context.restore();
+        }
+        else {
+            this._drawChildren('drawScene', canvas, top);
+        }
+        return this;
+    }
+    drawHit(can, top) {
+        if (!this.shouldDrawHit(top)) {
+            return this;
+        }
+        var layer = this.getLayer(), canvas = can || (layer && layer.hitCanvas), context = canvas && canvas.getContext(), cachedCanvas = this._getCanvasCache(), cachedHitCanvas = cachedCanvas && cachedCanvas.hit;
+        if (cachedHitCanvas) {
+            context.save();
+            var m = this.getAbsoluteTransform(top).getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            this._drawCachedHitCanvas(context);
+            context.restore();
+        }
+        else {
+            this._drawChildren('drawHit', canvas, top);
+        }
+        return this;
+    }
+    _drawChildren(drawMethod, canvas, top) {
+        var _a;
+        var context = canvas && canvas.getContext(), clipWidth = this.clipWidth(), clipHeight = this.clipHeight(), clipFunc = this.clipFunc(), hasClip = (clipWidth && clipHeight) || clipFunc;
+        const selfCache = top === this;
+        if (hasClip) {
+            context.save();
+            var transform = this.getAbsoluteTransform(top);
+            var m = transform.getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            context.beginPath();
+            if (clipFunc) {
+                clipFunc.call(this, context, this);
+            }
+            else {
+                var clipX = this.clipX();
+                var clipY = this.clipY();
+                context.rect(clipX, clipY, clipWidth, clipHeight);
+            }
+            context.clip();
+            m = transform.copy().invert().getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+        }
+        var hasComposition = !selfCache &&
+            this.globalCompositeOperation() !== 'source-over' &&
+            drawMethod === 'drawScene';
+        if (hasComposition) {
+            context.save();
+            context._applyGlobalCompositeOperation(this);
+        }
+        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
+            child[drawMethod](canvas, top);
+        });
+        if (hasComposition) {
+            context.restore();
+        }
+        if (hasClip) {
+            context.restore();
+        }
+    }
+    getClientRect(config) {
+        var _a;
+        config = config || {};
+        var skipTransform = config.skipTransform;
+        var relativeTo = config.relativeTo;
+        var minX, minY, maxX, maxY;
+        var selfRect = {
+            x: Infinity,
+            y: Infinity,
+            width: 0,
+            height: 0,
+        };
+        var that = this;
+        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
+            if (!child.visible()) {
+                return;
+            }
+            var rect = child.getClientRect({
+                relativeTo: that,
+                skipShadow: config.skipShadow,
+                skipStroke: config.skipStroke,
+            });
+            if (rect.width === 0 && rect.height === 0) {
+                return;
+            }
+            if (minX === undefined) {
+                minX = rect.x;
+                minY = rect.y;
+                maxX = rect.x + rect.width;
+                maxY = rect.y + rect.height;
+            }
+            else {
+                minX = Math.min(minX, rect.x);
+                minY = Math.min(minY, rect.y);
+                maxX = Math.max(maxX, rect.x + rect.width);
+                maxY = Math.max(maxY, rect.y + rect.height);
+            }
+        });
+        var shapes = this.find('Shape');
+        var hasVisible = false;
+        for (var i = 0; i < shapes.length; i++) {
+            var shape = shapes[i];
+            if (shape._isVisible(this)) {
+                hasVisible = true;
+                break;
+            }
+        }
+        if (hasVisible && minX !== undefined) {
+            selfRect = {
+                x: minX,
+                y: minY,
+                width: maxX - minX,
+                height: maxY - minY,
+            };
+        }
+        else {
+            selfRect = {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0,
+            };
+        }
+        if (!skipTransform) {
+            return this._transformedRect(selfRect, relativeTo);
+        }
+        return selfRect;
+    }
+}
+exports.Container = Container;
+Factory_1.Factory.addComponentsGetterSetter(Container, 'clip', [
+    'x',
+    'y',
+    'width',
+    'height',
+]);
+Factory_1.Factory.addGetterSetter(Container, 'clipX', undefined, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Container, 'clipY', undefined, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Container, 'clipWidth', undefined, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Container, 'clipHeight', undefined, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Container, 'clipFunc');

node_modules/konva/cmj/Context.d.ts

@@ -0,0 +1,76 @@
+import { Canvas } from './Canvas';
+import { Shape } from './Shape';
+export declare class Context {
+    canvas: Canvas;
+    _context: CanvasRenderingContext2D;
+    traceArr: Array<String>;
+    constructor(canvas: Canvas);
+    fillShape(shape: Shape): void;
+    _fill(shape: any): void;
+    strokeShape(shape: Shape): void;
+    _stroke(shape: any): void;
+    fillStrokeShape(shape: Shape): void;
+    getTrace(relaxed?: any, rounded?: any): string;
+    clearTrace(): void;
+    _trace(str: any): void;
+    reset(): void;
+    getCanvas(): Canvas;
+    clear(bounds?: any): void;
+    _applyLineCap(shape: any): void;
+    _applyOpacity(shape: any): void;
+    _applyLineJoin(shape: Shape): void;
+    setAttr(attr: any, val: any): void;
+    arc(a0: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+    arcTo(a0: any, a1: any, a2: any, a3: any, a4: any): void;
+    beginPath(): void;
+    bezierCurveTo(a0: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+    clearRect(a0: any, a1: any, a2: any, a3: any): void;
+    clip(): void;
+    closePath(): void;
+    createImageData(a0: any, a1: any): ImageData;
+    createLinearGradient(a0: any, a1: any, a2: any, a3: any): CanvasGradient;
+    createPattern(a0: any, a1: any): CanvasPattern;
+    createRadialGradient(a0: any, a1: any, a2: any, a3: any, a4: any, a5: any): CanvasGradient;
+    drawImage(a0: CanvasImageSource, a1: number, a2: number, a3?: number, a4?: number, a5?: number, a6?: number, a7?: number, a8?: number): void;
+    ellipse(a0: number, a1: number, a2: number, a3: number, a4: number, a5: number, a6: number, a7?: boolean): void;
+    isPointInPath(x: any, y: any): boolean;
+    fill(path2d?: Path2D): void;
+    fillRect(x: any, y: any, width: any, height: any): void;
+    strokeRect(x: any, y: any, width: any, height: any): void;
+    fillText(text: string, x: number, y: number, maxWidth?: number): void;
+    measureText(text: any): TextMetrics;
+    getImageData(a0: any, a1: any, a2: any, a3: any): ImageData;
+    lineTo(a0: any, a1: any): void;
+    moveTo(a0: any, a1: any): void;
+    rect(a0: any, a1: any, a2: any, a3: any): void;
+    putImageData(a0: any, a1: any, a2: any): void;
+    quadraticCurveTo(a0: any, a1: any, a2: any, a3: any): void;
+    restore(): void;
+    rotate(a0: any): void;
+    save(): void;
+    scale(a0: any, a1: any): void;
+    setLineDash(a0: any): void;
+    getLineDash(): number[];
+    setTransform(a0: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+    stroke(path2d?: Path2D): void;
+    strokeText(a0: any, a1: any, a2: any, a3: any): void;
+    transform(a0: any, a1: any, a2: any, a3: any, a4: any, a5: any): void;
+    translate(a0: any, a1: any): void;
+    _enableTrace(): void;
+    _applyGlobalCompositeOperation(node: any): void;
+}
+export declare class SceneContext extends Context {
+    _fillColor(shape: Shape): void;
+    _fillPattern(shape: any): void;
+    _fillLinearGradient(shape: any): void;
+    _fillRadialGradient(shape: any): void;
+    _fill(shape: any): void;
+    _strokeLinearGradient(shape: any): void;
+    _stroke(shape: any): void;
+    _applyShadow(shape: any): void;
+}
+export declare class HitContext extends Context {
+    _fill(shape: any): void;
+    strokeShape(shape: Shape): void;
+    _stroke(shape: any): void;
+}

node_modules/konva/cmj/Context.js

@@ -0,0 +1,526 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitContext = exports.SceneContext = exports.Context = void 0;
+const Util_1 = require("./Util");
+const Global_1 = require("./Global");
+function simplifyArray(arr) {
+    var retArr = [], len = arr.length, util = Util_1.Util, n, val;
+    for (n = 0; n < len; n++) {
+        val = arr[n];
+        if (util._isNumber(val)) {
+            val = Math.round(val * 1000) / 1000;
+        }
+        else if (!util._isString(val)) {
+            val = val + '';
+        }
+        retArr.push(val);
+    }
+    return retArr;
+}
+var COMMA = ',', OPEN_PAREN = '(', CLOSE_PAREN = ')', OPEN_PAREN_BRACKET = '([', CLOSE_BRACKET_PAREN = '])', SEMICOLON = ';', DOUBLE_PAREN = '()', EQUALS = '=', CONTEXT_METHODS = [
+    'arc',
+    'arcTo',
+    'beginPath',
+    'bezierCurveTo',
+    'clearRect',
+    'clip',
+    'closePath',
+    'createLinearGradient',
+    'createPattern',
+    'createRadialGradient',
+    'drawImage',
+    'ellipse',
+    'fill',
+    'fillText',
+    'getImageData',
+    'createImageData',
+    'lineTo',
+    'moveTo',
+    'putImageData',
+    'quadraticCurveTo',
+    'rect',
+    'restore',
+    'rotate',
+    'save',
+    'scale',
+    'setLineDash',
+    'setTransform',
+    'stroke',
+    'strokeText',
+    'transform',
+    'translate',
+];
+var CONTEXT_PROPERTIES = [
+    'fillStyle',
+    'strokeStyle',
+    'shadowColor',
+    'shadowBlur',
+    'shadowOffsetX',
+    'shadowOffsetY',
+    'lineCap',
+    'lineDashOffset',
+    'lineJoin',
+    'lineWidth',
+    'miterLimit',
+    'font',
+    'textAlign',
+    'textBaseline',
+    'globalAlpha',
+    'globalCompositeOperation',
+    'imageSmoothingEnabled',
+];
+const traceArrMax = 100;
+class Context {
+    constructor(canvas) {
+        this.canvas = canvas;
+        this._context = canvas._canvas.getContext('2d');
+        if (Global_1.Konva.enableTrace) {
+            this.traceArr = [];
+            this._enableTrace();
+        }
+    }
+    fillShape(shape) {
+        if (shape.fillEnabled()) {
+            this._fill(shape);
+        }
+    }
+    _fill(shape) {
+    }
+    strokeShape(shape) {
+        if (shape.hasStroke()) {
+            this._stroke(shape);
+        }
+    }
+    _stroke(shape) {
+    }
+    fillStrokeShape(shape) {
+        if (shape.attrs.fillAfterStrokeEnabled) {
+            this.strokeShape(shape);
+            this.fillShape(shape);
+        }
+        else {
+            this.fillShape(shape);
+            this.strokeShape(shape);
+        }
+    }
+    getTrace(relaxed, rounded) {
+        var traceArr = this.traceArr, len = traceArr.length, str = '', n, trace, method, args;
+        for (n = 0; n < len; n++) {
+            trace = traceArr[n];
+            method = trace.method;
+            if (method) {
+                args = trace.args;
+                str += method;
+                if (relaxed) {
+                    str += DOUBLE_PAREN;
+                }
+                else {
+                    if (Util_1.Util._isArray(args[0])) {
+                        str += OPEN_PAREN_BRACKET + args.join(COMMA) + CLOSE_BRACKET_PAREN;
+                    }
+                    else {
+                        if (rounded) {
+                            args = args.map((a) => typeof a === 'number' ? Math.floor(a) : a);
+                        }
+                        str += OPEN_PAREN + args.join(COMMA) + CLOSE_PAREN;
+                    }
+                }
+            }
+            else {
+                str += trace.property;
+                if (!relaxed) {
+                    str += EQUALS + trace.val;
+                }
+            }
+            str += SEMICOLON;
+        }
+        return str;
+    }
+    clearTrace() {
+        this.traceArr = [];
+    }
+    _trace(str) {
+        var traceArr = this.traceArr, len;
+        traceArr.push(str);
+        len = traceArr.length;
+        if (len >= traceArrMax) {
+            traceArr.shift();
+        }
+    }
+    reset() {
+        var pixelRatio = this.getCanvas().getPixelRatio();
+        this.setTransform(1 * pixelRatio, 0, 0, 1 * pixelRatio, 0, 0);
+    }
+    getCanvas() {
+        return this.canvas;
+    }
+    clear(bounds) {
+        var canvas = this.getCanvas();
+        if (bounds) {
+            this.clearRect(bounds.x || 0, bounds.y || 0, bounds.width || 0, bounds.height || 0);
+        }
+        else {
+            this.clearRect(0, 0, canvas.getWidth() / canvas.pixelRatio, canvas.getHeight() / canvas.pixelRatio);
+        }
+    }
+    _applyLineCap(shape) {
+        var lineCap = shape.getLineCap();
+        if (lineCap) {
+            this.setAttr('lineCap', lineCap);
+        }
+    }
+    _applyOpacity(shape) {
+        var absOpacity = shape.getAbsoluteOpacity();
+        if (absOpacity !== 1) {
+            this.setAttr('globalAlpha', absOpacity);
+        }
+    }
+    _applyLineJoin(shape) {
+        var lineJoin = shape.attrs.lineJoin;
+        if (lineJoin) {
+            this.setAttr('lineJoin', lineJoin);
+        }
+    }
+    setAttr(attr, val) {
+        this._context[attr] = val;
+    }
+    arc(a0, a1, a2, a3, a4, a5) {
+        this._context.arc(a0, a1, a2, a3, a4, a5);
+    }
+    arcTo(a0, a1, a2, a3, a4) {
+        this._context.arcTo(a0, a1, a2, a3, a4);
+    }
+    beginPath() {
+        this._context.beginPath();
+    }
+    bezierCurveTo(a0, a1, a2, a3, a4, a5) {
+        this._context.bezierCurveTo(a0, a1, a2, a3, a4, a5);
+    }
+    clearRect(a0, a1, a2, a3) {
+        this._context.clearRect(a0, a1, a2, a3);
+    }
+    clip() {
+        this._context.clip();
+    }
+    closePath() {
+        this._context.closePath();
+    }
+    createImageData(a0, a1) {
+        var a = arguments;
+        if (a.length === 2) {
+            return this._context.createImageData(a0, a1);
+        }
+        else if (a.length === 1) {
+            return this._context.createImageData(a0);
+        }
+    }
+    createLinearGradient(a0, a1, a2, a3) {
+        return this._context.createLinearGradient(a0, a1, a2, a3);
+    }
+    createPattern(a0, a1) {
+        return this._context.createPattern(a0, a1);
+    }
+    createRadialGradient(a0, a1, a2, a3, a4, a5) {
+        return this._context.createRadialGradient(a0, a1, a2, a3, a4, a5);
+    }
+    drawImage(a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+        var a = arguments, _context = this._context;
+        if (a.length === 3) {
+            _context.drawImage(a0, a1, a2);
+        }
+        else if (a.length === 5) {
+            _context.drawImage(a0, a1, a2, a3, a4);
+        }
+        else if (a.length === 9) {
+            _context.drawImage(a0, a1, a2, a3, a4, a5, a6, a7, a8);
+        }
+    }
+    ellipse(a0, a1, a2, a3, a4, a5, a6, a7) {
+        this._context.ellipse(a0, a1, a2, a3, a4, a5, a6, a7);
+    }
+    isPointInPath(x, y) {
+        return this._context.isPointInPath(x, y);
+    }
+    fill(path2d) {
+        if (path2d) {
+            this._context.fill(path2d);
+        }
+        else {
+            this._context.fill();
+        }
+    }
+    fillRect(x, y, width, height) {
+        this._context.fillRect(x, y, width, height);
+    }
+    strokeRect(x, y, width, height) {
+        this._context.strokeRect(x, y, width, height);
+    }
+    fillText(text, x, y, maxWidth) {
+        if (maxWidth) {
+            this._context.fillText(text, x, y, maxWidth);
+        }
+        else {
+            this._context.fillText(text, x, y);
+        }
+    }
+    measureText(text) {
+        return this._context.measureText(text);
+    }
+    getImageData(a0, a1, a2, a3) {
+        return this._context.getImageData(a0, a1, a2, a3);
+    }
+    lineTo(a0, a1) {
+        this._context.lineTo(a0, a1);
+    }
+    moveTo(a0, a1) {
+        this._context.moveTo(a0, a1);
+    }
+    rect(a0, a1, a2, a3) {
+        this._context.rect(a0, a1, a2, a3);
+    }
+    putImageData(a0, a1, a2) {
+        this._context.putImageData(a0, a1, a2);
+    }
+    quadraticCurveTo(a0, a1, a2, a3) {
+        this._context.quadraticCurveTo(a0, a1, a2, a3);
+    }
+    restore() {
+        this._context.restore();
+    }
+    rotate(a0) {
+        this._context.rotate(a0);
+    }
+    save() {
+        this._context.save();
+    }
+    scale(a0, a1) {
+        this._context.scale(a0, a1);
+    }
+    setLineDash(a0) {
+        if (this._context.setLineDash) {
+            this._context.setLineDash(a0);
+        }
+        else if ('mozDash' in this._context) {
+            this._context['mozDash'] = a0;
+        }
+        else if ('webkitLineDash' in this._context) {
+            this._context['webkitLineDash'] = a0;
+        }
+    }
+    getLineDash() {
+        return this._context.getLineDash();
+    }
+    setTransform(a0, a1, a2, a3, a4, a5) {
+        this._context.setTransform(a0, a1, a2, a3, a4, a5);
+    }
+    stroke(path2d) {
+        if (path2d) {
+            this._context.stroke(path2d);
+        }
+        else {
+            this._context.stroke();
+        }
+    }
+    strokeText(a0, a1, a2, a3) {
+        this._context.strokeText(a0, a1, a2, a3);
+    }
+    transform(a0, a1, a2, a3, a4, a5) {
+        this._context.transform(a0, a1, a2, a3, a4, a5);
+    }
+    translate(a0, a1) {
+        this._context.translate(a0, a1);
+    }
+    _enableTrace() {
+        var that = this, len = CONTEXT_METHODS.length, origSetter = this.setAttr, n, args;
+        var func = function (methodName) {
+            var origMethod = that[methodName], ret;
+            that[methodName] = function () {
+                args = simplifyArray(Array.prototype.slice.call(arguments, 0));
+                ret = origMethod.apply(that, arguments);
+                that._trace({
+                    method: methodName,
+                    args: args,
+                });
+                return ret;
+            };
+        };
+        for (n = 0; n < len; n++) {
+            func(CONTEXT_METHODS[n]);
+        }
+        that.setAttr = function () {
+            origSetter.apply(that, arguments);
+            var prop = arguments[0];
+            var val = arguments[1];
+            if (prop === 'shadowOffsetX' ||
+                prop === 'shadowOffsetY' ||
+                prop === 'shadowBlur') {
+                val = val / this.canvas.getPixelRatio();
+            }
+            that._trace({
+                property: prop,
+                val: val,
+            });
+        };
+    }
+    _applyGlobalCompositeOperation(node) {
+        const op = node.attrs.globalCompositeOperation;
+        var def = !op || op === 'source-over';
+        if (!def) {
+            this.setAttr('globalCompositeOperation', op);
+        }
+    }
+}
+exports.Context = Context;
+CONTEXT_PROPERTIES.forEach(function (prop) {
+    Object.defineProperty(Context.prototype, prop, {
+        get() {
+            return this._context[prop];
+        },
+        set(val) {
+            this._context[prop] = val;
+        },
+    });
+});
+class SceneContext extends Context {
+    _fillColor(shape) {
+        var fill = shape.fill();
+        this.setAttr('fillStyle', fill);
+        shape._fillFunc(this);
+    }
+    _fillPattern(shape) {
+        this.setAttr('fillStyle', shape._getFillPattern());
+        shape._fillFunc(this);
+    }
+    _fillLinearGradient(shape) {
+        var grd = shape._getLinearGradient();
+        if (grd) {
+            this.setAttr('fillStyle', grd);
+            shape._fillFunc(this);
+        }
+    }
+    _fillRadialGradient(shape) {
+        var grd = shape._getRadialGradient();
+        if (grd) {
+            this.setAttr('fillStyle', grd);
+            shape._fillFunc(this);
+        }
+    }
+    _fill(shape) {
+        var hasColor = shape.fill(), fillPriority = shape.getFillPriority();
+        if (hasColor && fillPriority === 'color') {
+            this._fillColor(shape);
+            return;
+        }
+        var hasPattern = shape.getFillPatternImage();
+        if (hasPattern && fillPriority === 'pattern') {
+            this._fillPattern(shape);
+            return;
+        }
+        var hasLinearGradient = shape.getFillLinearGradientColorStops();
+        if (hasLinearGradient && fillPriority === 'linear-gradient') {
+            this._fillLinearGradient(shape);
+            return;
+        }
+        var hasRadialGradient = shape.getFillRadialGradientColorStops();
+        if (hasRadialGradient && fillPriority === 'radial-gradient') {
+            this._fillRadialGradient(shape);
+            return;
+        }
+        if (hasColor) {
+            this._fillColor(shape);
+        }
+        else if (hasPattern) {
+            this._fillPattern(shape);
+        }
+        else if (hasLinearGradient) {
+            this._fillLinearGradient(shape);
+        }
+        else if (hasRadialGradient) {
+            this._fillRadialGradient(shape);
+        }
+    }
+    _strokeLinearGradient(shape) {
+        var start = shape.getStrokeLinearGradientStartPoint(), end = shape.getStrokeLinearGradientEndPoint(), colorStops = shape.getStrokeLinearGradientColorStops(), grd = this.createLinearGradient(start.x, start.y, end.x, end.y);
+        if (colorStops) {
+            for (var n = 0; n < colorStops.length; n += 2) {
+                grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
+            this.setAttr('strokeStyle', grd);
+        }
+    }
+    _stroke(shape) {
+        var dash = shape.dash(), strokeScaleEnabled = shape.getStrokeScaleEnabled();
+        if (shape.hasStroke()) {
+            if (!strokeScaleEnabled) {
+                this.save();
+                var pixelRatio = this.getCanvas().getPixelRatio();
+                this.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+            }
+            this._applyLineCap(shape);
+            if (dash && shape.dashEnabled()) {
+                this.setLineDash(dash);
+                this.setAttr('lineDashOffset', shape.dashOffset());
+            }
+            this.setAttr('lineWidth', shape.strokeWidth());
+            if (!shape.getShadowForStrokeEnabled()) {
+                this.setAttr('shadowColor', 'rgba(0,0,0,0)');
+            }
+            var hasLinearGradient = shape.getStrokeLinearGradientColorStops();
+            if (hasLinearGradient) {
+                this._strokeLinearGradient(shape);
+            }
+            else {
+                this.setAttr('strokeStyle', shape.stroke());
+            }
+            shape._strokeFunc(this);
+            if (!strokeScaleEnabled) {
+                this.restore();
+            }
+        }
+    }
+    _applyShadow(shape) {
+        var _a, _b, _c;
+        var color = (_a = shape.getShadowRGBA()) !== null && _a !== void 0 ? _a : 'black', blur = (_b = shape.getShadowBlur()) !== null && _b !== void 0 ? _b : 5, offset = (_c = shape.getShadowOffset()) !== null && _c !== void 0 ? _c : {
+            x: 0,
+            y: 0,
+        }, scale = shape.getAbsoluteScale(), ratio = this.canvas.getPixelRatio(), scaleX = scale.x * ratio, scaleY = scale.y * ratio;
+        this.setAttr('shadowColor', color);
+        this.setAttr('shadowBlur', blur * Math.min(Math.abs(scaleX), Math.abs(scaleY)));
+        this.setAttr('shadowOffsetX', offset.x * scaleX);
+        this.setAttr('shadowOffsetY', offset.y * scaleY);
+    }
+}
+exports.SceneContext = SceneContext;
+class HitContext extends Context {
+    _fill(shape) {
+        this.save();
+        this.setAttr('fillStyle', shape.colorKey);
+        shape._fillFuncHit(this);
+        this.restore();
+    }
+    strokeShape(shape) {
+        if (shape.hasHitStroke()) {
+            this._stroke(shape);
+        }
+    }
+    _stroke(shape) {
+        if (shape.hasHitStroke()) {
+            var strokeScaleEnabled = shape.getStrokeScaleEnabled();
+            if (!strokeScaleEnabled) {
+                this.save();
+                var pixelRatio = this.getCanvas().getPixelRatio();
+                this.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+            }
+            this._applyLineCap(shape);
+            var hitStrokeWidth = shape.hitStrokeWidth();
+            var strokeWidth = hitStrokeWidth === 'auto' ? shape.strokeWidth() : hitStrokeWidth;
+            this.setAttr('lineWidth', strokeWidth);
+            this.setAttr('strokeStyle', shape.colorKey);
+            shape._strokeFuncHit(this);
+            if (!strokeScaleEnabled) {
+                this.restore();
+            }
+        }
+    }
+}
+exports.HitContext = HitContext;

node_modules/konva/cmj/Core.d.ts

@@ -0,0 +1,3 @@
+export { Konva } from './_CoreInternals';
+import { Konva } from './_CoreInternals';
+export default Konva;

node_modules/konva/cmj/Core.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Konva = void 0;
+var _CoreInternals_1 = require("./_CoreInternals");
+Object.defineProperty(exports, "Konva", { enumerable: true, get: function () { return _CoreInternals_1.Konva; } });
+const _CoreInternals_2 = require("./_CoreInternals");
+exports.default = _CoreInternals_2.Konva;

node_modules/konva/cmj/DragAndDrop.d.ts

@@ -0,0 +1,17 @@
+import { Node } from './Node';
+import { Vector2d } from './types';
+export declare const DD: {
+    readonly isDragging: boolean;
+    justDragged: boolean;
+    readonly node: Node<import("./Node").NodeConfig>;
+    _dragElements: Map<number, {
+        node: Node;
+        startPointerPos: Vector2d;
+        offset: Vector2d;
+        pointerId?: number;
+        dragStatus: 'ready' | 'dragging' | 'stopped';
+    }>;
+    _drag(evt: any): void;
+    _endDragBefore(evt?: any): void;
+    _endDragAfter(evt: any): void;
+};

node_modules/konva/cmj/DragAndDrop.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DD = void 0;
+const Global_1 = require("./Global");
+const Util_1 = require("./Util");
+exports.DD = {
+    get isDragging() {
+        var flag = false;
+        exports.DD._dragElements.forEach((elem) => {
+            if (elem.dragStatus === 'dragging') {
+                flag = true;
+            }
+        });
+        return flag;
+    },
+    justDragged: false,
+    get node() {
+        var node;
+        exports.DD._dragElements.forEach((elem) => {
+            node = elem.node;
+        });
+        return node;
+    },
+    _dragElements: new Map(),
+    _drag(evt) {
+        const nodesToFireEvents = [];
+        exports.DD._dragElements.forEach((elem, key) => {
+            const { node } = elem;
+            const stage = node.getStage();
+            stage.setPointersPositions(evt);
+            if (elem.pointerId === undefined) {
+                elem.pointerId = Util_1.Util._getFirstPointerId(evt);
+            }
+            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
+            if (!pos) {
+                return;
+            }
+            if (elem.dragStatus !== 'dragging') {
+                var dragDistance = node.dragDistance();
+                var distance = Math.max(Math.abs(pos.x - elem.startPointerPos.x), Math.abs(pos.y - elem.startPointerPos.y));
+                if (distance < dragDistance) {
+                    return;
+                }
+                node.startDrag({ evt });
+                if (!node.isDragging()) {
+                    return;
+                }
+            }
+            node._setDragPosition(evt, elem);
+            nodesToFireEvents.push(node);
+        });
+        nodesToFireEvents.forEach((node) => {
+            node.fire('dragmove', {
+                type: 'dragmove',
+                target: node,
+                evt: evt,
+            }, true);
+        });
+    },
+    _endDragBefore(evt) {
+        exports.DD._dragElements.forEach((elem) => {
+            const { node } = elem;
+            const stage = node.getStage();
+            if (evt) {
+                stage.setPointersPositions(evt);
+            }
+            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
+            if (!pos) {
+                return;
+            }
+            if (elem.dragStatus === 'dragging' || elem.dragStatus === 'stopped') {
+                exports.DD.justDragged = true;
+                Global_1.Konva._mouseListenClick = false;
+                Global_1.Konva._touchListenClick = false;
+                Global_1.Konva._pointerListenClick = false;
+                elem.dragStatus = 'stopped';
+            }
+            const drawNode = elem.node.getLayer() ||
+                (elem.node instanceof Global_1.Konva['Stage'] && elem.node);
+            if (drawNode) {
+                drawNode.batchDraw();
+            }
+        });
+    },
+    _endDragAfter(evt) {
+        exports.DD._dragElements.forEach((elem, key) => {
+            if (elem.dragStatus === 'stopped') {
+                elem.node.fire('dragend', {
+                    type: 'dragend',
+                    target: elem.node,
+                    evt: evt,
+                }, true);
+            }
+            if (elem.dragStatus !== 'dragging') {
+                exports.DD._dragElements.delete(key);
+            }
+        });
+    },
+};
+if (Global_1.Konva.isBrowser) {
+    window.addEventListener('mouseup', exports.DD._endDragBefore, true);
+    window.addEventListener('touchend', exports.DD._endDragBefore, true);
+    window.addEventListener('mousemove', exports.DD._drag);
+    window.addEventListener('touchmove', exports.DD._drag);
+    window.addEventListener('mouseup', exports.DD._endDragAfter, false);
+    window.addEventListener('touchend', exports.DD._endDragAfter, false);
+}

node_modules/konva/cmj/Factory.d.ts

@@ -0,0 +1,11 @@
+export declare const Factory: {
+    addGetterSetter(constructor: any, attr: any, def?: any, validator?: any, after?: any): void;
+    addGetter(constructor: any, attr: any, def?: any): void;
+    addSetter(constructor: any, attr: any, validator?: any, after?: any): void;
+    overWriteSetter(constructor: any, attr: any, validator?: any, after?: any): void;
+    addComponentsGetterSetter(constructor: any, attr: any, components: any, validator?: any, after?: any): void;
+    addOverloadedGetterSetter(constructor: any, attr: any): void;
+    addDeprecatedGetterSetter(constructor: any, attr: any, def: any, validator: any): void;
+    backCompat(constructor: any, methods: any): void;
+    afterSetFilter(): void;
+};

node_modules/konva/cmj/Factory.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+const Util_1 = require("./Util");
+const Validators_1 = require("./Validators");
+var GET = 'get', SET = 'set';
+exports.Factory = {
+    addGetterSetter(constructor, attr, def, validator, after) {
+        exports.Factory.addGetter(constructor, attr, def);
+        exports.Factory.addSetter(constructor, attr, validator, after);
+        exports.Factory.addOverloadedGetterSetter(constructor, attr);
+    },
+    addGetter(constructor, attr, def) {
+        var method = GET + Util_1.Util._capitalize(attr);
+        constructor.prototype[method] =
+            constructor.prototype[method] ||
+                function () {
+                    var val = this.attrs[attr];
+                    return val === undefined ? def : val;
+                };
+    },
+    addSetter(constructor, attr, validator, after) {
+        var method = SET + Util_1.Util._capitalize(attr);
+        if (!constructor.prototype[method]) {
+            exports.Factory.overWriteSetter(constructor, attr, validator, after);
+        }
+    },
+    overWriteSetter(constructor, attr, validator, after) {
+        var method = SET + Util_1.Util._capitalize(attr);
+        constructor.prototype[method] = function (val) {
+            if (validator && val !== undefined && val !== null) {
+                val = validator.call(this, val, attr);
+            }
+            this._setAttr(attr, val);
+            if (after) {
+                after.call(this);
+            }
+            return this;
+        };
+    },
+    addComponentsGetterSetter(constructor, attr, components, validator, after) {
+        var len = components.length, capitalize = Util_1.Util._capitalize, getter = GET + capitalize(attr), setter = SET + capitalize(attr), n, component;
+        constructor.prototype[getter] = function () {
+            var ret = {};
+            for (n = 0; n < len; n++) {
+                component = components[n];
+                ret[component] = this.getAttr(attr + capitalize(component));
+            }
+            return ret;
+        };
+        var basicValidator = (0, Validators_1.getComponentValidator)(components);
+        constructor.prototype[setter] = function (val) {
+            var oldVal = this.attrs[attr], key;
+            if (validator) {
+                val = validator.call(this, val);
+            }
+            if (basicValidator) {
+                basicValidator.call(this, val, attr);
+            }
+            for (key in val) {
+                if (!val.hasOwnProperty(key)) {
+                    continue;
+                }
+                this._setAttr(attr + capitalize(key), val[key]);
+            }
+            this._fireChangeEvent(attr, oldVal, val);
+            if (after) {
+                after.call(this);
+            }
+            return this;
+        };
+        exports.Factory.addOverloadedGetterSetter(constructor, attr);
+    },
+    addOverloadedGetterSetter(constructor, attr) {
+        var capitalizedAttr = Util_1.Util._capitalize(attr), setter = SET + capitalizedAttr, getter = GET + capitalizedAttr;
+        constructor.prototype[attr] = function () {
+            if (arguments.length) {
+                this[setter](arguments[0]);
+                return this;
+            }
+            return this[getter]();
+        };
+    },
+    addDeprecatedGetterSetter(constructor, attr, def, validator) {
+        Util_1.Util.error('Adding deprecated ' + attr);
+        var method = GET + Util_1.Util._capitalize(attr);
+        var message = attr +
+            ' property is deprecated and will be removed soon. Look at Konva change log for more information.';
+        constructor.prototype[method] = function () {
+            Util_1.Util.error(message);
+            var val = this.attrs[attr];
+            return val === undefined ? def : val;
+        };
+        exports.Factory.addSetter(constructor, attr, validator, function () {
+            Util_1.Util.error(message);
+        });
+        exports.Factory.addOverloadedGetterSetter(constructor, attr);
+    },
+    backCompat(constructor, methods) {
+        Util_1.Util.each(methods, function (oldMethodName, newMethodName) {
+            var method = constructor.prototype[newMethodName];
+            var oldGetter = GET + Util_1.Util._capitalize(oldMethodName);
+            var oldSetter = SET + Util_1.Util._capitalize(oldMethodName);
+            function deprecated() {
+                method.apply(this, arguments);
+                Util_1.Util.error('"' +
+                    oldMethodName +
+                    '" method is deprecated and will be removed soon. Use ""' +
+                    newMethodName +
+                    '" instead.');
+            }
+            constructor.prototype[oldMethodName] = deprecated;
+            constructor.prototype[oldGetter] = deprecated;
+            constructor.prototype[oldSetter] = deprecated;
+        });
+    },
+    afterSetFilter() {
+        this._filterUpToDate = false;
+    },
+};

node_modules/konva/cmj/FastLayer.d.ts

@@ -0,0 +1,4 @@
+import { Layer } from './Layer';
+export declare class FastLayer extends Layer {
+    constructor(attrs: any);
+}

node_modules/konva/cmj/FastLayer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastLayer = void 0;
+const Util_1 = require("./Util");
+const Layer_1 = require("./Layer");
+const Global_1 = require("./Global");
+class FastLayer extends Layer_1.Layer {
+    constructor(attrs) {
+        super(attrs);
+        this.listening(false);
+        Util_1.Util.warn('Konva.Fast layer is deprecated. Please use "new Konva.Layer({ listening: false })" instead.');
+    }
+}
+exports.FastLayer = FastLayer;
+FastLayer.prototype.nodeType = 'FastLayer';
+(0, Global_1._registerNode)(FastLayer);

node_modules/konva/cmj/Global.d.ts

@@ -0,0 +1,33 @@
+export declare const glob: any;
+export declare const Konva: {
+    _global: any;
+    version: string;
+    isBrowser: boolean;
+    isUnminified: boolean;
+    dblClickWindow: number;
+    getAngle(angle: number): number;
+    enableTrace: boolean;
+    pointerEventsEnabled: boolean;
+    autoDrawEnabled: boolean;
+    hitOnDragEnabled: boolean;
+    capturePointerEventsEnabled: boolean;
+    _mouseListenClick: boolean;
+    _touchListenClick: boolean;
+    _pointerListenClick: boolean;
+    _mouseInDblClickWindow: boolean;
+    _touchInDblClickWindow: boolean;
+    _pointerInDblClickWindow: boolean;
+    _mouseDblClickPointerId: any;
+    _touchDblClickPointerId: any;
+    _pointerDblClickPointerId: any;
+    pixelRatio: number;
+    dragDistance: number;
+    angleDeg: boolean;
+    showWarnings: boolean;
+    dragButtons: number[];
+    isDragging(): any;
+    isDragReady(): boolean;
+    document: any;
+    _injectGlobal(Konva: any): void;
+};
+export declare const _registerNode: (NodeClass: any) => void;

node_modules/konva/cmj/Global.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._registerNode = exports.Konva = exports.glob = void 0;
+var PI_OVER_180 = Math.PI / 180;
+function detectBrowser() {
+    return (typeof window !== 'undefined' &&
+        ({}.toString.call(window) === '[object Window]' ||
+            {}.toString.call(window) === '[object global]'));
+}
+exports.glob = typeof global !== 'undefined'
+    ? global
+    : typeof window !== 'undefined'
+        ? window
+        : typeof WorkerGlobalScope !== 'undefined'
+            ? self
+            : {};
+exports.Konva = {
+    _global: exports.glob,
+    version: '@@version',
+    isBrowser: detectBrowser(),
+    isUnminified: /param/.test(function (param) { }.toString()),
+    dblClickWindow: 400,
+    getAngle(angle) {
+        return exports.Konva.angleDeg ? angle * PI_OVER_180 : angle;
+    },
+    enableTrace: false,
+    pointerEventsEnabled: true,
+    autoDrawEnabled: true,
+    hitOnDragEnabled: false,
+    capturePointerEventsEnabled: false,
+    _mouseListenClick: false,
+    _touchListenClick: false,
+    _pointerListenClick: false,
+    _mouseInDblClickWindow: false,
+    _touchInDblClickWindow: false,
+    _pointerInDblClickWindow: false,
+    _mouseDblClickPointerId: null,
+    _touchDblClickPointerId: null,
+    _pointerDblClickPointerId: null,
+    pixelRatio: (typeof window !== 'undefined' && window.devicePixelRatio) || 1,
+    dragDistance: 3,
+    angleDeg: true,
+    showWarnings: true,
+    dragButtons: [0, 1],
+    isDragging() {
+        return exports.Konva['DD'].isDragging;
+    },
+    isDragReady() {
+        return !!exports.Konva['DD'].node;
+    },
+    document: exports.glob.document,
+    _injectGlobal(Konva) {
+        exports.glob.Konva = Konva;
+    },
+};
+const _registerNode = (NodeClass) => {
+    exports.Konva[NodeClass.prototype.getClassName()] = NodeClass;
+};
+exports._registerNode = _registerNode;
+exports.Konva._injectGlobal(exports.Konva);

node_modules/konva/cmj/Group.d.ts

@@ -0,0 +1,6 @@
+import { Container } from './Container';
+import { Node } from './Node';
+import { Shape } from './Shape';
+export declare class Group extends Container<Group | Shape> {
+    _validateAdd(child: Node): void;
+}

node_modules/konva/cmj/Group.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = void 0;
+const Util_1 = require("./Util");
+const Container_1 = require("./Container");
+const Global_1 = require("./Global");
+class Group extends Container_1.Container {
+    _validateAdd(child) {
+        var type = child.getType();
+        if (type !== 'Group' && type !== 'Shape') {
+            Util_1.Util.throw('You may only add groups and shapes to groups.');
+        }
+    }
+}
+exports.Group = Group;
+Group.prototype.nodeType = 'Group';
+(0, Global_1._registerNode)(Group);

node_modules/konva/cmj/Layer.d.ts

@@ -0,0 +1,60 @@
+import { Container, ContainerConfig } from './Container';
+import { Node } from './Node';
+import { SceneCanvas, HitCanvas } from './Canvas';
+import { Stage } from './Stage';
+import { GetSet, Vector2d } from './types';
+import { Group } from './Group';
+import { Shape } from './Shape';
+export interface LayerConfig extends ContainerConfig {
+    clearBeforeDraw?: boolean;
+    hitGraphEnabled?: boolean;
+    imageSmoothingEnabled?: boolean;
+}
+export declare class Layer extends Container<Group | Shape> {
+    canvas: SceneCanvas;
+    hitCanvas: HitCanvas;
+    _waitingForDraw: boolean;
+    constructor(config?: LayerConfig);
+    createPNGStream(): any;
+    getCanvas(): SceneCanvas;
+    getNativeCanvasElement(): HTMLCanvasElement;
+    getHitCanvas(): HitCanvas;
+    getContext(): import("./Context").Context;
+    clear(bounds?: any): this;
+    setZIndex(index: any): this;
+    moveToTop(): boolean;
+    moveUp(): boolean;
+    moveDown(): boolean;
+    moveToBottom(): boolean;
+    getLayer(): this;
+    remove(): this;
+    getStage(): Stage;
+    setSize({ width, height }: {
+        width: any;
+        height: any;
+    }): this;
+    _validateAdd(child: any): void;
+    _toKonvaCanvas(config: any): any;
+    _checkVisibility(): void;
+    _setSmoothEnabled(): void;
+    getWidth(): number;
+    setWidth(): void;
+    getHeight(): number;
+    setHeight(): void;
+    batchDraw(): this;
+    getIntersection(pos: Vector2d): Shape<import("./Shape").ShapeConfig>;
+    _getIntersection(pos: Vector2d): {
+        shape?: Shape;
+        antialiased?: boolean;
+    };
+    drawScene(can?: SceneCanvas, top?: Node): this;
+    drawHit(can?: HitCanvas, top?: Node): this;
+    enableHitGraph(): this;
+    disableHitGraph(): this;
+    setHitGraphEnabled(val: any): void;
+    getHitGraphEnabled(val: any): boolean;
+    toggleHitCanvas(): void;
+    hitGraphEnabled: GetSet<boolean, this>;
+    clearBeforeDraw: GetSet<boolean, this>;
+    imageSmoothingEnabled: GetSet<boolean, this>;
+}

node_modules/konva/cmj/Layer.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layer = void 0;
+const Util_1 = require("./Util");
+const Container_1 = require("./Container");
+const Node_1 = require("./Node");
+const Factory_1 = require("./Factory");
+const Canvas_1 = require("./Canvas");
+const Validators_1 = require("./Validators");
+const Shape_1 = require("./Shape");
+const Global_1 = require("./Global");
+var HASH = '#', BEFORE_DRAW = 'beforeDraw', DRAW = 'draw', INTERSECTION_OFFSETS = [
+    { x: 0, y: 0 },
+    { x: -1, y: -1 },
+    { x: 1, y: -1 },
+    { x: 1, y: 1 },
+    { x: -1, y: 1 },
+], INTERSECTION_OFFSETS_LEN = INTERSECTION_OFFSETS.length;
+class Layer extends Container_1.Container {
+    constructor(config) {
+        super(config);
+        this.canvas = new Canvas_1.SceneCanvas();
+        this.hitCanvas = new Canvas_1.HitCanvas({
+            pixelRatio: 1,
+        });
+        this._waitingForDraw = false;
+        this.on('visibleChange.konva', this._checkVisibility);
+        this._checkVisibility();
+        this.on('imageSmoothingEnabledChange.konva', this._setSmoothEnabled);
+        this._setSmoothEnabled();
+    }
+    createPNGStream() {
+        const c = this.canvas._canvas;
+        return c.createPNGStream();
+    }
+    getCanvas() {
+        return this.canvas;
+    }
+    getNativeCanvasElement() {
+        return this.canvas._canvas;
+    }
+    getHitCanvas() {
+        return this.hitCanvas;
+    }
+    getContext() {
+        return this.getCanvas().getContext();
+    }
+    clear(bounds) {
+        this.getContext().clear(bounds);
+        this.getHitCanvas().getContext().clear(bounds);
+        return this;
+    }
+    setZIndex(index) {
+        super.setZIndex(index);
+        var stage = this.getStage();
+        if (stage && stage.content) {
+            stage.content.removeChild(this.getNativeCanvasElement());
+            if (index < stage.children.length - 1) {
+                stage.content.insertBefore(this.getNativeCanvasElement(), stage.children[index + 1].getCanvas()._canvas);
+            }
+            else {
+                stage.content.appendChild(this.getNativeCanvasElement());
+            }
+        }
+        return this;
+    }
+    moveToTop() {
+        Node_1.Node.prototype.moveToTop.call(this);
+        var stage = this.getStage();
+        if (stage && stage.content) {
+            stage.content.removeChild(this.getNativeCanvasElement());
+            stage.content.appendChild(this.getNativeCanvasElement());
+        }
+        return true;
+    }
+    moveUp() {
+        var moved = Node_1.Node.prototype.moveUp.call(this);
+        if (!moved) {
+            return false;
+        }
+        var stage = this.getStage();
+        if (!stage || !stage.content) {
+            return false;
+        }
+        stage.content.removeChild(this.getNativeCanvasElement());
+        if (this.index < stage.children.length - 1) {
+            stage.content.insertBefore(this.getNativeCanvasElement(), stage.children[this.index + 1].getCanvas()._canvas);
+        }
+        else {
+            stage.content.appendChild(this.getNativeCanvasElement());
+        }
+        return true;
+    }
+    moveDown() {
+        if (Node_1.Node.prototype.moveDown.call(this)) {
+            var stage = this.getStage();
+            if (stage) {
+                var children = stage.children;
+                if (stage.content) {
+                    stage.content.removeChild(this.getNativeCanvasElement());
+                    stage.content.insertBefore(this.getNativeCanvasElement(), children[this.index + 1].getCanvas()._canvas);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    moveToBottom() {
+        if (Node_1.Node.prototype.moveToBottom.call(this)) {
+            var stage = this.getStage();
+            if (stage) {
+                var children = stage.children;
+                if (stage.content) {
+                    stage.content.removeChild(this.getNativeCanvasElement());
+                    stage.content.insertBefore(this.getNativeCanvasElement(), children[1].getCanvas()._canvas);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    getLayer() {
+        return this;
+    }
+    remove() {
+        var _canvas = this.getNativeCanvasElement();
+        Node_1.Node.prototype.remove.call(this);
+        if (_canvas && _canvas.parentNode && Util_1.Util._isInDocument(_canvas)) {
+            _canvas.parentNode.removeChild(_canvas);
+        }
+        return this;
+    }
+    getStage() {
+        return this.parent;
+    }
+    setSize({ width, height }) {
+        this.canvas.setSize(width, height);
+        this.hitCanvas.setSize(width, height);
+        this._setSmoothEnabled();
+        return this;
+    }
+    _validateAdd(child) {
+        var type = child.getType();
+        if (type !== 'Group' && type !== 'Shape') {
+            Util_1.Util.throw('You may only add groups and shapes to a layer.');
+        }
+    }
+    _toKonvaCanvas(config) {
+        config = config || {};
+        config.width = config.width || this.getWidth();
+        config.height = config.height || this.getHeight();
+        config.x = config.x !== undefined ? config.x : this.x();
+        config.y = config.y !== undefined ? config.y : this.y();
+        return Node_1.Node.prototype._toKonvaCanvas.call(this, config);
+    }
+    _checkVisibility() {
+        const visible = this.visible();
+        if (visible) {
+            this.canvas._canvas.style.display = 'block';
+        }
+        else {
+            this.canvas._canvas.style.display = 'none';
+        }
+    }
+    _setSmoothEnabled() {
+        this.getContext()._context.imageSmoothingEnabled =
+            this.imageSmoothingEnabled();
+    }
+    getWidth() {
+        if (this.parent) {
+            return this.parent.width();
+        }
+    }
+    setWidth() {
+        Util_1.Util.warn('Can not change width of layer. Use "stage.width(value)" function instead.');
+    }
+    getHeight() {
+        if (this.parent) {
+            return this.parent.height();
+        }
+    }
+    setHeight() {
+        Util_1.Util.warn('Can not change height of layer. Use "stage.height(value)" function instead.');
+    }
+    batchDraw() {
+        if (!this._waitingForDraw) {
+            this._waitingForDraw = true;
+            Util_1.Util.requestAnimFrame(() => {
+                this.draw();
+                this._waitingForDraw = false;
+            });
+        }
+        return this;
+    }
+    getIntersection(pos) {
+        if (!this.isListening() || !this.isVisible()) {
+            return null;
+        }
+        var spiralSearchDistance = 1;
+        var continueSearch = false;
+        while (true) {
+            for (let i = 0; i < INTERSECTION_OFFSETS_LEN; i++) {
+                const intersectionOffset = INTERSECTION_OFFSETS[i];
+                const obj = this._getIntersection({
+                    x: pos.x + intersectionOffset.x * spiralSearchDistance,
+                    y: pos.y + intersectionOffset.y * spiralSearchDistance,
+                });
+                const shape = obj.shape;
+                if (shape) {
+                    return shape;
+                }
+                continueSearch = !!obj.antialiased;
+                if (!obj.antialiased) {
+                    break;
+                }
+            }
+            if (continueSearch) {
+                spiralSearchDistance += 1;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    _getIntersection(pos) {
+        const ratio = this.hitCanvas.pixelRatio;
+        const p = this.hitCanvas.context.getImageData(Math.round(pos.x * ratio), Math.round(pos.y * ratio), 1, 1).data;
+        const p3 = p[3];
+        if (p3 === 255) {
+            const colorKey = Util_1.Util._rgbToHex(p[0], p[1], p[2]);
+            const shape = Shape_1.shapes[HASH + colorKey];
+            if (shape) {
+                return {
+                    shape: shape,
+                };
+            }
+            return {
+                antialiased: true,
+            };
+        }
+        else if (p3 > 0) {
+            return {
+                antialiased: true,
+            };
+        }
+        return {};
+    }
+    drawScene(can, top) {
+        var layer = this.getLayer(), canvas = can || (layer && layer.getCanvas());
+        this._fire(BEFORE_DRAW, {
+            node: this,
+        });
+        if (this.clearBeforeDraw()) {
+            canvas.getContext().clear();
+        }
+        Container_1.Container.prototype.drawScene.call(this, canvas, top);
+        this._fire(DRAW, {
+            node: this,
+        });
+        return this;
+    }
+    drawHit(can, top) {
+        var layer = this.getLayer(), canvas = can || (layer && layer.hitCanvas);
+        if (layer && layer.clearBeforeDraw()) {
+            layer.getHitCanvas().getContext().clear();
+        }
+        Container_1.Container.prototype.drawHit.call(this, canvas, top);
+        return this;
+    }
+    enableHitGraph() {
+        this.hitGraphEnabled(true);
+        return this;
+    }
+    disableHitGraph() {
+        this.hitGraphEnabled(false);
+        return this;
+    }
+    setHitGraphEnabled(val) {
+        Util_1.Util.warn('hitGraphEnabled method is deprecated. Please use layer.listening() instead.');
+        this.listening(val);
+    }
+    getHitGraphEnabled(val) {
+        Util_1.Util.warn('hitGraphEnabled method is deprecated. Please use layer.listening() instead.');
+        return this.listening();
+    }
+    toggleHitCanvas() {
+        if (!this.parent || !this.parent['content']) {
+            return;
+        }
+        var parent = this.parent;
+        var added = !!this.hitCanvas._canvas.parentNode;
+        if (added) {
+            parent.content.removeChild(this.hitCanvas._canvas);
+        }
+        else {
+            parent.content.appendChild(this.hitCanvas._canvas);
+        }
+    }
+}
+exports.Layer = Layer;
+Layer.prototype.nodeType = 'Layer';
+(0, Global_1._registerNode)(Layer);
+Factory_1.Factory.addGetterSetter(Layer, 'imageSmoothingEnabled', true);
+Factory_1.Factory.addGetterSetter(Layer, 'clearBeforeDraw', true);
+Factory_1.Factory.addGetterSetter(Layer, 'hitGraphEnabled', true, (0, Validators_1.getBooleanValidator)());

node_modules/konva/cmj/Node.d.ts

@@ -0,0 +1,318 @@
+import { Transform } from './Util';
+import { SceneCanvas, Canvas } from './Canvas';
+import { Container } from './Container';
+import { GetSet, Vector2d, IRect } from './types';
+import { Stage } from './Stage';
+import { Context } from './Context';
+import { Shape } from './Shape';
+import { Layer } from './Layer';
+export declare type Filter = (this: Node, imageData: ImageData) => void;
+declare type globalCompositeOperationType = '' | 'source-over' | 'source-in' | 'source-out' | 'source-atop' | 'destination-over' | 'destination-in' | 'destination-out' | 'destination-atop' | 'lighter' | 'copy' | 'xor' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
+export interface NodeConfig {
+    [index: string]: any;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    visible?: boolean;
+    listening?: boolean;
+    id?: string;
+    name?: string;
+    opacity?: Number;
+    scale?: Vector2d;
+    scaleX?: number;
+    scaleY?: number;
+    rotation?: number;
+    rotationDeg?: number;
+    offset?: Vector2d;
+    offsetX?: number;
+    offsetY?: number;
+    draggable?: boolean;
+    dragDistance?: number;
+    dragBoundFunc?: (this: Node, pos: Vector2d) => Vector2d;
+    preventDefault?: boolean;
+    globalCompositeOperation?: globalCompositeOperationType;
+    filters?: Array<Filter>;
+}
+declare type NodeEventMap = GlobalEventHandlersEventMap & {
+    [index: string]: any;
+};
+export interface KonvaEventObject<EventType> {
+    type: string;
+    target: Shape | Stage;
+    evt: EventType;
+    currentTarget: Node;
+    cancelBubble: boolean;
+    child?: Node;
+}
+export declare type KonvaEventListener<This, EventType> = (this: This, ev: KonvaEventObject<EventType>) => void;
+export declare abstract class Node<Config extends NodeConfig = NodeConfig> {
+    _id: number;
+    eventListeners: {
+        [index: string]: Array<{
+            name: string;
+            handler: Function;
+        }>;
+    };
+    attrs: any;
+    index: number;
+    _allEventListeners: null | Array<Function>;
+    parent: Container<Node> | null;
+    _cache: Map<string, any>;
+    _attachedDepsListeners: Map<string, boolean>;
+    _lastPos: Vector2d;
+    _attrsAffectingSize: string[];
+    _batchingTransformChange: boolean;
+    _needClearTransformCache: boolean;
+    _filterUpToDate: boolean;
+    _isUnderCache: boolean;
+    nodeType: string;
+    className: string;
+    _dragEventId: number | null;
+    _shouldFireChangeEvents: boolean;
+    constructor(config?: Config);
+    hasChildren(): boolean;
+    _clearCache(attr?: string): void;
+    _getCache(attr: string, privateGetter: Function): any;
+    _calculate(name: string, deps: Array<string>, getter: Function): any;
+    _getCanvasCache(): any;
+    _clearSelfAndDescendantCache(attr?: string): void;
+    clearCache(): this;
+    cache(config?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        drawBorder?: boolean;
+        offset?: number;
+        pixelRatio?: number;
+        imageSmoothingEnabled?: boolean;
+        hitCanvasPixelRatio?: number;
+    }): this;
+    isCached(): boolean;
+    abstract drawScene(canvas?: Canvas, top?: Node): void;
+    abstract drawHit(canvas?: Canvas, top?: Node): void;
+    getClientRect(config?: {
+        skipTransform?: boolean;
+        skipShadow?: boolean;
+        skipStroke?: boolean;
+        relativeTo?: Container<Node>;
+    }): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    _transformedRect(rect: IRect, top: Node): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    _drawCachedSceneCanvas(context: Context): void;
+    _drawCachedHitCanvas(context: Context): void;
+    _getCachedSceneCanvas(): any;
+    on<K extends keyof NodeEventMap>(evtStr: K, handler: KonvaEventListener<this, NodeEventMap[K]>): any;
+    off(evtStr?: string, callback?: Function): this;
+    dispatchEvent(evt: any): this;
+    addEventListener(type: string, handler: (e: Event) => void): this;
+    removeEventListener(type: string): this;
+    _delegate(event: string, selector: string, handler: (e: Event) => void): void;
+    remove(): this;
+    _clearCaches(): void;
+    _remove(): void;
+    destroy(): this;
+    getAttr(attr: string): any;
+    getAncestors(): Node<NodeConfig>[];
+    getAttrs(): any;
+    setAttrs(config: any): this;
+    isListening(): any;
+    _isListening(relativeTo?: Node): boolean;
+    isVisible(): any;
+    _isVisible(relativeTo?: Node): boolean;
+    shouldDrawHit(top?: Node, skipDragCheck?: boolean): boolean;
+    show(): this;
+    hide(): this;
+    getZIndex(): number;
+    getAbsoluteZIndex(): number;
+    getDepth(): number;
+    _batchTransformChanges(func: any): void;
+    setPosition(pos: Vector2d): this;
+    getPosition(): {
+        x: number;
+        y: number;
+    };
+    getRelativePointerPosition(): {
+        x: number;
+        y: number;
+    };
+    getAbsolutePosition(top?: Node): {
+        x: number;
+        y: number;
+    };
+    setAbsolutePosition(pos: Vector2d): this;
+    _setTransform(trans: any): void;
+    _clearTransform(): {
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        offsetX: number;
+        offsetY: number;
+        skewX: number;
+        skewY: number;
+    };
+    move(change: Vector2d): this;
+    _eachAncestorReverse(func: any, top: any): void;
+    rotate(theta: number): this;
+    moveToTop(): boolean;
+    moveUp(): boolean;
+    moveDown(): boolean;
+    moveToBottom(): boolean;
+    setZIndex(zIndex: any): this;
+    getAbsoluteOpacity(): any;
+    _getAbsoluteOpacity(): number;
+    moveTo(newContainer: any): this;
+    toObject(): any;
+    toJSON(): string;
+    getParent(): Container<Node<NodeConfig>>;
+    findAncestors(selector: string, includeSelf?: boolean, stopNode?: Node): Node<NodeConfig>[];
+    isAncestorOf(node: Node): boolean;
+    findAncestor(selector?: string, includeSelf?: boolean, stopNode?: Container): any;
+    _isMatch(selector: string | Function): any;
+    getLayer(): Layer | null;
+    getStage(): Stage | null;
+    _getStage(): Stage | undefined;
+    fire(eventType: string, evt?: any, bubble?: boolean): this;
+    getAbsoluteTransform(top?: Node): Transform;
+    _getAbsoluteTransform(top?: Node): Transform;
+    getAbsoluteScale(top?: Node): {
+        x: number;
+        y: number;
+    };
+    getAbsoluteRotation(): number;
+    getTransform(): Transform;
+    _getTransform(): Transform;
+    clone(obj?: any): any;
+    _toKonvaCanvas(config: any): SceneCanvas;
+    toCanvas(config?: any): HTMLCanvasElement;
+    toDataURL(config?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        pixelRatio?: number;
+        mimeType?: string;
+        quality?: number;
+        callback?: (str: string) => void;
+    }): string;
+    toImage(config?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        pixelRatio?: number;
+        mimeType?: string;
+        quality?: number;
+        callback?: (img: HTMLImageElement) => void;
+    }): void;
+    setSize(size: any): this;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getClassName(): string;
+    getType(): string;
+    getDragDistance(): number;
+    _off(type: any, name?: any, callback?: any): void;
+    _fireChangeEvent(attr: any, oldVal: any, newVal: any): void;
+    addName(name: any): this;
+    hasName(name: any): boolean;
+    removeName(name: any): this;
+    setAttr(attr: any, val: any): this;
+    _requestDraw(): void;
+    _setAttr(key: any, val: any): void;
+    _setComponentAttr(key: any, component: any, val: any): void;
+    _fireAndBubble(eventType: any, evt: any, compareShape?: any): void;
+    _getProtoListeners(eventType: any): any;
+    _fire(eventType: any, evt: any): void;
+    draw(): this;
+    _createDragElement(evt: any): void;
+    startDrag(evt?: any, bubbleEvent?: boolean): void;
+    _setDragPosition(evt: any, elem: any): void;
+    stopDrag(evt?: any): void;
+    setDraggable(draggable: any): void;
+    isDragging(): boolean;
+    _listenDrag(): void;
+    _dragChange(): void;
+    _dragCleanup(): void;
+    isClientRectOnScreen(margin?: {
+        x: number;
+        y: number;
+    }): boolean;
+    preventDefault: GetSet<boolean, this>;
+    blue: GetSet<number, this>;
+    brightness: GetSet<number, this>;
+    contrast: GetSet<number, this>;
+    blurRadius: GetSet<number, this>;
+    luminance: GetSet<number, this>;
+    green: GetSet<number, this>;
+    alpha: GetSet<number, this>;
+    hue: GetSet<number, this>;
+    kaleidoscopeAngle: GetSet<number, this>;
+    kaleidoscopePower: GetSet<number, this>;
+    levels: GetSet<number, this>;
+    noise: GetSet<number, this>;
+    pixelSize: GetSet<number, this>;
+    red: GetSet<number, this>;
+    saturation: GetSet<number, this>;
+    threshold: GetSet<number, this>;
+    value: GetSet<number, this>;
+    dragBoundFunc: GetSet<(this: Node, pos: Vector2d) => Vector2d, this>;
+    draggable: GetSet<boolean, this>;
+    dragDistance: GetSet<number, this>;
+    embossBlend: GetSet<boolean, this>;
+    embossDirection: GetSet<string, this>;
+    embossStrength: GetSet<number, this>;
+    embossWhiteLevel: GetSet<number, this>;
+    enhance: GetSet<number, this>;
+    filters: GetSet<Filter[], this>;
+    position: GetSet<Vector2d, this>;
+    absolutePosition: GetSet<Vector2d, this>;
+    size: GetSet<{
+        width: number;
+        height: number;
+    }, this>;
+    id: GetSet<string, this>;
+    listening: GetSet<boolean, this>;
+    name: GetSet<string, this>;
+    offset: GetSet<Vector2d, this>;
+    offsetX: GetSet<number, this>;
+    offsetY: GetSet<number, this>;
+    opacity: GetSet<number, this>;
+    rotation: GetSet<number, this>;
+    zIndex: GetSet<number, this>;
+    scale: GetSet<Vector2d, this>;
+    scaleX: GetSet<number, this>;
+    scaleY: GetSet<number, this>;
+    skew: GetSet<Vector2d, this>;
+    skewX: GetSet<number, this>;
+    skewY: GetSet<number, this>;
+    to: (params: AnimTo) => void;
+    transformsEnabled: GetSet<string, this>;
+    visible: GetSet<boolean, this>;
+    width: GetSet<number, this>;
+    height: GetSet<number, this>;
+    x: GetSet<number, this>;
+    y: GetSet<number, this>;
+    globalCompositeOperation: GetSet<globalCompositeOperationType, this>;
+    static create(data: any, container?: any): any;
+    static _createNode(obj: any, container?: any): any;
+}
+interface AnimTo extends NodeConfig {
+    onFinish?: Function;
+    onUpdate?: Function;
+    duration?: number;
+}
+export {};

node_modules/konva/cmj/PointerEvents.d.ts

@@ -0,0 +1,11 @@
+import { KonvaEventObject } from './Node';
+import { Shape } from './Shape';
+import { Stage } from './Stage';
+export interface KonvaPointerEvent extends KonvaEventObject<PointerEvent> {
+    pointerId: number;
+}
+export declare function getCapturedShape(pointerId: number): Stage | Shape<import("./Shape").ShapeConfig>;
+export declare function createEvent(evt: PointerEvent): KonvaPointerEvent;
+export declare function hasPointerCapture(pointerId: number, shape: Shape | Stage): boolean;
+export declare function setPointerCapture(pointerId: number, shape: Shape | Stage): void;
+export declare function releaseCapture(pointerId: number, target?: Shape | Stage): void;

node_modules/konva/cmj/PointerEvents.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseCapture = exports.setPointerCapture = exports.hasPointerCapture = exports.createEvent = exports.getCapturedShape = void 0;
+const Global_1 = require("./Global");
+const Captures = new Map();
+const SUPPORT_POINTER_EVENTS = Global_1.Konva._global['PointerEvent'] !== undefined;
+function getCapturedShape(pointerId) {
+    return Captures.get(pointerId);
+}
+exports.getCapturedShape = getCapturedShape;
+function createEvent(evt) {
+    return {
+        evt,
+        pointerId: evt.pointerId,
+    };
+}
+exports.createEvent = createEvent;
+function hasPointerCapture(pointerId, shape) {
+    return Captures.get(pointerId) === shape;
+}
+exports.hasPointerCapture = hasPointerCapture;
+function setPointerCapture(pointerId, shape) {
+    releaseCapture(pointerId);
+    const stage = shape.getStage();
+    if (!stage)
+        return;
+    Captures.set(pointerId, shape);
+    if (SUPPORT_POINTER_EVENTS) {
+        shape._fire('gotpointercapture', createEvent(new PointerEvent('gotpointercapture')));
+    }
+}
+exports.setPointerCapture = setPointerCapture;
+function releaseCapture(pointerId, target) {
+    const shape = Captures.get(pointerId);
+    if (!shape)
+        return;
+    const stage = shape.getStage();
+    if (stage && stage.content) {
+    }
+    Captures.delete(pointerId);
+    if (SUPPORT_POINTER_EVENTS) {
+        shape._fire('lostpointercapture', createEvent(new PointerEvent('lostpointercapture')));
+    }
+}
+exports.releaseCapture = releaseCapture;

node_modules/konva/cmj/Shape.d.ts

@@ -0,0 +1,184 @@
+import { Node, NodeConfig } from './Node';
+import { Context } from './Context';
+import { GetSet, Vector2d } from './types';
+import { HitCanvas, SceneCanvas } from './Canvas';
+export declare type ShapeConfigHandler<TTarget> = {
+    bivarianceHack(ctx: Context, shape: TTarget): void;
+}['bivarianceHack'];
+export declare type LineJoin = 'round' | 'bevel' | 'miter';
+export declare type LineCap = 'butt' | 'round' | 'square';
+export interface ShapeConfig extends NodeConfig {
+    fill?: string;
+    fillPatternImage?: HTMLImageElement;
+    fillPatternX?: number;
+    fillPatternY?: number;
+    fillPatternOffset?: Vector2d;
+    fillPatternOffsetX?: number;
+    fillPatternOffsetY?: number;
+    fillPatternScale?: Vector2d;
+    fillPatternScaleX?: number;
+    fillPatternScaleY?: number;
+    fillPatternRotation?: number;
+    fillPatternRepeat?: string;
+    fillLinearGradientStartPoint?: Vector2d;
+    fillLinearGradientStartPointX?: number;
+    fillLinearGradientStartPointY?: number;
+    fillLinearGradientEndPoint?: Vector2d;
+    fillLinearGradientEndPointX?: number;
+    fillLinearGradientEndPointY?: number;
+    fillLinearGradientColorStops?: Array<number | string>;
+    fillRadialGradientStartPoint?: Vector2d;
+    fillRadialGradientStartPointX?: number;
+    fillRadialGradientStartPointY?: number;
+    fillRadialGradientEndPoint?: Vector2d;
+    fillRadialGradientEndPointX?: number;
+    fillRadialGradientEndPointY?: number;
+    fillRadialGradientStartRadius?: number;
+    fillRadialGradientEndRadius?: number;
+    fillRadialGradientColorStops?: Array<number | string>;
+    fillEnabled?: boolean;
+    fillPriority?: string;
+    stroke?: string | CanvasGradient;
+    strokeWidth?: number;
+    fillAfterStrokeEnabled?: boolean;
+    hitStrokeWidth?: number | string;
+    strokeScaleEnabled?: boolean;
+    strokeHitEnabled?: boolean;
+    strokeEnabled?: boolean;
+    lineJoin?: LineJoin;
+    lineCap?: LineCap;
+    sceneFunc?: (con: Context, shape: Shape) => void;
+    hitFunc?: (con: Context, shape: Shape) => void;
+    shadowColor?: string;
+    shadowBlur?: number;
+    shadowOffset?: Vector2d;
+    shadowOffsetX?: number;
+    shadowOffsetY?: number;
+    shadowOpacity?: number;
+    shadowEnabled?: boolean;
+    shadowForStrokeEnabled?: boolean;
+    dash?: number[];
+    dashOffset?: number;
+    dashEnabled?: boolean;
+    perfectDrawEnabled?: boolean;
+}
+export interface ShapeGetClientRectConfig {
+    skipTransform?: boolean;
+    skipShadow?: boolean;
+    skipStroke?: boolean;
+    relativeTo?: Node;
+}
+export declare const shapes: {
+    [key: string]: Shape;
+};
+export declare class Shape<Config extends ShapeConfig = ShapeConfig> extends Node<Config> {
+    _centroid: boolean;
+    colorKey: string;
+    _fillFunc: (ctx: Context) => void;
+    _strokeFunc: (ctx: Context) => void;
+    _fillFuncHit: (ctx: Context) => void;
+    _strokeFuncHit: (ctx: Context) => void;
+    constructor(config?: Config);
+    getContext(): Context;
+    getCanvas(): SceneCanvas;
+    getSceneFunc(): any;
+    getHitFunc(): any;
+    hasShadow(): any;
+    _hasShadow(): boolean;
+    _getFillPattern(): any;
+    __getFillPattern(): CanvasPattern;
+    _getLinearGradient(): any;
+    __getLinearGradient(): CanvasGradient;
+    _getRadialGradient(): any;
+    __getRadialGradient(): CanvasGradient;
+    getShadowRGBA(): any;
+    _getShadowRGBA(): string;
+    hasFill(): any;
+    hasStroke(): any;
+    hasHitStroke(): any;
+    intersects(point: any): boolean;
+    destroy(): this;
+    _useBufferCanvas(forceFill?: boolean): boolean;
+    setStrokeHitEnabled(val: number): void;
+    getStrokeHitEnabled(): boolean;
+    getSelfRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getClientRect(config?: ShapeGetClientRectConfig): {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+    drawScene(can?: SceneCanvas, top?: Node): this;
+    drawHit(can?: HitCanvas, top?: Node, skipDragCheck?: boolean): this;
+    drawHitFromCache(alphaThreshold?: number): this;
+    hasPointerCapture(pointerId: number): boolean;
+    setPointerCapture(pointerId: number): void;
+    releaseCapture(pointerId: number): void;
+    draggable: GetSet<boolean, this>;
+    embossBlend: GetSet<boolean, this>;
+    dash: GetSet<number[], this>;
+    dashEnabled: GetSet<boolean, this>;
+    dashOffset: GetSet<number, this>;
+    fill: GetSet<string, this>;
+    fillEnabled: GetSet<boolean, this>;
+    fillLinearGradientColorStops: GetSet<Array<number | string>, this>;
+    fillLinearGradientStartPoint: GetSet<Vector2d, this>;
+    fillLinearGradientStartPointX: GetSet<number, this>;
+    fillLinearGradientStartPointY: GetSet<number, this>;
+    fillLinearGradientEndPoint: GetSet<Vector2d, this>;
+    fillLinearGradientEndPointX: GetSet<number, this>;
+    fillLinearGradientEndPointY: GetSet<number, this>;
+    fillLinearRadialStartPoint: GetSet<Vector2d, this>;
+    fillLinearRadialStartPointX: GetSet<number, this>;
+    fillLinearRadialStartPointY: GetSet<number, this>;
+    fillLinearRadialEndPoint: GetSet<Vector2d, this>;
+    fillLinearRadialEndPointX: GetSet<number, this>;
+    fillLinearRadialEndPointY: GetSet<number, this>;
+    fillPatternImage: GetSet<HTMLImageElement | HTMLCanvasElement, this>;
+    fillRadialGradientStartRadius: GetSet<number, this>;
+    fillRadialGradientEndRadius: GetSet<number, this>;
+    fillRadialGradientColorStops: GetSet<Array<number | string>, this>;
+    fillRadialGradientStartPoint: GetSet<Vector2d, this>;
+    fillRadialGradientStartPointX: GetSet<number, this>;
+    fillRadialGradientStartPointY: GetSet<number, this>;
+    fillRadialGradientEndPoint: GetSet<Vector2d, this>;
+    fillRadialGradientEndPointX: GetSet<number, this>;
+    fillRadialGradientEndPointY: GetSet<number, this>;
+    fillPatternOffset: GetSet<Vector2d, this>;
+    fillPatternOffsetX: GetSet<number, this>;
+    fillPatternOffsetY: GetSet<number, this>;
+    fillPatternRepeat: GetSet<string, this>;
+    fillPatternRotation: GetSet<number, this>;
+    fillPatternScale: GetSet<Vector2d, this>;
+    fillPatternScaleX: GetSet<number, this>;
+    fillPatternScaleY: GetSet<number, this>;
+    fillPatternX: GetSet<number, this>;
+    fillPatternY: GetSet<number, this>;
+    fillPriority: GetSet<string, this>;
+    hitFunc: GetSet<ShapeConfigHandler<this>, this>;
+    lineCap: GetSet<LineCap, this>;
+    lineJoin: GetSet<LineJoin, this>;
+    perfectDrawEnabled: GetSet<boolean, this>;
+    sceneFunc: GetSet<ShapeConfigHandler<this>, this>;
+    shadowColor: GetSet<string, this>;
+    shadowEnabled: GetSet<boolean, this>;
+    shadowForStrokeEnabled: GetSet<boolean, this>;
+    shadowOffset: GetSet<Vector2d, this>;
+    shadowOffsetX: GetSet<number, this>;
+    shadowOffsetY: GetSet<number, this>;
+    shadowOpacity: GetSet<number, this>;
+    shadowBlur: GetSet<number, this>;
+    stroke: GetSet<string, this>;
+    strokeEnabled: GetSet<boolean, this>;
+    fillAfterStrokeEnabled: GetSet<boolean, this>;
+    strokeScaleEnabled: GetSet<boolean, this>;
+    strokeHitEnabled: GetSet<boolean, this>;
+    strokeWidth: GetSet<number, this>;
+    hitStrokeWidth: GetSet<number | 'auto', this>;
+    strokeLinearGradientColorStops: GetSet<Array<number | string>, this>;
+}

node_modules/konva/cmj/Shape.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shape = exports.shapes = void 0;
+const Global_1 = require("./Global");
+const Util_1 = require("./Util");
+const Factory_1 = require("./Factory");
+const Node_1 = require("./Node");
+const Validators_1 = require("./Validators");
+const Global_2 = require("./Global");
+const PointerEvents = require("./PointerEvents");
+var HAS_SHADOW = 'hasShadow';
+var SHADOW_RGBA = 'shadowRGBA';
+var patternImage = 'patternImage';
+var linearGradient = 'linearGradient';
+var radialGradient = 'radialGradient';
+let dummyContext;
+function getDummyContext() {
+    if (dummyContext) {
+        return dummyContext;
+    }
+    dummyContext = Util_1.Util.createCanvasElement().getContext('2d');
+    return dummyContext;
+}
+exports.shapes = {};
+function _fillFunc(context) {
+    context.fill();
+}
+function _strokeFunc(context) {
+    context.stroke();
+}
+function _fillFuncHit(context) {
+    context.fill();
+}
+function _strokeFuncHit(context) {
+    context.stroke();
+}
+function _clearHasShadowCache() {
+    this._clearCache(HAS_SHADOW);
+}
+function _clearGetShadowRGBACache() {
+    this._clearCache(SHADOW_RGBA);
+}
+function _clearFillPatternCache() {
+    this._clearCache(patternImage);
+}
+function _clearLinearGradientCache() {
+    this._clearCache(linearGradient);
+}
+function _clearRadialGradientCache() {
+    this._clearCache(radialGradient);
+}
+class Shape extends Node_1.Node {
+    constructor(config) {
+        super(config);
+        let key;
+        while (true) {
+            key = Util_1.Util.getRandomColor();
+            if (key && !(key in exports.shapes)) {
+                break;
+            }
+        }
+        this.colorKey = key;
+        exports.shapes[key] = this;
+    }
+    getContext() {
+        Util_1.Util.warn('shape.getContext() method is deprecated. Please do not use it.');
+        return this.getLayer().getContext();
+    }
+    getCanvas() {
+        Util_1.Util.warn('shape.getCanvas() method is deprecated. Please do not use it.');
+        return this.getLayer().getCanvas();
+    }
+    getSceneFunc() {
+        return this.attrs.sceneFunc || this['_sceneFunc'];
+    }
+    getHitFunc() {
+        return this.attrs.hitFunc || this['_hitFunc'];
+    }
+    hasShadow() {
+        return this._getCache(HAS_SHADOW, this._hasShadow);
+    }
+    _hasShadow() {
+        return (this.shadowEnabled() &&
+            this.shadowOpacity() !== 0 &&
+            !!(this.shadowColor() ||
+                this.shadowBlur() ||
+                this.shadowOffsetX() ||
+                this.shadowOffsetY()));
+    }
+    _getFillPattern() {
+        return this._getCache(patternImage, this.__getFillPattern);
+    }
+    __getFillPattern() {
+        if (this.fillPatternImage()) {
+            var ctx = getDummyContext();
+            const pattern = ctx.createPattern(this.fillPatternImage(), this.fillPatternRepeat() || 'repeat');
+            if (pattern && pattern.setTransform) {
+                const tr = new Util_1.Transform();
+                tr.translate(this.fillPatternX(), this.fillPatternY());
+                tr.rotate(Global_1.Konva.getAngle(this.fillPatternRotation()));
+                tr.scale(this.fillPatternScaleX(), this.fillPatternScaleY());
+                tr.translate(-1 * this.fillPatternOffsetX(), -1 * this.fillPatternOffsetY());
+                const m = tr.getMatrix();
+                pattern.setTransform({
+                    a: m[0],
+                    b: m[1],
+                    c: m[2],
+                    d: m[3],
+                    e: m[4],
+                    f: m[5],
+                });
+            }
+            return pattern;
+        }
+    }
+    _getLinearGradient() {
+        return this._getCache(linearGradient, this.__getLinearGradient);
+    }
+    __getLinearGradient() {
+        var colorStops = this.fillLinearGradientColorStops();
+        if (colorStops) {
+            var ctx = getDummyContext();
+            var start = this.fillLinearGradientStartPoint();
+            var end = this.fillLinearGradientEndPoint();
+            var grd = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
+            for (var n = 0; n < colorStops.length; n += 2) {
+                grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
+            return grd;
+        }
+    }
+    _getRadialGradient() {
+        return this._getCache(radialGradient, this.__getRadialGradient);
+    }
+    __getRadialGradient() {
+        var colorStops = this.fillRadialGradientColorStops();
+        if (colorStops) {
+            var ctx = getDummyContext();
+            var start = this.fillRadialGradientStartPoint();
+            var end = this.fillRadialGradientEndPoint();
+            var grd = ctx.createRadialGradient(start.x, start.y, this.fillRadialGradientStartRadius(), end.x, end.y, this.fillRadialGradientEndRadius());
+            for (var n = 0; n < colorStops.length; n += 2) {
+                grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
+            return grd;
+        }
+    }
+    getShadowRGBA() {
+        return this._getCache(SHADOW_RGBA, this._getShadowRGBA);
+    }
+    _getShadowRGBA() {
+        if (this.hasShadow()) {
+            var rgba = Util_1.Util.colorToRGBA(this.shadowColor());
+            return ('rgba(' +
+                rgba.r +
+                ',' +
+                rgba.g +
+                ',' +
+                rgba.b +
+                ',' +
+                rgba.a * (this.shadowOpacity() || 1) +
+                ')');
+        }
+    }
+    hasFill() {
+        return this._calculate('hasFill', [
+            'fillEnabled',
+            'fill',
+            'fillPatternImage',
+            'fillLinearGradientColorStops',
+            'fillRadialGradientColorStops',
+        ], () => {
+            return (this.fillEnabled() &&
+                !!(this.fill() ||
+                    this.fillPatternImage() ||
+                    this.fillLinearGradientColorStops() ||
+                    this.fillRadialGradientColorStops()));
+        });
+    }
+    hasStroke() {
+        return this._calculate('hasStroke', [
+            'strokeEnabled',
+            'strokeWidth',
+            'stroke',
+            'strokeLinearGradientColorStops',
+        ], () => {
+            return (this.strokeEnabled() &&
+                this.strokeWidth() &&
+                !!(this.stroke() || this.strokeLinearGradientColorStops()));
+        });
+    }
+    hasHitStroke() {
+        const width = this.hitStrokeWidth();
+        if (width === 'auto') {
+            return this.hasStroke();
+        }
+        return this.strokeEnabled() && !!width;
+    }
+    intersects(point) {
+        var stage = this.getStage(), bufferHitCanvas = stage.bufferHitCanvas, p;
+        bufferHitCanvas.getContext().clear();
+        this.drawHit(bufferHitCanvas, null, true);
+        p = bufferHitCanvas.context.getImageData(Math.round(point.x), Math.round(point.y), 1, 1).data;
+        return p[3] > 0;
+    }
+    destroy() {
+        Node_1.Node.prototype.destroy.call(this);
+        delete exports.shapes[this.colorKey];
+        delete this.colorKey;
+        return this;
+    }
+    _useBufferCanvas(forceFill) {
+        var _a;
+        if (!this.getStage()) {
+            return false;
+        }
+        const perfectDrawEnabled = (_a = this.attrs.perfectDrawEnabled) !== null && _a !== void 0 ? _a : true;
+        if (!perfectDrawEnabled) {
+            return false;
+        }
+        const hasFill = forceFill || this.hasFill();
+        const hasStroke = this.hasStroke();
+        const isTransparent = this.getAbsoluteOpacity() !== 1;
+        if (hasFill && hasStroke && isTransparent) {
+            return true;
+        }
+        const hasShadow = this.hasShadow();
+        const strokeForShadow = this.shadowForStrokeEnabled();
+        if (hasFill && hasStroke && hasShadow && strokeForShadow) {
+            return true;
+        }
+        return false;
+    }
+    setStrokeHitEnabled(val) {
+        Util_1.Util.warn('strokeHitEnabled property is deprecated. Please use hitStrokeWidth instead.');
+        if (val) {
+            this.hitStrokeWidth('auto');
+        }
+        else {
+            this.hitStrokeWidth(0);
+        }
+    }
+    getStrokeHitEnabled() {
+        if (this.hitStrokeWidth() === 0) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    getSelfRect() {
+        var size = this.size();
+        return {
+            x: this._centroid ? -size.width / 2 : 0,
+            y: this._centroid ? -size.height / 2 : 0,
+            width: size.width,
+            height: size.height,
+        };
+    }
+    getClientRect(config = {}) {
+        const skipTransform = config.skipTransform;
+        const relativeTo = config.relativeTo;
+        const fillRect = this.getSelfRect();
+        const applyStroke = !config.skipStroke && this.hasStroke();
+        const strokeWidth = (applyStroke && this.strokeWidth()) || 0;
+        const fillAndStrokeWidth = fillRect.width + strokeWidth;
+        const fillAndStrokeHeight = fillRect.height + strokeWidth;
+        const applyShadow = !config.skipShadow && this.hasShadow();
+        const shadowOffsetX = applyShadow ? this.shadowOffsetX() : 0;
+        const shadowOffsetY = applyShadow ? this.shadowOffsetY() : 0;
+        const preWidth = fillAndStrokeWidth + Math.abs(shadowOffsetX);
+        const preHeight = fillAndStrokeHeight + Math.abs(shadowOffsetY);
+        const blurRadius = (applyShadow && this.shadowBlur()) || 0;
+        const width = preWidth + blurRadius * 2;
+        const height = preHeight + blurRadius * 2;
+        let roundingOffset = 0;
+        if (Math.round(strokeWidth / 2) !== strokeWidth / 2) {
+            roundingOffset = 1;
+        }
+        const rect = {
+            width: width + roundingOffset,
+            height: height + roundingOffset,
+            x: -Math.round(strokeWidth / 2 + blurRadius) +
+                Math.min(shadowOffsetX, 0) +
+                fillRect.x,
+            y: -Math.round(strokeWidth / 2 + blurRadius) +
+                Math.min(shadowOffsetY, 0) +
+                fillRect.y,
+        };
+        if (!skipTransform) {
+            return this._transformedRect(rect, relativeTo);
+        }
+        return rect;
+    }
+    drawScene(can, top) {
+        var layer = this.getLayer(), canvas = can || layer.getCanvas(), context = canvas.getContext(), cachedCanvas = this._getCanvasCache(), drawFunc = this.getSceneFunc(), hasShadow = this.hasShadow(), stage, bufferCanvas, bufferContext;
+        var skipBuffer = canvas.isCache;
+        var cachingSelf = top === this;
+        if (!this.isVisible() && !cachingSelf) {
+            return this;
+        }
+        if (cachedCanvas) {
+            context.save();
+            var m = this.getAbsoluteTransform(top).getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            this._drawCachedSceneCanvas(context);
+            context.restore();
+            return this;
+        }
+        if (!drawFunc) {
+            return this;
+        }
+        context.save();
+        if (this._useBufferCanvas() && !skipBuffer) {
+            stage = this.getStage();
+            bufferCanvas = stage.bufferCanvas;
+            bufferContext = bufferCanvas.getContext();
+            bufferContext.clear();
+            bufferContext.save();
+            bufferContext._applyLineJoin(this);
+            var o = this.getAbsoluteTransform(top).getMatrix();
+            bufferContext.transform(o[0], o[1], o[2], o[3], o[4], o[5]);
+            drawFunc.call(this, bufferContext, this);
+            bufferContext.restore();
+            var ratio = bufferCanvas.pixelRatio;
+            if (hasShadow) {
+                context._applyShadow(this);
+            }
+            context._applyOpacity(this);
+            context._applyGlobalCompositeOperation(this);
+            context.drawImage(bufferCanvas._canvas, 0, 0, bufferCanvas.width / ratio, bufferCanvas.height / ratio);
+        }
+        else {
+            context._applyLineJoin(this);
+            if (!cachingSelf) {
+                var o = this.getAbsoluteTransform(top).getMatrix();
+                context.transform(o[0], o[1], o[2], o[3], o[4], o[5]);
+                context._applyOpacity(this);
+                context._applyGlobalCompositeOperation(this);
+            }
+            if (hasShadow) {
+                context._applyShadow(this);
+            }
+            drawFunc.call(this, context, this);
+        }
+        context.restore();
+        return this;
+    }
+    drawHit(can, top, skipDragCheck = false) {
+        if (!this.shouldDrawHit(top, skipDragCheck)) {
+            return this;
+        }
+        var layer = this.getLayer(), canvas = can || layer.hitCanvas, context = canvas && canvas.getContext(), drawFunc = this.hitFunc() || this.sceneFunc(), cachedCanvas = this._getCanvasCache(), cachedHitCanvas = cachedCanvas && cachedCanvas.hit;
+        if (!this.colorKey) {
+            Util_1.Util.warn('Looks like your canvas has a destroyed shape in it. Do not reuse shape after you destroyed it. If you want to reuse shape you should call remove() instead of destroy()');
+        }
+        if (cachedHitCanvas) {
+            context.save();
+            var m = this.getAbsoluteTransform(top).getMatrix();
+            context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            this._drawCachedHitCanvas(context);
+            context.restore();
+            return this;
+        }
+        if (!drawFunc) {
+            return this;
+        }
+        context.save();
+        context._applyLineJoin(this);
+        const selfCache = this === top;
+        if (!selfCache) {
+            var o = this.getAbsoluteTransform(top).getMatrix();
+            context.transform(o[0], o[1], o[2], o[3], o[4], o[5]);
+        }
+        drawFunc.call(this, context, this);
+        context.restore();
+        return this;
+    }
+    drawHitFromCache(alphaThreshold = 0) {
+        var cachedCanvas = this._getCanvasCache(), sceneCanvas = this._getCachedSceneCanvas(), hitCanvas = cachedCanvas.hit, hitContext = hitCanvas.getContext(), hitWidth = hitCanvas.getWidth(), hitHeight = hitCanvas.getHeight(), hitImageData, hitData, len, rgbColorKey, i, alpha;
+        hitContext.clear();
+        hitContext.drawImage(sceneCanvas._canvas, 0, 0, hitWidth, hitHeight);
+        try {
+            hitImageData = hitContext.getImageData(0, 0, hitWidth, hitHeight);
+            hitData = hitImageData.data;
+            len = hitData.length;
+            rgbColorKey = Util_1.Util._hexToRgb(this.colorKey);
+            for (i = 0; i < len; i += 4) {
+                alpha = hitData[i + 3];
+                if (alpha > alphaThreshold) {
+                    hitData[i] = rgbColorKey.r;
+                    hitData[i + 1] = rgbColorKey.g;
+                    hitData[i + 2] = rgbColorKey.b;
+                    hitData[i + 3] = 255;
+                }
+                else {
+                    hitData[i + 3] = 0;
+                }
+            }
+            hitContext.putImageData(hitImageData, 0, 0);
+        }
+        catch (e) {
+            Util_1.Util.error('Unable to draw hit graph from cached scene canvas. ' + e.message);
+        }
+        return this;
+    }
+    hasPointerCapture(pointerId) {
+        return PointerEvents.hasPointerCapture(pointerId, this);
+    }
+    setPointerCapture(pointerId) {
+        PointerEvents.setPointerCapture(pointerId, this);
+    }
+    releaseCapture(pointerId) {
+        PointerEvents.releaseCapture(pointerId, this);
+    }
+}
+exports.Shape = Shape;
+Shape.prototype._fillFunc = _fillFunc;
+Shape.prototype._strokeFunc = _strokeFunc;
+Shape.prototype._fillFuncHit = _fillFuncHit;
+Shape.prototype._strokeFuncHit = _strokeFuncHit;
+Shape.prototype._centroid = false;
+Shape.prototype.nodeType = 'Shape';
+(0, Global_2._registerNode)(Shape);
+Shape.prototype.eventListeners = {};
+Shape.prototype.on.call(Shape.prototype, 'shadowColorChange.konva shadowBlurChange.konva shadowOffsetChange.konva shadowOpacityChange.konva shadowEnabledChange.konva', _clearHasShadowCache);
+Shape.prototype.on.call(Shape.prototype, 'shadowColorChange.konva shadowOpacityChange.konva shadowEnabledChange.konva', _clearGetShadowRGBACache);
+Shape.prototype.on.call(Shape.prototype, 'fillPriorityChange.konva fillPatternImageChange.konva fillPatternRepeatChange.konva fillPatternScaleXChange.konva fillPatternScaleYChange.konva fillPatternOffsetXChange.konva fillPatternOffsetYChange.konva fillPatternXChange.konva fillPatternYChange.konva fillPatternRotationChange.konva', _clearFillPatternCache);
+Shape.prototype.on.call(Shape.prototype, 'fillPriorityChange.konva fillLinearGradientColorStopsChange.konva fillLinearGradientStartPointXChange.konva fillLinearGradientStartPointYChange.konva fillLinearGradientEndPointXChange.konva fillLinearGradientEndPointYChange.konva', _clearLinearGradientCache);
+Shape.prototype.on.call(Shape.prototype, 'fillPriorityChange.konva fillRadialGradientColorStopsChange.konva fillRadialGradientStartPointXChange.konva fillRadialGradientStartPointYChange.konva fillRadialGradientEndPointXChange.konva fillRadialGradientEndPointYChange.konva fillRadialGradientStartRadiusChange.konva fillRadialGradientEndRadiusChange.konva', _clearRadialGradientCache);
+Factory_1.Factory.addGetterSetter(Shape, 'stroke', undefined, (0, Validators_1.getStringOrGradientValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'strokeWidth', 2, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillAfterStrokeEnabled', false);
+Factory_1.Factory.addGetterSetter(Shape, 'hitStrokeWidth', 'auto', (0, Validators_1.getNumberOrAutoValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'strokeHitEnabled', true, (0, Validators_1.getBooleanValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'perfectDrawEnabled', true, (0, Validators_1.getBooleanValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'shadowForStrokeEnabled', true, (0, Validators_1.getBooleanValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'lineJoin');
+Factory_1.Factory.addGetterSetter(Shape, 'lineCap');
+Factory_1.Factory.addGetterSetter(Shape, 'sceneFunc');
+Factory_1.Factory.addGetterSetter(Shape, 'hitFunc');
+Factory_1.Factory.addGetterSetter(Shape, 'dash');
+Factory_1.Factory.addGetterSetter(Shape, 'dashOffset', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'shadowColor', undefined, (0, Validators_1.getStringValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'shadowBlur', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'shadowOpacity', 1, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'shadowOffset', ['x', 'y']);
+Factory_1.Factory.addGetterSetter(Shape, 'shadowOffsetX', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'shadowOffsetY', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternImage');
+Factory_1.Factory.addGetterSetter(Shape, 'fill', undefined, (0, Validators_1.getStringOrGradientValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternX', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternY', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillLinearGradientColorStops');
+Factory_1.Factory.addGetterSetter(Shape, 'strokeLinearGradientColorStops');
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientStartRadius', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientEndRadius', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientColorStops');
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternRepeat', 'repeat');
+Factory_1.Factory.addGetterSetter(Shape, 'fillEnabled', true);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeEnabled', true);
+Factory_1.Factory.addGetterSetter(Shape, 'shadowEnabled', true);
+Factory_1.Factory.addGetterSetter(Shape, 'dashEnabled', true);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeScaleEnabled', true);
+Factory_1.Factory.addGetterSetter(Shape, 'fillPriority', 'color');
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillPatternOffset', ['x', 'y']);
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternOffsetX', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternOffsetY', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillPatternScale', ['x', 'y']);
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternScaleX', 1, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternScaleY', 1, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillLinearGradientStartPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'strokeLinearGradientStartPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addGetterSetter(Shape, 'fillLinearGradientStartPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeLinearGradientStartPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillLinearGradientStartPointY', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeLinearGradientStartPointY', 0);
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillLinearGradientEndPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'strokeLinearGradientEndPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addGetterSetter(Shape, 'fillLinearGradientEndPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeLinearGradientEndPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillLinearGradientEndPointY', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'strokeLinearGradientEndPointY', 0);
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillRadialGradientStartPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientStartPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientStartPointY', 0);
+Factory_1.Factory.addComponentsGetterSetter(Shape, 'fillRadialGradientEndPoint', [
+    'x',
+    'y',
+]);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientEndPointX', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillRadialGradientEndPointY', 0);
+Factory_1.Factory.addGetterSetter(Shape, 'fillPatternRotation', 0);
+Factory_1.Factory.backCompat(Shape, {
+    dashArray: 'dash',
+    getDashArray: 'getDash',
+    setDashArray: 'getDash',
+    drawFunc: 'sceneFunc',
+    getDrawFunc: 'getSceneFunc',
+    setDrawFunc: 'setSceneFunc',
+    drawHitFunc: 'hitFunc',
+    getDrawHitFunc: 'getHitFunc',
+    setDrawHitFunc: 'setHitFunc',
+});

node_modules/konva/cmj/Stage.d.ts

@@ -0,0 +1,85 @@
+import { Container, ContainerConfig } from './Container';
+import { SceneCanvas, HitCanvas } from './Canvas';
+import { GetSet, Vector2d } from './types';
+import { Shape } from './Shape';
+import { Layer } from './Layer';
+export interface StageConfig extends ContainerConfig {
+    container: HTMLDivElement | string;
+}
+export declare const stages: Stage[];
+export declare class Stage extends Container<Layer> {
+    content: HTMLDivElement;
+    pointerPos: Vector2d | null;
+    _pointerPositions: (Vector2d & {
+        id?: number;
+    })[];
+    _changedPointerPositions: (Vector2d & {
+        id: number;
+    })[];
+    bufferCanvas: SceneCanvas;
+    bufferHitCanvas: HitCanvas;
+    _mouseTargetShape: Shape;
+    _touchTargetShape: Shape;
+    _pointerTargetShape: Shape;
+    _mouseClickStartShape: Shape;
+    _touchClickStartShape: Shape;
+    _pointerClickStartShape: Shape;
+    _mouseClickEndShape: Shape;
+    _touchClickEndShape: Shape;
+    _pointerClickEndShape: Shape;
+    _mouseDblTimeout: any;
+    _touchDblTimeout: any;
+    _pointerDblTimeout: any;
+    constructor(config: StageConfig);
+    _validateAdd(child: any): void;
+    _checkVisibility(): void;
+    setContainer(container: any): this;
+    shouldDrawHit(): boolean;
+    clear(): this;
+    clone(obj?: any): any;
+    destroy(): this;
+    getPointerPosition(): Vector2d | null;
+    _getPointerById(id?: number): Vector2d & {
+        id?: number;
+    };
+    getPointersPositions(): (Vector2d & {
+        id?: number;
+    })[];
+    getStage(): this;
+    getContent(): HTMLDivElement;
+    _toKonvaCanvas(config: any): SceneCanvas;
+    getIntersection(pos: Vector2d): Shape<import("./Shape").ShapeConfig>;
+    _resizeDOM(): void;
+    add(layer: Layer, ...rest: any[]): this;
+    getParent(): any;
+    getLayer(): any;
+    hasPointerCapture(pointerId: number): boolean;
+    setPointerCapture(pointerId: number): void;
+    releaseCapture(pointerId: number): void;
+    getLayers(): Layer[];
+    _bindContentEvents(): void;
+    _pointerenter(evt: any): void;
+    _pointerover(evt: any): void;
+    _getTargetShape(evenType: any): Shape<import("./Shape").ShapeConfig>;
+    _pointerleave(evt: any): void;
+    _pointerdown(evt: TouchEvent | MouseEvent | PointerEvent): void;
+    _pointermove(evt: TouchEvent | MouseEvent | PointerEvent): void;
+    _pointerup(evt: any): void;
+    _contextmenu(evt: any): void;
+    _wheel(evt: any): void;
+    _pointercancel(evt: PointerEvent): void;
+    _lostpointercapture(evt: PointerEvent): void;
+    setPointersPositions(evt: any): void;
+    _setPointerPosition(evt: any): void;
+    _getContentPosition(): {
+        top: number;
+        left: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    _buildDOM(): void;
+    cache(): this;
+    clearCache(): this;
+    batchDraw(): this;
+    container: GetSet<HTMLDivElement, this>;
+}

node_modules/konva/cmj/Stage.js

@@ -0,0 +1,693 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stage = exports.stages = void 0;
+const Util_1 = require("./Util");
+const Factory_1 = require("./Factory");
+const Container_1 = require("./Container");
+const Global_1 = require("./Global");
+const Canvas_1 = require("./Canvas");
+const DragAndDrop_1 = require("./DragAndDrop");
+const Global_2 = require("./Global");
+const PointerEvents = require("./PointerEvents");
+var STAGE = 'Stage', STRING = 'string', PX = 'px', MOUSEOUT = 'mouseout', MOUSELEAVE = 'mouseleave', MOUSEOVER = 'mouseover', MOUSEENTER = 'mouseenter', MOUSEMOVE = 'mousemove', MOUSEDOWN = 'mousedown', MOUSEUP = 'mouseup', POINTERMOVE = 'pointermove', POINTERDOWN = 'pointerdown', POINTERUP = 'pointerup', POINTERCANCEL = 'pointercancel', LOSTPOINTERCAPTURE = 'lostpointercapture', POINTEROUT = 'pointerout', POINTERLEAVE = 'pointerleave', POINTEROVER = 'pointerover', POINTERENTER = 'pointerenter', CONTEXTMENU = 'contextmenu', TOUCHSTART = 'touchstart', TOUCHEND = 'touchend', TOUCHMOVE = 'touchmove', TOUCHCANCEL = 'touchcancel', WHEEL = 'wheel', MAX_LAYERS_NUMBER = 5, EVENTS = [
+    [MOUSEENTER, '_pointerenter'],
+    [MOUSEDOWN, '_pointerdown'],
+    [MOUSEMOVE, '_pointermove'],
+    [MOUSEUP, '_pointerup'],
+    [MOUSELEAVE, '_pointerleave'],
+    [TOUCHSTART, '_pointerdown'],
+    [TOUCHMOVE, '_pointermove'],
+    [TOUCHEND, '_pointerup'],
+    [TOUCHCANCEL, '_pointercancel'],
+    [MOUSEOVER, '_pointerover'],
+    [WHEEL, '_wheel'],
+    [CONTEXTMENU, '_contextmenu'],
+    [POINTERDOWN, '_pointerdown'],
+    [POINTERMOVE, '_pointermove'],
+    [POINTERUP, '_pointerup'],
+    [POINTERCANCEL, '_pointercancel'],
+    [LOSTPOINTERCAPTURE, '_lostpointercapture'],
+];
+const EVENTS_MAP = {
+    mouse: {
+        [POINTEROUT]: MOUSEOUT,
+        [POINTERLEAVE]: MOUSELEAVE,
+        [POINTEROVER]: MOUSEOVER,
+        [POINTERENTER]: MOUSEENTER,
+        [POINTERMOVE]: MOUSEMOVE,
+        [POINTERDOWN]: MOUSEDOWN,
+        [POINTERUP]: MOUSEUP,
+        [POINTERCANCEL]: 'mousecancel',
+        pointerclick: 'click',
+        pointerdblclick: 'dblclick',
+    },
+    touch: {
+        [POINTEROUT]: 'touchout',
+        [POINTERLEAVE]: 'touchleave',
+        [POINTEROVER]: 'touchover',
+        [POINTERENTER]: 'touchenter',
+        [POINTERMOVE]: TOUCHMOVE,
+        [POINTERDOWN]: TOUCHSTART,
+        [POINTERUP]: TOUCHEND,
+        [POINTERCANCEL]: TOUCHCANCEL,
+        pointerclick: 'tap',
+        pointerdblclick: 'dbltap',
+    },
+    pointer: {
+        [POINTEROUT]: POINTEROUT,
+        [POINTERLEAVE]: POINTERLEAVE,
+        [POINTEROVER]: POINTEROVER,
+        [POINTERENTER]: POINTERENTER,
+        [POINTERMOVE]: POINTERMOVE,
+        [POINTERDOWN]: POINTERDOWN,
+        [POINTERUP]: POINTERUP,
+        [POINTERCANCEL]: POINTERCANCEL,
+        pointerclick: 'pointerclick',
+        pointerdblclick: 'pointerdblclick',
+    },
+};
+const getEventType = (type) => {
+    if (type.indexOf('pointer') >= 0) {
+        return 'pointer';
+    }
+    if (type.indexOf('touch') >= 0) {
+        return 'touch';
+    }
+    return 'mouse';
+};
+const getEventsMap = (eventType) => {
+    const type = getEventType(eventType);
+    if (type === 'pointer') {
+        return Global_1.Konva.pointerEventsEnabled && EVENTS_MAP.pointer;
+    }
+    if (type === 'touch') {
+        return EVENTS_MAP.touch;
+    }
+    if (type === 'mouse') {
+        return EVENTS_MAP.mouse;
+    }
+};
+function checkNoClip(attrs = {}) {
+    if (attrs.clipFunc || attrs.clipWidth || attrs.clipHeight) {
+        Util_1.Util.warn('Stage does not support clipping. Please use clip for Layers or Groups.');
+    }
+    return attrs;
+}
+const NO_POINTERS_MESSAGE = `Pointer position is missing and not registered by the stage. Looks like it is outside of the stage container. You can set it manually from event: stage.setPointersPositions(event);`;
+exports.stages = [];
+class Stage extends Container_1.Container {
+    constructor(config) {
+        super(checkNoClip(config));
+        this._pointerPositions = [];
+        this._changedPointerPositions = [];
+        this._buildDOM();
+        this._bindContentEvents();
+        exports.stages.push(this);
+        this.on('widthChange.konva heightChange.konva', this._resizeDOM);
+        this.on('visibleChange.konva', this._checkVisibility);
+        this.on('clipWidthChange.konva clipHeightChange.konva clipFuncChange.konva', () => {
+            checkNoClip(this.attrs);
+        });
+        this._checkVisibility();
+    }
+    _validateAdd(child) {
+        const isLayer = child.getType() === 'Layer';
+        const isFastLayer = child.getType() === 'FastLayer';
+        const valid = isLayer || isFastLayer;
+        if (!valid) {
+            Util_1.Util.throw('You may only add layers to the stage.');
+        }
+    }
+    _checkVisibility() {
+        if (!this.content) {
+            return;
+        }
+        const style = this.visible() ? '' : 'none';
+        this.content.style.display = style;
+    }
+    setContainer(container) {
+        if (typeof container === STRING) {
+            if (container.charAt(0) === '.') {
+                var className = container.slice(1);
+                container = document.getElementsByClassName(className)[0];
+            }
+            else {
+                var id;
+                if (container.charAt(0) !== '#') {
+                    id = container;
+                }
+                else {
+                    id = container.slice(1);
+                }
+                container = document.getElementById(id);
+            }
+            if (!container) {
+                throw 'Can not find container in document with id ' + id;
+            }
+        }
+        this._setAttr('container', container);
+        if (this.content) {
+            if (this.content.parentElement) {
+                this.content.parentElement.removeChild(this.content);
+            }
+            container.appendChild(this.content);
+        }
+        return this;
+    }
+    shouldDrawHit() {
+        return true;
+    }
+    clear() {
+        var layers = this.children, len = layers.length, n;
+        for (n = 0; n < len; n++) {
+            layers[n].clear();
+        }
+        return this;
+    }
+    clone(obj) {
+        if (!obj) {
+            obj = {};
+        }
+        obj.container =
+            typeof document !== 'undefined' && document.createElement('div');
+        return Container_1.Container.prototype.clone.call(this, obj);
+    }
+    destroy() {
+        super.destroy();
+        var content = this.content;
+        if (content && Util_1.Util._isInDocument(content)) {
+            this.container().removeChild(content);
+        }
+        var index = exports.stages.indexOf(this);
+        if (index > -1) {
+            exports.stages.splice(index, 1);
+        }
+        return this;
+    }
+    getPointerPosition() {
+        const pos = this._pointerPositions[0] || this._changedPointerPositions[0];
+        if (!pos) {
+            Util_1.Util.warn(NO_POINTERS_MESSAGE);
+            return null;
+        }
+        return {
+            x: pos.x,
+            y: pos.y,
+        };
+    }
+    _getPointerById(id) {
+        return this._pointerPositions.find((p) => p.id === id);
+    }
+    getPointersPositions() {
+        return this._pointerPositions;
+    }
+    getStage() {
+        return this;
+    }
+    getContent() {
+        return this.content;
+    }
+    _toKonvaCanvas(config) {
+        config = config || {};
+        config.x = config.x || 0;
+        config.y = config.y || 0;
+        config.width = config.width || this.width();
+        config.height = config.height || this.height();
+        var canvas = new Canvas_1.SceneCanvas({
+            width: config.width,
+            height: config.height,
+            pixelRatio: config.pixelRatio || 1,
+        });
+        var _context = canvas.getContext()._context;
+        var layers = this.children;
+        if (config.x || config.y) {
+            _context.translate(-1 * config.x, -1 * config.y);
+        }
+        layers.forEach(function (layer) {
+            if (!layer.isVisible()) {
+                return;
+            }
+            var layerCanvas = layer._toKonvaCanvas(config);
+            _context.drawImage(layerCanvas._canvas, config.x, config.y, layerCanvas.getWidth() / layerCanvas.getPixelRatio(), layerCanvas.getHeight() / layerCanvas.getPixelRatio());
+        });
+        return canvas;
+    }
+    getIntersection(pos) {
+        if (!pos) {
+            return null;
+        }
+        var layers = this.children, len = layers.length, end = len - 1, n;
+        for (n = end; n >= 0; n--) {
+            const shape = layers[n].getIntersection(pos);
+            if (shape) {
+                return shape;
+            }
+        }
+        return null;
+    }
+    _resizeDOM() {
+        var width = this.width();
+        var height = this.height();
+        if (this.content) {
+            this.content.style.width = width + PX;
+            this.content.style.height = height + PX;
+        }
+        this.bufferCanvas.setSize(width, height);
+        this.bufferHitCanvas.setSize(width, height);
+        this.children.forEach((layer) => {
+            layer.setSize({ width, height });
+            layer.draw();
+        });
+    }
+    add(layer, ...rest) {
+        if (arguments.length > 1) {
+            for (var i = 0; i < arguments.length; i++) {
+                this.add(arguments[i]);
+            }
+            return this;
+        }
+        super.add(layer);
+        var length = this.children.length;
+        if (length > MAX_LAYERS_NUMBER) {
+            Util_1.Util.warn('The stage has ' +
+                length +
+                ' layers. Recommended maximum number of layers is 3-5. Adding more layers into the stage may drop the performance. Rethink your tree structure, you can use Konva.Group.');
+        }
+        layer.setSize({ width: this.width(), height: this.height() });
+        layer.draw();
+        if (Global_1.Konva.isBrowser) {
+            this.content.appendChild(layer.canvas._canvas);
+        }
+        return this;
+    }
+    getParent() {
+        return null;
+    }
+    getLayer() {
+        return null;
+    }
+    hasPointerCapture(pointerId) {
+        return PointerEvents.hasPointerCapture(pointerId, this);
+    }
+    setPointerCapture(pointerId) {
+        PointerEvents.setPointerCapture(pointerId, this);
+    }
+    releaseCapture(pointerId) {
+        PointerEvents.releaseCapture(pointerId, this);
+    }
+    getLayers() {
+        return this.children;
+    }
+    _bindContentEvents() {
+        if (!Global_1.Konva.isBrowser) {
+            return;
+        }
+        EVENTS.forEach(([event, methodName]) => {
+            this.content.addEventListener(event, (evt) => {
+                this[methodName](evt);
+            });
+        });
+    }
+    _pointerenter(evt) {
+        this.setPointersPositions(evt);
+        const events = getEventsMap(evt.type);
+        this._fire(events.pointerenter, {
+            evt: evt,
+            target: this,
+            currentTarget: this,
+        });
+    }
+    _pointerover(evt) {
+        this.setPointersPositions(evt);
+        const events = getEventsMap(evt.type);
+        this._fire(events.pointerover, {
+            evt: evt,
+            target: this,
+            currentTarget: this,
+        });
+    }
+    _getTargetShape(evenType) {
+        let shape = this[evenType + 'targetShape'];
+        if (shape && !shape.getStage()) {
+            shape = null;
+        }
+        return shape;
+    }
+    _pointerleave(evt) {
+        const events = getEventsMap(evt.type);
+        const eventType = getEventType(evt.type);
+        if (!events) {
+            return;
+        }
+        this.setPointersPositions(evt);
+        var targetShape = this._getTargetShape(eventType);
+        var eventsEnabled = !DragAndDrop_1.DD.isDragging || Global_1.Konva.hitOnDragEnabled;
+        if (targetShape && eventsEnabled) {
+            targetShape._fireAndBubble(events.pointerout, { evt: evt });
+            targetShape._fireAndBubble(events.pointerleave, { evt: evt });
+            this._fire(events.pointerleave, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+            });
+            this[eventType + 'targetShape'] = null;
+        }
+        else if (eventsEnabled) {
+            this._fire(events.pointerleave, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+            });
+            this._fire(events.pointerout, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+            });
+        }
+        this.pointerPos = undefined;
+        this._pointerPositions = [];
+    }
+    _pointerdown(evt) {
+        const events = getEventsMap(evt.type);
+        const eventType = getEventType(evt.type);
+        if (!events) {
+            return;
+        }
+        this.setPointersPositions(evt);
+        var triggeredOnShape = false;
+        this._changedPointerPositions.forEach((pos) => {
+            var shape = this.getIntersection(pos);
+            DragAndDrop_1.DD.justDragged = false;
+            Global_1.Konva['_' + eventType + 'ListenClick'] = true;
+            const hasShape = shape && shape.isListening();
+            if (!hasShape) {
+                return;
+            }
+            if (Global_1.Konva.capturePointerEventsEnabled) {
+                shape.setPointerCapture(pos.id);
+            }
+            this[eventType + 'ClickStartShape'] = shape;
+            shape._fireAndBubble(events.pointerdown, {
+                evt: evt,
+                pointerId: pos.id,
+            });
+            triggeredOnShape = true;
+            const isTouch = evt.type.indexOf('touch') >= 0;
+            if (shape.preventDefault() && evt.cancelable && isTouch) {
+                evt.preventDefault();
+            }
+        });
+        if (!triggeredOnShape) {
+            this._fire(events.pointerdown, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+                pointerId: this._pointerPositions[0].id,
+            });
+        }
+    }
+    _pointermove(evt) {
+        const events = getEventsMap(evt.type);
+        const eventType = getEventType(evt.type);
+        if (!events) {
+            return;
+        }
+        if (DragAndDrop_1.DD.isDragging && DragAndDrop_1.DD.node.preventDefault() && evt.cancelable) {
+            evt.preventDefault();
+        }
+        this.setPointersPositions(evt);
+        var eventsEnabled = !DragAndDrop_1.DD.isDragging || Global_1.Konva.hitOnDragEnabled;
+        if (!eventsEnabled) {
+            return;
+        }
+        var processedShapesIds = {};
+        let triggeredOnShape = false;
+        var targetShape = this._getTargetShape(eventType);
+        this._changedPointerPositions.forEach((pos) => {
+            const shape = (PointerEvents.getCapturedShape(pos.id) ||
+                this.getIntersection(pos));
+            const pointerId = pos.id;
+            const event = { evt: evt, pointerId };
+            var differentTarget = targetShape !== shape;
+            if (differentTarget && targetShape) {
+                targetShape._fireAndBubble(events.pointerout, Object.assign({}, event), shape);
+                targetShape._fireAndBubble(events.pointerleave, Object.assign({}, event), shape);
+            }
+            if (shape) {
+                if (processedShapesIds[shape._id]) {
+                    return;
+                }
+                processedShapesIds[shape._id] = true;
+            }
+            if (shape && shape.isListening()) {
+                triggeredOnShape = true;
+                if (differentTarget) {
+                    shape._fireAndBubble(events.pointerover, Object.assign({}, event), targetShape);
+                    shape._fireAndBubble(events.pointerenter, Object.assign({}, event), targetShape);
+                    this[eventType + 'targetShape'] = shape;
+                }
+                shape._fireAndBubble(events.pointermove, Object.assign({}, event));
+            }
+            else {
+                if (targetShape) {
+                    this._fire(events.pointerover, {
+                        evt: evt,
+                        target: this,
+                        currentTarget: this,
+                        pointerId,
+                    });
+                    this[eventType + 'targetShape'] = null;
+                }
+            }
+        });
+        if (!triggeredOnShape) {
+            this._fire(events.pointermove, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+                pointerId: this._changedPointerPositions[0].id,
+            });
+        }
+    }
+    _pointerup(evt) {
+        const events = getEventsMap(evt.type);
+        const eventType = getEventType(evt.type);
+        if (!events) {
+            return;
+        }
+        this.setPointersPositions(evt);
+        const clickStartShape = this[eventType + 'ClickStartShape'];
+        const clickEndShape = this[eventType + 'ClickEndShape'];
+        var processedShapesIds = {};
+        let triggeredOnShape = false;
+        this._changedPointerPositions.forEach((pos) => {
+            const shape = (PointerEvents.getCapturedShape(pos.id) ||
+                this.getIntersection(pos));
+            if (shape) {
+                shape.releaseCapture(pos.id);
+                if (processedShapesIds[shape._id]) {
+                    return;
+                }
+                processedShapesIds[shape._id] = true;
+            }
+            const pointerId = pos.id;
+            const event = { evt: evt, pointerId };
+            let fireDblClick = false;
+            if (Global_1.Konva['_' + eventType + 'InDblClickWindow'] &&
+                Global_1.Konva['_' + eventType + 'InDblClickWindowId'] === pointerId) {
+                fireDblClick = true;
+                clearTimeout(this[eventType + 'DblTimeout']);
+            }
+            else if (!DragAndDrop_1.DD.justDragged) {
+                Global_1.Konva['_' + eventType + 'InDblClickWindow'] = true;
+                Global_1.Konva['_' + eventType + 'InDblClickWindowId'] = pointerId;
+                clearTimeout(this[eventType + 'DblTimeout']);
+            }
+            this[eventType + 'DblTimeout'] = setTimeout(function () {
+                Global_1.Konva['_' + eventType + 'InDblClickWindow'] = false;
+            }, Global_1.Konva.dblClickWindow);
+            if (shape && shape.isListening()) {
+                triggeredOnShape = true;
+                this[eventType + 'ClickEndShape'] = shape;
+                shape._fireAndBubble(events.pointerup, Object.assign({}, event));
+                if (Global_1.Konva['_' + eventType + 'ListenClick'] &&
+                    clickStartShape &&
+                    clickStartShape === shape) {
+                    shape._fireAndBubble(events.pointerclick, Object.assign({}, event));
+                    if (fireDblClick && clickEndShape && clickEndShape === shape) {
+                        shape._fireAndBubble(events.pointerdblclick, Object.assign({}, event));
+                    }
+                }
+            }
+            else {
+                this[eventType + 'ClickEndShape'] = null;
+                if (Global_1.Konva['_' + eventType + 'ListenClick']) {
+                    this._fire(events.pointerclick, {
+                        evt: evt,
+                        target: this,
+                        currentTarget: this,
+                        pointerId,
+                    });
+                }
+                if (fireDblClick) {
+                    this._fire(events.pointerdblclick, {
+                        evt: evt,
+                        target: this,
+                        currentTarget: this,
+                        pointerId,
+                    });
+                }
+            }
+        });
+        if (!triggeredOnShape) {
+            this._fire(events.pointerup, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+                pointerId: this._changedPointerPositions[0].id,
+            });
+        }
+        Global_1.Konva['_' + eventType + 'ListenClick'] = false;
+        if (evt.cancelable) {
+            evt.preventDefault();
+        }
+    }
+    _contextmenu(evt) {
+        this.setPointersPositions(evt);
+        var shape = this.getIntersection(this.getPointerPosition());
+        if (shape && shape.isListening()) {
+            shape._fireAndBubble(CONTEXTMENU, { evt: evt });
+        }
+        else {
+            this._fire(CONTEXTMENU, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+            });
+        }
+    }
+    _wheel(evt) {
+        this.setPointersPositions(evt);
+        var shape = this.getIntersection(this.getPointerPosition());
+        if (shape && shape.isListening()) {
+            shape._fireAndBubble(WHEEL, { evt: evt });
+        }
+        else {
+            this._fire(WHEEL, {
+                evt: evt,
+                target: this,
+                currentTarget: this,
+            });
+        }
+    }
+    _pointercancel(evt) {
+        this.setPointersPositions(evt);
+        const shape = PointerEvents.getCapturedShape(evt.pointerId) ||
+            this.getIntersection(this.getPointerPosition());
+        if (shape) {
+            shape._fireAndBubble(POINTERUP, PointerEvents.createEvent(evt));
+        }
+        PointerEvents.releaseCapture(evt.pointerId);
+    }
+    _lostpointercapture(evt) {
+        PointerEvents.releaseCapture(evt.pointerId);
+    }
+    setPointersPositions(evt) {
+        var contentPosition = this._getContentPosition(), x = null, y = null;
+        evt = evt ? evt : window.event;
+        if (evt.touches !== undefined) {
+            this._pointerPositions = [];
+            this._changedPointerPositions = [];
+            Array.prototype.forEach.call(evt.touches, (touch) => {
+                this._pointerPositions.push({
+                    id: touch.identifier,
+                    x: (touch.clientX - contentPosition.left) / contentPosition.scaleX,
+                    y: (touch.clientY - contentPosition.top) / contentPosition.scaleY,
+                });
+            });
+            Array.prototype.forEach.call(evt.changedTouches || evt.touches, (touch) => {
+                this._changedPointerPositions.push({
+                    id: touch.identifier,
+                    x: (touch.clientX - contentPosition.left) / contentPosition.scaleX,
+                    y: (touch.clientY - contentPosition.top) / contentPosition.scaleY,
+                });
+            });
+        }
+        else {
+            x = (evt.clientX - contentPosition.left) / contentPosition.scaleX;
+            y = (evt.clientY - contentPosition.top) / contentPosition.scaleY;
+            this.pointerPos = {
+                x: x,
+                y: y,
+            };
+            this._pointerPositions = [{ x, y, id: Util_1.Util._getFirstPointerId(evt) }];
+            this._changedPointerPositions = [
+                { x, y, id: Util_1.Util._getFirstPointerId(evt) },
+            ];
+        }
+    }
+    _setPointerPosition(evt) {
+        Util_1.Util.warn('Method _setPointerPosition is deprecated. Use "stage.setPointersPositions(event)" instead.');
+        this.setPointersPositions(evt);
+    }
+    _getContentPosition() {
+        if (!this.content || !this.content.getBoundingClientRect) {
+            return {
+                top: 0,
+                left: 0,
+                scaleX: 1,
+                scaleY: 1,
+            };
+        }
+        var rect = this.content.getBoundingClientRect();
+        return {
+            top: rect.top,
+            left: rect.left,
+            scaleX: rect.width / this.content.clientWidth || 1,
+            scaleY: rect.height / this.content.clientHeight || 1,
+        };
+    }
+    _buildDOM() {
+        this.bufferCanvas = new Canvas_1.SceneCanvas({
+            width: this.width(),
+            height: this.height(),
+        });
+        this.bufferHitCanvas = new Canvas_1.HitCanvas({
+            pixelRatio: 1,
+            width: this.width(),
+            height: this.height(),
+        });
+        if (!Global_1.Konva.isBrowser) {
+            return;
+        }
+        var container = this.container();
+        if (!container) {
+            throw 'Stage has no container. A container is required.';
+        }
+        container.innerHTML = '';
+        this.content = document.createElement('div');
+        this.content.style.position = 'relative';
+        this.content.style.userSelect = 'none';
+        this.content.className = 'konvajs-content';
+        this.content.setAttribute('role', 'presentation');
+        container.appendChild(this.content);
+        this._resizeDOM();
+    }
+    cache() {
+        Util_1.Util.warn('Cache function is not allowed for stage. You may use cache only for layers, groups and shapes.');
+        return this;
+    }
+    clearCache() {
+        return this;
+    }
+    batchDraw() {
+        this.getChildren().forEach(function (layer) {
+            layer.batchDraw();
+        });
+        return this;
+    }
+}
+exports.Stage = Stage;
+Stage.prototype.nodeType = STAGE;
+(0, Global_2._registerNode)(Stage);
+Factory_1.Factory.addGetterSetter(Stage, 'container');

node_modules/konva/cmj/Tween.d.ts

@@ -0,0 +1,86 @@
+import { Animation } from './Animation';
+import { Node, NodeConfig } from './Node';
+declare class TweenEngine {
+    prop: string;
+    propFunc: Function;
+    begin: number;
+    _pos: number;
+    duration: number;
+    prevPos: number;
+    yoyo: boolean;
+    _time: number;
+    _position: number;
+    _startTime: number;
+    _finish: number;
+    func: Function;
+    _change: number;
+    state: number;
+    onPlay: Function;
+    onReverse: Function;
+    onPause: Function;
+    onReset: Function;
+    onFinish: Function;
+    onUpdate: Function;
+    constructor(prop: any, propFunc: any, func: any, begin: any, finish: any, duration: any, yoyo: any);
+    fire(str: any): void;
+    setTime(t: any): void;
+    getTime(): number;
+    setPosition(p: any): void;
+    getPosition(t: any): any;
+    play(): void;
+    reverse(): void;
+    seek(t: any): void;
+    reset(): void;
+    finish(): void;
+    update(): void;
+    onEnterFrame(): void;
+    pause(): void;
+    getTimer(): number;
+}
+export interface TweenConfig extends NodeConfig {
+    onFinish?: Function;
+    onUpdate?: Function;
+    duration?: number;
+    node: Node;
+}
+export declare class Tween {
+    static attrs: {};
+    static tweens: {};
+    node: Node;
+    anim: Animation;
+    tween: TweenEngine;
+    _id: number;
+    onFinish: Function;
+    onReset: Function;
+    onUpdate: Function;
+    constructor(config: TweenConfig);
+    _addAttr(key: any, end: any): void;
+    _tweenFunc(i: any): void;
+    _addListeners(): void;
+    play(): this;
+    reverse(): this;
+    reset(): this;
+    seek(t: any): this;
+    pause(): this;
+    finish(): this;
+    destroy(): void;
+}
+export declare const Easings: {
+    BackEaseIn(t: any, b: any, c: any, d: any): any;
+    BackEaseOut(t: any, b: any, c: any, d: any): any;
+    BackEaseInOut(t: any, b: any, c: any, d: any): any;
+    ElasticEaseIn(t: any, b: any, c: any, d: any, a: any, p: any): any;
+    ElasticEaseOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+    ElasticEaseInOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+    BounceEaseOut(t: any, b: any, c: any, d: any): any;
+    BounceEaseIn(t: any, b: any, c: any, d: any): any;
+    BounceEaseInOut(t: any, b: any, c: any, d: any): any;
+    EaseIn(t: any, b: any, c: any, d: any): any;
+    EaseOut(t: any, b: any, c: any, d: any): any;
+    EaseInOut(t: any, b: any, c: any, d: any): any;
+    StrongEaseIn(t: any, b: any, c: any, d: any): any;
+    StrongEaseOut(t: any, b: any, c: any, d: any): any;
+    StrongEaseInOut(t: any, b: any, c: any, d: any): any;
+    Linear(t: any, b: any, c: any, d: any): any;
+};
+export {};

node_modules/konva/cmj/Tween.js

@@ -0,0 +1,520 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Easings = exports.Tween = void 0;
+const Util_1 = require("./Util");
+const Animation_1 = require("./Animation");
+const Node_1 = require("./Node");
+const Global_1 = require("./Global");
+var blacklist = {
+    node: 1,
+    duration: 1,
+    easing: 1,
+    onFinish: 1,
+    yoyo: 1,
+}, PAUSED = 1, PLAYING = 2, REVERSING = 3, idCounter = 0, colorAttrs = ['fill', 'stroke', 'shadowColor'];
+class TweenEngine {
+    constructor(prop, propFunc, func, begin, finish, duration, yoyo) {
+        this.prop = prop;
+        this.propFunc = propFunc;
+        this.begin = begin;
+        this._pos = begin;
+        this.duration = duration;
+        this._change = 0;
+        this.prevPos = 0;
+        this.yoyo = yoyo;
+        this._time = 0;
+        this._position = 0;
+        this._startTime = 0;
+        this._finish = 0;
+        this.func = func;
+        this._change = finish - this.begin;
+        this.pause();
+    }
+    fire(str) {
+        var handler = this[str];
+        if (handler) {
+            handler();
+        }
+    }
+    setTime(t) {
+        if (t > this.duration) {
+            if (this.yoyo) {
+                this._time = this.duration;
+                this.reverse();
+            }
+            else {
+                this.finish();
+            }
+        }
+        else if (t < 0) {
+            if (this.yoyo) {
+                this._time = 0;
+                this.play();
+            }
+            else {
+                this.reset();
+            }
+        }
+        else {
+            this._time = t;
+            this.update();
+        }
+    }
+    getTime() {
+        return this._time;
+    }
+    setPosition(p) {
+        this.prevPos = this._pos;
+        this.propFunc(p);
+        this._pos = p;
+    }
+    getPosition(t) {
+        if (t === undefined) {
+            t = this._time;
+        }
+        return this.func(t, this.begin, this._change, this.duration);
+    }
+    play() {
+        this.state = PLAYING;
+        this._startTime = this.getTimer() - this._time;
+        this.onEnterFrame();
+        this.fire('onPlay');
+    }
+    reverse() {
+        this.state = REVERSING;
+        this._time = this.duration - this._time;
+        this._startTime = this.getTimer() - this._time;
+        this.onEnterFrame();
+        this.fire('onReverse');
+    }
+    seek(t) {
+        this.pause();
+        this._time = t;
+        this.update();
+        this.fire('onSeek');
+    }
+    reset() {
+        this.pause();
+        this._time = 0;
+        this.update();
+        this.fire('onReset');
+    }
+    finish() {
+        this.pause();
+        this._time = this.duration;
+        this.update();
+        this.fire('onFinish');
+    }
+    update() {
+        this.setPosition(this.getPosition(this._time));
+        this.fire('onUpdate');
+    }
+    onEnterFrame() {
+        var t = this.getTimer() - this._startTime;
+        if (this.state === PLAYING) {
+            this.setTime(t);
+        }
+        else if (this.state === REVERSING) {
+            this.setTime(this.duration - t);
+        }
+    }
+    pause() {
+        this.state = PAUSED;
+        this.fire('onPause');
+    }
+    getTimer() {
+        return new Date().getTime();
+    }
+}
+class Tween {
+    constructor(config) {
+        var that = this, node = config.node, nodeId = node._id, duration, easing = config.easing || exports.Easings.Linear, yoyo = !!config.yoyo, key;
+        if (typeof config.duration === 'undefined') {
+            duration = 0.3;
+        }
+        else if (config.duration === 0) {
+            duration = 0.001;
+        }
+        else {
+            duration = config.duration;
+        }
+        this.node = node;
+        this._id = idCounter++;
+        var layers = node.getLayer() ||
+            (node instanceof Global_1.Konva['Stage'] ? node.getLayers() : null);
+        if (!layers) {
+            Util_1.Util.error('Tween constructor have `node` that is not in a layer. Please add node into layer first.');
+        }
+        this.anim = new Animation_1.Animation(function () {
+            that.tween.onEnterFrame();
+        }, layers);
+        this.tween = new TweenEngine(key, function (i) {
+            that._tweenFunc(i);
+        }, easing, 0, 1, duration * 1000, yoyo);
+        this._addListeners();
+        if (!Tween.attrs[nodeId]) {
+            Tween.attrs[nodeId] = {};
+        }
+        if (!Tween.attrs[nodeId][this._id]) {
+            Tween.attrs[nodeId][this._id] = {};
+        }
+        if (!Tween.tweens[nodeId]) {
+            Tween.tweens[nodeId] = {};
+        }
+        for (key in config) {
+            if (blacklist[key] === undefined) {
+                this._addAttr(key, config[key]);
+            }
+        }
+        this.reset();
+        this.onFinish = config.onFinish;
+        this.onReset = config.onReset;
+        this.onUpdate = config.onUpdate;
+    }
+    _addAttr(key, end) {
+        var node = this.node, nodeId = node._id, start, diff, tweenId, n, len, trueEnd, trueStart, endRGBA;
+        tweenId = Tween.tweens[nodeId][key];
+        if (tweenId) {
+            delete Tween.attrs[nodeId][tweenId][key];
+        }
+        start = node.getAttr(key);
+        if (Util_1.Util._isArray(end)) {
+            diff = [];
+            len = Math.max(end.length, start.length);
+            if (key === 'points' && end.length !== start.length) {
+                if (end.length > start.length) {
+                    trueStart = start;
+                    start = Util_1.Util._prepareArrayForTween(start, end, node.closed());
+                }
+                else {
+                    trueEnd = end;
+                    end = Util_1.Util._prepareArrayForTween(end, start, node.closed());
+                }
+            }
+            if (key.indexOf('fill') === 0) {
+                for (n = 0; n < len; n++) {
+                    if (n % 2 === 0) {
+                        diff.push(end[n] - start[n]);
+                    }
+                    else {
+                        var startRGBA = Util_1.Util.colorToRGBA(start[n]);
+                        endRGBA = Util_1.Util.colorToRGBA(end[n]);
+                        start[n] = startRGBA;
+                        diff.push({
+                            r: endRGBA.r - startRGBA.r,
+                            g: endRGBA.g - startRGBA.g,
+                            b: endRGBA.b - startRGBA.b,
+                            a: endRGBA.a - startRGBA.a,
+                        });
+                    }
+                }
+            }
+            else {
+                for (n = 0; n < len; n++) {
+                    diff.push(end[n] - start[n]);
+                }
+            }
+        }
+        else if (colorAttrs.indexOf(key) !== -1) {
+            start = Util_1.Util.colorToRGBA(start);
+            endRGBA = Util_1.Util.colorToRGBA(end);
+            diff = {
+                r: endRGBA.r - start.r,
+                g: endRGBA.g - start.g,
+                b: endRGBA.b - start.b,
+                a: endRGBA.a - start.a,
+            };
+        }
+        else {
+            diff = end - start;
+        }
+        Tween.attrs[nodeId][this._id][key] = {
+            start: start,
+            diff: diff,
+            end: end,
+            trueEnd: trueEnd,
+            trueStart: trueStart,
+        };
+        Tween.tweens[nodeId][key] = this._id;
+    }
+    _tweenFunc(i) {
+        var node = this.node, attrs = Tween.attrs[node._id][this._id], key, attr, start, diff, newVal, n, len, end;
+        for (key in attrs) {
+            attr = attrs[key];
+            start = attr.start;
+            diff = attr.diff;
+            end = attr.end;
+            if (Util_1.Util._isArray(start)) {
+                newVal = [];
+                len = Math.max(start.length, end.length);
+                if (key.indexOf('fill') === 0) {
+                    for (n = 0; n < len; n++) {
+                        if (n % 2 === 0) {
+                            newVal.push((start[n] || 0) + diff[n] * i);
+                        }
+                        else {
+                            newVal.push('rgba(' +
+                                Math.round(start[n].r + diff[n].r * i) +
+                                ',' +
+                                Math.round(start[n].g + diff[n].g * i) +
+                                ',' +
+                                Math.round(start[n].b + diff[n].b * i) +
+                                ',' +
+                                (start[n].a + diff[n].a * i) +
+                                ')');
+                        }
+                    }
+                }
+                else {
+                    for (n = 0; n < len; n++) {
+                        newVal.push((start[n] || 0) + diff[n] * i);
+                    }
+                }
+            }
+            else if (colorAttrs.indexOf(key) !== -1) {
+                newVal =
+                    'rgba(' +
+                        Math.round(start.r + diff.r * i) +
+                        ',' +
+                        Math.round(start.g + diff.g * i) +
+                        ',' +
+                        Math.round(start.b + diff.b * i) +
+                        ',' +
+                        (start.a + diff.a * i) +
+                        ')';
+            }
+            else {
+                newVal = start + diff * i;
+            }
+            node.setAttr(key, newVal);
+        }
+    }
+    _addListeners() {
+        this.tween.onPlay = () => {
+            this.anim.start();
+        };
+        this.tween.onReverse = () => {
+            this.anim.start();
+        };
+        this.tween.onPause = () => {
+            this.anim.stop();
+        };
+        this.tween.onFinish = () => {
+            var node = this.node;
+            var attrs = Tween.attrs[node._id][this._id];
+            if (attrs.points && attrs.points.trueEnd) {
+                node.setAttr('points', attrs.points.trueEnd);
+            }
+            if (this.onFinish) {
+                this.onFinish.call(this);
+            }
+        };
+        this.tween.onReset = () => {
+            var node = this.node;
+            var attrs = Tween.attrs[node._id][this._id];
+            if (attrs.points && attrs.points.trueStart) {
+                node.points(attrs.points.trueStart);
+            }
+            if (this.onReset) {
+                this.onReset();
+            }
+        };
+        this.tween.onUpdate = () => {
+            if (this.onUpdate) {
+                this.onUpdate.call(this);
+            }
+        };
+    }
+    play() {
+        this.tween.play();
+        return this;
+    }
+    reverse() {
+        this.tween.reverse();
+        return this;
+    }
+    reset() {
+        this.tween.reset();
+        return this;
+    }
+    seek(t) {
+        this.tween.seek(t * 1000);
+        return this;
+    }
+    pause() {
+        this.tween.pause();
+        return this;
+    }
+    finish() {
+        this.tween.finish();
+        return this;
+    }
+    destroy() {
+        var nodeId = this.node._id, thisId = this._id, attrs = Tween.tweens[nodeId], key;
+        this.pause();
+        for (key in attrs) {
+            delete Tween.tweens[nodeId][key];
+        }
+        delete Tween.attrs[nodeId][thisId];
+    }
+}
+exports.Tween = Tween;
+Tween.attrs = {};
+Tween.tweens = {};
+Node_1.Node.prototype.to = function (params) {
+    var onFinish = params.onFinish;
+    params.node = this;
+    params.onFinish = function () {
+        this.destroy();
+        if (onFinish) {
+            onFinish();
+        }
+    };
+    var tween = new Tween(params);
+    tween.play();
+};
+exports.Easings = {
+    BackEaseIn(t, b, c, d) {
+        var s = 1.70158;
+        return c * (t /= d) * t * ((s + 1) * t - s) + b;
+    },
+    BackEaseOut(t, b, c, d) {
+        var s = 1.70158;
+        return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+    },
+    BackEaseInOut(t, b, c, d) {
+        var s = 1.70158;
+        if ((t /= d / 2) < 1) {
+            return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
+        }
+        return (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;
+    },
+    ElasticEaseIn(t, b, c, d, a, p) {
+        var s = 0;
+        if (t === 0) {
+            return b;
+        }
+        if ((t /= d) === 1) {
+            return b + c;
+        }
+        if (!p) {
+            p = d * 0.3;
+        }
+        if (!a || a < Math.abs(c)) {
+            a = c;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(c / a);
+        }
+        return (-(a *
+            Math.pow(2, 10 * (t -= 1)) *
+            Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b);
+    },
+    ElasticEaseOut(t, b, c, d, a, p) {
+        var s = 0;
+        if (t === 0) {
+            return b;
+        }
+        if ((t /= d) === 1) {
+            return b + c;
+        }
+        if (!p) {
+            p = d * 0.3;
+        }
+        if (!a || a < Math.abs(c)) {
+            a = c;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(c / a);
+        }
+        return (a * Math.pow(2, -10 * t) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) +
+            c +
+            b);
+    },
+    ElasticEaseInOut(t, b, c, d, a, p) {
+        var s = 0;
+        if (t === 0) {
+            return b;
+        }
+        if ((t /= d / 2) === 2) {
+            return b + c;
+        }
+        if (!p) {
+            p = d * (0.3 * 1.5);
+        }
+        if (!a || a < Math.abs(c)) {
+            a = c;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(c / a);
+        }
+        if (t < 1) {
+            return (-0.5 *
+                (a *
+                    Math.pow(2, 10 * (t -= 1)) *
+                    Math.sin(((t * d - s) * (2 * Math.PI)) / p)) +
+                b);
+        }
+        return (a *
+            Math.pow(2, -10 * (t -= 1)) *
+            Math.sin(((t * d - s) * (2 * Math.PI)) / p) *
+            0.5 +
+            c +
+            b);
+    },
+    BounceEaseOut(t, b, c, d) {
+        if ((t /= d) < 1 / 2.75) {
+            return c * (7.5625 * t * t) + b;
+        }
+        else if (t < 2 / 2.75) {
+            return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b;
+        }
+        else if (t < 2.5 / 2.75) {
+            return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b;
+        }
+        else {
+            return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b;
+        }
+    },
+    BounceEaseIn(t, b, c, d) {
+        return c - exports.Easings.BounceEaseOut(d - t, 0, c, d) + b;
+    },
+    BounceEaseInOut(t, b, c, d) {
+        if (t < d / 2) {
+            return exports.Easings.BounceEaseIn(t * 2, 0, c, d) * 0.5 + b;
+        }
+        else {
+            return exports.Easings.BounceEaseOut(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
+        }
+    },
+    EaseIn(t, b, c, d) {
+        return c * (t /= d) * t + b;
+    },
+    EaseOut(t, b, c, d) {
+        return -c * (t /= d) * (t - 2) + b;
+    },
+    EaseInOut(t, b, c, d) {
+        if ((t /= d / 2) < 1) {
+            return (c / 2) * t * t + b;
+        }
+        return (-c / 2) * (--t * (t - 2) - 1) + b;
+    },
+    StrongEaseIn(t, b, c, d) {
+        return c * (t /= d) * t * t * t * t + b;
+    },
+    StrongEaseOut(t, b, c, d) {
+        return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+    },
+    StrongEaseInOut(t, b, c, d) {
+        if ((t /= d / 2) < 1) {
+            return (c / 2) * t * t * t * t * t + b;
+        }
+        return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b;
+    },
+    Linear(t, b, c, d) {
+        return (c * t) / d + b;
+    },
+};

node_modules/konva/cmj/Util.d.ts

@@ -0,0 +1,87 @@
+import { IRect, RGB, RGBA, Vector2d } from './types';
+export declare class Transform {
+    m: Array<number>;
+    dirty: boolean;
+    constructor(m?: number[]);
+    reset(): void;
+    copy(): Transform;
+    copyInto(tr: Transform): void;
+    point(point: Vector2d): {
+        x: number;
+        y: number;
+    };
+    translate(x: number, y: number): this;
+    scale(sx: number, sy: number): this;
+    rotate(rad: number): this;
+    getTranslation(): {
+        x: number;
+        y: number;
+    };
+    skew(sx: number, sy: number): this;
+    multiply(matrix: Transform): this;
+    invert(): this;
+    getMatrix(): number[];
+    setAbsolutePosition(x: number, y: number): this;
+    decompose(): {
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        skewX: number;
+        skewY: number;
+    };
+}
+export declare const Util: {
+    _isElement(obj: any): obj is Element;
+    _isFunction(obj: any): boolean;
+    _isPlainObject(obj: any): boolean;
+    _isArray(obj: any): obj is any[];
+    _isNumber(obj: any): obj is number;
+    _isString(obj: any): obj is string;
+    _isBoolean(obj: any): obj is boolean;
+    isObject(val: any): val is Object;
+    isValidSelector(selector: any): boolean;
+    _sign(number: number): 1 | -1;
+    requestAnimFrame(callback: Function): void;
+    createCanvasElement(): HTMLCanvasElement;
+    createImageElement(): HTMLImageElement;
+    _isInDocument(el: any): boolean;
+    _urlToImage(url: string, callback: Function): void;
+    _rgbToHex(r: number, g: number, b: number): string;
+    _hexToRgb(hex: string): RGB;
+    getRandomColor(): string;
+    getRGB(color: string): RGB;
+    colorToRGBA(str: string): RGBA;
+    _namedColorToRBA(str: string): {
+        r: any;
+        g: any;
+        b: any;
+        a: number;
+    };
+    _rgbColorToRGBA(str: string): RGBA;
+    _rgbaColorToRGBA(str: string): RGBA;
+    _hex6ColorToRGBA(str: string): RGBA;
+    _hex3ColorToRGBA(str: string): RGBA;
+    _hslColorToRGBA(str: string): RGBA;
+    haveIntersection(r1: IRect, r2: IRect): boolean;
+    cloneObject<Any>(obj: Any): Any;
+    cloneArray(arr: Array<any>): any[];
+    degToRad(deg: number): number;
+    radToDeg(rad: number): number;
+    _degToRad(deg: number): number;
+    _radToDeg(rad: number): number;
+    _getRotation(radians: any): any;
+    _capitalize(str: string): string;
+    throw(str: string): never;
+    error(str: string): void;
+    warn(str: string): void;
+    each(obj: any, func: any): void;
+    _inRange(val: any, left: any, right: any): boolean;
+    _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
+    _getProjectionToLine(pt: Vector2d, line: any, isClosed: any): Vector2d;
+    _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): any[];
+    _prepareToStringify(obj: any): any;
+    _assign<T, U>(target: T, source: U): T & U;
+    _getFirstPointerId(evt: any): any;
+};

node_modules/konva/cmj/Util.js

@@ -0,0 +1,746 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Util = exports.Transform = void 0;
+const Global_1 = require("./Global");
+class Transform {
+    constructor(m = [1, 0, 0, 1, 0, 0]) {
+        this.dirty = false;
+        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() {
+        return new Transform(this.m);
+    }
+    copyInto(tr) {
+        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];
+    }
+    point(point) {
+        var 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],
+        };
+    }
+    translate(x, y) {
+        this.m[4] += this.m[0] * x + this.m[2] * y;
+        this.m[5] += this.m[1] * x + this.m[3] * y;
+        return this;
+    }
+    scale(sx, sy) {
+        this.m[0] *= sx;
+        this.m[1] *= sx;
+        this.m[2] *= sy;
+        this.m[3] *= sy;
+        return this;
+    }
+    rotate(rad) {
+        var c = Math.cos(rad);
+        var s = Math.sin(rad);
+        var m11 = this.m[0] * c + this.m[2] * s;
+        var m12 = this.m[1] * c + this.m[3] * s;
+        var m21 = this.m[0] * -s + this.m[2] * c;
+        var 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;
+    }
+    getTranslation() {
+        return {
+            x: this.m[4],
+            y: this.m[5],
+        };
+    }
+    skew(sx, sy) {
+        var m11 = this.m[0] + this.m[2] * sy;
+        var m12 = this.m[1] + this.m[3] * sy;
+        var m21 = this.m[2] + this.m[0] * sx;
+        var 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;
+    }
+    multiply(matrix) {
+        var m11 = this.m[0] * matrix.m[0] + this.m[2] * matrix.m[1];
+        var m12 = this.m[1] * matrix.m[0] + this.m[3] * matrix.m[1];
+        var m21 = this.m[0] * matrix.m[2] + this.m[2] * matrix.m[3];
+        var m22 = this.m[1] * matrix.m[2] + this.m[3] * matrix.m[3];
+        var dx = this.m[0] * matrix.m[4] + this.m[2] * matrix.m[5] + this.m[4];
+        var 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() {
+        var d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+        var m0 = this.m[3] * d;
+        var m1 = -this.m[1] * d;
+        var m2 = -this.m[2] * d;
+        var m3 = this.m[0] * d;
+        var m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+        var 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;
+    }
+    getMatrix() {
+        return this.m;
+    }
+    setAbsolutePosition(x, y) {
+        var m0 = this.m[0], m1 = this.m[1], m2 = this.m[2], m3 = this.m[3], m4 = this.m[4], m5 = this.m[5], yt = (m0 * (y - m5) - m1 * (x - m4)) / (m0 * m3 - m1 * m2), xt = (x - m4 - m2 * yt) / m0;
+        return this.translate(xt, yt);
+    }
+    decompose() {
+        var a = this.m[0];
+        var b = this.m[1];
+        var c = this.m[2];
+        var d = this.m[3];
+        var e = this.m[4];
+        var f = this.m[5];
+        var delta = a * d - b * c;
+        let result = {
+            x: e,
+            y: f,
+            rotation: 0,
+            scaleX: 0,
+            scaleY: 0,
+            skewX: 0,
+            skewY: 0,
+        };
+        if (a != 0 || b != 0) {
+            var 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) {
+            var 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 {
+        }
+        result.rotation = exports.Util._getRotation(result.rotation);
+        return result;
+    }
+}
+exports.Transform = Transform;
+var 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})\)/, animQueue = [];
+const req = (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame) ||
+    function (f) {
+        setTimeout(f, 60);
+    };
+exports.Util = {
+    _isElement(obj) {
+        return !!(obj && obj.nodeType == 1);
+    },
+    _isFunction(obj) {
+        return !!(obj && obj.constructor && obj.call && obj.apply);
+    },
+    _isPlainObject(obj) {
+        return !!obj && obj.constructor === Object;
+    },
+    _isArray(obj) {
+        return Object.prototype.toString.call(obj) === OBJECT_ARRAY;
+    },
+    _isNumber(obj) {
+        return (Object.prototype.toString.call(obj) === OBJECT_NUMBER &&
+            !isNaN(obj) &&
+            isFinite(obj));
+    },
+    _isString(obj) {
+        return Object.prototype.toString.call(obj) === OBJECT_STRING;
+    },
+    _isBoolean(obj) {
+        return Object.prototype.toString.call(obj) === OBJECT_BOOLEAN;
+    },
+    isObject(val) {
+        return val instanceof Object;
+    },
+    isValidSelector(selector) {
+        if (typeof selector !== 'string') {
+            return false;
+        }
+        var firstChar = selector[0];
+        return (firstChar === '#' ||
+            firstChar === '.' ||
+            firstChar === firstChar.toUpperCase());
+    },
+    _sign(number) {
+        if (number === 0) {
+            return 1;
+        }
+        if (number > 0) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    },
+    requestAnimFrame(callback) {
+        animQueue.push(callback);
+        if (animQueue.length === 1) {
+            req(function () {
+                const queue = animQueue;
+                animQueue = [];
+                queue.forEach(function (cb) {
+                    cb();
+                });
+            });
+        }
+    },
+    createCanvasElement() {
+        var canvas = document.createElement('canvas');
+        try {
+            canvas.style = canvas.style || {};
+        }
+        catch (e) { }
+        return canvas;
+    },
+    createImageElement() {
+        return document.createElement('img');
+    },
+    _isInDocument(el) {
+        while ((el = el.parentNode)) {
+            if (el == document) {
+                return true;
+            }
+        }
+        return false;
+    },
+    _urlToImage(url, callback) {
+        var imageObj = exports.Util.createImageElement();
+        imageObj.onload = function () {
+            callback(imageObj);
+        };
+        imageObj.src = url;
+    },
+    _rgbToHex(r, g, b) {
+        return ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+    },
+    _hexToRgb(hex) {
+        hex = hex.replace(HASH, EMPTY_STRING);
+        var bigint = parseInt(hex, 16);
+        return {
+            r: (bigint >> 16) & 255,
+            g: (bigint >> 8) & 255,
+            b: bigint & 255,
+        };
+    },
+    getRandomColor() {
+        var randColor = ((Math.random() * 0xffffff) << 0).toString(16);
+        while (randColor.length < 6) {
+            randColor = ZERO + randColor;
+        }
+        return HASH + randColor;
+    },
+    getRGB(color) {
+        var rgb;
+        if (color in COLORS) {
+            rgb = COLORS[color];
+            return {
+                r: rgb[0],
+                g: rgb[1],
+                b: rgb[2],
+            };
+        }
+        else if (color[0] === HASH) {
+            return this._hexToRgb(color.substring(1));
+        }
+        else if (color.substr(0, 4) === RGB_PAREN) {
+            rgb = RGB_REGEX.exec(color.replace(/ /g, ''));
+            return {
+                r: parseInt(rgb[1], 10),
+                g: parseInt(rgb[2], 10),
+                b: parseInt(rgb[3], 10),
+            };
+        }
+        else {
+            return {
+                r: 0,
+                g: 0,
+                b: 0,
+            };
+        }
+    },
+    colorToRGBA(str) {
+        str = str || 'black';
+        return (exports.Util._namedColorToRBA(str) ||
+            exports.Util._hex3ColorToRGBA(str) ||
+            exports.Util._hex6ColorToRGBA(str) ||
+            exports.Util._rgbColorToRGBA(str) ||
+            exports.Util._rgbaColorToRGBA(str) ||
+            exports.Util._hslColorToRGBA(str));
+    },
+    _namedColorToRBA(str) {
+        var c = COLORS[str.toLowerCase()];
+        if (!c) {
+            return null;
+        }
+        return {
+            r: c[0],
+            g: c[1],
+            b: c[2],
+            a: 1,
+        };
+    },
+    _rgbColorToRGBA(str) {
+        if (str.indexOf('rgb(') === 0) {
+            str = str.match(/rgb\(([^)]+)\)/)[1];
+            var parts = str.split(/ *, */).map(Number);
+            return {
+                r: parts[0],
+                g: parts[1],
+                b: parts[2],
+                a: 1,
+            };
+        }
+    },
+    _rgbaColorToRGBA(str) {
+        if (str.indexOf('rgba(') === 0) {
+            str = str.match(/rgba\(([^)]+)\)/)[1];
+            var parts = str.split(/ *, */).map(Number);
+            return {
+                r: parts[0],
+                g: parts[1],
+                b: parts[2],
+                a: parts[3],
+            };
+        }
+    },
+    _hex6ColorToRGBA(str) {
+        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,
+            };
+        }
+    },
+    _hex3ColorToRGBA(str) {
+        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,
+            };
+        }
+    },
+    _hslColorToRGBA(str) {
+        if (/hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.test(str)) {
+            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,
+            };
+        }
+    },
+    haveIntersection(r1, r2) {
+        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(obj) {
+        var retObj = {};
+        for (var 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]);
+            }
+            else {
+                retObj[key] = obj[key];
+            }
+        }
+        return retObj;
+    },
+    cloneArray(arr) {
+        return arr.slice(0);
+    },
+    degToRad(deg) {
+        return deg * PI_OVER_DEG180;
+    },
+    radToDeg(rad) {
+        return rad * DEG180_OVER_PI;
+    },
+    _degToRad(deg) {
+        exports.Util.warn('Util._degToRad is removed. Please use public Util.degToRad instead.');
+        return exports.Util.degToRad(deg);
+    },
+    _radToDeg(rad) {
+        exports.Util.warn('Util._radToDeg is removed. Please use public Util.radToDeg instead.');
+        return exports.Util.radToDeg(rad);
+    },
+    _getRotation(radians) {
+        return Global_1.Konva.angleDeg ? exports.Util.radToDeg(radians) : radians;
+    },
+    _capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+    throw(str) {
+        throw new Error(KONVA_ERROR + str);
+    },
+    error(str) {
+        console.error(KONVA_ERROR + str);
+    },
+    warn(str) {
+        if (!Global_1.Konva.showWarnings) {
+            return;
+        }
+        console.warn(KONVA_WARNING + str);
+    },
+    each(obj, func) {
+        for (var key in obj) {
+            func(key, obj[key]);
+        }
+    },
+    _inRange(val, left, right) {
+        return left <= val && val < right;
+    },
+    _getProjectionToSegment(x1, y1, x2, y2, x3, y3) {
+        var x, y, dist;
+        var 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 {
+            var 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];
+    },
+    _getProjectionToLine(pt, line, isClosed) {
+        var pc = exports.Util.cloneObject(pt);
+        var dist = Number.MAX_VALUE;
+        line.forEach(function (p1, i) {
+            if (!isClosed && i === line.length - 1) {
+                return;
+            }
+            var p2 = line[(i + 1) % line.length];
+            var proj = exports.Util._getProjectionToSegment(p1.x, p1.y, p2.x, p2.y, pt.x, pt.y);
+            var 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) {
+        var n, start = [], end = [];
+        if (startArray.length > endArray.length) {
+            var temp = endArray;
+            endArray = startArray;
+            startArray = temp;
+        }
+        for (n = 0; n < startArray.length; n += 2) {
+            start.push({
+                x: startArray[n],
+                y: startArray[n + 1],
+            });
+        }
+        for (n = 0; n < endArray.length; n += 2) {
+            end.push({
+                x: endArray[n],
+                y: endArray[n + 1],
+            });
+        }
+        var newStart = [];
+        end.forEach(function (point) {
+            var pr = exports.Util._getProjectionToLine(point, start, isClosed);
+            newStart.push(pr.x);
+            newStart.push(pr.y);
+        });
+        return newStart;
+    },
+    _prepareToStringify(obj) {
+        var desc;
+        obj.visitedByCircularReferenceRemoval = true;
+        for (var key in obj) {
+            if (!(obj.hasOwnProperty(key) && obj[key] && typeof obj[key] == 'object')) {
+                continue;
+            }
+            desc = Object.getOwnPropertyDescriptor(obj, key);
+            if (obj[key].visitedByCircularReferenceRemoval ||
+                exports.Util._isElement(obj[key])) {
+                if (desc.configurable) {
+                    delete obj[key];
+                }
+                else {
+                    return null;
+                }
+            }
+            else if (exports.Util._prepareToStringify(obj[key]) === null) {
+                if (desc.configurable) {
+                    delete obj[key];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        delete obj.visitedByCircularReferenceRemoval;
+        return obj;
+    },
+    _assign(target, source) {
+        for (var key in source) {
+            target[key] = source[key];
+        }
+        return target;
+    },
+    _getFirstPointerId(evt) {
+        if (!evt.touches) {
+            return 999;
+        }
+        else {
+            return evt.changedTouches[0].identifier;
+        }
+    },
+};

node_modules/konva/cmj/Validators.d.ts

@@ -0,0 +1,11 @@
+export declare function RGBComponent(val: number): number;
+export declare function alphaComponent(val: number): number;
+export declare function getNumberValidator(): <T>(val: T, attr: string) => void | T;
+export declare function getNumberOrArrayOfNumbersValidator(noOfElements: number): <T>(val: T, attr: string) => void | T;
+export declare function getNumberOrAutoValidator(): <T extends string>(val: T, attr: string) => void | T;
+export declare function getStringValidator(): (val: any, attr: string) => any;
+export declare function getStringOrGradientValidator(): (val: any, attr: string) => any;
+export declare function getFunctionValidator(): (val: any, attr: string) => any;
+export declare function getNumberArrayValidator(): (val: any, attr: string) => any;
+export declare function getBooleanValidator(): (val: any, attr: string) => any;
+export declare function getComponentValidator(components: any): (val: any, attr: string) => any;

node_modules/konva/cmj/Validators.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentValidator = exports.getBooleanValidator = exports.getNumberArrayValidator = exports.getFunctionValidator = exports.getStringOrGradientValidator = exports.getStringValidator = exports.getNumberOrAutoValidator = exports.getNumberOrArrayOfNumbersValidator = exports.getNumberValidator = exports.alphaComponent = exports.RGBComponent = void 0;
+const Global_1 = require("./Global");
+const Util_1 = require("./Util");
+function _formatValue(val) {
+    if (Util_1.Util._isString(val)) {
+        return '"' + val + '"';
+    }
+    if (Object.prototype.toString.call(val) === '[object Number]') {
+        return val;
+    }
+    if (Util_1.Util._isBoolean(val)) {
+        return val;
+    }
+    return Object.prototype.toString.call(val);
+}
+function RGBComponent(val) {
+    if (val > 255) {
+        return 255;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    return Math.round(val);
+}
+exports.RGBComponent = RGBComponent;
+function alphaComponent(val) {
+    if (val > 1) {
+        return 1;
+    }
+    else if (val < 0.0001) {
+        return 0.0001;
+    }
+    return val;
+}
+exports.alphaComponent = alphaComponent;
+function getNumberValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            if (!Util_1.Util._isNumber(val)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a number.');
+            }
+            return val;
+        };
+    }
+}
+exports.getNumberValidator = getNumberValidator;
+function getNumberOrArrayOfNumbersValidator(noOfElements) {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            let isNumber = Util_1.Util._isNumber(val);
+            let isValidArray = Util_1.Util._isArray(val) && val.length == noOfElements;
+            if (!isNumber && !isValidArray) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a number or Array<number>(' +
+                    noOfElements +
+                    ')');
+            }
+            return val;
+        };
+    }
+}
+exports.getNumberOrArrayOfNumbersValidator = getNumberOrArrayOfNumbersValidator;
+function getNumberOrAutoValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            var isNumber = Util_1.Util._isNumber(val);
+            var isAuto = val === 'auto';
+            if (!(isNumber || isAuto)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a number or "auto".');
+            }
+            return val;
+        };
+    }
+}
+exports.getNumberOrAutoValidator = getNumberOrAutoValidator;
+function getStringValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            if (!Util_1.Util._isString(val)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a string.');
+            }
+            return val;
+        };
+    }
+}
+exports.getStringValidator = getStringValidator;
+function getStringOrGradientValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            const isString = Util_1.Util._isString(val);
+            const isGradient = Object.prototype.toString.call(val) === '[object CanvasGradient]' ||
+                (val && val.addColorStop);
+            if (!(isString || isGradient)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a string or a native gradient.');
+            }
+            return val;
+        };
+    }
+}
+exports.getStringOrGradientValidator = getStringOrGradientValidator;
+function getFunctionValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            if (!Util_1.Util._isFunction(val)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a function.');
+            }
+            return val;
+        };
+    }
+}
+exports.getFunctionValidator = getFunctionValidator;
+function getNumberArrayValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            if (!Util_1.Util._isArray(val)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a array of numbers.');
+            }
+            else {
+                val.forEach(function (item) {
+                    if (!Util_1.Util._isNumber(item)) {
+                        Util_1.Util.warn('"' +
+                            attr +
+                            '" attribute has non numeric element ' +
+                            item +
+                            '. Make sure that all elements are numbers.');
+                    }
+                });
+            }
+            return val;
+        };
+    }
+}
+exports.getNumberArrayValidator = getNumberArrayValidator;
+function getBooleanValidator() {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            var isBool = val === true || val === false;
+            if (!isBool) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be a boolean.');
+            }
+            return val;
+        };
+    }
+}
+exports.getBooleanValidator = getBooleanValidator;
+function getComponentValidator(components) {
+    if (Global_1.Konva.isUnminified) {
+        return function (val, attr) {
+            if (!Util_1.Util.isObject(val)) {
+                Util_1.Util.warn(_formatValue(val) +
+                    ' is a not valid value for "' +
+                    attr +
+                    '" attribute. The value should be an object with properties ' +
+                    components);
+            }
+            return val;
+        };
+    }
+}
+exports.getComponentValidator = getComponentValidator;

node_modules/konva/cmj/_CoreInternals.d.ts

@@ -0,0 +1,147 @@
+import { Transform } from './Util';
+import { Node } from './Node';
+import { Container } from './Container';
+import { Stage } from './Stage';
+import { Layer } from './Layer';
+import { FastLayer } from './FastLayer';
+import { Group } from './Group';
+import { Shape } from './Shape';
+import { Animation } from './Animation';
+import { Tween } from './Tween';
+import { Context } from './Context';
+import { Canvas } from './Canvas';
+export declare const Konva: {
+    _global: any;
+    version: string;
+    isBrowser: boolean;
+    isUnminified: boolean;
+    dblClickWindow: number;
+    getAngle(angle: number): number;
+    enableTrace: boolean;
+    pointerEventsEnabled: boolean;
+    autoDrawEnabled: boolean;
+    hitOnDragEnabled: boolean;
+    capturePointerEventsEnabled: boolean;
+    _mouseListenClick: boolean;
+    _touchListenClick: boolean;
+    _pointerListenClick: boolean;
+    _mouseInDblClickWindow: boolean;
+    _touchInDblClickWindow: boolean;
+    _pointerInDblClickWindow: boolean;
+    _mouseDblClickPointerId: any;
+    _touchDblClickPointerId: any;
+    _pointerDblClickPointerId: any;
+    pixelRatio: number;
+    dragDistance: number;
+    angleDeg: boolean;
+    showWarnings: boolean;
+    dragButtons: number[];
+    isDragging(): any;
+    isDragReady(): boolean;
+    document: any;
+    _injectGlobal(Konva: any): void;
+} & {
+    Util: {
+        _isElement(obj: any): obj is Element;
+        _isFunction(obj: any): boolean;
+        _isPlainObject(obj: any): boolean;
+        _isArray(obj: any): obj is any[];
+        _isNumber(obj: any): obj is number;
+        _isString(obj: any): obj is string;
+        _isBoolean(obj: any): obj is boolean;
+        isObject(val: any): val is Object;
+        isValidSelector(selector: any): boolean;
+        _sign(number: number): 1 | -1;
+        requestAnimFrame(callback: Function): void;
+        createCanvasElement(): HTMLCanvasElement;
+        createImageElement(): HTMLImageElement;
+        _isInDocument(el: any): boolean;
+        _urlToImage(url: string, callback: Function): void;
+        _rgbToHex(r: number, g: number, b: number): string;
+        _hexToRgb(hex: string): import("./types").RGB;
+        getRandomColor(): string;
+        getRGB(color: string): import("./types").RGB;
+        colorToRGBA(str: string): import("./types").RGBA;
+        _namedColorToRBA(str: string): {
+            r: any;
+            g: any;
+            b: any;
+            a: number;
+        };
+        _rgbColorToRGBA(str: string): import("./types").RGBA;
+        _rgbaColorToRGBA(str: string): import("./types").RGBA;
+        _hex6ColorToRGBA(str: string): import("./types").RGBA;
+        _hex3ColorToRGBA(str: string): import("./types").RGBA;
+        _hslColorToRGBA(str: string): import("./types").RGBA;
+        haveIntersection(r1: import("./types").IRect, r2: import("./types").IRect): boolean;
+        cloneObject<Any>(obj: Any): Any;
+        cloneArray(arr: any[]): any[];
+        degToRad(deg: number): number;
+        radToDeg(rad: number): number;
+        _degToRad(deg: number): number;
+        _radToDeg(rad: number): number;
+        _getRotation(radians: any): any;
+        _capitalize(str: string): string;
+        throw(str: string): never;
+        error(str: string): void;
+        warn(str: string): void;
+        each(obj: any, func: any): void;
+        _inRange(val: any, left: any, right: any): boolean;
+        _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
+        _getProjectionToLine(pt: import("./types").Vector2d, line: any, isClosed: any): import("./types").Vector2d;
+        _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): any[];
+        _prepareToStringify(obj: any): any;
+        _assign<T, U>(target: T, source: U): T & U;
+        _getFirstPointerId(evt: any): any;
+    };
+    Transform: typeof Transform;
+    Node: typeof Node;
+    Container: typeof Container;
+    Stage: typeof Stage;
+    stages: Stage[];
+    Layer: typeof Layer;
+    FastLayer: typeof FastLayer;
+    Group: typeof Group;
+    DD: {
+        readonly isDragging: boolean;
+        justDragged: boolean;
+        readonly node: Node<import("./Node").NodeConfig>;
+        _dragElements: Map<number, {
+            node: Node<import("./Node").NodeConfig>;
+            startPointerPos: import("./types").Vector2d;
+            offset: import("./types").Vector2d;
+            pointerId?: number;
+            dragStatus: "ready" | "dragging" | "stopped";
+        }>;
+        _drag(evt: any): void;
+        _endDragBefore(evt?: any): void;
+        _endDragAfter(evt: any): void;
+    };
+    Shape: typeof Shape;
+    shapes: {
+        [key: string]: Shape<import("./Shape").ShapeConfig>;
+    };
+    Animation: typeof Animation;
+    Tween: typeof Tween;
+    Easings: {
+        BackEaseIn(t: any, b: any, c: any, d: any): any;
+        BackEaseOut(t: any, b: any, c: any, d: any): any;
+        BackEaseInOut(t: any, b: any, c: any, d: any): any;
+        ElasticEaseIn(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        ElasticEaseOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        ElasticEaseInOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        BounceEaseOut(t: any, b: any, c: any, d: any): any;
+        BounceEaseIn(t: any, b: any, c: any, d: any): any;
+        BounceEaseInOut(t: any, b: any, c: any, d: any): any;
+        EaseIn(t: any, b: any, c: any, d: any): any;
+        EaseOut(t: any, b: any, c: any, d: any): any;
+        EaseInOut(t: any, b: any, c: any, d: any): any;
+        StrongEaseIn(t: any, b: any, c: any, d: any): any;
+        StrongEaseOut(t: any, b: any, c: any, d: any): any;
+        StrongEaseInOut(t: any, b: any, c: any, d: any): any;
+        Linear(t: any, b: any, c: any, d: any): any;
+    };
+    Context: typeof Context;
+    Canvas: typeof Canvas;
+};
+export default Konva;

node_modules/konva/cmj/_CoreInternals.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Konva = void 0;
+const Global_1 = require("./Global");
+const Util_1 = require("./Util");
+const Node_1 = require("./Node");
+const Container_1 = require("./Container");
+const Stage_1 = require("./Stage");
+const Layer_1 = require("./Layer");
+const FastLayer_1 = require("./FastLayer");
+const Group_1 = require("./Group");
+const DragAndDrop_1 = require("./DragAndDrop");
+const Shape_1 = require("./Shape");
+const Animation_1 = require("./Animation");
+const Tween_1 = require("./Tween");
+const Context_1 = require("./Context");
+const Canvas_1 = require("./Canvas");
+exports.Konva = Util_1.Util._assign(Global_1.Konva, {
+    Util: Util_1.Util,
+    Transform: Util_1.Transform,
+    Node: Node_1.Node,
+    Container: Container_1.Container,
+    Stage: Stage_1.Stage,
+    stages: Stage_1.stages,
+    Layer: Layer_1.Layer,
+    FastLayer: FastLayer_1.FastLayer,
+    Group: Group_1.Group,
+    DD: DragAndDrop_1.DD,
+    Shape: Shape_1.Shape,
+    shapes: Shape_1.shapes,
+    Animation: Animation_1.Animation,
+    Tween: Tween_1.Tween,
+    Easings: Tween_1.Easings,
+    Context: Context_1.Context,
+    Canvas: Canvas_1.Canvas,
+});
+exports.default = exports.Konva;

node_modules/konva/cmj/_FullInternals.d.ts

@@ -0,0 +1,191 @@
+import { Arc } from './shapes/Arc';
+import { Arrow } from './shapes/Arrow';
+import { Circle } from './shapes/Circle';
+import { Ellipse } from './shapes/Ellipse';
+import { Image } from './shapes/Image';
+import { Label, Tag } from './shapes/Label';
+import { Line } from './shapes/Line';
+import { Path } from './shapes/Path';
+import { Rect } from './shapes/Rect';
+import { RegularPolygon } from './shapes/RegularPolygon';
+import { Ring } from './shapes/Ring';
+import { Sprite } from './shapes/Sprite';
+import { Star } from './shapes/Star';
+import { Text } from './shapes/Text';
+import { TextPath } from './shapes/TextPath';
+import { Transformer } from './shapes/Transformer';
+import { Wedge } from './shapes/Wedge';
+export declare const Konva: {
+    _global: any;
+    version: string;
+    isBrowser: boolean;
+    isUnminified: boolean;
+    dblClickWindow: number;
+    getAngle(angle: number): number;
+    enableTrace: boolean;
+    pointerEventsEnabled: boolean;
+    autoDrawEnabled: boolean;
+    hitOnDragEnabled: boolean;
+    capturePointerEventsEnabled: boolean;
+    _mouseListenClick: boolean;
+    _touchListenClick: boolean;
+    _pointerListenClick: boolean;
+    _mouseInDblClickWindow: boolean;
+    _touchInDblClickWindow: boolean;
+    _pointerInDblClickWindow: boolean;
+    _mouseDblClickPointerId: any;
+    _touchDblClickPointerId: any;
+    _pointerDblClickPointerId: any;
+    pixelRatio: number;
+    dragDistance: number;
+    angleDeg: boolean;
+    showWarnings: boolean;
+    dragButtons: number[];
+    isDragging(): any;
+    isDragReady(): boolean;
+    document: any;
+    _injectGlobal(Konva: any): void;
+} & {
+    Util: {
+        _isElement(obj: any): obj is Element;
+        _isFunction(obj: any): boolean;
+        _isPlainObject(obj: any): boolean;
+        _isArray(obj: any): obj is any[];
+        _isNumber(obj: any): obj is number;
+        _isString(obj: any): obj is string;
+        _isBoolean(obj: any): obj is boolean;
+        isObject(val: any): val is Object;
+        isValidSelector(selector: any): boolean;
+        _sign(number: number): 1 | -1;
+        requestAnimFrame(callback: Function): void;
+        createCanvasElement(): HTMLCanvasElement;
+        createImageElement(): HTMLImageElement;
+        _isInDocument(el: any): boolean;
+        _urlToImage(url: string, callback: Function): void;
+        _rgbToHex(r: number, g: number, b: number): string;
+        _hexToRgb(hex: string): import("./types").RGB;
+        getRandomColor(): string;
+        getRGB(color: string): import("./types").RGB;
+        colorToRGBA(str: string): import("./types").RGBA;
+        _namedColorToRBA(str: string): {
+            r: any;
+            g: any;
+            b: any;
+            a: number;
+        };
+        _rgbColorToRGBA(str: string): import("./types").RGBA;
+        _rgbaColorToRGBA(str: string): import("./types").RGBA;
+        _hex6ColorToRGBA(str: string): import("./types").RGBA;
+        _hex3ColorToRGBA(str: string): import("./types").RGBA;
+        _hslColorToRGBA(str: string): import("./types").RGBA;
+        haveIntersection(r1: import("./types").IRect, r2: import("./types").IRect): boolean;
+        cloneObject<Any>(obj: Any): Any;
+        cloneArray(arr: any[]): any[];
+        degToRad(deg: number): number;
+        radToDeg(rad: number): number;
+        _degToRad(deg: number): number;
+        _radToDeg(rad: number): number;
+        _getRotation(radians: any): any;
+        _capitalize(str: string): string;
+        throw(str: string): never;
+        error(str: string): void;
+        warn(str: string): void;
+        each(obj: any, func: any): void;
+        _inRange(val: any, left: any, right: any): boolean;
+        _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
+        _getProjectionToLine(pt: import("./types").Vector2d, line: any, isClosed: any): import("./types").Vector2d;
+        _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): any[];
+        _prepareToStringify(obj: any): any;
+        _assign<T, U>(target: T, source: U): T & U;
+        _getFirstPointerId(evt: any): any;
+    };
+    Transform: typeof import("./Util").Transform;
+    Node: typeof import("./Node").Node;
+    Container: typeof import("./Container").Container;
+    Stage: typeof import("./Stage").Stage;
+    stages: import("./Stage").Stage[];
+    Layer: typeof import("./Layer").Layer;
+    FastLayer: typeof import("./FastLayer").FastLayer;
+    Group: typeof import("./Group").Group;
+    DD: {
+        readonly isDragging: boolean;
+        justDragged: boolean;
+        readonly node: import("./Node").Node<import("./Node").NodeConfig>;
+        _dragElements: Map<number, {
+            node: import("./Node").Node<import("./Node").NodeConfig>;
+            startPointerPos: import("./types").Vector2d;
+            offset: import("./types").Vector2d;
+            pointerId?: number;
+            dragStatus: "ready" | "dragging" | "stopped";
+        }>;
+        _drag(evt: any): void;
+        _endDragBefore(evt?: any): void;
+        _endDragAfter(evt: any): void;
+    };
+    Shape: typeof import("./Shape").Shape;
+    shapes: {
+        [key: string]: import("./Shape").Shape<import("./Shape").ShapeConfig>;
+    };
+    Animation: typeof import("./Animation").Animation;
+    Tween: typeof import("./Tween").Tween;
+    Easings: {
+        BackEaseIn(t: any, b: any, c: any, d: any): any;
+        BackEaseOut(t: any, b: any, c: any, d: any): any;
+        BackEaseInOut(t: any, b: any, c: any, d: any): any;
+        ElasticEaseIn(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        ElasticEaseOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        ElasticEaseInOut(t: any, b: any, c: any, d: any, a: any, p: any): any;
+        BounceEaseOut(t: any, b: any, c: any, d: any): any;
+        BounceEaseIn(t: any, b: any, c: any, d: any): any;
+        BounceEaseInOut(t: any, b: any, c: any, d: any): any;
+        EaseIn(t: any, b: any, c: any, d: any): any;
+        EaseOut(t: any, b: any, c: any, d: any): any;
+        EaseInOut(t: any, b: any, c: any, d: any): any;
+        StrongEaseIn(t: any, b: any, c: any, d: any): any;
+        StrongEaseOut(t: any, b: any, c: any, d: any): any;
+        StrongEaseInOut(t: any, b: any, c: any, d: any): any;
+        Linear(t: any, b: any, c: any, d: any): any;
+    };
+    Context: typeof import("./Context").Context;
+    Canvas: typeof import("./Canvas").Canvas;
+} & {
+    Arc: typeof Arc;
+    Arrow: typeof Arrow;
+    Circle: typeof Circle;
+    Ellipse: typeof Ellipse;
+    Image: typeof Image;
+    Label: typeof Label;
+    Tag: typeof Tag;
+    Line: typeof Line;
+    Path: typeof Path;
+    Rect: typeof Rect;
+    RegularPolygon: typeof RegularPolygon;
+    Ring: typeof Ring;
+    Sprite: typeof Sprite;
+    Star: typeof Star;
+    Text: typeof Text;
+    TextPath: typeof TextPath;
+    Transformer: typeof Transformer;
+    Wedge: typeof Wedge;
+    Filters: {
+        Blur: import("./Node").Filter;
+        Brighten: import("./Node").Filter;
+        Contrast: import("./Node").Filter;
+        Emboss: import("./Node").Filter;
+        Enhance: import("./Node").Filter;
+        Grayscale: import("./Node").Filter;
+        HSL: import("./Node").Filter;
+        HSV: import("./Node").Filter;
+        Invert: import("./Node").Filter;
+        Kaleidoscope: import("./Node").Filter;
+        Mask: import("./Node").Filter;
+        Noise: import("./Node").Filter;
+        Pixelate: import("./Node").Filter;
+        Posterize: import("./Node").Filter;
+        RGB: import("./Node").Filter;
+        RGBA: import("./Node").Filter;
+        Sepia: import("./Node").Filter;
+        Solarize: import("./Node").Filter;
+        Threshold: import("./Node").Filter;
+    };
+};

node_modules/konva/cmj/_FullInternals.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Konva = void 0;
+const _CoreInternals_1 = require("./_CoreInternals");
+const Arc_1 = require("./shapes/Arc");
+const Arrow_1 = require("./shapes/Arrow");
+const Circle_1 = require("./shapes/Circle");
+const Ellipse_1 = require("./shapes/Ellipse");
+const Image_1 = require("./shapes/Image");
+const Label_1 = require("./shapes/Label");
+const Line_1 = require("./shapes/Line");
+const Path_1 = require("./shapes/Path");
+const Rect_1 = require("./shapes/Rect");
+const RegularPolygon_1 = require("./shapes/RegularPolygon");
+const Ring_1 = require("./shapes/Ring");
+const Sprite_1 = require("./shapes/Sprite");
+const Star_1 = require("./shapes/Star");
+const Text_1 = require("./shapes/Text");
+const TextPath_1 = require("./shapes/TextPath");
+const Transformer_1 = require("./shapes/Transformer");
+const Wedge_1 = require("./shapes/Wedge");
+const Blur_1 = require("./filters/Blur");
+const Brighten_1 = require("./filters/Brighten");
+const Contrast_1 = require("./filters/Contrast");
+const Emboss_1 = require("./filters/Emboss");
+const Enhance_1 = require("./filters/Enhance");
+const Grayscale_1 = require("./filters/Grayscale");
+const HSL_1 = require("./filters/HSL");
+const HSV_1 = require("./filters/HSV");
+const Invert_1 = require("./filters/Invert");
+const Kaleidoscope_1 = require("./filters/Kaleidoscope");
+const Mask_1 = require("./filters/Mask");
+const Noise_1 = require("./filters/Noise");
+const Pixelate_1 = require("./filters/Pixelate");
+const Posterize_1 = require("./filters/Posterize");
+const RGB_1 = require("./filters/RGB");
+const RGBA_1 = require("./filters/RGBA");
+const Sepia_1 = require("./filters/Sepia");
+const Solarize_1 = require("./filters/Solarize");
+const Threshold_1 = require("./filters/Threshold");
+exports.Konva = _CoreInternals_1.Konva.Util._assign(_CoreInternals_1.Konva, {
+    Arc: Arc_1.Arc,
+    Arrow: Arrow_1.Arrow,
+    Circle: Circle_1.Circle,
+    Ellipse: Ellipse_1.Ellipse,
+    Image: Image_1.Image,
+    Label: Label_1.Label,
+    Tag: Label_1.Tag,
+    Line: Line_1.Line,
+    Path: Path_1.Path,
+    Rect: Rect_1.Rect,
+    RegularPolygon: RegularPolygon_1.RegularPolygon,
+    Ring: Ring_1.Ring,
+    Sprite: Sprite_1.Sprite,
+    Star: Star_1.Star,
+    Text: Text_1.Text,
+    TextPath: TextPath_1.TextPath,
+    Transformer: Transformer_1.Transformer,
+    Wedge: Wedge_1.Wedge,
+    Filters: {
+        Blur: Blur_1.Blur,
+        Brighten: Brighten_1.Brighten,
+        Contrast: Contrast_1.Contrast,
+        Emboss: Emboss_1.Emboss,
+        Enhance: Enhance_1.Enhance,
+        Grayscale: Grayscale_1.Grayscale,
+        HSL: HSL_1.HSL,
+        HSV: HSV_1.HSV,
+        Invert: Invert_1.Invert,
+        Kaleidoscope: Kaleidoscope_1.Kaleidoscope,
+        Mask: Mask_1.Mask,
+        Noise: Noise_1.Noise,
+        Pixelate: Pixelate_1.Pixelate,
+        Posterize: Posterize_1.Posterize,
+        RGB: RGB_1.RGB,
+        RGBA: RGBA_1.RGBA,
+        Sepia: Sepia_1.Sepia,
+        Solarize: Solarize_1.Solarize,
+        Threshold: Threshold_1.Threshold,
+    },
+});

node_modules/konva/cmj/filters/Blur.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Blur: Filter;

node_modules/konva/cmj/filters/Blur.js

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blur = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+function BlurStack() {
+    this.r = 0;
+    this.g = 0;
+    this.b = 0;
+    this.a = 0;
+    this.next = null;
+}
+var mul_table = [
+    512,
+    512,
+    456,
+    512,
+    328,
+    456,
+    335,
+    512,
+    405,
+    328,
+    271,
+    456,
+    388,
+    335,
+    292,
+    512,
+    454,
+    405,
+    364,
+    328,
+    298,
+    271,
+    496,
+    456,
+    420,
+    388,
+    360,
+    335,
+    312,
+    292,
+    273,
+    512,
+    482,
+    454,
+    428,
+    405,
+    383,
+    364,
+    345,
+    328,
+    312,
+    298,
+    284,
+    271,
+    259,
+    496,
+    475,
+    456,
+    437,
+    420,
+    404,
+    388,
+    374,
+    360,
+    347,
+    335,
+    323,
+    312,
+    302,
+    292,
+    282,
+    273,
+    265,
+    512,
+    497,
+    482,
+    468,
+    454,
+    441,
+    428,
+    417,
+    405,
+    394,
+    383,
+    373,
+    364,
+    354,
+    345,
+    337,
+    328,
+    320,
+    312,
+    305,
+    298,
+    291,
+    284,
+    278,
+    271,
+    265,
+    259,
+    507,
+    496,
+    485,
+    475,
+    465,
+    456,
+    446,
+    437,
+    428,
+    420,
+    412,
+    404,
+    396,
+    388,
+    381,
+    374,
+    367,
+    360,
+    354,
+    347,
+    341,
+    335,
+    329,
+    323,
+    318,
+    312,
+    307,
+    302,
+    297,
+    292,
+    287,
+    282,
+    278,
+    273,
+    269,
+    265,
+    261,
+    512,
+    505,
+    497,
+    489,
+    482,
+    475,
+    468,
+    461,
+    454,
+    447,
+    441,
+    435,
+    428,
+    422,
+    417,
+    411,
+    405,
+    399,
+    394,
+    389,
+    383,
+    378,
+    373,
+    368,
+    364,
+    359,
+    354,
+    350,
+    345,
+    341,
+    337,
+    332,
+    328,
+    324,
+    320,
+    316,
+    312,
+    309,
+    305,
+    301,
+    298,
+    294,
+    291,
+    287,
+    284,
+    281,
+    278,
+    274,
+    271,
+    268,
+    265,
+    262,
+    259,
+    257,
+    507,
+    501,
+    496,
+    491,
+    485,
+    480,
+    475,
+    470,
+    465,
+    460,
+    456,
+    451,
+    446,
+    442,
+    437,
+    433,
+    428,
+    424,
+    420,
+    416,
+    412,
+    408,
+    404,
+    400,
+    396,
+    392,
+    388,
+    385,
+    381,
+    377,
+    374,
+    370,
+    367,
+    363,
+    360,
+    357,
+    354,
+    350,
+    347,
+    344,
+    341,
+    338,
+    335,
+    332,
+    329,
+    326,
+    323,
+    320,
+    318,
+    315,
+    312,
+    310,
+    307,
+    304,
+    302,
+    299,
+    297,
+    294,
+    292,
+    289,
+    287,
+    285,
+    282,
+    280,
+    278,
+    275,
+    273,
+    271,
+    269,
+    267,
+    265,
+    263,
+    261,
+    259,
+];
+var shg_table = [
+    9,
+    11,
+    12,
+    13,
+    13,
+    14,
+    14,
+    15,
+    15,
+    15,
+    15,
+    16,
+    16,
+    16,
+    16,
+    17,
+    17,
+    17,
+    17,
+    17,
+    17,
+    17,
+    18,
+    18,
+    18,
+    18,
+    18,
+    18,
+    18,
+    18,
+    18,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    19,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    20,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    21,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    22,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    23,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+    24,
+];
+function filterGaussBlurRGBA(imageData, radius) {
+    var pixels = imageData.data, width = imageData.width, height = imageData.height;
+    var x, y, i, p, yp, yi, yw, r_sum, g_sum, b_sum, a_sum, r_out_sum, g_out_sum, b_out_sum, a_out_sum, r_in_sum, g_in_sum, b_in_sum, a_in_sum, pr, pg, pb, pa, rbs;
+    var div = radius + radius + 1, widthMinus1 = width - 1, heightMinus1 = height - 1, radiusPlus1 = radius + 1, sumFactor = (radiusPlus1 * (radiusPlus1 + 1)) / 2, stackStart = new BlurStack(), stackEnd = null, stack = stackStart, stackIn = null, stackOut = null, mul_sum = mul_table[radius], shg_sum = shg_table[radius];
+    for (i = 1; i < div; i++) {
+        stack = stack.next = new BlurStack();
+        if (i === radiusPlus1) {
+            stackEnd = stack;
+        }
+    }
+    stack.next = stackStart;
+    yw = yi = 0;
+    for (y = 0; y < height; y++) {
+        r_in_sum = g_in_sum = b_in_sum = a_in_sum = r_sum = g_sum = b_sum = a_sum = 0;
+        r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+        g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+        b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+        a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+        r_sum += sumFactor * pr;
+        g_sum += sumFactor * pg;
+        b_sum += sumFactor * pb;
+        a_sum += sumFactor * pa;
+        stack = stackStart;
+        for (i = 0; i < radiusPlus1; i++) {
+            stack.r = pr;
+            stack.g = pg;
+            stack.b = pb;
+            stack.a = pa;
+            stack = stack.next;
+        }
+        for (i = 1; i < radiusPlus1; i++) {
+            p = yi + ((widthMinus1 < i ? widthMinus1 : i) << 2);
+            r_sum += (stack.r = pr = pixels[p]) * (rbs = radiusPlus1 - i);
+            g_sum += (stack.g = pg = pixels[p + 1]) * rbs;
+            b_sum += (stack.b = pb = pixels[p + 2]) * rbs;
+            a_sum += (stack.a = pa = pixels[p + 3]) * rbs;
+            r_in_sum += pr;
+            g_in_sum += pg;
+            b_in_sum += pb;
+            a_in_sum += pa;
+            stack = stack.next;
+        }
+        stackIn = stackStart;
+        stackOut = stackEnd;
+        for (x = 0; x < width; x++) {
+            pixels[yi + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+            if (pa !== 0) {
+                pa = 255 / pa;
+                pixels[yi] = ((r_sum * mul_sum) >> shg_sum) * pa;
+                pixels[yi + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+                pixels[yi + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+            }
+            else {
+                pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;
+            }
+            r_sum -= r_out_sum;
+            g_sum -= g_out_sum;
+            b_sum -= b_out_sum;
+            a_sum -= a_out_sum;
+            r_out_sum -= stackIn.r;
+            g_out_sum -= stackIn.g;
+            b_out_sum -= stackIn.b;
+            a_out_sum -= stackIn.a;
+            p = (yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1)) << 2;
+            r_in_sum += stackIn.r = pixels[p];
+            g_in_sum += stackIn.g = pixels[p + 1];
+            b_in_sum += stackIn.b = pixels[p + 2];
+            a_in_sum += stackIn.a = pixels[p + 3];
+            r_sum += r_in_sum;
+            g_sum += g_in_sum;
+            b_sum += b_in_sum;
+            a_sum += a_in_sum;
+            stackIn = stackIn.next;
+            r_out_sum += pr = stackOut.r;
+            g_out_sum += pg = stackOut.g;
+            b_out_sum += pb = stackOut.b;
+            a_out_sum += pa = stackOut.a;
+            r_in_sum -= pr;
+            g_in_sum -= pg;
+            b_in_sum -= pb;
+            a_in_sum -= pa;
+            stackOut = stackOut.next;
+            yi += 4;
+        }
+        yw += width;
+    }
+    for (x = 0; x < width; x++) {
+        g_in_sum = b_in_sum = a_in_sum = r_in_sum = g_sum = b_sum = a_sum = r_sum = 0;
+        yi = x << 2;
+        r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+        g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+        b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+        a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+        r_sum += sumFactor * pr;
+        g_sum += sumFactor * pg;
+        b_sum += sumFactor * pb;
+        a_sum += sumFactor * pa;
+        stack = stackStart;
+        for (i = 0; i < radiusPlus1; i++) {
+            stack.r = pr;
+            stack.g = pg;
+            stack.b = pb;
+            stack.a = pa;
+            stack = stack.next;
+        }
+        yp = width;
+        for (i = 1; i <= radius; i++) {
+            yi = (yp + x) << 2;
+            r_sum += (stack.r = pr = pixels[yi]) * (rbs = radiusPlus1 - i);
+            g_sum += (stack.g = pg = pixels[yi + 1]) * rbs;
+            b_sum += (stack.b = pb = pixels[yi + 2]) * rbs;
+            a_sum += (stack.a = pa = pixels[yi + 3]) * rbs;
+            r_in_sum += pr;
+            g_in_sum += pg;
+            b_in_sum += pb;
+            a_in_sum += pa;
+            stack = stack.next;
+            if (i < heightMinus1) {
+                yp += width;
+            }
+        }
+        yi = x;
+        stackIn = stackStart;
+        stackOut = stackEnd;
+        for (y = 0; y < height; y++) {
+            p = yi << 2;
+            pixels[p + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+            if (pa > 0) {
+                pa = 255 / pa;
+                pixels[p] = ((r_sum * mul_sum) >> shg_sum) * pa;
+                pixels[p + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+                pixels[p + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+            }
+            else {
+                pixels[p] = pixels[p + 1] = pixels[p + 2] = 0;
+            }
+            r_sum -= r_out_sum;
+            g_sum -= g_out_sum;
+            b_sum -= b_out_sum;
+            a_sum -= a_out_sum;
+            r_out_sum -= stackIn.r;
+            g_out_sum -= stackIn.g;
+            b_out_sum -= stackIn.b;
+            a_out_sum -= stackIn.a;
+            p =
+                (x +
+                    ((p = y + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width) <<
+                    2;
+            r_sum += r_in_sum += stackIn.r = pixels[p];
+            g_sum += g_in_sum += stackIn.g = pixels[p + 1];
+            b_sum += b_in_sum += stackIn.b = pixels[p + 2];
+            a_sum += a_in_sum += stackIn.a = pixels[p + 3];
+            stackIn = stackIn.next;
+            r_out_sum += pr = stackOut.r;
+            g_out_sum += pg = stackOut.g;
+            b_out_sum += pb = stackOut.b;
+            a_out_sum += pa = stackOut.a;
+            r_in_sum -= pr;
+            g_in_sum -= pg;
+            b_in_sum -= pb;
+            a_in_sum -= pa;
+            stackOut = stackOut.next;
+            yi += width;
+        }
+    }
+}
+const Blur = function Blur(imageData) {
+    var radius = Math.round(this.blurRadius());
+    if (radius > 0) {
+        filterGaussBlurRGBA(imageData, radius);
+    }
+};
+exports.Blur = Blur;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'blurRadius', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Brighten.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Brighten: Filter;

node_modules/konva/cmj/filters/Brighten.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Brighten = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Brighten = function (imageData) {
+    var brightness = this.brightness() * 255, data = imageData.data, len = data.length, i;
+    for (i = 0; i < len; i += 4) {
+        data[i] += brightness;
+        data[i + 1] += brightness;
+        data[i + 2] += brightness;
+    }
+};
+exports.Brighten = Brighten;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'brightness', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Contrast.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Contrast: Filter;

node_modules/konva/cmj/filters/Contrast.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contrast = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Contrast = function (imageData) {
+    var adjust = Math.pow((this.contrast() + 100) / 100, 2);
+    var data = imageData.data, nPixels = data.length, red = 150, green = 150, blue = 150, i;
+    for (i = 0; i < nPixels; i += 4) {
+        red = data[i];
+        green = data[i + 1];
+        blue = data[i + 2];
+        red /= 255;
+        red -= 0.5;
+        red *= adjust;
+        red += 0.5;
+        red *= 255;
+        green /= 255;
+        green -= 0.5;
+        green *= adjust;
+        green += 0.5;
+        green *= 255;
+        blue /= 255;
+        blue -= 0.5;
+        blue *= adjust;
+        blue += 0.5;
+        blue *= 255;
+        red = red < 0 ? 0 : red > 255 ? 255 : red;
+        green = green < 0 ? 0 : green > 255 ? 255 : green;
+        blue = blue < 0 ? 0 : blue > 255 ? 255 : blue;
+        data[i] = red;
+        data[i + 1] = green;
+        data[i + 2] = blue;
+    }
+};
+exports.Contrast = Contrast;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'contrast', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Emboss.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Emboss: Filter;

node_modules/konva/cmj/filters/Emboss.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emboss = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Util_1 = require("../Util");
+const Validators_1 = require("../Validators");
+const Emboss = function (imageData) {
+    var strength = this.embossStrength() * 10, greyLevel = this.embossWhiteLevel() * 255, direction = this.embossDirection(), blend = this.embossBlend(), dirY = 0, dirX = 0, data = imageData.data, w = imageData.width, h = imageData.height, w4 = w * 4, y = h;
+    switch (direction) {
+        case 'top-left':
+            dirY = -1;
+            dirX = -1;
+            break;
+        case 'top':
+            dirY = -1;
+            dirX = 0;
+            break;
+        case 'top-right':
+            dirY = -1;
+            dirX = 1;
+            break;
+        case 'right':
+            dirY = 0;
+            dirX = 1;
+            break;
+        case 'bottom-right':
+            dirY = 1;
+            dirX = 1;
+            break;
+        case 'bottom':
+            dirY = 1;
+            dirX = 0;
+            break;
+        case 'bottom-left':
+            dirY = 1;
+            dirX = -1;
+            break;
+        case 'left':
+            dirY = 0;
+            dirX = -1;
+            break;
+        default:
+            Util_1.Util.error('Unknown emboss direction: ' + direction);
+    }
+    do {
+        var offsetY = (y - 1) * w4;
+        var otherY = dirY;
+        if (y + otherY < 1) {
+            otherY = 0;
+        }
+        if (y + otherY > h) {
+            otherY = 0;
+        }
+        var offsetYOther = (y - 1 + otherY) * w * 4;
+        var x = w;
+        do {
+            var offset = offsetY + (x - 1) * 4;
+            var otherX = dirX;
+            if (x + otherX < 1) {
+                otherX = 0;
+            }
+            if (x + otherX > w) {
+                otherX = 0;
+            }
+            var offsetOther = offsetYOther + (x - 1 + otherX) * 4;
+            var dR = data[offset] - data[offsetOther];
+            var dG = data[offset + 1] - data[offsetOther + 1];
+            var dB = data[offset + 2] - data[offsetOther + 2];
+            var dif = dR;
+            var absDif = dif > 0 ? dif : -dif;
+            var absG = dG > 0 ? dG : -dG;
+            var absB = dB > 0 ? dB : -dB;
+            if (absG > absDif) {
+                dif = dG;
+            }
+            if (absB > absDif) {
+                dif = dB;
+            }
+            dif *= strength;
+            if (blend) {
+                var r = data[offset] + dif;
+                var g = data[offset + 1] + dif;
+                var b = data[offset + 2] + dif;
+                data[offset] = r > 255 ? 255 : r < 0 ? 0 : r;
+                data[offset + 1] = g > 255 ? 255 : g < 0 ? 0 : g;
+                data[offset + 2] = b > 255 ? 255 : b < 0 ? 0 : b;
+            }
+            else {
+                var grey = greyLevel - dif;
+                if (grey < 0) {
+                    grey = 0;
+                }
+                else if (grey > 255) {
+                    grey = 255;
+                }
+                data[offset] = data[offset + 1] = data[offset + 2] = grey;
+            }
+        } while (--x);
+    } while (--y);
+};
+exports.Emboss = Emboss;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'embossStrength', 0.5, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'embossWhiteLevel', 0.5, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'embossDirection', 'top-left', null, Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'embossBlend', false, null, Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Enhance.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Enhance: Filter;

node_modules/konva/cmj/filters/Enhance.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enhance = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+function remap(fromValue, fromMin, fromMax, toMin, toMax) {
+    var fromRange = fromMax - fromMin, toRange = toMax - toMin, toValue;
+    if (fromRange === 0) {
+        return toMin + toRange / 2;
+    }
+    if (toRange === 0) {
+        return toMin;
+    }
+    toValue = (fromValue - fromMin) / fromRange;
+    toValue = toRange * toValue + toMin;
+    return toValue;
+}
+const Enhance = function (imageData) {
+    var data = imageData.data, nSubPixels = data.length, rMin = data[0], rMax = rMin, r, gMin = data[1], gMax = gMin, g, bMin = data[2], bMax = bMin, b, i;
+    var enhanceAmount = this.enhance();
+    if (enhanceAmount === 0) {
+        return;
+    }
+    for (i = 0; i < nSubPixels; i += 4) {
+        r = data[i + 0];
+        if (r < rMin) {
+            rMin = r;
+        }
+        else if (r > rMax) {
+            rMax = r;
+        }
+        g = data[i + 1];
+        if (g < gMin) {
+            gMin = g;
+        }
+        else if (g > gMax) {
+            gMax = g;
+        }
+        b = data[i + 2];
+        if (b < bMin) {
+            bMin = b;
+        }
+        else if (b > bMax) {
+            bMax = b;
+        }
+    }
+    if (rMax === rMin) {
+        rMax = 255;
+        rMin = 0;
+    }
+    if (gMax === gMin) {
+        gMax = 255;
+        gMin = 0;
+    }
+    if (bMax === bMin) {
+        bMax = 255;
+        bMin = 0;
+    }
+    var rMid, rGoalMax, rGoalMin, gMid, gGoalMax, gGoalMin, bMid, bGoalMax, bGoalMin;
+    if (enhanceAmount > 0) {
+        rGoalMax = rMax + enhanceAmount * (255 - rMax);
+        rGoalMin = rMin - enhanceAmount * (rMin - 0);
+        gGoalMax = gMax + enhanceAmount * (255 - gMax);
+        gGoalMin = gMin - enhanceAmount * (gMin - 0);
+        bGoalMax = bMax + enhanceAmount * (255 - bMax);
+        bGoalMin = bMin - enhanceAmount * (bMin - 0);
+    }
+    else {
+        rMid = (rMax + rMin) * 0.5;
+        rGoalMax = rMax + enhanceAmount * (rMax - rMid);
+        rGoalMin = rMin + enhanceAmount * (rMin - rMid);
+        gMid = (gMax + gMin) * 0.5;
+        gGoalMax = gMax + enhanceAmount * (gMax - gMid);
+        gGoalMin = gMin + enhanceAmount * (gMin - gMid);
+        bMid = (bMax + bMin) * 0.5;
+        bGoalMax = bMax + enhanceAmount * (bMax - bMid);
+        bGoalMin = bMin + enhanceAmount * (bMin - bMid);
+    }
+    for (i = 0; i < nSubPixels; i += 4) {
+        data[i + 0] = remap(data[i + 0], rMin, rMax, rGoalMin, rGoalMax);
+        data[i + 1] = remap(data[i + 1], gMin, gMax, gGoalMin, gGoalMax);
+        data[i + 2] = remap(data[i + 2], bMin, bMax, bGoalMin, bGoalMax);
+    }
+};
+exports.Enhance = Enhance;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'enhance', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Grayscale.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Grayscale: Filter;

node_modules/konva/cmj/filters/Grayscale.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grayscale = void 0;
+const Grayscale = function (imageData) {
+    var data = imageData.data, len = data.length, i, brightness;
+    for (i = 0; i < len; i += 4) {
+        brightness = 0.34 * data[i] + 0.5 * data[i + 1] + 0.16 * data[i + 2];
+        data[i] = brightness;
+        data[i + 1] = brightness;
+        data[i + 2] = brightness;
+    }
+};
+exports.Grayscale = Grayscale;

node_modules/konva/cmj/filters/HSL.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const HSL: Filter;

node_modules/konva/cmj/filters/HSL.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSL = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'hue', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'saturation', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'luminance', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+const HSL = function (imageData) {
+    var data = imageData.data, nPixels = data.length, v = 1, s = Math.pow(2, this.saturation()), h = Math.abs(this.hue() + 360) % 360, l = this.luminance() * 127, i;
+    var vsu = v * s * Math.cos((h * Math.PI) / 180), vsw = v * s * Math.sin((h * Math.PI) / 180);
+    var rr = 0.299 * v + 0.701 * vsu + 0.167 * vsw, rg = 0.587 * v - 0.587 * vsu + 0.33 * vsw, rb = 0.114 * v - 0.114 * vsu - 0.497 * vsw;
+    var gr = 0.299 * v - 0.299 * vsu - 0.328 * vsw, gg = 0.587 * v + 0.413 * vsu + 0.035 * vsw, gb = 0.114 * v - 0.114 * vsu + 0.293 * vsw;
+    var br = 0.299 * v - 0.3 * vsu + 1.25 * vsw, bg = 0.587 * v - 0.586 * vsu - 1.05 * vsw, bb = 0.114 * v + 0.886 * vsu - 0.2 * vsw;
+    var r, g, b, a;
+    for (i = 0; i < nPixels; i += 4) {
+        r = data[i + 0];
+        g = data[i + 1];
+        b = data[i + 2];
+        a = data[i + 3];
+        data[i + 0] = rr * r + rg * g + rb * b + l;
+        data[i + 1] = gr * r + gg * g + gb * b + l;
+        data[i + 2] = br * r + bg * g + bb * b + l;
+        data[i + 3] = a;
+    }
+};
+exports.HSL = HSL;

node_modules/konva/cmj/filters/HSV.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const HSV: Filter;

node_modules/konva/cmj/filters/HSV.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSV = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const HSV = function (imageData) {
+    var data = imageData.data, nPixels = data.length, v = Math.pow(2, this.value()), s = Math.pow(2, this.saturation()), h = Math.abs(this.hue() + 360) % 360, i;
+    var vsu = v * s * Math.cos((h * Math.PI) / 180), vsw = v * s * Math.sin((h * Math.PI) / 180);
+    var rr = 0.299 * v + 0.701 * vsu + 0.167 * vsw, rg = 0.587 * v - 0.587 * vsu + 0.33 * vsw, rb = 0.114 * v - 0.114 * vsu - 0.497 * vsw;
+    var gr = 0.299 * v - 0.299 * vsu - 0.328 * vsw, gg = 0.587 * v + 0.413 * vsu + 0.035 * vsw, gb = 0.114 * v - 0.114 * vsu + 0.293 * vsw;
+    var br = 0.299 * v - 0.3 * vsu + 1.25 * vsw, bg = 0.587 * v - 0.586 * vsu - 1.05 * vsw, bb = 0.114 * v + 0.886 * vsu - 0.2 * vsw;
+    var r, g, b, a;
+    for (i = 0; i < nPixels; i += 4) {
+        r = data[i + 0];
+        g = data[i + 1];
+        b = data[i + 2];
+        a = data[i + 3];
+        data[i + 0] = rr * r + rg * g + rb * b;
+        data[i + 1] = gr * r + gg * g + gb * b;
+        data[i + 2] = br * r + bg * g + bb * b;
+        data[i + 3] = a;
+    }
+};
+exports.HSV = HSV;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'hue', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'saturation', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'value', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Invert.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Invert: Filter;

node_modules/konva/cmj/filters/Invert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Invert = void 0;
+const Invert = function (imageData) {
+    var data = imageData.data, len = data.length, i;
+    for (i = 0; i < len; i += 4) {
+        data[i] = 255 - data[i];
+        data[i + 1] = 255 - data[i + 1];
+        data[i + 2] = 255 - data[i + 2];
+    }
+};
+exports.Invert = Invert;

node_modules/konva/cmj/filters/Kaleidoscope.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Kaleidoscope: Filter;

node_modules/konva/cmj/filters/Kaleidoscope.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kaleidoscope = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Util_1 = require("../Util");
+const Validators_1 = require("../Validators");
+var ToPolar = function (src, dst, opt) {
+    var srcPixels = src.data, dstPixels = dst.data, xSize = src.width, ySize = src.height, xMid = opt.polarCenterX || xSize / 2, yMid = opt.polarCenterY || ySize / 2, i, x, y, r = 0, g = 0, b = 0, a = 0;
+    var rad, rMax = Math.sqrt(xMid * xMid + yMid * yMid);
+    x = xSize - xMid;
+    y = ySize - yMid;
+    rad = Math.sqrt(x * x + y * y);
+    rMax = rad > rMax ? rad : rMax;
+    var rSize = ySize, tSize = xSize, radius, theta;
+    var conversion = ((360 / tSize) * Math.PI) / 180, sin, cos;
+    for (theta = 0; theta < tSize; theta += 1) {
+        sin = Math.sin(theta * conversion);
+        cos = Math.cos(theta * conversion);
+        for (radius = 0; radius < rSize; radius += 1) {
+            x = Math.floor(xMid + ((rMax * radius) / rSize) * cos);
+            y = Math.floor(yMid + ((rMax * radius) / rSize) * sin);
+            i = (y * xSize + x) * 4;
+            r = srcPixels[i + 0];
+            g = srcPixels[i + 1];
+            b = srcPixels[i + 2];
+            a = srcPixels[i + 3];
+            i = (theta + radius * xSize) * 4;
+            dstPixels[i + 0] = r;
+            dstPixels[i + 1] = g;
+            dstPixels[i + 2] = b;
+            dstPixels[i + 3] = a;
+        }
+    }
+};
+var FromPolar = function (src, dst, opt) {
+    var srcPixels = src.data, dstPixels = dst.data, xSize = src.width, ySize = src.height, xMid = opt.polarCenterX || xSize / 2, yMid = opt.polarCenterY || ySize / 2, i, x, y, dx, dy, r = 0, g = 0, b = 0, a = 0;
+    var rad, rMax = Math.sqrt(xMid * xMid + yMid * yMid);
+    x = xSize - xMid;
+    y = ySize - yMid;
+    rad = Math.sqrt(x * x + y * y);
+    rMax = rad > rMax ? rad : rMax;
+    var rSize = ySize, tSize = xSize, radius, theta, phaseShift = opt.polarRotation || 0;
+    var x1, y1;
+    for (x = 0; x < xSize; x += 1) {
+        for (y = 0; y < ySize; y += 1) {
+            dx = x - xMid;
+            dy = y - yMid;
+            radius = (Math.sqrt(dx * dx + dy * dy) * rSize) / rMax;
+            theta = ((Math.atan2(dy, dx) * 180) / Math.PI + 360 + phaseShift) % 360;
+            theta = (theta * tSize) / 360;
+            x1 = Math.floor(theta);
+            y1 = Math.floor(radius);
+            i = (y1 * xSize + x1) * 4;
+            r = srcPixels[i + 0];
+            g = srcPixels[i + 1];
+            b = srcPixels[i + 2];
+            a = srcPixels[i + 3];
+            i = (y * xSize + x) * 4;
+            dstPixels[i + 0] = r;
+            dstPixels[i + 1] = g;
+            dstPixels[i + 2] = b;
+            dstPixels[i + 3] = a;
+        }
+    }
+};
+const Kaleidoscope = function (imageData) {
+    var xSize = imageData.width, ySize = imageData.height;
+    var x, y, xoff, i, r, g, b, a, srcPos, dstPos;
+    var power = Math.round(this.kaleidoscopePower());
+    var angle = Math.round(this.kaleidoscopeAngle());
+    var offset = Math.floor((xSize * (angle % 360)) / 360);
+    if (power < 1) {
+        return;
+    }
+    var tempCanvas = Util_1.Util.createCanvasElement();
+    tempCanvas.width = xSize;
+    tempCanvas.height = ySize;
+    var scratchData = tempCanvas
+        .getContext('2d')
+        .getImageData(0, 0, xSize, ySize);
+    ToPolar(imageData, scratchData, {
+        polarCenterX: xSize / 2,
+        polarCenterY: ySize / 2,
+    });
+    var minSectionSize = xSize / Math.pow(2, power);
+    while (minSectionSize <= 8) {
+        minSectionSize = minSectionSize * 2;
+        power -= 1;
+    }
+    minSectionSize = Math.ceil(minSectionSize);
+    var sectionSize = minSectionSize;
+    var xStart = 0, xEnd = sectionSize, xDelta = 1;
+    if (offset + minSectionSize > xSize) {
+        xStart = sectionSize;
+        xEnd = 0;
+        xDelta = -1;
+    }
+    for (y = 0; y < ySize; y += 1) {
+        for (x = xStart; x !== xEnd; x += xDelta) {
+            xoff = Math.round(x + offset) % xSize;
+            srcPos = (xSize * y + xoff) * 4;
+            r = scratchData.data[srcPos + 0];
+            g = scratchData.data[srcPos + 1];
+            b = scratchData.data[srcPos + 2];
+            a = scratchData.data[srcPos + 3];
+            dstPos = (xSize * y + x) * 4;
+            scratchData.data[dstPos + 0] = r;
+            scratchData.data[dstPos + 1] = g;
+            scratchData.data[dstPos + 2] = b;
+            scratchData.data[dstPos + 3] = a;
+        }
+    }
+    for (y = 0; y < ySize; y += 1) {
+        sectionSize = Math.floor(minSectionSize);
+        for (i = 0; i < power; i += 1) {
+            for (x = 0; x < sectionSize + 1; x += 1) {
+                srcPos = (xSize * y + x) * 4;
+                r = scratchData.data[srcPos + 0];
+                g = scratchData.data[srcPos + 1];
+                b = scratchData.data[srcPos + 2];
+                a = scratchData.data[srcPos + 3];
+                dstPos = (xSize * y + sectionSize * 2 - x - 1) * 4;
+                scratchData.data[dstPos + 0] = r;
+                scratchData.data[dstPos + 1] = g;
+                scratchData.data[dstPos + 2] = b;
+                scratchData.data[dstPos + 3] = a;
+            }
+            sectionSize *= 2;
+        }
+    }
+    FromPolar(scratchData, imageData, { polarRotation: 0 });
+};
+exports.Kaleidoscope = Kaleidoscope;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'kaleidoscopePower', 2, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'kaleidoscopeAngle', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Mask.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Mask: Filter;

node_modules/konva/cmj/filters/Mask.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mask = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+function pixelAt(idata, x, y) {
+    var idx = (y * idata.width + x) * 4;
+    var d = [];
+    d.push(idata.data[idx++], idata.data[idx++], idata.data[idx++], idata.data[idx++]);
+    return d;
+}
+function rgbDistance(p1, p2) {
+    return Math.sqrt(Math.pow(p1[0] - p2[0], 2) +
+        Math.pow(p1[1] - p2[1], 2) +
+        Math.pow(p1[2] - p2[2], 2));
+}
+function rgbMean(pTab) {
+    var m = [0, 0, 0];
+    for (var i = 0; i < pTab.length; i++) {
+        m[0] += pTab[i][0];
+        m[1] += pTab[i][1];
+        m[2] += pTab[i][2];
+    }
+    m[0] /= pTab.length;
+    m[1] /= pTab.length;
+    m[2] /= pTab.length;
+    return m;
+}
+function backgroundMask(idata, threshold) {
+    var rgbv_no = pixelAt(idata, 0, 0);
+    var rgbv_ne = pixelAt(idata, idata.width - 1, 0);
+    var rgbv_so = pixelAt(idata, 0, idata.height - 1);
+    var rgbv_se = pixelAt(idata, idata.width - 1, idata.height - 1);
+    var thres = threshold || 10;
+    if (rgbDistance(rgbv_no, rgbv_ne) < thres &&
+        rgbDistance(rgbv_ne, rgbv_se) < thres &&
+        rgbDistance(rgbv_se, rgbv_so) < thres &&
+        rgbDistance(rgbv_so, rgbv_no) < thres) {
+        var mean = rgbMean([rgbv_ne, rgbv_no, rgbv_se, rgbv_so]);
+        var mask = [];
+        for (var i = 0; i < idata.width * idata.height; i++) {
+            var d = rgbDistance(mean, [
+                idata.data[i * 4],
+                idata.data[i * 4 + 1],
+                idata.data[i * 4 + 2],
+            ]);
+            mask[i] = d < thres ? 0 : 255;
+        }
+        return mask;
+    }
+}
+function applyMask(idata, mask) {
+    for (var i = 0; i < idata.width * idata.height; i++) {
+        idata.data[4 * i + 3] = mask[i];
+    }
+}
+function erodeMask(mask, sw, sh) {
+    var weights = [1, 1, 1, 1, 0, 1, 1, 1, 1];
+    var side = Math.round(Math.sqrt(weights.length));
+    var halfSide = Math.floor(side / 2);
+    var maskResult = [];
+    for (var y = 0; y < sh; y++) {
+        for (var x = 0; x < sw; x++) {
+            var so = y * sw + x;
+            var a = 0;
+            for (var cy = 0; cy < side; cy++) {
+                for (var cx = 0; cx < side; cx++) {
+                    var scy = y + cy - halfSide;
+                    var scx = x + cx - halfSide;
+                    if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
+                        var srcOff = scy * sw + scx;
+                        var wt = weights[cy * side + cx];
+                        a += mask[srcOff] * wt;
+                    }
+                }
+            }
+            maskResult[so] = a === 255 * 8 ? 255 : 0;
+        }
+    }
+    return maskResult;
+}
+function dilateMask(mask, sw, sh) {
+    var weights = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    var side = Math.round(Math.sqrt(weights.length));
+    var halfSide = Math.floor(side / 2);
+    var maskResult = [];
+    for (var y = 0; y < sh; y++) {
+        for (var x = 0; x < sw; x++) {
+            var so = y * sw + x;
+            var a = 0;
+            for (var cy = 0; cy < side; cy++) {
+                for (var cx = 0; cx < side; cx++) {
+                    var scy = y + cy - halfSide;
+                    var scx = x + cx - halfSide;
+                    if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
+                        var srcOff = scy * sw + scx;
+                        var wt = weights[cy * side + cx];
+                        a += mask[srcOff] * wt;
+                    }
+                }
+            }
+            maskResult[so] = a >= 255 * 4 ? 255 : 0;
+        }
+    }
+    return maskResult;
+}
+function smoothEdgeMask(mask, sw, sh) {
+    var weights = [1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9];
+    var side = Math.round(Math.sqrt(weights.length));
+    var halfSide = Math.floor(side / 2);
+    var maskResult = [];
+    for (var y = 0; y < sh; y++) {
+        for (var x = 0; x < sw; x++) {
+            var so = y * sw + x;
+            var a = 0;
+            for (var cy = 0; cy < side; cy++) {
+                for (var cx = 0; cx < side; cx++) {
+                    var scy = y + cy - halfSide;
+                    var scx = x + cx - halfSide;
+                    if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
+                        var srcOff = scy * sw + scx;
+                        var wt = weights[cy * side + cx];
+                        a += mask[srcOff] * wt;
+                    }
+                }
+            }
+            maskResult[so] = a;
+        }
+    }
+    return maskResult;
+}
+const Mask = function (imageData) {
+    var threshold = this.threshold(), mask = backgroundMask(imageData, threshold);
+    if (mask) {
+        mask = erodeMask(mask, imageData.width, imageData.height);
+        mask = dilateMask(mask, imageData.width, imageData.height);
+        mask = smoothEdgeMask(mask, imageData.width, imageData.height);
+        applyMask(imageData, mask);
+    }
+    return imageData;
+};
+exports.Mask = Mask;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'threshold', 0, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Noise.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Noise: Filter;

node_modules/konva/cmj/filters/Noise.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Noise = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Noise = function (imageData) {
+    var amount = this.noise() * 255, data = imageData.data, nPixels = data.length, half = amount / 2, i;
+    for (i = 0; i < nPixels; i += 4) {
+        data[i + 0] += half - 2 * half * Math.random();
+        data[i + 1] += half - 2 * half * Math.random();
+        data[i + 2] += half - 2 * half * Math.random();
+    }
+};
+exports.Noise = Noise;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'noise', 0.2, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Pixelate.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Pixelate: Filter;

node_modules/konva/cmj/filters/Pixelate.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pixelate = void 0;
+const Factory_1 = require("../Factory");
+const Util_1 = require("../Util");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Pixelate = function (imageData) {
+    var pixelSize = Math.ceil(this.pixelSize()), width = imageData.width, height = imageData.height, x, y, i, red, green, blue, alpha, nBinsX = Math.ceil(width / pixelSize), nBinsY = Math.ceil(height / pixelSize), xBinStart, xBinEnd, yBinStart, yBinEnd, xBin, yBin, pixelsInBin, data = imageData.data;
+    if (pixelSize <= 0) {
+        Util_1.Util.error('pixelSize value can not be <= 0');
+        return;
+    }
+    for (xBin = 0; xBin < nBinsX; xBin += 1) {
+        for (yBin = 0; yBin < nBinsY; yBin += 1) {
+            red = 0;
+            green = 0;
+            blue = 0;
+            alpha = 0;
+            xBinStart = xBin * pixelSize;
+            xBinEnd = xBinStart + pixelSize;
+            yBinStart = yBin * pixelSize;
+            yBinEnd = yBinStart + pixelSize;
+            pixelsInBin = 0;
+            for (x = xBinStart; x < xBinEnd; x += 1) {
+                if (x >= width) {
+                    continue;
+                }
+                for (y = yBinStart; y < yBinEnd; y += 1) {
+                    if (y >= height) {
+                        continue;
+                    }
+                    i = (width * y + x) * 4;
+                    red += data[i + 0];
+                    green += data[i + 1];
+                    blue += data[i + 2];
+                    alpha += data[i + 3];
+                    pixelsInBin += 1;
+                }
+            }
+            red = red / pixelsInBin;
+            green = green / pixelsInBin;
+            blue = blue / pixelsInBin;
+            alpha = alpha / pixelsInBin;
+            for (x = xBinStart; x < xBinEnd; x += 1) {
+                if (x >= width) {
+                    continue;
+                }
+                for (y = yBinStart; y < yBinEnd; y += 1) {
+                    if (y >= height) {
+                        continue;
+                    }
+                    i = (width * y + x) * 4;
+                    data[i + 0] = red;
+                    data[i + 1] = green;
+                    data[i + 2] = blue;
+                    data[i + 3] = alpha;
+                }
+            }
+        }
+    }
+};
+exports.Pixelate = Pixelate;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'pixelSize', 8, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/Posterize.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Posterize: Filter;

node_modules/konva/cmj/filters/Posterize.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Posterize = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Posterize = function (imageData) {
+    var levels = Math.round(this.levels() * 254) + 1, data = imageData.data, len = data.length, scale = 255 / levels, i;
+    for (i = 0; i < len; i += 1) {
+        data[i] = Math.floor(data[i] / scale) * scale;
+    }
+};
+exports.Posterize = Posterize;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'levels', 0.5, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/RGB.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const RGB: Filter;

node_modules/konva/cmj/filters/RGB.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGB = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const RGB = function (imageData) {
+    var data = imageData.data, nPixels = data.length, red = this.red(), green = this.green(), blue = this.blue(), i, brightness;
+    for (i = 0; i < nPixels; i += 4) {
+        brightness =
+            (0.34 * data[i] + 0.5 * data[i + 1] + 0.16 * data[i + 2]) / 255;
+        data[i] = brightness * red;
+        data[i + 1] = brightness * green;
+        data[i + 2] = brightness * blue;
+        data[i + 3] = data[i + 3];
+    }
+};
+exports.RGB = RGB;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'red', 0, function (val) {
+    this._filterUpToDate = false;
+    if (val > 255) {
+        return 255;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    else {
+        return Math.round(val);
+    }
+});
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'green', 0, function (val) {
+    this._filterUpToDate = false;
+    if (val > 255) {
+        return 255;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    else {
+        return Math.round(val);
+    }
+});
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'blue', 0, Validators_1.RGBComponent, Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/filters/RGBA.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const RGBA: Filter;

node_modules/konva/cmj/filters/RGBA.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGBA = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const RGBA = function (imageData) {
+    var data = imageData.data, nPixels = data.length, red = this.red(), green = this.green(), blue = this.blue(), alpha = this.alpha(), i, ia;
+    for (i = 0; i < nPixels; i += 4) {
+        ia = 1 - alpha;
+        data[i] = red * alpha + data[i] * ia;
+        data[i + 1] = green * alpha + data[i + 1] * ia;
+        data[i + 2] = blue * alpha + data[i + 2] * ia;
+    }
+};
+exports.RGBA = RGBA;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'red', 0, function (val) {
+    this._filterUpToDate = false;
+    if (val > 255) {
+        return 255;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    else {
+        return Math.round(val);
+    }
+});
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'green', 0, function (val) {
+    this._filterUpToDate = false;
+    if (val > 255) {
+        return 255;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    else {
+        return Math.round(val);
+    }
+});
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'blue', 0, Validators_1.RGBComponent, Factory_1.Factory.afterSetFilter);
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'alpha', 1, function (val) {
+    this._filterUpToDate = false;
+    if (val > 1) {
+        return 1;
+    }
+    else if (val < 0) {
+        return 0;
+    }
+    else {
+        return val;
+    }
+});

node_modules/konva/cmj/filters/Sepia.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Sepia: Filter;

node_modules/konva/cmj/filters/Sepia.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sepia = void 0;
+const Sepia = function (imageData) {
+    var data = imageData.data, nPixels = data.length, i, r, g, b;
+    for (i = 0; i < nPixels; i += 4) {
+        r = data[i + 0];
+        g = data[i + 1];
+        b = data[i + 2];
+        data[i + 0] = Math.min(255, r * 0.393 + g * 0.769 + b * 0.189);
+        data[i + 1] = Math.min(255, r * 0.349 + g * 0.686 + b * 0.168);
+        data[i + 2] = Math.min(255, r * 0.272 + g * 0.534 + b * 0.131);
+    }
+};
+exports.Sepia = Sepia;

node_modules/konva/cmj/filters/Solarize.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Solarize: Filter;

node_modules/konva/cmj/filters/Solarize.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Solarize = void 0;
+const Solarize = function (imageData) {
+    var data = imageData.data, w = imageData.width, h = imageData.height, w4 = w * 4, y = h;
+    do {
+        var offsetY = (y - 1) * w4;
+        var x = w;
+        do {
+            var offset = offsetY + (x - 1) * 4;
+            var r = data[offset];
+            var g = data[offset + 1];
+            var b = data[offset + 2];
+            if (r > 127) {
+                r = 255 - r;
+            }
+            if (g > 127) {
+                g = 255 - g;
+            }
+            if (b > 127) {
+                b = 255 - b;
+            }
+            data[offset] = r;
+            data[offset + 1] = g;
+            data[offset + 2] = b;
+        } while (--x);
+    } while (--y);
+};
+exports.Solarize = Solarize;

node_modules/konva/cmj/filters/Threshold.d.ts

@@ -0,0 +1,2 @@
+import { Filter } from '../Node';
+export declare const Threshold: Filter;

node_modules/konva/cmj/filters/Threshold.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Threshold = void 0;
+const Factory_1 = require("../Factory");
+const Node_1 = require("../Node");
+const Validators_1 = require("../Validators");
+const Threshold = function (imageData) {
+    var level = this.threshold() * 255, data = imageData.data, len = data.length, i;
+    for (i = 0; i < len; i += 1) {
+        data[i] = data[i] < level ? 0 : 255;
+    }
+};
+exports.Threshold = Threshold;
+Factory_1.Factory.addGetterSetter(Node_1.Node, 'threshold', 0.5, (0, Validators_1.getNumberValidator)(), Factory_1.Factory.afterSetFilter);

node_modules/konva/cmj/index-node.d.ts

@@ -0,0 +1,2 @@
+import { Konva } from './_FullInternals';
+export default Konva;

node_modules/konva/cmj/index-node.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _FullInternals_1 = require("./_FullInternals");
+const Canvas = require("canvas");
+const canvas = Canvas['default'] || Canvas;
+const isNode = typeof global.document === 'undefined';
+if (isNode) {
+    _FullInternals_1.Konva.Util['createCanvasElement'] = () => {
+        const node = canvas.createCanvas(300, 300);
+        if (!node['style']) {
+            node['style'] = {};
+        }
+        return node;
+    };
+    _FullInternals_1.Konva.Util.createImageElement = () => {
+        const node = new canvas.Image();
+        return node;
+    };
+}
+exports.default = _FullInternals_1.Konva;

node_modules/konva/cmj/index-types.d.ts

@@ -0,0 +1,179 @@
+// the purpose of that file is very stupid
+// I was not able to generate correct typescript declarations from the main source code
+// because right now Konva is an object. Typescript can not define types from object like this:
+// const stage : Konva.Stage = new Konva.Stage();
+// we can convert Konva to namespace
+// but I was not able to find a way to extend it
+// so here we just need to define full API of Konva manually
+
+// filters
+import { Blur } from './filters/Blur';
+import { Brighten } from './filters/Brighten';
+import { Contrast } from './filters/Contrast';
+import { Emboss } from './filters/Emboss';
+import { Enhance } from './filters/Enhance';
+import { Grayscale } from './filters/Grayscale';
+import { HSL } from './filters/HSL';
+import { HSV } from './filters/HSV';
+import { Invert } from './filters/Invert';
+import { Kaleidoscope } from './filters/Kaleidoscope';
+import { Mask } from './filters/Mask';
+import { Noise } from './filters/Noise';
+import { Pixelate } from './filters/Pixelate';
+import { Posterize } from './filters/Posterize';
+import { RGB } from './filters/RGB';
+import { RGBA } from './filters/RGBA';
+import { Sepia } from './filters/Sepia';
+import { Solarize } from './filters/Solarize';
+import { Threshold } from './filters/Threshold';
+
+declare namespace Konva {
+  export let enableTrace: number;
+  export let pixelRatio: number;
+  export let autoDrawEnabled: boolean;
+  export let dragDistance: number;
+  export let angleDeg: boolean;
+  export let showWarnings: boolean;
+  export let capturePointerEventsEnabled: boolean;
+  export let dragButtons: Array<number>;
+  export let hitOnDragEnabled: boolean;
+  export const isDragging: () => boolean;
+  export const isDragReady: () => boolean;
+
+  export type Vector2d = import('./types').Vector2d;
+
+  export const Node: typeof import('./Node').Node;
+  export type Node = import('./Node').Node;
+  export type NodeConfig = import('./Node').NodeConfig;
+
+  export type KonvaEventObject<
+    EventType
+  > = import('./Node').KonvaEventObject<EventType>;
+
+  export type KonvaPointerEvent = import('./PointerEvents').KonvaPointerEvent;
+
+  export type KonvaEventListener<
+    This,
+    EventType
+  > = import('./Node').KonvaEventListener<This, EventType>;
+
+  export const Container: typeof import('./Container').Container;
+  export type Container = import('./Container').Container<Node>;
+  export type ContainerConfig = import('./Container').ContainerConfig;
+
+  export const Transform: typeof import('./Util').Transform;
+  export type Transform = import('./Util').Transform;
+
+  export const Util: typeof import('./Util').Util;
+
+  export const Context: typeof import('./Context').Context;
+  export type Context = import('./Context').Context;
+
+  export const Stage: typeof import('./Stage').Stage;
+  export type Stage = import('./Stage').Stage;
+  export const stages: typeof import('./Stage').stages;
+
+  export const Layer: typeof import('./Layer').Layer;
+  export type Layer = import('./Layer').Layer;
+  export type LayerConfig = import('./Layer').LayerConfig;
+
+  export const FastLayer: typeof import('./FastLayer').FastLayer;
+  export type FastLayer = import('./FastLayer').FastLayer;
+
+  export const Group: typeof import('./Group').Group;
+  export type Group = import('./Group').Group;
+
+  export const DD: typeof import('./DragAndDrop').DD;
+
+  export const Shape: typeof import('./Shape').Shape;
+  export type Shape = import('./Shape').Shape;
+  export type ShapeConfig = import('./Shape').ShapeConfig;
+  export const shapes: typeof import('./Shape').shapes;
+
+  export const Animation: typeof import('./Animation').Animation;
+  export type Animation = import('./Animation').Animation;
+
+  export const Tween: typeof import('./Tween').Tween;
+  export type Tween = import('./Tween').Tween;
+  export type TweenConfig = import('./Tween').TweenConfig;
+  export const Easings: typeof import('./Tween').Easings;
+
+  export const Arc: typeof import('./shapes/Arc').Arc;
+  export type Arc = import('./shapes/Arc').Arc;
+  export type ArcConfig = import('./shapes/Arc').ArcConfig;
+  export const Arrow: typeof import('./shapes/Arrow').Arrow;
+  export type Arrow = import('./shapes/Arrow').Arrow;
+  export type ArrowConfig = import('./shapes/Arrow').ArrowConfig;
+  export const Circle: typeof import('./shapes/Circle').Circle;
+  export type Circle = import('./shapes/Circle').Circle;
+  export type CircleConfig = import('./shapes/Circle').CircleConfig;
+  export const Ellipse: typeof import('./shapes/Ellipse').Ellipse;
+  export type Ellipse = import('./shapes/Ellipse').Ellipse;
+  export type EllipseConfig = import('./shapes/Ellipse').EllipseConfig;
+  export const Image: typeof import('./shapes/Image').Image;
+  export type Image = import('./shapes/Image').Image;
+  export type ImageConfig = import('./shapes/Image').ImageConfig;
+  export const Label: typeof import('./shapes/Label').Label;
+  export type Label = import('./shapes/Label').Label;
+  export type LabelConfig = import('./shapes/Label').LabelConfig;
+  export const Tag: typeof import('./shapes/Label').Tag;
+  export type Tag = import('./shapes/Label').Tag;
+  export type TagConfig = import('./shapes/Label').TagConfig;
+  export const Line: typeof import('./shapes/Line').Line;
+  export type Line = import('./shapes/Line').Line;
+  export type LineConfig = import('./shapes/Line').LineConfig;
+  export const Path: typeof import('./shapes/Path').Path;
+  export type Path = import('./shapes/Path').Path;
+  export type PathConfig = import('./shapes/Path').PathConfig;
+  export const Rect: typeof import('./shapes/Rect').Rect;
+  export type Rect = import('./shapes/Rect').Rect;
+  export type RectConfig = import('./shapes/Rect').RectConfig;
+  export const RegularPolygon: typeof import('./shapes/RegularPolygon').RegularPolygon;
+  export type RegularPolygon = import('./shapes/RegularPolygon').RegularPolygon;
+  export type RegularPolygonConfig = import('./shapes/RegularPolygon').RegularPolygonConfig;
+  export const Ring: typeof import('./shapes/Ring').Ring;
+  export type Ring = import('./shapes/Ring').Ring;
+  export type RingConfig = import('./shapes/Ring').RingConfig;
+  export const Sprite: typeof import('./shapes/Sprite').Sprite;
+  export type Sprite = import('./shapes/Sprite').Sprite;
+  export type SpriteConfig = import('./shapes/Sprite').SpriteConfig;
+  export const Star: typeof import('./shapes/Star').Star;
+  export type Star = import('./shapes/Star').Star;
+  export type StarConfig = import('./shapes/Star').StarConfig;
+  export const Text: typeof import('./shapes/Text').Text;
+  export type Text = import('./shapes/Text').Text;
+  export type TextConfig = import('./shapes/Text').TextConfig;
+  export const TextPath: typeof import('./shapes/TextPath').TextPath;
+  export type TextPath = import('./shapes/TextPath').TextPath;
+  export type TextPathConfig = import('./shapes/TextPath').TextPathConfig;
+  export const Transformer: typeof import('./shapes/Transformer').Transformer;
+  export type Transformer = import('./shapes/Transformer').Transformer;
+  export type TransformerConfig = import('./shapes/Transformer').TransformerConfig;
+  export const Wedge: typeof import('./shapes/Wedge').Wedge;
+  export type Wedge = import('./shapes/Wedge').Wedge;
+  export type WedgeConfig = import('./shapes/Wedge').WedgeConfig;
+
+  export const Filters: {
+    Blur: typeof Blur;
+    Brighten: typeof Brighten;
+    Contrast: typeof Contrast;
+    Emboss: typeof Emboss;
+    Enhance: typeof Enhance;
+    Grayscale: typeof Grayscale;
+    HSL: typeof HSL;
+    HSV: typeof HSV;
+    Invert: typeof Invert;
+    Kaleidoscope: typeof Kaleidoscope;
+    Mask: typeof Mask;
+    Noise: typeof Noise;
+    Pixelate: typeof Pixelate;
+    Posterize: typeof Posterize;
+    RGB: typeof RGB;
+    RGBA: typeof RGBA;
+    Sepia: typeof Sepia;
+    Solarize: typeof Solarize;
+    Threshold: typeof Threshold;
+  };
+}
+
+export default Konva;

node_modules/konva/cmj/index.d.ts

@@ -0,0 +1,2 @@
+import { Konva } from './_FullInternals';
+export default Konva;

node_modules/konva/cmj/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _FullInternals_1 = require("./_FullInternals");
+exports.default = _FullInternals_1.Konva;

node_modules/konva/cmj/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "commonjs",
+  "main": "./index-node.js",
+  "browser": "./index.js",
+  "typings": "./index-types.d.ts"
+}

node_modules/konva/cmj/shapes/Arc.d.ts

@@ -0,0 +1,19 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { GetSet } from '../types';
+export interface ArcConfig extends ShapeConfig {
+    angle: number;
+    innerRadius: number;
+    outerRadius: number;
+    clockwise?: boolean;
+}
+export declare class Arc extends Shape<ArcConfig> {
+    _sceneFunc(context: any): void;
+    getWidth(): number;
+    getHeight(): number;
+    setWidth(width: any): void;
+    setHeight(height: any): void;
+    innerRadius: GetSet<number, this>;
+    outerRadius: GetSet<number, this>;
+    angle: GetSet<number, this>;
+    clockwise: GetSet<boolean, this>;
+}

node_modules/konva/cmj/shapes/Arc.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arc = void 0;
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Global_1 = require("../Global");
+const Validators_1 = require("../Validators");
+const Global_2 = require("../Global");
+class Arc extends Shape_1.Shape {
+    _sceneFunc(context) {
+        var angle = Global_1.Konva.getAngle(this.angle()), clockwise = this.clockwise();
+        context.beginPath();
+        context.arc(0, 0, this.outerRadius(), 0, angle, clockwise);
+        context.arc(0, 0, this.innerRadius(), angle, 0, !clockwise);
+        context.closePath();
+        context.fillStrokeShape(this);
+    }
+    getWidth() {
+        return this.outerRadius() * 2;
+    }
+    getHeight() {
+        return this.outerRadius() * 2;
+    }
+    setWidth(width) {
+        this.outerRadius(width / 2);
+    }
+    setHeight(height) {
+        this.outerRadius(height / 2);
+    }
+}
+exports.Arc = Arc;
+Arc.prototype._centroid = true;
+Arc.prototype.className = 'Arc';
+Arc.prototype._attrsAffectingSize = ['innerRadius', 'outerRadius'];
+(0, Global_2._registerNode)(Arc);
+Factory_1.Factory.addGetterSetter(Arc, 'innerRadius', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Arc, 'outerRadius', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Arc, 'angle', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Arc, 'clockwise', false, (0, Validators_1.getBooleanValidator)());

node_modules/konva/cmj/shapes/Arrow.d.ts

@@ -0,0 +1,25 @@
+import { Line, LineConfig } from './Line';
+import { GetSet } from '../types';
+export interface ArrowConfig extends LineConfig {
+    points: number[];
+    tension?: number;
+    closed?: boolean;
+    pointerLength?: number;
+    pointerWidth?: number;
+    pointerAtBeginning?: boolean;
+    pointerAtEnding?: boolean;
+}
+export declare class Arrow extends Line<ArrowConfig> {
+    _sceneFunc(ctx: any): void;
+    __fillStroke(ctx: any): void;
+    getSelfRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    pointerLength: GetSet<number, this>;
+    pointerWidth: GetSet<number, this>;
+    pointerAtEnding: GetSet<boolean, this>;
+    pointerAtBeginning: GetSet<boolean, this>;
+}

node_modules/konva/cmj/shapes/Arrow.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arrow = void 0;
+const Factory_1 = require("../Factory");
+const Line_1 = require("./Line");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+const Path_1 = require("./Path");
+class Arrow extends Line_1.Line {
+    _sceneFunc(ctx) {
+        super._sceneFunc(ctx);
+        var PI2 = Math.PI * 2;
+        var points = this.points();
+        var tp = points;
+        var fromTension = this.tension() !== 0 && points.length > 4;
+        if (fromTension) {
+            tp = this.getTensionPoints();
+        }
+        var length = this.pointerLength();
+        var n = points.length;
+        var dx, dy;
+        if (fromTension) {
+            const lp = [
+                tp[tp.length - 4],
+                tp[tp.length - 3],
+                tp[tp.length - 2],
+                tp[tp.length - 1],
+                points[n - 2],
+                points[n - 1],
+            ];
+            const lastLength = Path_1.Path.calcLength(tp[tp.length - 4], tp[tp.length - 3], 'C', lp);
+            const previous = Path_1.Path.getPointOnQuadraticBezier(Math.min(1, 1 - length / lastLength), lp[0], lp[1], lp[2], lp[3], lp[4], lp[5]);
+            dx = points[n - 2] - previous.x;
+            dy = points[n - 1] - previous.y;
+        }
+        else {
+            dx = points[n - 2] - points[n - 4];
+            dy = points[n - 1] - points[n - 3];
+        }
+        var radians = (Math.atan2(dy, dx) + PI2) % PI2;
+        var width = this.pointerWidth();
+        if (this.pointerAtEnding()) {
+            ctx.save();
+            ctx.beginPath();
+            ctx.translate(points[n - 2], points[n - 1]);
+            ctx.rotate(radians);
+            ctx.moveTo(0, 0);
+            ctx.lineTo(-length, width / 2);
+            ctx.lineTo(-length, -width / 2);
+            ctx.closePath();
+            ctx.restore();
+            this.__fillStroke(ctx);
+        }
+        if (this.pointerAtBeginning()) {
+            ctx.save();
+            ctx.beginPath();
+            ctx.translate(points[0], points[1]);
+            if (fromTension) {
+                dx = (tp[0] + tp[2]) / 2 - points[0];
+                dy = (tp[1] + tp[3]) / 2 - points[1];
+            }
+            else {
+                dx = points[2] - points[0];
+                dy = points[3] - points[1];
+            }
+            ctx.rotate((Math.atan2(-dy, -dx) + PI2) % PI2);
+            ctx.moveTo(0, 0);
+            ctx.lineTo(-length, width / 2);
+            ctx.lineTo(-length, -width / 2);
+            ctx.closePath();
+            ctx.restore();
+            this.__fillStroke(ctx);
+        }
+    }
+    __fillStroke(ctx) {
+        var isDashEnabled = this.dashEnabled();
+        if (isDashEnabled) {
+            this.attrs.dashEnabled = false;
+            ctx.setLineDash([]);
+        }
+        ctx.fillStrokeShape(this);
+        if (isDashEnabled) {
+            this.attrs.dashEnabled = true;
+        }
+    }
+    getSelfRect() {
+        const lineRect = super.getSelfRect();
+        const offset = this.pointerWidth() / 2;
+        return {
+            x: lineRect.x - offset,
+            y: lineRect.y - offset,
+            width: lineRect.width + offset * 2,
+            height: lineRect.height + offset * 2,
+        };
+    }
+}
+exports.Arrow = Arrow;
+Arrow.prototype.className = 'Arrow';
+(0, Global_1._registerNode)(Arrow);
+Factory_1.Factory.addGetterSetter(Arrow, 'pointerLength', 10, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Arrow, 'pointerWidth', 10, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Arrow, 'pointerAtBeginning', false);
+Factory_1.Factory.addGetterSetter(Arrow, 'pointerAtEnding', true);

node_modules/konva/cmj/shapes/Circle.d.ts

@@ -0,0 +1,13 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { GetSet } from '../types';
+export interface CircleConfig extends ShapeConfig {
+    radius?: number;
+}
+export declare class Circle extends Shape<CircleConfig> {
+    _sceneFunc(context: any): void;
+    getWidth(): number;
+    getHeight(): number;
+    setWidth(width: any): void;
+    setHeight(height: any): void;
+    radius: GetSet<number, this>;
+}

node_modules/konva/cmj/shapes/Circle.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Circle = void 0;
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+class Circle extends Shape_1.Shape {
+    _sceneFunc(context) {
+        context.beginPath();
+        context.arc(0, 0, this.attrs.radius || 0, 0, Math.PI * 2, false);
+        context.closePath();
+        context.fillStrokeShape(this);
+    }
+    getWidth() {
+        return this.radius() * 2;
+    }
+    getHeight() {
+        return this.radius() * 2;
+    }
+    setWidth(width) {
+        if (this.radius() !== width / 2) {
+            this.radius(width / 2);
+        }
+    }
+    setHeight(height) {
+        if (this.radius() !== height / 2) {
+            this.radius(height / 2);
+        }
+    }
+}
+exports.Circle = Circle;
+Circle.prototype._centroid = true;
+Circle.prototype.className = 'Circle';
+Circle.prototype._attrsAffectingSize = ['radius'];
+(0, Global_1._registerNode)(Circle);
+Factory_1.Factory.addGetterSetter(Circle, 'radius', 0, (0, Validators_1.getNumberValidator)());

node_modules/konva/cmj/shapes/Ellipse.d.ts

@@ -0,0 +1,16 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { GetSet, Vector2d } from '../types';
+export interface EllipseConfig extends ShapeConfig {
+    radiusX: number;
+    radiusY: number;
+}
+export declare class Ellipse extends Shape<EllipseConfig> {
+    _sceneFunc(context: any): void;
+    getWidth(): number;
+    getHeight(): number;
+    setWidth(width: any): void;
+    setHeight(height: any): void;
+    radius: GetSet<Vector2d, this>;
+    radiusX: GetSet<number, this>;
+    radiusY: GetSet<number, this>;
+}

node_modules/konva/cmj/shapes/Ellipse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ellipse = void 0;
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+class Ellipse extends Shape_1.Shape {
+    _sceneFunc(context) {
+        var rx = this.radiusX(), ry = this.radiusY();
+        context.beginPath();
+        context.save();
+        if (rx !== ry) {
+            context.scale(1, ry / rx);
+        }
+        context.arc(0, 0, rx, 0, Math.PI * 2, false);
+        context.restore();
+        context.closePath();
+        context.fillStrokeShape(this);
+    }
+    getWidth() {
+        return this.radiusX() * 2;
+    }
+    getHeight() {
+        return this.radiusY() * 2;
+    }
+    setWidth(width) {
+        this.radiusX(width / 2);
+    }
+    setHeight(height) {
+        this.radiusY(height / 2);
+    }
+}
+exports.Ellipse = Ellipse;
+Ellipse.prototype.className = 'Ellipse';
+Ellipse.prototype._centroid = true;
+Ellipse.prototype._attrsAffectingSize = ['radiusX', 'radiusY'];
+(0, Global_1._registerNode)(Ellipse);
+Factory_1.Factory.addComponentsGetterSetter(Ellipse, 'radius', ['x', 'y']);
+Factory_1.Factory.addGetterSetter(Ellipse, 'radiusX', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Ellipse, 'radiusY', 0, (0, Validators_1.getNumberValidator)());

node_modules/konva/cmj/shapes/Image.d.ts

@@ -0,0 +1,23 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { GetSet, IRect } from '../types';
+import { Context } from '../Context';
+export interface ImageConfig extends ShapeConfig {
+    image: CanvasImageSource | undefined;
+    crop?: IRect;
+}
+export declare class Image extends Shape<ImageConfig> {
+    constructor(attrs: ImageConfig);
+    _setImageLoad(): void;
+    _useBufferCanvas(): boolean;
+    _sceneFunc(context: Context): void;
+    _hitFunc(context: any): void;
+    getWidth(): any;
+    getHeight(): any;
+    static fromURL(url: any, callback: any): void;
+    image: GetSet<CanvasImageSource | undefined, this>;
+    crop: GetSet<IRect, this>;
+    cropX: GetSet<number, this>;
+    cropY: GetSet<number, this>;
+    cropWidth: GetSet<number, this>;
+    cropHeight: GetSet<number, this>;
+}

node_modules/konva/cmj/shapes/Image.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = void 0;
+const Util_1 = require("../Util");
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+class Image extends Shape_1.Shape {
+    constructor(attrs) {
+        super(attrs);
+        this.on('imageChange.konva', () => {
+            this._setImageLoad();
+        });
+        this._setImageLoad();
+    }
+    _setImageLoad() {
+        const image = this.image();
+        if (image && image.complete) {
+            return;
+        }
+        if (image && image.readyState === 4) {
+            return;
+        }
+        if (image && image['addEventListener']) {
+            image['addEventListener']('load', () => {
+                this._requestDraw();
+            });
+        }
+    }
+    _useBufferCanvas() {
+        return super._useBufferCanvas(true);
+    }
+    _sceneFunc(context) {
+        const width = this.getWidth();
+        const height = this.getHeight();
+        const image = this.attrs.image;
+        let params;
+        if (image) {
+            const cropWidth = this.attrs.cropWidth;
+            const cropHeight = this.attrs.cropHeight;
+            if (cropWidth && cropHeight) {
+                params = [
+                    image,
+                    this.cropX(),
+                    this.cropY(),
+                    cropWidth,
+                    cropHeight,
+                    0,
+                    0,
+                    width,
+                    height,
+                ];
+            }
+            else {
+                params = [image, 0, 0, width, height];
+            }
+        }
+        if (this.hasFill() || this.hasStroke()) {
+            context.beginPath();
+            context.rect(0, 0, width, height);
+            context.closePath();
+            context.fillStrokeShape(this);
+        }
+        if (image) {
+            context.drawImage.apply(context, params);
+        }
+    }
+    _hitFunc(context) {
+        var width = this.width(), height = this.height();
+        context.beginPath();
+        context.rect(0, 0, width, height);
+        context.closePath();
+        context.fillStrokeShape(this);
+    }
+    getWidth() {
+        var _a, _b;
+        return (_a = this.attrs.width) !== null && _a !== void 0 ? _a : (_b = this.image()) === null || _b === void 0 ? void 0 : _b.width;
+    }
+    getHeight() {
+        var _a, _b;
+        return (_a = this.attrs.height) !== null && _a !== void 0 ? _a : (_b = this.image()) === null || _b === void 0 ? void 0 : _b.height;
+    }
+    static fromURL(url, callback) {
+        var img = Util_1.Util.createImageElement();
+        img.onload = function () {
+            var image = new Image({
+                image: img,
+            });
+            callback(image);
+        };
+        img.crossOrigin = 'Anonymous';
+        img.src = url;
+    }
+}
+exports.Image = Image;
+Image.prototype.className = 'Image';
+(0, Global_1._registerNode)(Image);
+Factory_1.Factory.addGetterSetter(Image, 'image');
+Factory_1.Factory.addComponentsGetterSetter(Image, 'crop', ['x', 'y', 'width', 'height']);
+Factory_1.Factory.addGetterSetter(Image, 'cropX', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Image, 'cropY', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Image, 'cropWidth', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Image, 'cropHeight', 0, (0, Validators_1.getNumberValidator)());

node_modules/konva/cmj/shapes/Label.d.ts

@@ -0,0 +1,35 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { Group } from '../Group';
+import { ContainerConfig } from '../Container';
+import { GetSet } from '../types';
+import { Text } from './Text';
+export interface LabelConfig extends ContainerConfig {
+}
+export declare class Label extends Group {
+    constructor(config?: any);
+    getText(): Text;
+    getTag(): Tag;
+    _addListeners(text: any): void;
+    getWidth(): number;
+    getHeight(): number;
+    _sync(): void;
+}
+export interface TagConfig extends ShapeConfig {
+    pointerDirection?: string;
+    pointerWidth?: number;
+    pointerHeight?: number;
+    cornerRadius?: number | Array<number>;
+}
+export declare class Tag extends Shape<TagConfig> {
+    _sceneFunc(context: any): void;
+    getSelfRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    pointerDirection: GetSet<'left' | 'top' | 'right' | 'bottom', this>;
+    pointerWidth: GetSet<number, this>;
+    pointerHeight: GetSet<number, this>;
+    cornerRadius: GetSet<number, this>;
+}

node_modules/konva/cmj/shapes/Label.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tag = exports.Label = void 0;
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Group_1 = require("../Group");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+var ATTR_CHANGE_LIST = [
+    'fontFamily',
+    'fontSize',
+    'fontStyle',
+    'padding',
+    'lineHeight',
+    'text',
+    'width',
+    'height',
+], CHANGE_KONVA = 'Change.konva', NONE = 'none', UP = 'up', RIGHT = 'right', DOWN = 'down', LEFT = 'left', attrChangeListLen = ATTR_CHANGE_LIST.length;
+class Label extends Group_1.Group {
+    constructor(config) {
+        super(config);
+        this.on('add.konva', function (evt) {
+            this._addListeners(evt.child);
+            this._sync();
+        });
+    }
+    getText() {
+        return this.find('Text')[0];
+    }
+    getTag() {
+        return this.find('Tag')[0];
+    }
+    _addListeners(text) {
+        var that = this, n;
+        var func = function () {
+            that._sync();
+        };
+        for (n = 0; n < attrChangeListLen; n++) {
+            text.on(ATTR_CHANGE_LIST[n] + CHANGE_KONVA, func);
+        }
+    }
+    getWidth() {
+        return this.getText().width();
+    }
+    getHeight() {
+        return this.getText().height();
+    }
+    _sync() {
+        var text = this.getText(), tag = this.getTag(), width, height, pointerDirection, pointerWidth, x, y, pointerHeight;
+        if (text && tag) {
+            width = text.width();
+            height = text.height();
+            pointerDirection = tag.pointerDirection();
+            pointerWidth = tag.pointerWidth();
+            pointerHeight = tag.pointerHeight();
+            x = 0;
+            y = 0;
+            switch (pointerDirection) {
+                case UP:
+                    x = width / 2;
+                    y = -1 * pointerHeight;
+                    break;
+                case RIGHT:
+                    x = width + pointerWidth;
+                    y = height / 2;
+                    break;
+                case DOWN:
+                    x = width / 2;
+                    y = height + pointerHeight;
+                    break;
+                case LEFT:
+                    x = -1 * pointerWidth;
+                    y = height / 2;
+                    break;
+            }
+            tag.setAttrs({
+                x: -1 * x,
+                y: -1 * y,
+                width: width,
+                height: height,
+            });
+            text.setAttrs({
+                x: -1 * x,
+                y: -1 * y,
+            });
+        }
+    }
+}
+exports.Label = Label;
+Label.prototype.className = 'Label';
+(0, Global_1._registerNode)(Label);
+class Tag extends Shape_1.Shape {
+    _sceneFunc(context) {
+        var width = this.width(), height = this.height(), pointerDirection = this.pointerDirection(), pointerWidth = this.pointerWidth(), pointerHeight = this.pointerHeight(), cornerRadius = this.cornerRadius();
+        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.beginPath();
+        context.moveTo(topLeft, 0);
+        if (pointerDirection === UP) {
+            context.lineTo((width - pointerWidth) / 2, 0);
+            context.lineTo(width / 2, -1 * pointerHeight);
+            context.lineTo((width + pointerWidth) / 2, 0);
+        }
+        context.lineTo(width - topRight, 0);
+        context.arc(width - topRight, topRight, topRight, (Math.PI * 3) / 2, 0, false);
+        if (pointerDirection === RIGHT) {
+            context.lineTo(width, (height - pointerHeight) / 2);
+            context.lineTo(width + pointerWidth, height / 2);
+            context.lineTo(width, (height + pointerHeight) / 2);
+        }
+        context.lineTo(width, height - bottomRight);
+        context.arc(width - bottomRight, height - bottomRight, bottomRight, 0, Math.PI / 2, false);
+        if (pointerDirection === DOWN) {
+            context.lineTo((width + pointerWidth) / 2, height);
+            context.lineTo(width / 2, height + pointerHeight);
+            context.lineTo((width - pointerWidth) / 2, height);
+        }
+        context.lineTo(bottomLeft, height);
+        context.arc(bottomLeft, height - bottomLeft, bottomLeft, Math.PI / 2, Math.PI, false);
+        if (pointerDirection === LEFT) {
+            context.lineTo(0, (height + pointerHeight) / 2);
+            context.lineTo(-1 * pointerWidth, height / 2);
+            context.lineTo(0, (height - pointerHeight) / 2);
+        }
+        context.lineTo(0, topLeft);
+        context.arc(topLeft, topLeft, topLeft, Math.PI, (Math.PI * 3) / 2, false);
+        context.closePath();
+        context.fillStrokeShape(this);
+    }
+    getSelfRect() {
+        var x = 0, y = 0, pointerWidth = this.pointerWidth(), pointerHeight = this.pointerHeight(), direction = this.pointerDirection(), width = this.width(), height = this.height();
+        if (direction === UP) {
+            y -= pointerHeight;
+            height += pointerHeight;
+        }
+        else if (direction === DOWN) {
+            height += pointerHeight;
+        }
+        else if (direction === LEFT) {
+            x -= pointerWidth * 1.5;
+            width += pointerWidth;
+        }
+        else if (direction === RIGHT) {
+            width += pointerWidth * 1.5;
+        }
+        return {
+            x: x,
+            y: y,
+            width: width,
+            height: height,
+        };
+    }
+}
+exports.Tag = Tag;
+Tag.prototype.className = 'Tag';
+(0, Global_1._registerNode)(Tag);
+Factory_1.Factory.addGetterSetter(Tag, 'pointerDirection', NONE);
+Factory_1.Factory.addGetterSetter(Tag, 'pointerWidth', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Tag, 'pointerHeight', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Tag, 'cornerRadius', 0, (0, Validators_1.getNumberOrArrayOfNumbersValidator)(4));

node_modules/konva/cmj/shapes/Line.d.ts

@@ -0,0 +1,28 @@
+import { Shape, ShapeConfig } from '../Shape';
+import { GetSet } from '../types';
+import { Context } from '../Context';
+export interface LineConfig extends ShapeConfig {
+    points?: number[];
+    tension?: number;
+    closed?: boolean;
+    bezier?: boolean;
+}
+export declare class Line<Config extends LineConfig = LineConfig> extends Shape<Config> {
+    constructor(config?: Config);
+    _sceneFunc(context: Context): void;
+    getTensionPoints(): any;
+    _getTensionPoints(): any[];
+    _getTensionPointsClosed(): any[];
+    getWidth(): number;
+    getHeight(): number;
+    getSelfRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    closed: GetSet<boolean, this>;
+    bezier: GetSet<boolean, this>;
+    tension: GetSet<number, this>;
+    points: GetSet<number[], this>;
+}

node_modules/konva/cmj/shapes/Line.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Line = void 0;
+const Factory_1 = require("../Factory");
+const Shape_1 = require("../Shape");
+const Validators_1 = require("../Validators");
+const Global_1 = require("../Global");
+function getControlPoints(x0, y0, x1, y1, x2, y2, t) {
+    var d01 = Math.sqrt(Math.pow(x1 - x0, 2) + Math.pow(y1 - y0, 2)), d12 = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)), fa = (t * d01) / (d01 + d12), fb = (t * d12) / (d01 + d12), p1x = x1 - fa * (x2 - x0), p1y = y1 - fa * (y2 - y0), p2x = x1 + fb * (x2 - x0), p2y = y1 + fb * (y2 - y0);
+    return [p1x, p1y, p2x, p2y];
+}
+function expandPoints(p, tension) {
+    var len = p.length, allPoints = [], n, cp;
+    for (n = 2; n < len - 2; n += 2) {
+        cp = getControlPoints(p[n - 2], p[n - 1], p[n], p[n + 1], p[n + 2], p[n + 3], tension);
+        if (isNaN(cp[0])) {
+            continue;
+        }
+        allPoints.push(cp[0]);
+        allPoints.push(cp[1]);
+        allPoints.push(p[n]);
+        allPoints.push(p[n + 1]);
+        allPoints.push(cp[2]);
+        allPoints.push(cp[3]);
+    }
+    return allPoints;
+}
+class Line extends Shape_1.Shape {
+    constructor(config) {
+        super(config);
+        this.on('pointsChange.konva tensionChange.konva closedChange.konva bezierChange.konva', function () {
+            this._clearCache('tensionPoints');
+        });
+    }
+    _sceneFunc(context) {
+        var points = this.points(), length = points.length, tension = this.tension(), closed = this.closed(), bezier = this.bezier(), tp, len, n;
+        if (!length) {
+            return;
+        }
+        context.beginPath();
+        context.moveTo(points[0], points[1]);
+        if (tension !== 0 && length > 4) {
+            tp = this.getTensionPoints();
+            len = tp.length;
+            n = closed ? 0 : 4;
+            if (!closed) {
+                context.quadraticCurveTo(tp[0], tp[1], tp[2], tp[3]);
+            }
+            while (n < len - 2) {
+                context.bezierCurveTo(tp[n++], tp[n++], tp[n++], tp[n++], tp[n++], tp[n++]);
+            }
+            if (!closed) {
+                context.quadraticCurveTo(tp[len - 2], tp[len - 1], points[length - 2], points[length - 1]);
+            }
+        }
+        else if (bezier) {
+            n = 2;
+            while (n < length) {
+                context.bezierCurveTo(points[n++], points[n++], points[n++], points[n++], points[n++], points[n++]);
+            }
+        }
+        else {
+            for (n = 2; n < length; n += 2) {
+                context.lineTo(points[n], points[n + 1]);
+            }
+        }
+        if (closed) {
+            context.closePath();
+            context.fillStrokeShape(this);
+        }
+        else {
+            context.strokeShape(this);
+        }
+    }
+    getTensionPoints() {
+        return this._getCache('tensionPoints', this._getTensionPoints);
+    }
+    _getTensionPoints() {
+        if (this.closed()) {
+            return this._getTensionPointsClosed();
+        }
+        else {
+            return expandPoints(this.points(), this.tension());
+        }
+    }
+    _getTensionPointsClosed() {
+        var p = this.points(), len = p.length, tension = this.tension(), firstControlPoints = getControlPoints(p[len - 2], p[len - 1], p[0], p[1], p[2], p[3], tension), lastControlPoints = getControlPoints(p[len - 4], p[len - 3], p[len - 2], p[len - 1], p[0], p[1], tension), middle = expandPoints(p, tension), tp = [firstControlPoints[2], firstControlPoints[3]]
+            .concat(middle)
+            .concat([
+            lastControlPoints[0],
+            lastControlPoints[1],
+            p[len - 2],
+            p[len - 1],
+            lastControlPoints[2],
+            lastControlPoints[3],
+            firstControlPoints[0],
+            firstControlPoints[1],
+            p[0],
+            p[1],
+        ]);
+        return tp;
+    }
+    getWidth() {
+        return this.getSelfRect().width;
+    }
+    getHeight() {
+        return this.getSelfRect().height;
+    }
+    getSelfRect() {
+        var points = this.points();
+        if (points.length < 4) {
+            return {
+                x: points[0] || 0,
+                y: points[1] || 0,
+                width: 0,
+                height: 0,
+            };
+        }
+        if (this.tension() !== 0) {
+            points = [
+                points[0],
+                points[1],
+                ...this._getTensionPoints(),
+                points[points.length - 2],
+                points[points.length - 1],
+            ];
+        }
+        else {
+            points = this.points();
+        }
+        var minX = points[0];
+        var maxX = points[0];
+        var minY = points[1];
+        var maxY = points[1];
+        var x, y;
+        for (var i = 0; i < points.length / 2; i++) {
+            x = points[i * 2];
+            y = points[i * 2 + 1];
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            minY = Math.min(minY, y);
+            maxY = Math.max(maxY, y);
+        }
+        return {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        };
+    }
+}
+exports.Line = Line;
+Line.prototype.className = 'Line';
+Line.prototype._attrsAffectingSize = ['points', 'bezier', 'tension'];
+(0, Global_1._registerNode)(Line);
+Factory_1.Factory.addGetterSetter(Line, 'closed', false);
+Factory_1.Factory.addGetterSetter(Line, 'bezier', false);
+Factory_1.Factory.addGetterSetter(Line, 'tension', 0, (0, Validators_1.getNumberValidator)());
+Factory_1.Factory.addGetterSetter(Line, 'points', [], (0, Validators_1.getNumberArrayValidator)());