Changeset 0c6b92a for imaps-frontend/node_modules/konva/lib

imaps-frontend/node_modules/konva/lib/Animation.js

rd565449	r0c6b92a
117	117	}
118	118	}
119		for (let key in layerHash) {
	119	for (const key in layerHash) {
120	120	if (!layerHash.hasOwnProperty(key)) {
121	121	continue;

imaps-frontend/node_modules/konva/lib/BezierFunctions.js

-              rd565449
+              r0c6b92a
 exports.binomialCoefficients = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]];
 const getCubicArcLength = (xs, ys, t) => {
-    let z;
     let sum;
     let correctedT;
     const n = 20;
     z = t / 2;
+    const z = t / 2;
     sum = 0;
     for (let i = 0; i < n; i++) {

imaps-frontend/node_modules/konva/lib/Canvas.js

-              rd565449
+              r0c6b92a
 const Factory_1 = require("./Factory");
 const Validators_1 = require("./Validators");
 var _pixelRatio;
+let _pixelRatio;
 function getDevicePixelRatio() {
     if (_pixelRatio) {
         return _pixelRatio;
+    }
     var canvas = Util_1.Util.createCanvasElement();
     var context = canvas.getContext('2d');
+    const canvas = Util_1.Util.createCanvasElement();
+    const context = canvas.getContext('2d');
     _pixelRatio = (function () {
         var devicePixelRatio = Global_1.Konva._global.devicePixelRatio || 1, backingStoreRatio = context.webkitBackingStorePixelRatio ||
+        const devicePixelRatio = Global_1.Konva._global.devicePixelRatio || 1, backingStoreRatio = context.webkitBackingStorePixelRatio ||
             context.mozBackingStorePixelRatio ||
             context.msBackingStorePixelRatio ||
 …
         this.height = 0;
         this.isCache = false;
         var conf = config || {};
         var pixelRatio = conf.pixelRatio || Global_1.Konva.pixelRatio || getDevicePixelRatio();
+        const conf = config || {};
+        const pixelRatio = conf.pixelRatio || Global_1.Konva.pixelRatio || getDevicePixelRatio();
         this.pixelRatio = pixelRatio;
         this._canvas = Util_1.Util.createCanvasElement();
 …
+    }
     setPixelRatio(pixelRatio) {
         var previousRatio = this.pixelRatio;
+        const previousRatio = this.pixelRatio;
         this.pixelRatio = pixelRatio;
         this.setSize(this.getWidth() / previousRatio, this.getHeight() / previousRatio);
 …
         this.width = this._canvas.width = width * this.pixelRatio;
         this._canvas.style.width = width + 'px';
         var pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
         _context.scale(pixelRatio, pixelRatio);
+    }
 …
         this.height = this._canvas.height = height * this.pixelRatio;
         this._canvas.style.height = height + 'px';
         var pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
         _context.scale(pixelRatio, pixelRatio);
+    }

imaps-frontend/node_modules/konva/lib/Container.d.ts

rd565449	r0c6b92a
29	29	attrs: any;
30	30	className: string;
31		children?: ~~any[] \| undefined~~;
	31	children?: Array<any>;
32	32	};
33	33	isAncestorOf(node: Node): boolean;

imaps-frontend/node_modules/konva/lib/Container.js

-              rd565449
+              r0c6b92a
+        }
         const children = this.children || [];
         var results = [];
+        const results = [];
         children.forEach(function (child) {
             if (filterFunc(child)) {
 …
+        }
         if (children.length > 1) {
             for (var i = 0; i < children.length; i++) {
+            for (let i = 0; i < children.length; i++) {
                 this.add(children[i]);
+            }
 …
+    }
     findOne(selector) {
         var result = this._generalFind(selector, true);
+        const result = this._generalFind(selector, true);
         return result.length > 0 ? result[0] : undefined;
+    }
     _generalFind(selector, findOne) {
         var retArr = [];
+        const retArr = [];
         this._descendants((node) => {
             const valid = node._isMatch(selector);
 …
+    }
     toObject() {
         var obj = Node_1.Node.prototype.toObject.call(this);
+        const obj = Node_1.Node.prototype.toObject.call(this);
         obj.children = [];
         this.getChildren().forEach((child) => {
 …
+    }
     isAncestorOf(node) {
         var parent = node.getParent();
+        let parent = node.getParent();
         while (parent) {
             if (parent._id === this._id) {
 …
+    }
     clone(obj) {
         var node = Node_1.Node.prototype.clone.call(this, obj);
+        const node = Node_1.Node.prototype.clone.call(this, obj);
         this.getChildren().forEach(function (no) {
             node.add(no.clone());
 …
+    }
     getAllIntersections(pos) {
         var arr = [];
+        const arr = [];
         this.find('Shape').forEach((shape) => {
             if (shape.isVisible() && shape.intersects(pos)) {
 …
+    }
     drawScene(can, top, bufferCanvas) {
         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;
+        const layer = this.getLayer(), canvas = can || (layer && layer.getCanvas()), context = canvas && canvas.getContext(), cachedCanvas = this._getCanvasCache(), cachedSceneCanvas = cachedCanvas && cachedCanvas.scene;
+        const caching = canvas && canvas.isCache;
         if (!this.isVisible() && !caching) {
             return this;
 …
         if (cachedSceneCanvas) {
             context.save();
             var m = this.getAbsoluteTransform(top).getMatrix();
+            const m = this.getAbsoluteTransform(top).getMatrix();
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             this._drawCachedSceneCanvas(context);
 …
             return this;
+        }
         var layer = this.getLayer(), canvas = can || (layer && layer.hitCanvas), context = canvas && canvas.getContext(), cachedCanvas = this._getCanvasCache(), cachedHitCanvas = cachedCanvas && cachedCanvas.hit;
+        const 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();
+            const m = this.getAbsoluteTransform(top).getMatrix();
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             this._drawCachedHitCanvas(context);
 …
     _drawChildren(drawMethod, canvas, top, bufferCanvas) {
         var _a;
         var context = canvas && canvas.getContext(), clipWidth = this.clipWidth(), clipHeight = this.clipHeight(), clipFunc = this.clipFunc(), hasClip = (typeof clipWidth === 'number' && typeof clipHeight === 'number') ||
+        const context = canvas && canvas.getContext(), clipWidth = this.clipWidth(), clipHeight = this.clipHeight(), clipFunc = this.clipFunc(), hasClip = (typeof clipWidth === 'number' && typeof clipHeight === 'number') ||
             clipFunc;
         const selfCache = top === this;
         if (hasClip) {
             context.save();
             var transform = this.getAbsoluteTransform(top);
             var m = transform.getMatrix();
+            const transform = this.getAbsoluteTransform(top);
+            let m = transform.getMatrix();
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             context.beginPath();
 …
+            }
             else {
                 var clipX = this.clipX();
                 var clipY = this.clipY();
+                const clipX = this.clipX();
+                const clipY = this.clipY();
                 context.rect(clipX || 0, clipY || 0, clipWidth, clipHeight);
+            }
 …
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+        }
         var hasComposition = !selfCache &&
+        const hasComposition = !selfCache &&
             this.globalCompositeOperation() !== 'source-over' &&
             drawMethod === 'drawScene';
 …
     getClientRect(config = {}) {
         var _a;
         var skipTransform = config.skipTransform;
         var relativeTo = config.relativeTo;
         var minX, minY, maxX, maxY;
         var selfRect = {
+        const skipTransform = config.skipTransform;
+        const relativeTo = config.relativeTo;
+        let minX, minY, maxX, maxY;
+        let selfRect = {
             x: Infinity,
             y: Infinity,
 …
             height: 0,
         };
         var that = this;
+        const that = this;
         (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
             if (!child.visible()) {
                 return;
+            }
             var rect = child.getClientRect({
+            const rect = child.getClientRect({
                 relativeTo: that,
                 skipShadow: config.skipShadow,
 …
+            }
         });
         var shapes = this.find('Shape');
         var hasVisible = false;
         for (var i = 0; i < shapes.length; i++) {
             var shape = shapes[i];
+        const shapes = this.find('Shape');
+        let hasVisible = false;
+        for (let i = 0; i < shapes.length; i++) {
+            const shape = shapes[i];
             if (shape._isVisible(this)) {
                 hasVisible = true;

imaps-frontend/node_modules/konva/lib/Context.d.ts

-              rd565449
+              r0c6b92a
 import { IRect } from './types.js';
 import type { Node } from './Node.js';
 declare var CONTEXT_PROPERTIES: readonly ["fillStyle", "strokeStyle", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY", "letterSpacing", "lineCap", "lineDashOffset", "lineJoin", "lineWidth", "miterLimit", "direction", "font", "textAlign", "textBaseline", "globalAlpha", "globalCompositeOperation", "imageSmoothingEnabled"];
+declare const CONTEXT_PROPERTIES: readonly ["fillStyle", "strokeStyle", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY", "letterSpacing", "lineCap", "lineDashOffset", "lineJoin", "lineWidth", "miterLimit", "direction", "font", "textAlign", "textBaseline", "globalAlpha", "globalCompositeOperation", "imageSmoothingEnabled"];
 interface ExtendedCanvasRenderingContext2D extends CanvasRenderingContext2D {
     letterSpacing: string;
 …
     canvas: Canvas;
     _context: CanvasRenderingContext2D;
     traceArr: Array<String>;
+    traceArr: Array<string>;
     constructor(canvas: Canvas);
     fillShape(shape: Shape): void;

imaps-frontend/node_modules/konva/lib/Context.js

-              rd565449
+              r0c6b92a
 const Global_1 = require("./Global");
 function simplifyArray(arr) {
     var retArr = [], len = arr.length, util = Util_1.Util, n, val;
+    let retArr = [], len = arr.length, util = Util_1.Util, n, val;
     for (n = 0; n < len; n++) {
         val = arr[n];
 …
     return retArr;
+}
 var COMMA = ',', OPEN_PAREN = '(', CLOSE_PAREN = ')', OPEN_PAREN_BRACKET = '([', CLOSE_BRACKET_PAREN = '])', SEMICOLON = ';', DOUBLE_PAREN = '()', EQUALS = '=', CONTEXT_METHODS = [
+const COMMA = ',', OPEN_PAREN = '(', CLOSE_PAREN = ')', OPEN_PAREN_BRACKET = '([', CLOSE_BRACKET_PAREN = '])', SEMICOLON = ';', DOUBLE_PAREN = '()', EQUALS = '=', CONTEXT_METHODS = [
     'arc',
     'arcTo',
 …
     'translate',
 ];
 var CONTEXT_PROPERTIES = [
+const CONTEXT_PROPERTIES = [
     'fillStyle',
     'strokeStyle',
 …
+    }
     getTrace(relaxed, rounded) {
         var traceArr = this.traceArr, len = traceArr.length, str = '', n, trace, method, args;
+        let traceArr = this.traceArr, len = traceArr.length, str = '', n, trace, method, args;
         for (n = 0; n < len; n++) {
             trace = traceArr[n];
 …
+    }
     _trace(str) {
         var traceArr = this.traceArr, len;
+        let traceArr = this.traceArr, len;
         traceArr.push(str);
         len = traceArr.length;
 …
+    }
     reset() {
         var pixelRatio = this.getCanvas().getPixelRatio();
+        const pixelRatio = this.getCanvas().getPixelRatio();
         this.setTransform(1 * pixelRatio, 0, 0, 1 * pixelRatio, 0, 0);
+    }
 …
+    }
     clear(bounds) {
         var canvas = this.getCanvas();
+        const canvas = this.getCanvas();
         if (bounds) {
             this.clearRect(bounds.x || 0, bounds.y || 0, bounds.width || 0, bounds.height || 0);
 …
+    }
     _applyOpacity(shape) {
         var absOpacity = shape.getAbsoluteOpacity();
+        const absOpacity = shape.getAbsoluteOpacity();
         if (absOpacity !== 1) {
             this.setAttr('globalAlpha', absOpacity);
 …
+    }
     createImageData(width, height) {
         var a = arguments;
+        const a = arguments;
         if (a.length === 2) {
             return this._context.createImageData(width, height);
 …
+    }
     drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight) {
         var a = arguments, _context = this._context;
+        const a = arguments, _context = this._context;
         if (a.length === 3) {
             _context.drawImage(image, sx, sy);
 …
+    }
     _enableTrace() {
         var that = this, len = CONTEXT_METHODS.length, origSetter = this.setAttr, n, args;
         var func = function (methodName) {
             var origMethod = that[methodName], ret;
+        let that = this, len = CONTEXT_METHODS.length, origSetter = this.setAttr, n, args;
+        const func = function (methodName) {
+            let origMethod = that[methodName], ret;
             that[methodName] = function () {
                 args = simplifyArray(Array.prototype.slice.call(arguments, 0));
 …
         that.setAttr = function () {
             origSetter.apply(that, arguments);
             var prop = arguments[0];
             var val = arguments[1];
+            const prop = arguments[0];
+            let val = arguments[1];
             if (prop === 'shadowOffsetX' ||
                 prop === 'shadowOffsetY' ||
 …
     _applyGlobalCompositeOperation(node) {
         const op = node.attrs.globalCompositeOperation;
         var def = !op || op === 'source-over';
+        const def = !op || op === 'source-over';
         if (!def) {
             this.setAttr('globalCompositeOperation', op);
 …
+    }
     _fillColor(shape) {
         var fill = shape.fill();
+        const fill = shape.fill();
         this.setAttr('fillStyle', fill);
         shape._fillFunc(this);
 …
+    }
     _fillLinearGradient(shape) {
         var grd = shape._getLinearGradient();
+        const grd = shape._getLinearGradient();
         if (grd) {
             this.setAttr('fillStyle', grd);
 …
         const 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) {
+            for (let n = 0; n < colorStops.length; n += 2) {
                 grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
 …
+    }
     _stroke(shape) {
         var dash = shape.dash(), strokeScaleEnabled = shape.getStrokeScaleEnabled();
+        const dash = shape.dash(), strokeScaleEnabled = shape.getStrokeScaleEnabled();
         if (shape.hasStroke()) {
             if (!strokeScaleEnabled) {
                 this.save();
                 var pixelRatio = this.getCanvas().getPixelRatio();
+                const pixelRatio = this.getCanvas().getPixelRatio();
                 this.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+            }
 …
                 this.setAttr('shadowColor', 'rgba(0,0,0,0)');
+            }
             var hasLinearGradient = shape.getStrokeLinearGradientColorStops();
+            const hasLinearGradient = shape.getStrokeLinearGradientColorStops();
             if (hasLinearGradient) {
                 this._strokeLinearGradient(shape);
 …
     _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 : {
+        const 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,
 …
             if (!strokeScaleEnabled) {
                 this.save();
                 var pixelRatio = this.getCanvas().getPixelRatio();
+                const 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;
+            const hitStrokeWidth = shape.hitStrokeWidth();
+            const strokeWidth = hitStrokeWidth === 'auto' ? shape.strokeWidth() : hitStrokeWidth;
             this.setAttr('lineWidth', strokeWidth);
             this.setAttr('strokeStyle', shape.colorKey);

imaps-frontend/node_modules/konva/lib/DragAndDrop.d.ts

-              rd565449
+              r0c6b92a
         startPointerPos: Vector2d;
         offset: Vector2d;
         pointerId?: number | undefined;
         dragStatus: 'ready' | 'dragging' | 'stopped';
+        pointerId?: number;
+        dragStatus: "ready" | "dragging" | "stopped";
     }>;
     _drag(evt: any): void;

imaps-frontend/node_modules/konva/lib/DragAndDrop.js

-              rd565449
+              r0c6b92a
 exports.DD = {
     get isDragging() {
         var flag = false;
+        let flag = false;
         exports.DD._dragElements.forEach((elem) => {
             if (elem.dragStatus === 'dragging') {
 …
     justDragged: false,
     get node() {
         var node;
+        let node;
         exports.DD._dragElements.forEach((elem) => {
             node = elem.node;
 …
+            }
             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));
+                const dragDistance = node.dragDistance();
+                const distance = Math.max(Math.abs(pos.x - elem.startPointerPos.x), Math.abs(pos.y - elem.startPointerPos.y));
                 if (distance < dragDistance) {
                     return;
 …
     window.addEventListener('mouseup', exports.DD._endDragBefore, true);
     window.addEventListener('touchend', exports.DD._endDragBefore, true);
+    window.addEventListener('touchcancel', 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);
+    window.addEventListener('touchcancel', exports.DD._endDragAfter, false);
+}

imaps-frontend/node_modules/konva/lib/Factory.js

-              rd565449
+              r0c6b92a
 const Util_1 = require("./Util");
 const Validators_1 = require("./Validators");
 var GET = 'get', SET = 'set';
+const GET = 'get', SET = 'set';
 exports.Factory = {
     addGetterSetter(constructor, attr, def, validator, after) {
 …
     },
     addGetter(constructor, attr, def) {
         var method = GET + Util_1.Util._capitalize(attr);
+        const method = GET + Util_1.Util._capitalize(attr);
         constructor.prototype[method] =
             constructor.prototype[method] ||
                 function () {
                     var val = this.attrs[attr];
+                    const val = this.attrs[attr];
                     return val === undefined ? def : val;
                 };
     },
     addSetter(constructor, attr, validator, after) {
         var method = SET + Util_1.Util._capitalize(attr);
+        const 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);
+        const method = SET + Util_1.Util._capitalize(attr);
         constructor.prototype[method] = function (val) {
             if (validator && val !== undefined && val !== null) {
 …
     },
     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;
+        let len = components.length, capitalize = Util_1.Util._capitalize, getter = GET + capitalize(attr), setter = SET + capitalize(attr), n, component;
         constructor.prototype[getter] = function () {
             var ret = {};
+            const ret = {};
             for (n = 0; n < len; n++) {
                 component = components[n];
 …
             return ret;
         };
         var basicValidator = (0, Validators_1.getComponentValidator)(components);
+        const basicValidator = (0, Validators_1.getComponentValidator)(components);
         constructor.prototype[setter] = function (val) {
             var oldVal = this.attrs[attr], key;
+            let oldVal = this.attrs[attr], key;
             if (validator) {
                 val = validator.call(this, val);
 …
     },
     addOverloadedGetterSetter(constructor, attr) {
         var capitalizedAttr = Util_1.Util._capitalize(attr), setter = SET + capitalizedAttr, getter = GET + capitalizedAttr;
+        const capitalizedAttr = Util_1.Util._capitalize(attr), setter = SET + capitalizedAttr, getter = GET + capitalizedAttr;
         constructor.prototype[attr] = function () {
             if (arguments.length) {
 …
     addDeprecatedGetterSetter(constructor, attr, def, validator) {
         Util_1.Util.error('Adding deprecated ' + attr);
         var method = GET + Util_1.Util._capitalize(attr);
         var message = attr +
+        const method = GET + Util_1.Util._capitalize(attr);
+        const 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];
+            const val = this.attrs[attr];
             return val === undefined ? def : val;
         };
 …
     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);
+            const method = constructor.prototype[newMethodName];
+            const oldGetter = GET + Util_1.Util._capitalize(oldMethodName);
+            const oldSetter = SET + Util_1.Util._capitalize(oldMethodName);
             function deprecated() {
                 method.apply(this, arguments);

imaps-frontend/node_modules/konva/lib/Global.js

rd565449	r0c6b92a
17	17	exports.Konva = {
18	18	_global: exports.glob,
19		version: '9.3.14',
	19	version: '9.3.16',
20	20	isBrowser: detectBrowser(),
21	21	isUnminified: /param/.test(function (param) { }.toString()),

imaps-frontend/node_modules/konva/lib/Group.js

rd565449	r0c6b92a
7	7	class Group extends Container_1.Container {
8	8	_validateAdd(child) {
9		~~var~~ type = child.getType();
	9	const type = child.getType();
10	10	if (type !== 'Group' && type !== 'Shape') {
11	11	Util_1.Util.throw('You may only add groups and shapes to groups.');

imaps-frontend/node_modules/konva/lib/Layer.js

-              rd565449
+              r0c6b92a
 const Shape_1 = require("./Shape");
 const Global_1 = require("./Global");
 var HASH = '#', BEFORE_DRAW = 'beforeDraw', DRAW = 'draw', INTERSECTION_OFFSETS = [
+const HASH = '#', BEFORE_DRAW = 'beforeDraw', DRAW = 'draw', INTERSECTION_OFFSETS = [
     { x: 0, y: 0 },
     { x: -1, y: -1 },
 …
     setZIndex(index) {
         super.setZIndex(index);
         var stage = this.getStage();
+        const stage = this.getStage();
         if (stage && stage.content) {
             stage.content.removeChild(this.getNativeCanvasElement());
 …
     moveToTop() {
         Node_1.Node.prototype.moveToTop.call(this);
         var stage = this.getStage();
+        const stage = this.getStage();
         if (stage && stage.content) {
             stage.content.removeChild(this.getNativeCanvasElement());
 …
+    }
     moveUp() {
         var moved = Node_1.Node.prototype.moveUp.call(this);
+        const moved = Node_1.Node.prototype.moveUp.call(this);
         if (!moved) {
             return false;
+        }
         var stage = this.getStage();
+        const stage = this.getStage();
         if (!stage || !stage.content) {
             return false;
 …
     moveDown() {
         if (Node_1.Node.prototype.moveDown.call(this)) {
             var stage = this.getStage();
+            const stage = this.getStage();
             if (stage) {
                 var children = stage.children;
+                const children = stage.children;
                 if (stage.content) {
                     stage.content.removeChild(this.getNativeCanvasElement());
 …
     moveToBottom() {
         if (Node_1.Node.prototype.moveToBottom.call(this)) {
             var stage = this.getStage();
+            const stage = this.getStage();
             if (stage) {
                 var children = stage.children;
+                const children = stage.children;
                 if (stage.content) {
                     stage.content.removeChild(this.getNativeCanvasElement());
 …
+    }
     remove() {
         var _canvas = this.getNativeCanvasElement();
+        const _canvas = this.getNativeCanvasElement();
         Node_1.Node.prototype.remove.call(this);
         if (_canvas && _canvas.parentNode && Util_1.Util._isInDocument(_canvas)) {
 …
+    }
     _validateAdd(child) {
         var type = child.getType();
+        const type = child.getType();
         if (type !== 'Group' && type !== 'Shape') {
             Util_1.Util.throw('You may only add groups and shapes to a layer.');
 …
             return null;
+        }
         var spiralSearchDistance = 1;
         var continueSearch = false;
+        let spiralSearchDistance = 1;
+        let continueSearch = false;
         while (true) {
             for (let i = 0; i < INTERSECTION_OFFSETS_LEN; i++) {
 …
+    }
     drawScene(can, top) {
         var layer = this.getLayer(), canvas = can || (layer && layer.getCanvas());
+        const layer = this.getLayer(), canvas = can || (layer && layer.getCanvas());
         this._fire(BEFORE_DRAW, {
             node: this,
 …
+    }
     drawHit(can, top) {
         var layer = this.getLayer(), canvas = can || (layer && layer.hitCanvas);
+        const layer = this.getLayer(), canvas = can || (layer && layer.hitCanvas);
         if (layer && layer.clearBeforeDraw()) {
             layer.getHitCanvas().getContext().clear();
 …
             return;
+        }
         var parent = this.parent;
         var added = !!this.hitCanvas._canvas.parentNode;
+        const parent = this.parent;
+        const added = !!this.hitCanvas._canvas.parentNode;
         if (added) {
             parent.content.removeChild(this.hitCanvas._canvas);

imaps-frontend/node_modules/konva/lib/Node.d.ts

-              rd565449
+              r0c6b92a
     [index: string]: any;
 };
 export interface KonvaEventObject<EventType> {
+export interface KonvaEventObject<EventType, This = Node> {
     type: string;
     target: Shape | Stage;
     evt: EventType;
     pointerId: number;
     currentTarget: Node;
+    currentTarget: This;
     cancelBubble: boolean;
     child?: Node;
+}
 export type KonvaEventListener<This, EventType> = (this: This, ev: KonvaEventObject<EventType>) => void;
+export type KonvaEventListener<This, EventType> = (this: This, ev: KonvaEventObject<EventType, This>) => void;
 export declare abstract class Node<Config extends NodeConfig = NodeConfig> {
     _id: number;
 …
         attrs: Config & Record<string, any>;
         className: string;
         children?: any[] | undefined;
+        children?: Array<any>;
     };
     toJSON(): string;
 …
     transformsEnabled: GetSet<string, this>;
     visible: GetSet<boolean, this>;
     width: number;
+    width: GetSet<number, this>;
     height: GetSet<number, this>;
     x: GetSet<number, this>;

imaps-frontend/node_modules/konva/lib/Node.js

-              rd565449
+              r0c6b92a
 const DragAndDrop_1 = require("./DragAndDrop");
 const Validators_1 = require("./Validators");
 var ABSOLUTE_OPACITY = 'absoluteOpacity', ALL_LISTENERS = 'allEventListeners', ABSOLUTE_TRANSFORM = 'absoluteTransform', ABSOLUTE_SCALE = 'absoluteScale', CANVAS = 'canvas', CHANGE = 'Change', CHILDREN = 'children', KONVA = 'konva', LISTENING = 'listening', MOUSEENTER = 'mouseenter', MOUSELEAVE = 'mouseleave', NAME = 'name', SET = 'set', SHAPE = 'Shape', SPACE = ' ', STAGE = 'stage', TRANSFORM = 'transform', UPPER_STAGE = 'Stage', VISIBLE = 'visible', TRANSFORM_CHANGE_STR = [
+const ABSOLUTE_OPACITY = 'absoluteOpacity', ALL_LISTENERS = 'allEventListeners', ABSOLUTE_TRANSFORM = 'absoluteTransform', ABSOLUTE_SCALE = 'absoluteScale', CANVAS = 'canvas', CHANGE = 'Change', CHILDREN = 'children', KONVA = 'konva', LISTENING = 'listening', MOUSEENTER = 'mouseenter', MOUSELEAVE = 'mouseleave', NAME = 'name', SET = 'set', SHAPE = 'Shape', SPACE = ' ', STAGE = 'stage', TRANSFORM = 'transform', UPPER_STAGE = 'Stage', VISIBLE = 'visible', TRANSFORM_CHANGE_STR = [
     'xChange.konva',
     'yChange.konva',
 …
+    }
     _getCache(attr, privateGetter) {
         var cache = this._cache.get(attr);
         var isTransform = attr === TRANSFORM || attr === ABSOLUTE_TRANSFORM;
         var invalid = cache === undefined || (isTransform && cache.dirty === true);
+        let cache = this._cache.get(attr);
+        const isTransform = attr === TRANSFORM || attr === ABSOLUTE_TRANSFORM;
+        const invalid = cache === undefined || (isTransform && cache.dirty === true);
         if (invalid) {
             cache = privateGetter.call(this);
 …
+    }
     cache(config) {
         var conf = config || {};
         var rect = {};
+        const conf = config || {};
+        let rect = {};
         if (conf.x === undefined ||
             conf.y === undefined ||
 …
             });
+        }
         var width = Math.ceil(conf.width || rect.width), height = Math.ceil(conf.height || rect.height), pixelRatio = conf.pixelRatio, x = conf.x === undefined ? Math.floor(rect.x) : conf.x, y = conf.y === undefined ? Math.floor(rect.y) : conf.y, offset = conf.offset || 0, drawBorder = conf.drawBorder || false, hitCanvasPixelRatio = conf.hitCanvasPixelRatio || 1;
+        let width = Math.ceil(conf.width || rect.width), height = Math.ceil(conf.height || rect.height), pixelRatio = conf.pixelRatio, x = conf.x === undefined ? Math.floor(rect.x) : conf.x, y = conf.y === undefined ? Math.floor(rect.y) : conf.y, offset = conf.offset || 0, drawBorder = conf.drawBorder || false, hitCanvasPixelRatio = conf.hitCanvasPixelRatio || 1;
         if (!width || !height) {
             Util_1.Util.error('Can not cache the node. Width or height of the node equals 0. Caching is skipped.');
 …
         x -= offset;
         y -= offset;
         var cachedSceneCanvas = new Canvas_1.SceneCanvas({
+        const cachedSceneCanvas = new Canvas_1.SceneCanvas({
             pixelRatio: pixelRatio,
             width: width,
 …
+    }
     _transformedRect(rect, top) {
         var points = [
+        const points = [
             { x: rect.x, y: rect.y },
             { x: rect.x + rect.width, y: rect.y },
 …
             { x: rect.x, y: rect.y + rect.height },
         ];
         var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
         var trans = this.getAbsoluteTransform(top);
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        const trans = this.getAbsoluteTransform(top);
         points.forEach(function (point) {
             var transformed = trans.point(point);
+            const transformed = trans.point(point);
             if (minX === undefined) {
                 minX = maxX = transformed.x;
 …
         const canvasCache = this._getCanvasCache();
         context.translate(canvasCache.x, canvasCache.y);
         var cacheCanvas = this._getCachedSceneCanvas();
         var ratio = cacheCanvas.pixelRatio;
+        const cacheCanvas = this._getCachedSceneCanvas();
+        const ratio = cacheCanvas.pixelRatio;
         context.drawImage(cacheCanvas._canvas, 0, 0, cacheCanvas.width / ratio, cacheCanvas.height / ratio);
         context.restore();
+    }
     _drawCachedHitCanvas(context) {
         var canvasCache = this._getCanvasCache(), hitCanvas = canvasCache.hit;
+        const canvasCache = this._getCanvasCache(), hitCanvas = canvasCache.hit;
         context.save();
         context.translate(canvasCache.x, canvasCache.y);
 …
+    }
     _getCachedSceneCanvas() {
         var filters = this.filters(), cachedCanvas = this._getCanvasCache(), sceneCanvas = cachedCanvas.scene, filterCanvas = cachedCanvas.filter, filterContext = filterCanvas.getContext(), len, imageData, n, filter;
+        let filters = this.filters(), cachedCanvas = this._getCanvasCache(), sceneCanvas = cachedCanvas.scene, filterCanvas = cachedCanvas.filter, filterContext = filterCanvas.getContext(), len, imageData, n, filter;
         if (filters) {
             if (!this._filterUpToDate) {
                 var ratio = sceneCanvas.pixelRatio;
+                const ratio = sceneCanvas.pixelRatio;
                 filterCanvas.setSize(sceneCanvas.width / sceneCanvas.pixelRatio, sceneCanvas.height / sceneCanvas.pixelRatio);
                 try {
 …
             return this._delegate.apply(this, arguments);
+        }
         var events = evtStr.split(SPACE), len = events.length, n, event, parts, baseEvent, name;
+        let events = evtStr.split(SPACE), len = events.length, n, event, parts, baseEvent, name;
         for (n = 0; n < len; n++) {
             event = events[n];
 …
+    }
     off(evtStr, callback) {
         var events = (evtStr || '').split(SPACE), len = events.length, n, t, event, parts, baseEvent, name;
+        let events = (evtStr || '').split(SPACE), len = events.length, n, t, event, parts, baseEvent, name;
         this._cache && this._cache.delete(ALL_LISTENERS);
         if (!evtStr) {
 …
+    }
     dispatchEvent(evt) {
         var e = {
+        const e = {
             target: this,
             type: evt.type,
 …
+    }
     _delegate(event, selector, handler) {
         var stopNode = this;
+        const stopNode = this;
         this.on(event, function (evt) {
             var targets = evt.target.findAncestors(selector, true, stopNode);
             for (var i = 0; i < targets.length; i++) {
+            const targets = evt.target.findAncestors(selector, true, stopNode);
+            for (let i = 0; i < targets.length; i++) {
                 evt = Util_1.Util.cloneObject(evt);
                 evt.currentTarget = targets[i];
 …
     _remove() {
         this._clearCaches();
         var parent = this.getParent();
+        const parent = this.getParent();
         if (parent && parent.children) {
             parent.children.splice(this.index, 1);
 …
+    }
     getAttr(attr) {
         var method = 'get' + Util_1.Util._capitalize(attr);
+        const method = 'get' + Util_1.Util._capitalize(attr);
         if (Util_1.Util._isFunction(this[method])) {
             return this[method]();
 …
+    }
     getAncestors() {
         var parent = this.getParent(), ancestors = [];
+        let parent = this.getParent(), ancestors = [];
         while (parent) {
             ancestors.push(parent);
 …
     setAttrs(config) {
         this._batchTransformChanges(() => {
             var key, method;
+            let key, method;
             if (!config) {
                 return this;
 …
             return this._isVisible(top) && this._isListening(top);
+        }
         var layer = this.getLayer();
         var layerUnderDrag = false;
+        const layer = this.getLayer();
+        let layerUnderDrag = false;
         DragAndDrop_1.DD._dragElements.forEach((elem) => {
             if (elem.dragStatus !== 'dragging') {
 …
+            }
         });
         var dragSkip = !skipDragCheck &&
+        const dragSkip = !skipDragCheck &&
             !Global_1.Konva.hitOnDragEnabled &&
             (layerUnderDrag || Global_1.Konva.isTransforming());
 …
+    }
     getAbsoluteZIndex() {
         var depth = this.getDepth(), that = this, index = 0, nodes, len, n, child;
+        let depth = this.getDepth(), that = this, index = 0, nodes, len, n, child;
         function addChildren(children) {
             nodes = [];
 …
+    }
     getDepth() {
         var depth = 0, parent = this.parent;
+        let depth = 0, parent = this.parent;
         while (parent) {
             depth++;
 …
             return null;
+        }
         var pos = stage.getPointerPosition();
+        const pos = stage.getPointerPosition();
         if (!pos) {
             return null;
+        }
         var transform = this.getAbsoluteTransform().copy();
+        const transform = this.getAbsoluteTransform().copy();
         transform.invert();
         return transform.point(pos);
 …
             top = true;
+        }
         var absoluteMatrix = this.getAbsoluteTransform(top).getMatrix(), absoluteTransform = new Util_1.Transform(), offset = this.offset();
+        const absoluteMatrix = this.getAbsoluteTransform(top).getMatrix(), absoluteTransform = new Util_1.Transform(), offset = this.offset();
         absoluteTransform.m = absoluteMatrix.slice();
         absoluteTransform.translate(offset.x, offset.y);
 …
         this.attrs.y = y;
         this._clearCache(TRANSFORM);
         var it = this._getAbsoluteTransform().copy();
+        const it = this._getAbsoluteTransform().copy();
         it.invert();
         it.translate(pos.x, pos.y);
 …
+    }
     _setTransform(trans) {
         var key;
+        let key;
         for (key in trans) {
             this.attrs[key] = trans[key];
 …
+    }
     _clearTransform() {
         var trans = {
+        const trans = {
             x: this.x(),
             y: this.y(),
 …
+    }
     move(change) {
         var changeX = change.x, changeY = change.y, x = this.x(), y = this.y();
+        let changeX = change.x, changeY = change.y, x = this.x(), y = this.y();
         if (changeX !== undefined) {
             x += changeX;
 …
+    }
     _eachAncestorReverse(func, top) {
         var family = [], parent = this.getParent(), len, n;
+        let family = [], parent = this.getParent(), len, n;
         if (top && top._id === this._id) {
             return;
 …
             return false;
+        }
         var index = this.index, len = this.parent.getChildren().length;
+        const index = this.index, len = this.parent.getChildren().length;
         if (index < len - 1) {
             this.parent.children.splice(index, 1);
 …
             return false;
+        }
         var index = this.index, len = this.parent.getChildren().length;
+        const index = this.index, len = this.parent.getChildren().length;
         if (index < len - 1) {
             this.parent.children.splice(index, 1);
 …
             return false;
+        }
         var index = this.index;
+        const index = this.index;
         if (index > 0) {
             this.parent.children.splice(index, 1);
 …
             return false;
+        }
         var index = this.index;
+        const index = this.index;
         if (index > 0) {
             this.parent.children.splice(index, 1);
 …
                 '.');
+        }
         var index = this.index;
+        const index = this.index;
         this.parent.children.splice(index, 1);
         this.parent.children.splice(zIndex, 0, this);
 …
+    }
     _getAbsoluteOpacity() {
         var absOpacity = this.opacity();
         var parent = this.getParent();
+        let absOpacity = this.opacity();
+        const parent = this.getParent();
         if (parent && !parent._isUnderCache) {
             absOpacity *= parent.getAbsoluteOpacity();
 …
+    }
     toObject() {
         var attrs = this.getAttrs(), key, val, getter, defaultValue, nonPlainObject;
+        let attrs = this.getAttrs(), key, val, getter, defaultValue, nonPlainObject;
         const obj = {
             attrs: {},
 …
+    }
     findAncestors(selector, includeSelf, stopNode) {
         var res = [];
+        const res = [];
         if (includeSelf && this._isMatch(selector)) {
             res.push(this);
+        }
         var ancestor = this.parent;
+        let ancestor = this.parent;
         while (ancestor) {
             if (ancestor === stopNode) {
 …
             return selector(this);
+        }
         var selectorArr = selector.replace(/ /g, '').split(','), len = selectorArr.length, n, sel;
+        let selectorArr = selector.replace(/ /g, '').split(','), len = selectorArr.length, n, sel;
         for (n = 0; n < len; n++) {
             sel = selectorArr[n];
 …
+    }
     getLayer() {
         var parent = this.getParent();
+        const parent = this.getParent();
         return parent ? parent.getLayer() : null;
+    }
 …
+    }
     _getStage() {
         var parent = this.getParent();
+        const parent = this.getParent();
         if (parent) {
             return parent.getStage();
 …
+    }
     _getAbsoluteTransform(top) {
         var at;
+        let at;
         if (top) {
             at = new Util_1.Transform();
             this._eachAncestorReverse(function (node) {
                 var transformsEnabled = node.transformsEnabled();
+                const transformsEnabled = node.transformsEnabled();
                 if (transformsEnabled === 'all') {
                     at.multiply(node.getTransform());
 …
                 at.reset();
+            }
             var transformsEnabled = this.transformsEnabled();
+            const transformsEnabled = this.transformsEnabled();
             if (transformsEnabled === 'all') {
                 at.multiply(this.getTransform());
 …
+    }
     getAbsoluteScale(top) {
         var parent = this;
+        let parent = this;
         while (parent) {
             if (parent._isUnderCache) {
 …
     _getTransform() {
         var _a, _b;
         var m = this._cache.get(TRANSFORM) || new Util_1.Transform();
+        const m = this._cache.get(TRANSFORM) || new Util_1.Transform();
         m.reset();
         var x = this.x(), y = this.y(), rotation = Global_1.Konva.getAngle(this.rotation()), scaleX = (_a = this.attrs.scaleX) !== null && _a !== void 0 ? _a : 1, scaleY = (_b = this.attrs.scaleY) !== null && _b !== void 0 ? _b : 1, skewX = this.attrs.skewX || 0, skewY = this.attrs.skewY || 0, offsetX = this.attrs.offsetX || 0, offsetY = this.attrs.offsetY || 0;
+        const x = this.x(), y = this.y(), rotation = Global_1.Konva.getAngle(this.rotation()), scaleX = (_a = this.attrs.scaleX) !== null && _a !== void 0 ? _a : 1, scaleY = (_b = this.attrs.scaleY) !== null && _b !== void 0 ? _b : 1, skewX = this.attrs.skewX || 0, skewY = this.attrs.skewY || 0, offsetX = this.attrs.offsetX || 0, offsetY = this.attrs.offsetY || 0;
         if (x !== 0 || y !== 0) {
             m.translate(x, y);
 …
+    }
     clone(obj) {
         var attrs = Util_1.Util.cloneObject(this.attrs), key, allListeners, len, n, listener;
+        let attrs = Util_1.Util.cloneObject(this.attrs), key, allListeners, len, n, listener;
         for (key in obj) {
             attrs[key] = obj[key];
+        }
         var node = new this.constructor(attrs);
+        const node = new this.constructor(attrs);
         for (key in this.eventListeners) {
             allListeners = this.eventListeners[key];
 …
     _toKonvaCanvas(config) {
         config = config || {};
         var box = this.getClientRect();
         var stage = this.getStage(), x = config.x !== undefined ? config.x : Math.floor(box.x), y = config.y !== undefined ? config.y : Math.floor(box.y), pixelRatio = config.pixelRatio || 1, canvas = new Canvas_1.SceneCanvas({
+        const box = this.getClientRect();
+        const stage = this.getStage(), x = config.x !== undefined ? config.x : Math.floor(box.x), y = config.y !== undefined ? config.y : Math.floor(box.y), pixelRatio = config.pixelRatio || 1, canvas = new Canvas_1.SceneCanvas({
             width: config.width || Math.ceil(box.width) || (stage ? stage.width() : 0),
             height: config.height ||
 …
     toDataURL(config) {
         config = config || {};
         var mimeType = config.mimeType || null, quality = config.quality || null;
         var url = this._toKonvaCanvas(config).toDataURL(mimeType, quality);
+        const mimeType = config.mimeType || null, quality = config.quality || null;
+        const url = this._toKonvaCanvas(config).toDataURL(mimeType, quality);
         if (config.callback) {
             config.callback(url);
 …
+    }
     _off(type, name, callback) {
         var evtListeners = this.eventListeners[type], i, evtName, handler;
+        let evtListeners = this.eventListeners[type], i, evtName, handler;
         for (i = 0; i < evtListeners.length; i++) {
             evtName = evtListeners[i].name;
 …
     addName(name) {
         if (!this.hasName(name)) {
             var oldName = this.name();
             var newName = oldName ? oldName + ' ' + name : name;
+            const oldName = this.name();
+            const newName = oldName ? oldName + ' ' + name : name;
             this.name(newName);
+        }
 …
             return false;
+        }
         var names = (fullName || '').split(/\s/g);
+        const names = (fullName || '').split(/\s/g);
         return names.indexOf(name) !== -1;
+    }
     removeName(name) {
         var names = (this.name() || '').split(/\s/g);
         var index = names.indexOf(name);
+        const names = (this.name() || '').split(/\s/g);
+        const index = names.indexOf(name);
         if (index !== -1) {
             names.splice(index, 1);
 …
+    }
     setAttr(attr, val) {
         var func = this[SET + Util_1.Util._capitalize(attr)];
+        const func = this[SET + Util_1.Util._capitalize(attr)];
         if (Util_1.Util._isFunction(func)) {
             func.call(this, val);
 …
+    }
     _setAttr(key, val) {
         var oldVal = this.attrs[key];
+        const oldVal = this.attrs[key];
         if (oldVal === val && !Util_1.Util.isObject(val)) {
             return;
 …
+    }
     _setComponentAttr(key, component, val) {
         var oldVal;
+        let oldVal;
         if (val !== undefined) {
             oldVal = this.attrs[key];
 …
             evt.target = this;
+        }
         var shouldStop = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
+        const shouldStop = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
             ((compareShape &&
                 (this === compareShape ||
 …
         if (!shouldStop) {
             this._fire(eventType, evt);
             var stopBubble = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
+            const stopBubble = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
                 compareShape &&
                 compareShape.isAncestorOf &&
 …
+    }
     _createDragElement(evt) {
         var pointerId = evt ? evt.pointerId : undefined;
         var stage = this.getStage();
         var ap = this.getAbsolutePosition();
+        const pointerId = evt ? evt.pointerId : undefined;
+        const stage = this.getStage();
+        const ap = this.getAbsolutePosition();
         if (!stage) {
             return;
+        }
         var pos = stage._getPointerById(pointerId) ||
+        const pos = stage._getPointerById(pointerId) ||
             stage._changedPointerPositions[0] ||
             ap;
 …
             return;
+        }
         var newNodePos = {
+        let newNodePos = {
             x: pos.x - elem.offset.x,
             y: pos.y - elem.offset.y,
         };
         var dbf = this.dragBoundFunc();
+        const dbf = this.dragBoundFunc();
         if (dbf !== undefined) {
             const bounded = dbf.call(this, newNodePos, evt);
 …
         this._dragCleanup();
         this.on('mousedown.konva touchstart.konva', function (evt) {
             var shouldCheckButton = evt.evt['button'] !== undefined;
             var canDrag = !shouldCheckButton || Global_1.Konva.dragButtons.indexOf(evt.evt['button']) >= 0;
+            const shouldCheckButton = evt.evt['button'] !== undefined;
+            const canDrag = !shouldCheckButton || Global_1.Konva.dragButtons.indexOf(evt.evt['button']) >= 0;
             if (!canDrag) {
                 return;
 …
                 return;
+            }
             var hasDraggingChild = false;
+            let hasDraggingChild = false;
             DragAndDrop_1.DD._dragElements.forEach((elem) => {
                 if (this.isAncestorOf(elem.node)) {
 …
         else {
             this._dragCleanup();
             var stage = this.getStage();
+            const stage = this.getStage();
             if (!stage) {
                 return;
 …
+    }
     static _createNode(obj, container) {
         var className = Node.prototype.getClassName.call(obj), children = obj.children, no, len, n;
+        let className = Node.prototype.getClassName.call(obj), children = obj.children, no, len, n;
         if (container) {
             obj.attrs.container = container;

imaps-frontend/node_modules/konva/lib/PointerEvents.js

-              rd565449
+              r0c6b92a
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseCapture = exports.setPointerCapture = exports.hasPointerCapture = exports.createEvent = exports.getCapturedShape = void 0;
+exports.getCapturedShape = getCapturedShape;
+exports.createEvent = createEvent;
+exports.hasPointerCapture = hasPointerCapture;
+exports.setPointerCapture = setPointerCapture;
+exports.releaseCapture = releaseCapture;
 const Global_1 = require("./Global");
 const Captures = new Map();
 …
     return Captures.get(pointerId);
+}
-exports.getCapturedShape = getCapturedShape;
 function createEvent(evt) {
     return {
 …
     };
+}
-exports.createEvent = createEvent;
 function hasPointerCapture(pointerId, shape) {
     return Captures.get(pointerId) === shape;
+}
-exports.hasPointerCapture = hasPointerCapture;
 function setPointerCapture(pointerId, shape) {
     releaseCapture(pointerId);
 …
+    }
+}
-exports.setPointerCapture = setPointerCapture;
 function releaseCapture(pointerId, target) {
     const shape = Captures.get(pointerId);
 …
+    }
+}
-exports.releaseCapture = releaseCapture;

imaps-frontend/node_modules/konva/lib/Shape.js

-              rd565449
+              r0c6b92a
 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';
+const HAS_SHADOW = 'hasShadow';
+const SHADOW_RGBA = 'shadowRGBA';
+const patternImage = 'patternImage';
+const linearGradient = 'linearGradient';
+const radialGradient = 'radialGradient';
 let dummyContext;
 function getDummyContext() {
 …
     __getFillPattern() {
         if (this.fillPatternImage()) {
             var ctx = getDummyContext();
+            const ctx = getDummyContext();
             const pattern = ctx.createPattern(this.fillPatternImage(), this.fillPatternRepeat() || 'repeat');
             if (pattern && pattern.setTransform) {
 …
+    }
     __getLinearGradient() {
         var colorStops = this.fillLinearGradientColorStops();
+        const 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) {
+            const ctx = getDummyContext();
+            const start = this.fillLinearGradientStartPoint();
+            const end = this.fillLinearGradientEndPoint();
+            const grd = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
+            for (let n = 0; n < colorStops.length; n += 2) {
                 grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
 …
+    }
     __getRadialGradient() {
         var colorStops = this.fillRadialGradientColorStops();
+        const 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) {
+            const ctx = getDummyContext();
+            const start = this.fillRadialGradientStartPoint();
+            const end = this.fillRadialGradientEndPoint();
+            const grd = ctx.createRadialGradient(start.x, start.y, this.fillRadialGradientStartRadius(), end.x, end.y, this.fillRadialGradientEndRadius());
+            for (let n = 0; n < colorStops.length; n += 2) {
                 grd.addColorStop(colorStops[n], colorStops[n + 1]);
+            }
 …
             return;
+        }
         var rgba = Util_1.Util.colorToRGBA(this.shadowColor());
+        const rgba = Util_1.Util.colorToRGBA(this.shadowColor());
         if (rgba) {
             return ('rgba(' +
 …
+    }
     intersects(point) {
         var stage = this.getStage();
+        const stage = this.getStage();
         if (!stage) {
             return false;
 …
+    }
     getSelfRect() {
         var size = this.size();
+        const size = this.size();
         return {
             x: this._centroid ? -size.width / 2 : 0,
 …
+    }
     drawScene(can, top, bufferCanvas) {
         var layer = this.getLayer();
         var canvas = can || layer.getCanvas(), context = canvas.getContext(), cachedCanvas = this._getCanvasCache(), drawFunc = this.getSceneFunc(), hasShadow = this.hasShadow(), stage, bufferContext;
         var skipBuffer = canvas.isCache;
         var cachingSelf = top === this;
+        const layer = this.getLayer();
+        let canvas = can || layer.getCanvas(), context = canvas.getContext(), cachedCanvas = this._getCanvasCache(), drawFunc = this.getSceneFunc(), hasShadow = this.hasShadow(), stage, bufferContext;
+        const skipBuffer = canvas.isCache;
+        const cachingSelf = top === this;
         if (!this.isVisible() && !cachingSelf) {
             return this;
 …
         if (cachedCanvas) {
             context.save();
             var m = this.getAbsoluteTransform(top).getMatrix();
+            const m = this.getAbsoluteTransform(top).getMatrix();
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             this._drawCachedSceneCanvas(context);
 …
             drawFunc.call(this, bufferContext, this);
             bufferContext.restore();
             var ratio = bc.pixelRatio;
+            const ratio = bc.pixelRatio;
             if (hasShadow) {
                 context._applyShadow(this);
 …
             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;
+        const 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();
+            const m = this.getAbsoluteTransform(top).getMatrix();
             context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             this._drawCachedHitCanvas(context);
 …
         const selfCache = this === top;
         if (!selfCache) {
             var o = this.getAbsoluteTransform(top).getMatrix();
+            const o = this.getAbsoluteTransform(top).getMatrix();
             context.transform(o[0], o[1], o[2], o[3], o[4], o[5]);
+        }
 …
+    }
     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;
+        let 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);

imaps-frontend/node_modules/konva/lib/Stage.d.ts

-              rd565449
+              r0c6b92a
 import { Layer } from './Layer.js';
 export interface StageConfig extends ContainerConfig {
     container: HTMLDivElement | string;
+    container?: HTMLDivElement | string;
+}
 export declare const stages: Stage[];
 …
     getPointerPosition(): Vector2d | null;
     _getPointerById(id?: number): (Vector2d & {
         id?: number | undefined;
+        id?: number;
     }) | undefined;
     getPointersPositions(): (Vector2d & {
         id?: number | undefined;
+        id?: number;
     })[];
     getStage(): this;

imaps-frontend/node_modules/konva/lib/Stage.js

-              rd565449
+              r0c6b92a
 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 = [
+const 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'],
 …
         if (typeof container === STRING) {
             if (container.charAt(0) === '.') {
                 var className = container.slice(1);
+                const className = container.slice(1);
                 container = document.getElementsByClassName(className)[0];
+            }
 …
+    }
     clear() {
         var layers = this.children, len = layers.length, n;
+        let layers = this.children, len = layers.length, n;
         for (n = 0; n < len; n++) {
             layers[n].clear();
 …
     destroy() {
         super.destroy();
         var content = this.content;
+        const content = this.content;
         if (content && Util_1.Util._isInDocument(content)) {
             this.container().removeChild(content);
+        }
         var index = exports.stages.indexOf(this);
+        const index = exports.stages.indexOf(this);
         if (index > -1) {
             exports.stages.splice(index, 1);
 …
         config.width = config.width || this.width();
         config.height = config.height || this.height();
         var canvas = new Canvas_1.SceneCanvas({
+        const canvas = new Canvas_1.SceneCanvas({
             width: config.width,
             height: config.height,
             pixelRatio: config.pixelRatio || 1,
         });
         var _context = canvas.getContext()._context;
         var layers = this.children;
+        const _context = canvas.getContext()._context;
+        const layers = this.children;
         if (config.x || config.y) {
             _context.translate(-1 * config.x, -1 * config.y);
 …
                 return;
+            }
             var layerCanvas = layer._toKonvaCanvas(config);
+            const layerCanvas = layer._toKonvaCanvas(config);
             _context.drawImage(layerCanvas._canvas, config.x, config.y, layerCanvas.getWidth() / layerCanvas.getPixelRatio(), layerCanvas.getHeight() / layerCanvas.getPixelRatio());
         });
 …
             return null;
+        }
         var layers = this.children, len = layers.length, end = len - 1, n;
+        let layers = this.children, len = layers.length, end = len - 1, n;
         for (n = end; n >= 0; n--) {
             const shape = layers[n].getIntersection(pos);
 …
+    }
     _resizeDOM() {
         var width = this.width();
         var height = this.height();
+        const width = this.width();
+        const height = this.height();
         if (this.content) {
             this.content.style.width = width + PX;
 …
     add(layer, ...rest) {
         if (arguments.length > 1) {
             for (var i = 0; i < arguments.length; i++) {
+            for (let i = 0; i < arguments.length; i++) {
                 this.add(arguments[i]);
+            }
 …
+        }
         super.add(layer);
         var length = this.children.length;
+        const length = this.children.length;
         if (length > MAX_LAYERS_NUMBER) {
             Util_1.Util.warn('The stage has ' +
 …
+        }
         this.setPointersPositions(evt);
         var targetShape = this._getTargetShape(eventType);
         var eventsEnabled = !(Global_1.Konva.isDragging() || Global_1.Konva.isTransforming()) || Global_1.Konva.hitOnDragEnabled;
+        const targetShape = this._getTargetShape(eventType);
+        const eventsEnabled = !(Global_1.Konva.isDragging() || Global_1.Konva.isTransforming()) || Global_1.Konva.hitOnDragEnabled;
         if (targetShape && eventsEnabled) {
             targetShape._fireAndBubble(events.pointerout, { evt: evt });
 …
+        }
         this.setPointersPositions(evt);
         var triggeredOnShape = false;
+        let triggeredOnShape = false;
         this._changedPointerPositions.forEach((pos) => {
             var shape = this.getIntersection(pos);
+            const shape = this.getIntersection(pos);
             DragAndDrop_1.DD.justDragged = false;
             Global_1.Konva['_' + eventType + 'ListenClick'] = true;
 …
+        }
         this.setPointersPositions(evt);
         var eventsEnabled = !(Global_1.Konva.isDragging() || Global_1.Konva.isTransforming()) || Global_1.Konva.hitOnDragEnabled;
+        const eventsEnabled = !(Global_1.Konva.isDragging() || Global_1.Konva.isTransforming()) || Global_1.Konva.hitOnDragEnabled;
         if (!eventsEnabled) {
             return;
+        }
         var processedShapesIds = {};
+        const processedShapesIds = {};
         let triggeredOnShape = false;
         var targetShape = this._getTargetShape(eventType);
+        const targetShape = this._getTargetShape(eventType);
         this._changedPointerPositions.forEach((pos) => {
             const shape = (PointerEvents.getCapturedShape(pos.id) ||
 …
             const pointerId = pos.id;
             const event = { evt: evt, pointerId };
             var differentTarget = targetShape !== shape;
+            const differentTarget = targetShape !== shape;
             if (differentTarget && targetShape) {
                 targetShape._fireAndBubble(events.pointerout, { ...event }, shape);
 …
         const clickStartShape = this[eventType + 'ClickStartShape'];
         const clickEndShape = this[eventType + 'ClickEndShape'];
         var processedShapesIds = {};
+        const processedShapesIds = {};
         let triggeredOnShape = false;
         this._changedPointerPositions.forEach((pos) => {
 …
     _contextmenu(evt) {
         this.setPointersPositions(evt);
         var shape = this.getIntersection(this.getPointerPosition());
+        const shape = this.getIntersection(this.getPointerPosition());
         if (shape && shape.isListening()) {
             shape._fireAndBubble(CONTEXTMENU, { evt: evt });
 …
     _wheel(evt) {
         this.setPointersPositions(evt);
         var shape = this.getIntersection(this.getPointerPosition());
+        const shape = this.getIntersection(this.getPointerPosition());
         if (shape && shape.isListening()) {
             shape._fireAndBubble(WHEEL, { evt: evt });
 …
+    }
     setPointersPositions(evt) {
         var contentPosition = this._getContentPosition(), x = null, y = null;
+        let contentPosition = this._getContentPosition(), x = null, y = null;
         evt = evt ? evt : window.event;
         if (evt.touches !== undefined) {
 …
             };
+        }
         var rect = this.content.getBoundingClientRect();
+        const rect = this.content.getBoundingClientRect();
         return {
             top: rect.top,
 …
             return;
+        }
         var container = this.container();
+        const container = this.container();
         if (!container) {
             throw 'Stage has no container. A container is required.';

imaps-frontend/node_modules/konva/lib/Tween.js

-              rd565449
+              r0c6b92a
 const Node_1 = require("./Node");
 const Global_1 = require("./Global");
 var blacklist = {
+let blacklist = {
     node: 1,
     duration: 1,
 …
+    }
     fire(str) {
         var handler = this[str];
+        const handler = this[str];
         if (handler) {
             handler();
 …
+    }
     onEnterFrame() {
         var t = this.getTimer() - this._startTime;
+        const t = this.getTimer() - this._startTime;
         if (this.state === PLAYING) {
             this.setTime(t);
 …
 class Tween {
     constructor(config) {
         var that = this, node = config.node, nodeId = node._id, duration, easing = config.easing || exports.Easings.Linear, yoyo = !!config.yoyo, key;
+        let 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;
 …
         this.node = node;
         this._id = idCounter++;
         var layers = node.getLayer() ||
+        const layers = node.getLayer() ||
             (node instanceof Global_1.Konva['Stage'] ? node.getLayers() : null);
         if (!layers) {
 …
+    }
     _addAttr(key, end) {
         var node = this.node, nodeId = node._id, start, diff, tweenId, n, len, trueEnd, trueStart, endRGBA;
+        let node = this.node, nodeId = node._id, start, diff, tweenId, n, len, trueEnd, trueStart, endRGBA;
         tweenId = Tween.tweens[nodeId][key];
         if (tweenId) {
 …
+                    }
                     else {
                         var startRGBA = Util_1.Util.colorToRGBA(start[n]);
+                        const startRGBA = Util_1.Util.colorToRGBA(start[n]);
                         endRGBA = Util_1.Util.colorToRGBA(end[n]);
                         start[n] = startRGBA;
 …
+    }
     _tweenFunc(i) {
         var node = this.node, attrs = Tween.attrs[node._id][this._id], key, attr, start, diff, newVal, n, len, end;
+        let 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];
 …
         };
         this.tween.onFinish = () => {
             var node = this.node;
             var attrs = Tween.attrs[node._id][this._id];
+            const node = this.node;
+            const attrs = Tween.attrs[node._id][this._id];
             if (attrs.points && attrs.points.trueEnd) {
                 node.setAttr('points', attrs.points.trueEnd);
 …
         };
         this.tween.onReset = () => {
             var node = this.node;
             var attrs = Tween.attrs[node._id][this._id];
+            const node = this.node;
+            const attrs = Tween.attrs[node._id][this._id];
             if (attrs.points && attrs.points.trueStart) {
                 node.points(attrs.points.trueStart);
 …
+    }
     destroy() {
         var nodeId = this.node._id, thisId = this._id, attrs = Tween.tweens[nodeId], key;
+        let nodeId = this.node._id, thisId = this._id, attrs = Tween.tweens[nodeId], key;
         this.pause();
         for (key in attrs) {
 …
 Tween.tweens = {};
 Node_1.Node.prototype.to = function (params) {
     var onFinish = params.onFinish;
+    const onFinish = params.onFinish;
     params.node = this;
     params.onFinish = function () {
 …
+        }
     };
     var tween = new Tween(params);
+    const tween = new Tween(params);
     tween.play();
 };
 exports.Easings = {
     BackEaseIn(t, b, c, d) {
         var s = 1.70158;
+        const s = 1.70158;
         return c * (t /= d) * t * ((s + 1) * t - s) + b;
     },
     BackEaseOut(t, b, c, d) {
         var s = 1.70158;
+        const 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;
+        let s = 1.70158;
         if ((t /= d / 2) < 1) {
             return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
 …
     },
     ElasticEaseIn(t, b, c, d, a, p) {
         var s = 0;
+        let s = 0;
         if (t === 0) {
             return b;
 …
     },
     ElasticEaseOut(t, b, c, d, a, p) {
         var s = 0;
+        let s = 0;
         if (t === 0) {
             return b;
 …
     },
     ElasticEaseInOut(t, b, c, d, a, p) {
         var s = 0;
+        let s = 0;
         if (t === 0) {
             return b;

imaps-frontend/node_modules/konva/lib/Util.d.ts

-              rd565449
+              r0c6b92a
     _isFunction(obj: any): boolean;
     _isPlainObject(obj: any): boolean;
     _isArray(obj: any): obj is any[];
+    _isArray(obj: any): obj is Array<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;
+    isObject(val: any): val is object;
     isValidSelector(selector: any): boolean;
     _sign(number: number): 1 | -1;
 …
     error(str: string): void;
     warn(str: string): void;
     each(obj: Object, func: Function): void;
+    each(obj: object, func: Function): void;
     _inRange(val: number, left: number, right: number): boolean;
     _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
 …
     _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): number[];
     _prepareToStringify<T>(obj: any): T | null;
     _assign<T_1, U>(target: T_1, source: U): T_1 & U;
+    _assign<T, U>(target: T, source: U): T & U;
     _getFirstPointerId(evt: any): any;
     releaseCanvas(...canvases: HTMLCanvasElement[]): void;

imaps-frontend/node_modules/konva/lib/Util.js

-              rd565449
+              r0c6b92a
+    }
     point(point) {
         var m = this.m;
+        const m = this.m;
         return {
             x: m[0] * point.x + m[2] * point.y + m[4],
 …
+    }
     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;
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        const m11 = this.m[0] * c + this.m[2] * s;
+        const m12 = this.m[1] * c + this.m[3] * s;
+        const m21 = this.m[0] * -s + this.m[2] * c;
+        const m22 = this.m[1] * -s + this.m[3] * c;
         this.m[0] = m11;
         this.m[1] = m12;
 …
+    }
     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;
+        const m11 = this.m[0] + this.m[2] * sy;
+        const m12 = this.m[1] + this.m[3] * sy;
+        const m21 = this.m[2] + this.m[0] * sx;
+        const m22 = this.m[3] + this.m[1] * sx;
         this.m[0] = m11;
         this.m[1] = m12;
 …
+    }
     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];
+        const m11 = this.m[0] * matrix.m[0] + this.m[2] * matrix.m[1];
+        const m12 = this.m[1] * matrix.m[0] + this.m[3] * matrix.m[1];
+        const m21 = this.m[0] * matrix.m[2] + this.m[2] * matrix.m[3];
+        const m22 = this.m[1] * matrix.m[2] + this.m[3] * matrix.m[3];
+        const dx = this.m[0] * matrix.m[4] + this.m[2] * matrix.m[5] + this.m[4];
+        const dy = this.m[1] * matrix.m[4] + this.m[3] * matrix.m[5] + this.m[5];
         this.m[0] = m11;
         this.m[1] = m12;
 …
+    }
     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]);
+        const d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
+        const m0 = this.m[3] * d;
+        const m1 = -this.m[1] * d;
+        const m2 = -this.m[2] * d;
+        const m3 = this.m[0] * d;
+        const m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
+        const m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
         this.m[0] = m0;
         this.m[1] = m1;
 …
+    }
     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 = {
+        const a = this.m[0];
+        const b = this.m[1];
+        const c = this.m[2];
+        const d = this.m[3];
+        const e = this.m[4];
+        const f = this.m[5];
+        const delta = a * d - b * c;
+        const result = {
             x: e,
             y: f,
 …
         };
         if (a != 0 || b != 0) {
             var r = Math.sqrt(a * a + b * b);
+            const r = Math.sqrt(a * a + b * b);
             result.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);
             result.scaleX = r;
 …
+        }
         else if (c != 0 || d != 0) {
             var s = Math.sqrt(c * c + d * d);
+            const s = Math.sqrt(c * c + d * d);
             result.rotation =
                 Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));
 …
+}
 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 = {
+let 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],
 …
             return false;
+        }
         var firstChar = selector[0];
+        const firstChar = selector[0];
         return (firstChar === '#' ||
             firstChar === '.' ||
 …
     },
     createCanvasElement() {
         var canvas = document.createElement('canvas');
+        const canvas = document.createElement('canvas');
         try {
             canvas.style = canvas.style || {};
 …
     },
     _urlToImage(url, callback) {
         var imageObj = exports.Util.createImageElement();
+        const imageObj = exports.Util.createImageElement();
         imageObj.onload = function () {
             callback(imageObj);
 …
     _hexToRgb(hex) {
         hex = hex.replace(HASH, EMPTY_STRING);
         var bigint = parseInt(hex, 16);
+        const bigint = parseInt(hex, 16);
         return {
             r: (bigint >> 16) & 255,
 …
     },
     getRandomColor() {
         var randColor = ((Math.random() * 0xffffff) << 0).toString(16);
+        let randColor = ((Math.random() * 0xffffff) << 0).toString(16);
         while (randColor.length < 6) {
             randColor = ZERO + randColor;
 …
     },
     getRGB(color) {
         var rgb;
+        let rgb;
         if (color in COLORS) {
             rgb = COLORS[color];
 …
     },
     _namedColorToRBA(str) {
         var c = COLORS[str.toLowerCase()];
+        const c = COLORS[str.toLowerCase()];
         if (!c) {
             return null;
 …
         if (str.indexOf('rgb(') === 0) {
             str = str.match(/rgb\(([^)]+)\)/)[1];
             var parts = str.split(/ *, */).map(Number);
+            const parts = str.split(/ *, */).map(Number);
             return {
                 r: parts[0],
 …
         if (str.indexOf('rgba(') === 0) {
             str = str.match(/rgba\(([^)]+)\)/)[1];
             var parts = str.split(/ *, */).map((n, index) => {
+            const parts = str.split(/ *, */).map((n, index) => {
                 if (n.slice(-1) === '%') {
                     return index === 3 ? parseInt(n) / 100 : (parseInt(n) / 100) * 255;
 …
     },
     cloneObject(obj) {
         var retObj = {};
         for (var key in obj) {
+        const retObj = {};
+        for (const key in obj) {
             if (this._isPlainObject(obj[key])) {
                 retObj[key] = this.cloneObject(obj[key]);
 …
     },
     each(obj, func) {
         for (var key in obj) {
+        for (const key in obj) {
             func(key, obj[key]);
+        }
 …
     },
     _getProjectionToSegment(x1, y1, x2, y2, x3, y3) {
         var x, y, dist;
         var pd2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
+        let x, y, dist;
+        const pd2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
         if (pd2 == 0) {
             x = x1;
 …
+        }
         else {
             var u = ((x3 - x1) * (x2 - x1) + (y3 - y1) * (y2 - y1)) / pd2;
+            const u = ((x3 - x1) * (x2 - x1) + (y3 - y1) * (y2 - y1)) / pd2;
             if (u < 0) {
                 x = x1;
 …
     },
     _getProjectionToLine(pt, line, isClosed) {
         var pc = exports.Util.cloneObject(pt);
         var dist = Number.MAX_VALUE;
+        const pc = exports.Util.cloneObject(pt);
+        let 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];
+            const p2 = line[(i + 1) % line.length];
+            const proj = exports.Util._getProjectionToSegment(p1.x, p1.y, p2.x, p2.y, pt.x, pt.y);
+            const px = proj[0], py = proj[1], pdist = proj[2];
             if (pdist < dist) {
                 pc.x = px;
 …
     },
     _prepareArrayForTween(startArray, endArray, isClosed) {
         var n, start = [], end = [];
+        let n, start = [], end = [];
         if (startArray.length > endArray.length) {
             var temp = endArray;
+            const temp = endArray;
             endArray = startArray;
             startArray = temp;
 …
             });
+        }
         var newStart = [];
+        const newStart = [];
         end.forEach(function (point) {
             var pr = exports.Util._getProjectionToLine(point, start, isClosed);
+            const pr = exports.Util._getProjectionToLine(point, start, isClosed);
             newStart.push(pr.x);
             newStart.push(pr.y);
 …
     },
     _prepareToStringify(obj) {
         var desc;
+        let desc;
         obj.visitedByCircularReferenceRemoval = true;
         for (var key in obj) {
+        for (const key in obj) {
             if (!(obj.hasOwnProperty(key) && obj[key] && typeof obj[key] == 'object')) {
                 continue;
 …
     },
     _assign(target, source) {
         for (var key in source) {
+        for (const key in source) {
             target[key] = source[key];
+        }

imaps-frontend/node_modules/konva/lib/Validators.js

-              rd565449
+              r0c6b92a
 "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;
+exports.RGBComponent = RGBComponent;
+exports.alphaComponent = alphaComponent;
+exports.getNumberValidator = getNumberValidator;
+exports.getNumberOrArrayOfNumbersValidator = getNumberOrArrayOfNumbersValidator;
+exports.getNumberOrAutoValidator = getNumberOrAutoValidator;
+exports.getStringValidator = getStringValidator;
+exports.getStringOrGradientValidator = getStringOrGradientValidator;
+exports.getFunctionValidator = getFunctionValidator;
+exports.getNumberArrayValidator = getNumberArrayValidator;
+exports.getBooleanValidator = getBooleanValidator;
+exports.getComponentValidator = getComponentValidator;
 const Global_1 = require("./Global");
 const Util_1 = require("./Util");
 …
     return Math.round(val);
+}
-exports.RGBComponent = RGBComponent;
 function alphaComponent(val) {
     if (val > 1) {
 …
     return val;
+}
-exports.alphaComponent = alphaComponent;
 function getNumberValidator() {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-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;
+            const isNumber = Util_1.Util._isNumber(val);
+            const isValidArray = Util_1.Util._isArray(val) && val.length == noOfElements;
             if (!isNumber && !isValidArray) {
                 Util_1.Util.warn(_formatValue(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';
+            const isNumber = Util_1.Util._isNumber(val);
+            const isAuto = val === 'auto';
             if (!(isNumber || isAuto)) {
                 Util_1.Util.warn(_formatValue(val) +
 …
+    }
+}
-exports.getNumberOrAutoValidator = getNumberOrAutoValidator;
 function getStringValidator() {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-exports.getStringValidator = getStringValidator;
 function getStringOrGradientValidator() {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-exports.getStringOrGradientValidator = getStringOrGradientValidator;
 function getFunctionValidator() {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-exports.getFunctionValidator = getFunctionValidator;
 function getNumberArrayValidator() {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-exports.getNumberArrayValidator = getNumberArrayValidator;
 function getBooleanValidator() {
     if (Global_1.Konva.isUnminified) {
         return function (val, attr) {
             var isBool = val === true || val === false;
+            const isBool = val === true || val === false;
             if (!isBool) {
                 Util_1.Util.warn(_formatValue(val) +
 …
+    }
+}
-exports.getBooleanValidator = getBooleanValidator;
 function getComponentValidator(components) {
     if (Global_1.Konva.isUnminified) {
 …
+    }
+}
-exports.getComponentValidator = getComponentValidator;

imaps-frontend/node_modules/konva/lib/_CoreInternals.d.ts

-              rd565449
+              r0c6b92a
         _isFunction(obj: any): boolean;
         _isPlainObject(obj: any): boolean;
         _isArray(obj: any): obj is any[];
+        _isArray(obj: any): obj is Array<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;
+        isObject(val: any): val is object;
         isValidSelector(selector: any): boolean;
         _sign(number: number): 1 | -1;
 …
         haveIntersection(r1: import("./types").IRect, r2: import("./types.js").IRect): boolean;
         cloneObject<Any>(obj: Any): Any;
         cloneArray(arr: any[]): any[];
+        cloneArray(arr: Array<any>): any[];
         degToRad(deg: number): number;
         radToDeg(rad: number): number;
 …
         error(str: string): void;
         warn(str: string): void;
         each(obj: Object, func: Function): void;
+        each(obj: object, func: Function): void;
         _inRange(val: number, left: number, right: number): boolean;
         _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
         _getProjectionToLine(pt: import("./types").Vector2d, line: import("./types").Vector2d[], isClosed: boolean): import("./types.js").Vector2d;
+        _getProjectionToLine(pt: import("./types").Vector2d, line: Array<import("./types").Vector2d>, isClosed: boolean): import("./types.js").Vector2d;
         _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): number[];
         _prepareToStringify<T>(obj: any): T | null;
         _assign<T_1, U>(target: T_1, source: U): T_1 & U;
+        _assign<T, U>(target: T, source: U): T & U;
         _getFirstPointerId(evt: any): any;
         releaseCanvas(...canvases: HTMLCanvasElement[]): void;
 …
         readonly node: Node<import("./Node.js").NodeConfig> | undefined;
         _dragElements: Map<number, {
             node: Node<import("./Node.js").NodeConfig>;
+            node: Node;
             startPointerPos: import("./types.js").Vector2d;
             offset: import("./types.js").Vector2d;
             pointerId?: number | undefined;
+            pointerId?: number;
             dragStatus: "ready" | "dragging" | "stopped";
         }>;

imaps-frontend/node_modules/konva/lib/_FullInternals.d.ts

-              rd565449
+              r0c6b92a
         _isFunction(obj: any): boolean;
         _isPlainObject(obj: any): boolean;
         _isArray(obj: any): obj is any[];
+        _isArray(obj: any): obj is Array<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;
+        isObject(val: any): val is object;
         isValidSelector(selector: any): boolean;
         _sign(number: number): 1 | -1;
 …
         haveIntersection(r1: import("./types").IRect, r2: import("./types.js").IRect): boolean;
         cloneObject<Any>(obj: Any): Any;
         cloneArray(arr: any[]): any[];
+        cloneArray(arr: Array<any>): any[];
         degToRad(deg: number): number;
         radToDeg(rad: number): number;
 …
         error(str: string): void;
         warn(str: string): void;
         each(obj: Object, func: Function): void;
+        each(obj: object, func: Function): void;
         _inRange(val: number, left: number, right: number): boolean;
         _getProjectionToSegment(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any[];
         _getProjectionToLine(pt: import("./types").Vector2d, line: import("./types").Vector2d[], isClosed: boolean): import("./types.js").Vector2d;
+        _getProjectionToLine(pt: import("./types").Vector2d, line: Array<import("./types").Vector2d>, isClosed: boolean): import("./types.js").Vector2d;
         _prepareArrayForTween(startArray: any, endArray: any, isClosed: any): number[];
         _prepareToStringify<T>(obj: any): T | null;
         _assign<T_1, U>(target: T_1, source: U): T_1 & U;
+        _assign<T, U>(target: T, source: U): T & U;
         _getFirstPointerId(evt: any): any;
         releaseCanvas(...canvases: HTMLCanvasElement[]): void;
 …
         readonly node: import("./Node").Node<import("./Node.js").NodeConfig> | undefined;
         _dragElements: Map<number, {
             node: import("./Node").Node<import("./Node.js").NodeConfig>;
+            node: import("./Node.js").Node;
             startPointerPos: import("./types.js").Vector2d;
             offset: import("./types.js").Vector2d;
             pointerId?: number | undefined;
+            pointerId?: number;
             dragStatus: "ready" | "dragging" | "stopped";
         }>;

imaps-frontend/node_modules/konva/lib/filters/Blur.js

-              rd565449
+              r0c6b92a
     this.next = null;
+}
 var mul_table = [
+const mul_table = [
 , 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292,
 , 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292,
 …
 , 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259,
 ];
 var shg_table = [
+const shg_table = [
 , 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17,
 , 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
 …
 ];
 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];
+    const pixels = imageData.data, width = imageData.width, height = imageData.height;
+    let 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;
+    let 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();
 …
+}
 const Blur = function Blur(imageData) {
     var radius = Math.round(this.blurRadius());
+    const radius = Math.round(this.blurRadius());
     if (radius > 0) {
         filterGaussBlurRGBA(imageData, radius);

imaps-frontend/node_modules/konva/lib/filters/Brighten.js

rd565449	r0c6b92a
6	6	const Validators_1 = require("../Validators");
7	7	const Brighten = function (imageData) {
8		~~var~~ brightness = this.brightness() * 255, data = imageData.data, len = data.length, i;
	8	let brightness = this.brightness() * 255, data = imageData.data, len = data.length, i;
9	9	for (i = 0; i < len; i += 4) {
10	10	data[i] += brightness;

imaps-frontend/node_modules/konva/lib/filters/Contrast.js

-              rd565449
+              r0c6b92a
 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;
+    const adjust = Math.pow((this.contrast() + 100) / 100, 2);
+    let data = imageData.data, nPixels = data.length, red = 150, green = 150, blue = 150, i;
     for (i = 0; i < nPixels; i += 4) {
         red = data[i];

imaps-frontend/node_modules/konva/lib/filters/Emboss.js

-              rd565449
+              r0c6b92a
 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;
+    let 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':
 …
+    }
     do {
         var offsetY = (y - 1) * w4;
         var otherY = dirY;
+        const offsetY = (y - 1) * w4;
+        let otherY = dirY;
         if (y + otherY < 1) {
             otherY = 0;
 …
             otherY = 0;
+        }
         var offsetYOther = (y - 1 + otherY) * w * 4;
         var x = w;
+        const offsetYOther = (y - 1 + otherY) * w * 4;
+        let x = w;
         do {
             var offset = offsetY + (x - 1) * 4;
             var otherX = dirX;
+            const offset = offsetY + (x - 1) * 4;
+            let otherX = dirX;
             if (x + otherX < 1) {
                 otherX = 0;
 …
                 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;
+            const offsetOther = offsetYOther + (x - 1 + otherX) * 4;
+            const dR = data[offset] - data[offsetOther];
+            const dG = data[offset + 1] - data[offsetOther + 1];
+            const dB = data[offset + 2] - data[offsetOther + 2];
+            let dif = dR;
+            const absDif = dif > 0 ? dif : -dif;
+            const absG = dG > 0 ? dG : -dG;
+            const absB = dB > 0 ? dB : -dB;
             if (absG > absDif) {
                 dif = dG;
 …
             dif *= strength;
             if (blend) {
                 var r = data[offset] + dif;
                 var g = data[offset + 1] + dif;
                 var b = data[offset + 2] + dif;
+                const r = data[offset] + dif;
+                const g = data[offset + 1] + dif;
+                const b = data[offset + 2] + dif;
                 data[offset] = r > 255 ? 255 : r < 0 ? 0 : r;
                 data[offset + 1] = g > 255 ? 255 : g < 0 ? 0 : g;
 …
+            }
             else {
                 var grey = greyLevel - dif;
+                let grey = greyLevel - dif;
                 if (grey < 0) {
                     grey = 0;

imaps-frontend/node_modules/konva/lib/filters/Enhance.js

-              rd565449
+              r0c6b92a
 const Validators_1 = require("../Validators");
 function remap(fromValue, fromMin, fromMax, toMin, toMax) {
     var fromRange = fromMax - fromMin, toRange = toMax - toMin, toValue;
+    let fromRange = fromMax - fromMin, toRange = toMax - toMin, toValue;
     if (fromRange === 0) {
         return toMin + toRange / 2;
 …
+}
 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();
+    let 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;
+    const enhanceAmount = this.enhance();
     if (enhanceAmount === 0) {
         return;
 …
         bMin = 0;
+    }
     var rMid, rGoalMax, rGoalMin, gMid, gGoalMax, gGoalMin, bMid, bGoalMax, bGoalMin;
+    let rMid, rGoalMax, rGoalMin, gMid, gGoalMax, gGoalMin, bMid, bGoalMax, bGoalMin;
     if (enhanceAmount > 0) {
         rGoalMax = rMax + enhanceAmount * (255 - rMax);

imaps-frontend/node_modules/konva/lib/filters/Grayscale.js

rd565449	r0c6b92a
3	3	exports.Grayscale = void 0;
4	4	const Grayscale = function (imageData) {
5		~~var~~ data = imageData.data, len = data.length, i, brightness;
	5	let data = imageData.data, len = data.length, i, brightness;
6	6	for (i = 0; i < len; i += 4) {
7	7	brightness = 0.34 * data[i] + 0.5 * data[i + 1] + 0.16 * data[i + 2];

imaps-frontend/node_modules/konva/lib/filters/HSL.js

-              rd565449
+              r0c6b92a
 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;
+    let 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;
+    const vsu = v * s * Math.cos((h * Math.PI) / 180), vsw = v * s * Math.sin((h * Math.PI) / 180);
+    const 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;
+    const 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;
+    const 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;
+    let r, g, b, a;
     for (i = 0; i < nPixels; i += 4) {
         r = data[i + 0];

imaps-frontend/node_modules/konva/lib/filters/HSV.js

-              rd565449
+              r0c6b92a
 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) {
+    const 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;
+    const vsu = v * s * Math.cos((h * Math.PI) / 180), vsw = v * s * Math.sin((h * Math.PI) / 180);
+    const 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;
+    const 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;
+    const 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;
+    let r, g, b, a;
+    for (let i = 0; i < nPixels; i += 4) {
         r = data[i + 0];
         g = data[i + 1];

imaps-frontend/node_modules/konva/lib/filters/Invert.js

rd565449	r0c6b92a
3	3	exports.Invert = void 0;
4	4	const Invert = function (imageData) {
5		~~var~~ data = imageData.data, len = data.length, i;
	5	let data = imageData.data, len = data.length, i;
6	6	for (i = 0; i < len; i += 4) {
7	7	data[i] = 255 - data[i];

imaps-frontend/node_modules/konva/lib/filters/Kaleidoscope.js

-              rd565449
+              r0c6b92a
 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);
+const ToPolar = function (src, dst, opt) {
+    let 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;
+    let 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;
+    let rSize = ySize, tSize = xSize, radius, theta;
+    let conversion = ((360 / tSize) * Math.PI) / 180, sin, cos;
     for (theta = 0; theta < tSize; theta += 1) {
         sin = Math.sin(theta * conversion);
 …
+    }
 };
 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);
+const FromPolar = function (src, dst, opt) {
+    let 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;
+    let 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;
+    let rSize = ySize, tSize = xSize, radius, theta, phaseShift = opt.polarRotation || 0;
+    let x1, y1;
     for (x = 0; x < xSize; x += 1) {
         for (y = 0; y < ySize; y += 1) {
 …
 };
 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);
+    const xSize = imageData.width, ySize = imageData.height;
+    let x, y, xoff, i, r, g, b, a, srcPos, dstPos;
+    let power = Math.round(this.kaleidoscopePower());
+    const angle = Math.round(this.kaleidoscopeAngle());
+    const offset = Math.floor((xSize * (angle % 360)) / 360);
     if (power < 1) {
         return;
+    }
     var tempCanvas = Util_1.Util.createCanvasElement();
+    const tempCanvas = Util_1.Util.createCanvasElement();
     tempCanvas.width = xSize;
     tempCanvas.height = ySize;
     var scratchData = tempCanvas
+    const scratchData = tempCanvas
         .getContext('2d')
         .getImageData(0, 0, xSize, ySize);
 …
         polarCenterY: ySize / 2,
     });
     var minSectionSize = xSize / Math.pow(2, power);
+    let minSectionSize = xSize / Math.pow(2, power);
     while (minSectionSize <= 8) {
         minSectionSize = minSectionSize * 2;
 …
+    }
     minSectionSize = Math.ceil(minSectionSize);
     var sectionSize = minSectionSize;
     var xStart = 0, xEnd = sectionSize, xDelta = 1;
+    let sectionSize = minSectionSize;
+    let xStart = 0, xEnd = sectionSize, xDelta = 1;
     if (offset + minSectionSize > xSize) {
         xStart = sectionSize;

imaps-frontend/node_modules/konva/lib/filters/Mask.js

-              rd565449
+              r0c6b92a
 const Validators_1 = require("../Validators");
 function pixelAt(idata, x, y) {
     var idx = (y * idata.width + x) * 4;
     var d = [];
+    let idx = (y * idata.width + x) * 4;
+    const d = [];
     d.push(idata.data[idx++], idata.data[idx++], idata.data[idx++], idata.data[idx++]);
     return d;
 …
+}
 function rgbMean(pTab) {
     var m = [0, 0, 0];
     for (var i = 0; i < pTab.length; i++) {
+    const m = [0, 0, 0];
+    for (let i = 0; i < pTab.length; i++) {
         m[0] += pTab[i][0];
         m[1] += pTab[i][1];
 …
+}
 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;
+    const rgbv_no = pixelAt(idata, 0, 0);
+    const rgbv_ne = pixelAt(idata, idata.width - 1, 0);
+    const rgbv_so = pixelAt(idata, 0, idata.height - 1);
+    const rgbv_se = pixelAt(idata, idata.width - 1, idata.height - 1);
+    const 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, [
+        const mean = rgbMean([rgbv_ne, rgbv_no, rgbv_se, rgbv_so]);
+        const mask = [];
+        for (let i = 0; i < idata.width * idata.height; i++) {
+            const d = rgbDistance(mean, [
                 idata.data[i * 4],
                 idata.data[i * 4 + 1],
 …
+}
 function applyMask(idata, mask) {
     for (var i = 0; i < idata.width * idata.height; i++) {
+    for (let 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;
+    const weights = [1, 1, 1, 1, 0, 1, 1, 1, 1];
+    const side = Math.round(Math.sqrt(weights.length));
+    const halfSide = Math.floor(side / 2);
+    const maskResult = [];
+    for (let y = 0; y < sh; y++) {
+        for (let x = 0; x < sw; x++) {
+            const so = y * sw + x;
+            let a = 0;
+            for (let cy = 0; cy < side; cy++) {
+                for (let cx = 0; cx < side; cx++) {
+                    const scy = y + cy - halfSide;
+                    const scx = x + cx - halfSide;
                     if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
                         var srcOff = scy * sw + scx;
                         var wt = weights[cy * side + cx];
+                        const srcOff = scy * sw + scx;
+                        const wt = weights[cy * side + cx];
                         a += mask[srcOff] * wt;
+                    }
 …
+}
 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;
+    const weights = [1, 1, 1, 1, 1, 1, 1, 1, 1];
+    const side = Math.round(Math.sqrt(weights.length));
+    const halfSide = Math.floor(side / 2);
+    const maskResult = [];
+    for (let y = 0; y < sh; y++) {
+        for (let x = 0; x < sw; x++) {
+            const so = y * sw + x;
+            let a = 0;
+            for (let cy = 0; cy < side; cy++) {
+                for (let cx = 0; cx < side; cx++) {
+                    const scy = y + cy - halfSide;
+                    const scx = x + cx - halfSide;
                     if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
                         var srcOff = scy * sw + scx;
                         var wt = weights[cy * side + cx];
+                        const srcOff = scy * sw + scx;
+                        const wt = weights[cy * side + cx];
                         a += mask[srcOff] * wt;
+                    }
 …
+}
 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;
+    const weights = [1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9];
+    const side = Math.round(Math.sqrt(weights.length));
+    const halfSide = Math.floor(side / 2);
+    const maskResult = [];
+    for (let y = 0; y < sh; y++) {
+        for (let x = 0; x < sw; x++) {
+            const so = y * sw + x;
+            let a = 0;
+            for (let cy = 0; cy < side; cy++) {
+                for (let cx = 0; cx < side; cx++) {
+                    const scy = y + cy - halfSide;
+                    const scx = x + cx - halfSide;
                     if (scy >= 0 && scy < sh && scx >= 0 && scx < sw) {
                         var srcOff = scy * sw + scx;
                         var wt = weights[cy * side + cx];
+                        const srcOff = scy * sw + scx;
+                        const wt = weights[cy * side + cx];
                         a += mask[srcOff] * wt;
+                    }
 …
+}
 const Mask = function (imageData) {
     var threshold = this.threshold(), mask = backgroundMask(imageData, threshold);
+    let threshold = this.threshold(), mask = backgroundMask(imageData, threshold);
     if (mask) {
         mask = erodeMask(mask, imageData.width, imageData.height);

imaps-frontend/node_modules/konva/lib/filters/Noise.js

-              rd565449
+              r0c6b92a
 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) {
+    const amount = this.noise() * 255, data = imageData.data, nPixels = data.length, half = amount / 2;
+    for (let i = 0; i < nPixels; i += 4) {
         data[i + 0] += half - 2 * half * Math.random();
         data[i + 1] += half - 2 * half * Math.random();

imaps-frontend/node_modules/konva/lib/filters/Pixelate.js

rd565449	r0c6b92a
7	7	const Validators_1 = require("../Validators");
8	8	const Pixelate = function (imageData) {
9		~~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;
	9	let 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;
10	10	if (pixelSize <= 0) {
11	11	Util_1.Util.error('pixelSize value can not be <= 0');

imaps-frontend/node_modules/konva/lib/filters/Posterize.js

rd565449	r0c6b92a
6	6	const Validators_1 = require("../Validators");
7	7	const Posterize = function (imageData) {
8		~~var~~ levels = Math.round(this.levels() * 254) + 1, data = imageData.data, len = data.length, scale = 255 / levels, i;
	8	let levels = Math.round(this.levels() * 254) + 1, data = imageData.data, len = data.length, scale = 255 / levels, i;
9	9	for (i = 0; i < len; i += 1) {
10	10	data[i] = Math.floor(data[i] / scale) * scale;

imaps-frontend/node_modules/konva/lib/filters/RGB.js

rd565449	r0c6b92a
6	6	const Validators_1 = require("../Validators");
7	7	const RGB = function (imageData) {
8		~~var~~ data = imageData.data, nPixels = data.length, red = this.red(), green = this.green(), blue = this.blue(), i, brightness;
	8	let data = imageData.data, nPixels = data.length, red = this.red(), green = this.green(), blue = this.blue(), i, brightness;
9	9	for (i = 0; i < nPixels; i += 4) {
10	10	brightness =

imaps-frontend/node_modules/konva/lib/filters/RGBA.js

-              rd565449
+              r0c6b92a
 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;
+    const data = imageData.data, nPixels = data.length, red = this.red(), green = this.green(), blue = this.blue(), alpha = this.alpha();
+    for (let i = 0; i < nPixels; i += 4) {
+        const ia = 1 - alpha;
         data[i] = red * alpha + data[i] * ia;
         data[i + 1] = green * alpha + data[i + 1] * ia;

imaps-frontend/node_modules/konva/lib/filters/Sepia.js

rd565449	r0c6b92a
3	3	exports.Sepia = void 0;
4	4	const Sepia = function (imageData) {
5		~~var~~ data = imageData.data, nPixels = data.length, i, r, g, b;
	5	let data = imageData.data, nPixels = data.length, i, r, g, b;
6	6	for (i = 0; i < nPixels; i += 4) {
7	7	r = data[i + 0];

imaps-frontend/node_modules/konva/lib/filters/Solarize.js

-              rd565449
+              r0c6b92a
 exports.Solarize = void 0;
 const Solarize = function (imageData) {
+    var data = imageData.data, w = imageData.width, h = imageData.height, w4 = w * 4, y = h;
+    const data = imageData.data, w = imageData.width, h = imageData.height, w4 = w * 4;
+    let y = h;
     do {
         var offsetY = (y - 1) * w4;
         var x = w;
+        const offsetY = (y - 1) * w4;
+        let x = w;
         do {
             var offset = offsetY + (x - 1) * 4;
             var r = data[offset];
             var g = data[offset + 1];
             var b = data[offset + 2];
+            const offset = offsetY + (x - 1) * 4;
+            let r = data[offset];
+            let g = data[offset + 1];
+            let b = data[offset + 2];
             if (r > 127) {
                 r = 255 - r;

imaps-frontend/node_modules/konva/lib/filters/Threshold.js

-              rd565449
+              r0c6b92a
 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) {
+    const level = this.threshold() * 255, data = imageData.data, len = data.length;
+    for (let i = 0; i < len; i += 1) {
         data[i] = data[i] < level ? 0 : 255;
+    }

imaps-frontend/node_modules/konva/lib/shapes/Arc.js

rd565449	r0c6b92a
9	9	class Arc extends Shape_1.Shape {
10	10	_sceneFunc(context) {
11		~~var~~ angle = Global_1.Konva.getAngle(this.angle()), clockwise = this.clockwise();
	11	const angle = Global_1.Konva.getAngle(this.angle()), clockwise = this.clockwise();
12	12	context.beginPath();
13	13	context.arc(0, 0, this.outerRadius(), 0, angle, clockwise);

imaps-frontend/node_modules/konva/lib/shapes/Arrow.js

-              rd565449
+              r0c6b92a
     _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;
+        const PI2 = Math.PI * 2;
+        const points = this.points();
+        let tp = points;
+        const fromTension = this.tension() !== 0 && points.length > 4;
         if (fromTension) {
             tp = this.getTensionPoints();
+        }
         var length = this.pointerLength();
         var n = points.length;
         var dx, dy;
+        const length = this.pointerLength();
+        const n = points.length;
+        let dx, dy;
         if (fromTension) {
             const lp = [
 …
             dy = points[n - 1] - points[n - 3];
+        }
         var radians = (Math.atan2(dy, dx) + PI2) % PI2;
         var width = this.pointerWidth();
+        const radians = (Math.atan2(dy, dx) + PI2) % PI2;
+        const width = this.pointerWidth();
         if (this.pointerAtEnding()) {
             ctx.save();
 …
+    }
     __fillStroke(ctx) {
         var isDashEnabled = this.dashEnabled();
+        const isDashEnabled = this.dashEnabled();
         if (isDashEnabled) {
             this.attrs.dashEnabled = false;

imaps-frontend/node_modules/konva/lib/shapes/Ellipse.js

rd565449	r0c6b92a
8	8	class Ellipse extends Shape_1.Shape {
9	9	_sceneFunc(context) {
10		~~var~~ rx = this.radiusX(), ry = this.radiusY();
	10	const rx = this.radiusX(), ry = this.radiusY();
11	11	context.beginPath();
12	12	context.save();

imaps-frontend/node_modules/konva/lib/shapes/Image.js

-              rd565449
+              r0c6b92a
+    }
     _hitFunc(context) {
         var width = this.width(), height = this.height(), cornerRadius = this.cornerRadius();
+        const width = this.width(), height = this.height(), cornerRadius = this.cornerRadius();
         context.beginPath();
         if (!cornerRadius) {
 …
+    }
     static fromURL(url, callback, onError = null) {
         var img = Util_1.Util.createImageElement();
+        const img = Util_1.Util.createImageElement();
         img.onload = function () {
             var image = new Image({
+            const image = new Image({
                 image: img,
             });

imaps-frontend/node_modules/konva/lib/shapes/Label.d.ts

rd565449	r0c6b92a
30	30	height: number;
31	31	};
32		pointerDirection: GetSet<'left' \| 'top' \| 'right' \| 'bottom', this>;
	32	pointerDirection: GetSet<'left' \| 'top' \| 'right' \| 'bottom' \| 'up' \| 'down', this>;
33	33	pointerWidth: GetSet<number, this>;
34	34	pointerHeight: GetSet<number, this>;

imaps-frontend/node_modules/konva/lib/shapes/Label.js

-              rd565449
+              r0c6b92a
 const Validators_1 = require("../Validators");
 const Global_1 = require("../Global");
 var ATTR_CHANGE_LIST = [
+const ATTR_CHANGE_LIST = [
     'fontFamily',
     'fontSize',
 …
+    }
     _addListeners(text) {
         var that = this, n;
         var func = function () {
+        let that = this, n;
+        const func = function () {
             that._sync();
         };
 …
+    }
     _sync() {
         var text = this.getText(), tag = this.getTag(), width, height, pointerDirection, pointerWidth, x, y, pointerHeight;
+        let text = this.getText(), tag = this.getTag(), width, height, pointerDirection, pointerWidth, x, y, pointerHeight;
         if (text && tag) {
             width = text.width();
 …
 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();
+        const width = this.width(), height = this.height(), pointerDirection = this.pointerDirection(), pointerWidth = this.pointerWidth(), pointerHeight = this.pointerHeight(), cornerRadius = this.cornerRadius();
         let topLeft = 0;
         let topRight = 0;
 …
+    }
     getSelfRect() {
         var x = 0, y = 0, pointerWidth = this.pointerWidth(), pointerHeight = this.pointerHeight(), direction = this.pointerDirection(), width = this.width(), height = this.height();
+        let x = 0, y = 0, pointerWidth = this.pointerWidth(), pointerHeight = this.pointerHeight(), direction = this.pointerDirection(), width = this.width(), height = this.height();
         if (direction === UP) {
             y -= pointerHeight;

imaps-frontend/node_modules/konva/lib/shapes/Line.d.ts

rd565449	r0c6b92a
1	1	import { Shape, ShapeConfig } from '../Shape.js';
	2	import { Context } from '../Context.js';
2	3	import { GetSet } from '../types.js';
3		~~import { Context } from '../Context.js';~~
4	4	export interface LineConfig extends ShapeConfig {
5	5	points?: number[] \| Int8Array \| Uint8Array \| Uint8ClampedArray \| Int16Array \| Uint16Array \| Int32Array \| Uint32Array \| Float32Array \| Float64Array;

imaps-frontend/node_modules/konva/lib/shapes/Line.js

-              rd565449
+              r0c6b92a
 exports.Line = void 0;
 const Factory_1 = require("../Factory");
+const Global_1 = require("../Global");
 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);
+    const 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);
+    const len = p.length, allPoints = [];
+    for (let n = 2; n < len - 2; n += 2) {
+        const 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;
 …
+    }
     _sceneFunc(context) {
         var points = this.points(), length = points.length, tension = this.tension(), closed = this.closed(), bezier = this.bezier(), tp, len, n;
+        let points = this.points(), length = points.length, tension = this.tension(), closed = this.closed(), bezier = this.bezier(), tp, len, n;
         if (!length) {
             return;
 …
+    }
     _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]]
+        const 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([
 …
+    }
     getSelfRect() {
         var points = this.points();
+        let points = this.points();
         if (points.length < 4) {
             return {
 …
             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++) {
+        let minX = points[0];
+        let maxX = points[0];
+        let minY = points[1];
+        let maxY = points[1];
+        let x, y;
+        for (let i = 0; i < points.length / 2; i++) {
             x = points[i * 2];
             y = points[i * 2 + 1];

imaps-frontend/node_modules/konva/lib/shapes/Path.d.ts

-              rd565449
+              r0c6b92a
     getLength(): number;
     getPointAtLength(length: any): {
         x: any;
         y: any;
+        x: number;
+        y: number;
     } | null;
     data: GetSet<string, this>;
     static getLineLength(x1: any, y1: any, x2: any, y2: any): number;
     static getPathLength(dataArray: PathSegment[]): number;
     static getPointAtLengthOfDataArray(length: number, dataArray: any): {
         x: any;
         y: any;
+    static getPointAtLengthOfDataArray(length: number, dataArray: PathSegment[]): {
+        x: number;
+        y: number;
     } | null;
     static getPointOnLine(dist: any, P1x: any, P1y: any, P2x: any, P2y: any, fromX?: any, fromY?: any): {
         x: any;
         y: any;
+    static getPointOnLine(dist: number, P1x: number, P1y: number, P2x: number, P2y: number, fromX?: number, fromY?: number): {
+        x: number;
+        y: number;
     };
     static getPointOnCubicBezier(pct: any, P1x: any, P1y: any, P2x: any, P2y: any, P3x: any, P3y: any, P4x: any, P4y: any): {

imaps-frontend/node_modules/konva/lib/shapes/Path.js

-              rd565449
+              r0c6b92a
+    }
     _sceneFunc(context) {
         var ca = this.dataArray;
+        const ca = this.dataArray;
         context.beginPath();
         var isClosed = false;
         for (var n = 0; n < ca.length; n++) {
             var c = ca[n].command;
             var p = ca[n].points;
+        let isClosed = false;
+        for (let n = 0; n < ca.length; n++) {
+            const c = ca[n].command;
+            const p = ca[n].points;
             switch (c) {
                 case 'L':
 …
+    }
     getSelfRect() {
         var points = [];
+        let points = [];
         this.dataArray.forEach(function (data) {
             if (data.command === 'A') {
                 var start = data.points[4];
                 var dTheta = data.points[5];
                 var end = data.points[4] + dTheta;
                 var inc = Math.PI / 180.0;
+                const start = data.points[4];
+                const dTheta = data.points[5];
+                const end = data.points[4] + dTheta;
+                let inc = Math.PI / 180.0;
                 if (Math.abs(start - end) < inc) {
                     inc = Math.abs(start - end);
 …
+            }
         });
         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++) {
+        let minX = points[0];
+        let maxX = points[0];
+        let minY = points[1];
+        let maxY = points[1];
+        let x, y;
+        for (let i = 0; i < points.length / 2; i++) {
             x = points[i * 2];
             y = points[i * 2 + 1];
 …
     static getPathLength(dataArray) {
         let pathLength = 0;
         for (var i = 0; i < dataArray.length; ++i) {
+        for (let i = 0; i < dataArray.length; ++i) {
             pathLength += dataArray[i].pathLength;
+        }
 …
+    }
     static getPointAtLengthOfDataArray(length, dataArray) {
         var point, i = 0, ii = dataArray.length;
+        let points, i = 0, ii = dataArray.length;
         if (!ii) {
             return null;
 …
+        }
         if (i === ii) {
             point = dataArray[i - 1].points.slice(-2);
+            points = dataArray[i - 1].points.slice(-2);
             return {
                 x: point[0],
                 y: point[1],
+                x: points[0],
+                y: points[1],
             };
+        }
         if (length < 0.01) {
             point = dataArray[i].points.slice(0, 2);
+            points = dataArray[i].points.slice(0, 2);
             return {
                 x: point[0],
                 y: point[1],
+                x: points[0],
+                y: points[1],
             };
+        }
         var cp = dataArray[i];
         var p = cp.points;
+        const cp = dataArray[i];
+        const p = cp.points;
         switch (cp.command) {
             case 'L':
 …
             return (1 - t) * (1 - t) * (1 - t);
+        }
         var x = P4x * CB1(pct) + P3x * CB2(pct) + P2x * CB3(pct) + P1x * CB4(pct);
         var y = P4y * CB1(pct) + P3y * CB2(pct) + P2y * CB3(pct) + P1y * CB4(pct);
+        const x = P4x * CB1(pct) + P3x * CB2(pct) + P2x * CB3(pct) + P1x * CB4(pct);
+        const y = P4y * CB1(pct) + P3y * CB2(pct) + P2y * CB3(pct) + P1y * CB4(pct);
         return {
             x: x,
 …
             return (1 - t) * (1 - t);
+        }
         var x = P3x * QB1(pct) + P2x * QB2(pct) + P1x * QB3(pct);
         var y = P3y * QB1(pct) + P2y * QB2(pct) + P1y * QB3(pct);
+        const x = P3x * QB1(pct) + P2x * QB2(pct) + P1x * QB3(pct);
+        const y = P3y * QB1(pct) + P2y * QB2(pct) + P1y * QB3(pct);
         return {
             x: x,
 …
+    }
     static getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi) {
         var cosPsi = Math.cos(psi), sinPsi = Math.sin(psi);
         var pt = {
+        const cosPsi = Math.cos(psi), sinPsi = Math.sin(psi);
+        const pt = {
             x: rx * Math.cos(theta),
             y: ry * Math.sin(theta),
 …
             return [];
+        }
         var cs = data;
         var cc = [
+        let cs = data;
+        const cc = [
             'm',
             'M',
 …
             cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);
+        }
         var arr = cs.split('|');
         var ca = [];
         var coords = [];
         var cpx = 0;
         var cpy = 0;
         var re = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/gi;
         var match;
+        const arr = cs.split('|');
+        const ca = [];
+        const coords = [];
+        let cpx = 0;
+        let cpy = 0;
+        const re = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/gi;
+        let match;
         for (n = 1; n < arr.length; n++) {
             var str = arr[n];
             var c = str.charAt(0);
+            let str = arr[n];
+            let c = str.charAt(0);
             str = str.slice(1);
             coords.length = 0;
 …
                 coords.push(match[0]);
+            }
             var p = [];
             for (var j = 0, jlen = coords.length; j < jlen; j++) {
+            const p = [];
+            for (let j = 0, jlen = coords.length; j < jlen; j++) {
                 if (coords[j] === '00') {
                     p.push(0, 0);
                     continue;
+                }
                 var parsed = parseFloat(coords[j]);
+                const parsed = parseFloat(coords[j]);
                 if (!isNaN(parsed)) {
                     p.push(parsed);
 …
                     break;
+                }
                 var cmd = '';
                 var points = [];
                 var startX = cpx, startY = cpy;
+                let cmd = '';
+                let points = [];
+                const startX = cpx, startY = cpy;
                 var prevCmd, ctlPtx, ctlPty;
                 var rx, ry, psi, fa, fs, x1, y1;
 …
                         cmd = 'M';
                         if (ca.length > 2 && ca[ca.length - 1].command === 'z') {
                             for (var idx = ca.length - 2; idx >= 0; idx--) {
+                            for (let idx = ca.length - 2; idx >= 0; idx--) {
                                 if (ca[idx].command === 'M') {
                                     cpx = ca[idx].points[0] + dx;
 …
+    }
     static calcLength(x, y, cmd, points) {
         var len, p1, p2, t;
         var path = Path;
+        let len, p1, p2, t;
+        const path = Path;
         switch (cmd) {
             case 'L':
 …
+    }
     static convertEndpointToCenterParameterization(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg) {
         var psi = psiDeg * (Math.PI / 180.0);
         var xp = (Math.cos(psi) * (x1 - x2)) / 2.0 + (Math.sin(psi) * (y1 - y2)) / 2.0;
         var yp = (-1 * Math.sin(psi) * (x1 - x2)) / 2.0 +
+        const psi = psiDeg * (Math.PI / 180.0);
+        const xp = (Math.cos(psi) * (x1 - x2)) / 2.0 + (Math.sin(psi) * (y1 - y2)) / 2.0;
+        const yp = (-1 * Math.sin(psi) * (x1 - x2)) / 2.0 +
             (Math.cos(psi) * (y1 - y2)) / 2.0;
         var lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+        const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
         if (lambda > 1) {
             rx *= Math.sqrt(lambda);
             ry *= Math.sqrt(lambda);
+        }
         var f = Math.sqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) /
+        let f = Math.sqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) /
             (rx * rx * (yp * yp) + ry * ry * (xp * xp)));
         if (fa === fs) {
 …
             f = 0;
+        }
         var cxp = (f * rx * yp) / ry;
         var cyp = (f * -ry * xp) / rx;
         var cx = (x1 + x2) / 2.0 + Math.cos(psi) * cxp - Math.sin(psi) * cyp;
         var cy = (y1 + y2) / 2.0 + Math.sin(psi) * cxp + Math.cos(psi) * cyp;
         var vMag = function (v) {
+        const cxp = (f * rx * yp) / ry;
+        const cyp = (f * -ry * xp) / rx;
+        const cx = (x1 + x2) / 2.0 + Math.cos(psi) * cxp - Math.sin(psi) * cyp;
+        const cy = (y1 + y2) / 2.0 + Math.sin(psi) * cxp + Math.cos(psi) * cyp;
+        const vMag = function (v) {
             return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
         };
         var vRatio = function (u, v) {
+        const vRatio = function (u, v) {
             return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));
         };
         var vAngle = function (u, v) {
+        const vAngle = function (u, v) {
             return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));
         };
         var theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);
         var u = [(xp - cxp) / rx, (yp - cyp) / ry];
         var v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];
         var dTheta = vAngle(u, v);
+        const theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);
+        const u = [(xp - cxp) / rx, (yp - cyp) / ry];
+        const v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];
+        let dTheta = vAngle(u, v);
         if (vRatio(u, v) <= -1) {
             dTheta = Math.PI;

imaps-frontend/node_modules/konva/lib/shapes/Rect.js

rd565449	r0c6b92a
9	9	class Rect extends Shape_1.Shape {
10	10	_sceneFunc(context) {
11		~~var~~ cornerRadius = this.cornerRadius(), width = this.width(), height = this.height();
	11	const cornerRadius = this.cornerRadius(), width = this.width(), height = this.height();
12	12	context.beginPath();
13	13	if (!cornerRadius) {

imaps-frontend/node_modules/konva/lib/shapes/RegularPolygon.js

-              rd565449
+              r0c6b92a
         context.beginPath();
         context.moveTo(points[0].x, points[0].y);
         for (var n = 1; n < points.length; n++) {
+        for (let n = 1; n < points.length; n++) {
             context.lineTo(points[n].x, points[n].y);
+        }
 …
         const radius = this.attrs.radius || 0;
         const points = [];
         for (var n = 0; n < sides; n++) {
+        for (let n = 0; n < sides; n++) {
             points.push({
                 x: radius * Math.sin((n * 2 * Math.PI) / sides),
 …
     getSelfRect() {
         const points = this._getPoints();
         var minX = points[0].x;
         var maxX = points[0].y;
         var minY = points[0].x;
         var maxY = points[0].y;
+        let minX = points[0].x;
+        let maxX = points[0].y;
+        let minY = points[0].x;
+        let maxY = points[0].y;
         points.forEach((point) => {
             minX = Math.min(minX, point.x);

imaps-frontend/node_modules/konva/lib/shapes/Ring.js

rd565449	r0c6b92a
6	6	const Validators_1 = require("../Validators");
7	7	const Global_1 = require("../Global");
8		~~var~~ PIx2 = Math.PI * 2;
	8	const PIx2 = Math.PI * 2;
9	9	class Ring extends Shape_1.Shape {
10	10	_sceneFunc(context) {

imaps-frontend/node_modules/konva/lib/shapes/Sprite.js

-              rd565449
+              r0c6b92a
         this._updated = true;
         this.anim = new Animation_1.Animation(() => {
             var updated = this._updated;
+            const updated = this._updated;
             this._updated = false;
             return updated;
 …
+    }
     _sceneFunc(context) {
         var anim = this.animation(), index = this.frameIndex(), ix4 = index * 4, set = this.animations()[anim], offsets = this.frameOffsets(), x = set[ix4 + 0], y = set[ix4 + 1], width = set[ix4 + 2], height = set[ix4 + 3], image = this.image();
+        const anim = this.animation(), index = this.frameIndex(), ix4 = index * 4, set = this.animations()[anim], offsets = this.frameOffsets(), x = set[ix4 + 0], y = set[ix4 + 1], width = set[ix4 + 2], height = set[ix4 + 3], image = this.image();
         if (this.hasFill() || this.hasStroke()) {
             context.beginPath();
 …
         if (image) {
             if (offsets) {
                 var offset = offsets[anim], ix2 = index * 2;
+                const offset = offsets[anim], ix2 = index * 2;
                 context.drawImage(image, x, y, width, height, offset[ix2 + 0], offset[ix2 + 1], width, height);
+            }
 …
+    }
     _hitFunc(context) {
         var anim = this.animation(), index = this.frameIndex(), ix4 = index * 4, set = this.animations()[anim], offsets = this.frameOffsets(), width = set[ix4 + 2], height = set[ix4 + 3];
+        const anim = this.animation(), index = this.frameIndex(), ix4 = index * 4, set = this.animations()[anim], offsets = this.frameOffsets(), width = set[ix4 + 2], height = set[ix4 + 3];
         context.beginPath();
         if (offsets) {
             var offset = offsets[anim];
             var ix2 = index * 2;
+            const offset = offsets[anim];
+            const ix2 = index * 2;
             context.rect(offset[ix2 + 0], offset[ix2 + 1], width, height);
+        }
 …
+    }
     _setInterval() {
         var that = this;
+        const that = this;
         this.interval = setInterval(function () {
             that._updateIndex();
 …
             return;
+        }
         var layer = this.getLayer();
+        const layer = this.getLayer();
         this.anim.setLayers(layer);
         this._setInterval();
 …
+    }
     _updateIndex() {
         var index = this.frameIndex(), animation = this.animation(), animations = this.animations(), anim = animations[animation], len = anim.length / 4;
+        const index = this.frameIndex(), animation = this.animation(), animations = this.animations(), anim = animations[animation], len = anim.length / 4;
         if (index < len - 1) {
             this.frameIndex(index + 1);

imaps-frontend/node_modules/konva/lib/shapes/Star.js

-              rd565449
+              r0c6b92a
 class Star extends Shape_1.Shape {
     _sceneFunc(context) {
         var innerRadius = this.innerRadius(), outerRadius = this.outerRadius(), numPoints = this.numPoints();
+        const innerRadius = this.innerRadius(), outerRadius = this.outerRadius(), numPoints = this.numPoints();
         context.beginPath();
         context.moveTo(0, 0 - outerRadius);
         for (var n = 1; n < numPoints * 2; n++) {
             var radius = n % 2 === 0 ? outerRadius : innerRadius;
             var x = radius * Math.sin((n * Math.PI) / numPoints);
             var y = -1 * radius * Math.cos((n * Math.PI) / numPoints);
+        for (let n = 1; n < numPoints * 2; n++) {
+            const radius = n % 2 === 0 ? outerRadius : innerRadius;
+            const x = radius * Math.sin((n * Math.PI) / numPoints);
+            const y = -1 * radius * Math.cos((n * Math.PI) / numPoints);
             context.lineTo(x, y);
+        }

imaps-frontend/node_modules/konva/lib/shapes/Text.d.ts

-              rd565449
+              r0c6b92a
     getTextWidth(): number;
     getTextHeight(): number;
     measureSize(text: any): {
         actualBoundingBoxAscent: any;
         actualBoundingBoxDescent: any;
         actualBoundingBoxLeft: any;
         actualBoundingBoxRight: any;
         alphabeticBaseline: any;
         emHeightAscent: any;
         emHeightDescent: any;
         fontBoundingBoxAscent: any;
         fontBoundingBoxDescent: any;
         hangingBaseline: any;
         ideographicBaseline: any;
         width: any;
+    measureSize(text: string): {
+        actualBoundingBoxAscent: number;
+        actualBoundingBoxDescent: number;
+        actualBoundingBoxLeft: number;
+        actualBoundingBoxRight: number;
+        alphabeticBaseline: number;
+        emHeightAscent: number;
+        emHeightDescent: number;
+        fontBoundingBoxAscent: number;
+        fontBoundingBoxDescent: number;
+        hangingBaseline: number;
+        ideographicBaseline: number;
+        width: number;
         height: number;
     };

imaps-frontend/node_modules/konva/lib/shapes/Text.js

-              rd565449
+              r0c6b92a
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = exports.stringToArray = void 0;
+exports.Text = void 0;
+exports.stringToArray = stringToArray;
 const Util_1 = require("../Util");
 const Factory_1 = require("../Factory");
 …
 const Global_2 = require("../Global");
 function stringToArray(string) {
+    return Array.from(string);
+}
+exports.stringToArray = stringToArray;
+var AUTO = 'auto', CENTER = 'center', INHERIT = 'inherit', JUSTIFY = 'justify', CHANGE_KONVA = 'Change.konva', CONTEXT_2D = '2d', DASH = '-', LEFT = 'left', LTR = 'ltr', TEXT = 'text', TEXT_UPPER = 'Text', TOP = 'top', BOTTOM = 'bottom', MIDDLE = 'middle', NORMAL = 'normal', PX_SPACE = 'px ', SPACE = ' ', RIGHT = 'right', RTL = 'rtl', WORD = 'word', CHAR = 'char', NONE = 'none', ELLIPSIS = '…', ATTR_CHANGE_LIST = [
+    return [...string].reduce((acc, char, index, array) => {
+        if (/\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?(?:\u200D\p{Emoji_Presentation})+/u.test(char)) {
+            acc.push(char);
+        }
+        else if (/\p{Regional_Indicator}{2}/u.test(char + (array[index + 1] || ''))) {
+            acc.push(char + array[index + 1]);
+        }
+        else if (index > 0 && /\p{Mn}|\p{Me}|\p{Mc}/u.test(char)) {
+            acc[acc.length - 1] += char;
+        }
+        else {
+            acc.push(char);
+        }
+        return acc;
+    }, []);
+}
+const AUTO = 'auto', CENTER = 'center', INHERIT = 'inherit', JUSTIFY = 'justify', CHANGE_KONVA = 'Change.konva', CONTEXT_2D = '2d', DASH = '-', LEFT = 'left', TEXT = 'text', TEXT_UPPER = 'Text', TOP = 'top', BOTTOM = 'bottom', MIDDLE = 'middle', NORMAL = 'normal', PX_SPACE = 'px ', SPACE = ' ', RIGHT = 'right', RTL = 'rtl', WORD = 'word', CHAR = 'char', NONE = 'none', ELLIPSIS = '…', ATTR_CHANGE_LIST = [
     'direction',
     'fontFamily',
 …
         .join(', ');
+}
 var dummyContext;
+let dummyContext;
 function getDummyContext() {
     if (dummyContext) {
 …
         this._partialTextX = 0;
         this._partialTextY = 0;
         for (var n = 0; n < attrChangeListLen; n++) {
+        for (let n = 0; n < attrChangeListLen; n++) {
             this.on(ATTR_CHANGE_LIST[n] + CHANGE_KONVA, this._setTextData);
+        }
 …
+    }
     _sceneFunc(context) {
         var textArr = this.textArr, textArrLen = textArr.length;
+        const textArr = this.textArr, textArrLen = textArr.length;
         if (!this.text()) {
             return;
+        }
         var padding = this.padding(), fontSize = this.fontSize(), lineHeightPx = this.lineHeight() * fontSize, verticalAlign = this.verticalAlign(), direction = this.direction(), alignY = 0, align = this.align(), totalWidth = this.getWidth(), letterSpacing = this.letterSpacing(), fill = this.fill(), textDecoration = this.textDecoration(), shouldUnderline = textDecoration.indexOf('underline') !== -1, shouldLineThrough = textDecoration.indexOf('line-through') !== -1, n;
+        let padding = this.padding(), fontSize = this.fontSize(), lineHeightPx = this.lineHeight() * fontSize, verticalAlign = this.verticalAlign(), direction = this.direction(), alignY = 0, align = this.align(), totalWidth = this.getWidth(), letterSpacing = this.letterSpacing(), fill = this.fill(), textDecoration = this.textDecoration(), shouldUnderline = textDecoration.indexOf('underline') !== -1, shouldLineThrough = textDecoration.indexOf('line-through') !== -1, n;
         direction = direction === INHERIT ? context.direction : direction;
         var translateY = lineHeightPx / 2;
         var baseline = MIDDLE;
+        let translateY = lineHeightPx / 2;
+        let baseline = MIDDLE;
         if (Global_1.Konva._fixTextRendering) {
             var metrics = this.measureSize('M');
+            const metrics = this.measureSize('M');
             baseline = 'alphabetic';
             translateY =
 …
                 context.save();
                 context.beginPath();
                 let yOffset = Global_1.Konva._fixTextRendering
+                const yOffset = Global_1.Konva._fixTextRendering
                     ? Math.round(fontSize / 4)
                     : Math.round(fontSize / 2);
 …
                 context.save();
                 context.beginPath();
                 let yOffset = Global_1.Konva._fixTextRendering ? -Math.round(fontSize / 4) : 0;
+                const yOffset = Global_1.Konva._fixTextRendering ? -Math.round(fontSize / 4) : 0;
                 context.moveTo(lineTranslateX, translateY + lineTranslateY + yOffset);
                 spacesNumber = text.split(' ').length - 1;
 …
             if (direction !== RTL && (letterSpacing !== 0 || align === JUSTIFY)) {
                 spacesNumber = text.split(' ').length - 1;
                 var array = stringToArray(text);
                 for (var li = 0; li < array.length; li++) {
                     var letter = array[li];
+                const array = stringToArray(text);
+                for (let li = 0; li < array.length; li++) {
+                    const letter = array[li];
                     if (letter === ' ' && !lastLine && align === JUSTIFY) {
                         lineTranslateX += (totalWidth - padding * 2 - width) / spacesNumber;
 …
+    }
     _hitFunc(context) {
         var width = this.getWidth(), height = this.getHeight();
+        const width = this.getWidth(), height = this.getHeight();
         context.beginPath();
         context.rect(0, 0, width, height);
 …
+    }
     setText(text) {
         var str = Util_1.Util._isString(text)
+        const str = Util_1.Util._isString(text)
             ? text
             : text === null || text === undefined
 …
+    }
     getWidth() {
         var isAuto = this.attrs.width === AUTO || this.attrs.width === undefined;
+        const isAuto = this.attrs.width === AUTO || this.attrs.width === undefined;
         return isAuto ? this.getTextWidth() + this.padding() * 2 : this.attrs.width;
+    }
     getHeight() {
         var isAuto = this.attrs.height === AUTO || this.attrs.height === undefined;
+        const isAuto = this.attrs.height === AUTO || this.attrs.height === undefined;
         return isAuto
             ? this.fontSize() * this.textArr.length * this.lineHeight() +
 …
     measureSize(text) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         var _context = getDummyContext(), fontSize = this.fontSize(), metrics;
+        let _context = getDummyContext(), fontSize = this.fontSize(), metrics;
         _context.save();
         _context.font = this._getContextFont();
 …
             line = line.trim();
+        }
         var width = this._getTextWidth(line);
+        const width = this._getTextWidth(line);
         return this.textArr.push({
             text: line,
 …
+    }
     _getTextWidth(text) {
         var letterSpacing = this.letterSpacing();
         var length = text.length;
+        const letterSpacing = this.letterSpacing();
+        const length = text.length;
         return (getDummyContext().measureText(text).width +
             (length ? letterSpacing * (length - 1) : 0));
+    }
     _setTextData() {
         var lines = this.text().split('\n'), fontSize = +this.fontSize(), textWidth = 0, lineHeightPx = this.lineHeight() * fontSize, width = this.attrs.width, height = this.attrs.height, fixedWidth = width !== AUTO && width !== undefined, fixedHeight = height !== AUTO && height !== undefined, padding = this.padding(), maxWidth = width - padding * 2, maxHeightPx = height - padding * 2, currentHeightPx = 0, wrap = this.wrap(), shouldWrap = wrap !== NONE, wrapAtWord = wrap !== CHAR && shouldWrap, shouldAddEllipsis = this.ellipsis();
+        let lines = this.text().split('\n'), fontSize = +this.fontSize(), textWidth = 0, lineHeightPx = this.lineHeight() * fontSize, width = this.attrs.width, height = this.attrs.height, fixedWidth = width !== AUTO && width !== undefined, fixedHeight = height !== AUTO && height !== undefined, padding = this.padding(), maxWidth = width - padding * 2, maxHeightPx = height - padding * 2, currentHeightPx = 0, wrap = this.wrap(), shouldWrap = wrap !== NONE, wrapAtWord = wrap !== CHAR && shouldWrap, shouldAddEllipsis = this.ellipsis();
         this.textArr = [];
         getDummyContext().font = this._getContextFont();
         var additionalWidth = shouldAddEllipsis ? this._getTextWidth(ELLIPSIS) : 0;
         for (var i = 0, max = lines.length; i < max; ++i) {
             var line = lines[i];
             var lineWidth = this._getTextWidth(line);
+        const additionalWidth = shouldAddEllipsis ? this._getTextWidth(ELLIPSIS) : 0;
+        for (let i = 0, max = lines.length; i < max; ++i) {
+            let line = lines[i];
+            let lineWidth = this._getTextWidth(line);
             if (fixedWidth && lineWidth > maxWidth) {
                 while (line.length > 0) {
                     var low = 0, high = line.length, match = '', matchWidth = 0;
+                    let low = 0, high = line.length, match = '', matchWidth = 0;
                     while (low < high) {
                         var mid = (low + high) >>> 1, substr = line.slice(0, mid + 1), substrWidth = this._getTextWidth(substr) + additionalWidth;
+                        const mid = (low + high) >>> 1, substr = line.slice(0, mid + 1), substrWidth = this._getTextWidth(substr) + additionalWidth;
                         if (substrWidth <= maxWidth) {
                             low = mid + 1;
 …
                         if (wrapAtWord) {
                             var wrapIndex;
                             var nextChar = line[match.length];
                             var nextIsSpaceOrDash = nextChar === SPACE || nextChar === DASH;
+                            const nextChar = line[match.length];
+                            const nextIsSpaceOrDash = nextChar === SPACE || nextChar === DASH;
                             if (nextIsSpaceOrDash && matchWidth <= maxWidth) {
                                 wrapIndex = match.length;
 …
                         textWidth = Math.max(textWidth, matchWidth);
                         currentHeightPx += lineHeightPx;
                         var shouldHandleEllipsis = this._shouldHandleEllipsis(currentHeightPx);
+                        const shouldHandleEllipsis = this._shouldHandleEllipsis(currentHeightPx);
                         if (shouldHandleEllipsis) {
                             this._tryToAddEllipsisToLastLine();
 …
+    }
     _shouldHandleEllipsis(currentHeightPx) {
         var fontSize = +this.fontSize(), lineHeightPx = this.lineHeight() * fontSize, height = this.attrs.height, fixedHeight = height !== AUTO && height !== undefined, padding = this.padding(), maxHeightPx = height - padding * 2, wrap = this.wrap(), shouldWrap = wrap !== NONE;
+        const fontSize = +this.fontSize(), lineHeightPx = this.lineHeight() * fontSize, height = this.attrs.height, fixedHeight = height !== AUTO && height !== undefined, padding = this.padding(), maxHeightPx = height - padding * 2, wrap = this.wrap(), shouldWrap = wrap !== NONE;
         return (!shouldWrap ||
             (fixedHeight && currentHeightPx + lineHeightPx > maxHeightPx));
+    }
     _tryToAddEllipsisToLastLine() {
         var width = this.attrs.width, fixedWidth = width !== AUTO && width !== undefined, padding = this.padding(), maxWidth = width - padding * 2, shouldAddEllipsis = this.ellipsis();
         var lastLine = this.textArr[this.textArr.length - 1];
+        const width = this.attrs.width, fixedWidth = width !== AUTO && width !== undefined, padding = this.padding(), maxWidth = width - padding * 2, shouldAddEllipsis = this.ellipsis();
+        const lastLine = this.textArr[this.textArr.length - 1];
         if (!lastLine || !shouldAddEllipsis) {
             return;
+        }
         if (fixedWidth) {
             var haveSpace = this._getTextWidth(lastLine.text + ELLIPSIS) < maxWidth;
+            const haveSpace = this._getTextWidth(lastLine.text + ELLIPSIS) < maxWidth;
             if (!haveSpace) {
                 lastLine.text = lastLine.text.slice(0, lastLine.text.length - 3);

imaps-frontend/node_modules/konva/lib/shapes/TextPath.d.ts

-              rd565449
+              r0c6b92a
     _getTextPathLength(): number;
     _getPointAtLength(length: number): {
         x: any;
         y: any;
+        x: number;
+        y: number;
     } | null;
     _readDataAttribute(): void;

imaps-frontend/node_modules/konva/lib/shapes/TextPath.js

-              rd565449
+              r0c6b92a
 const Validators_1 = require("../Validators");
 const Global_1 = require("../Global");
 var EMPTY_STRING = '', NORMAL = 'normal';
+const EMPTY_STRING = '', NORMAL = 'normal';
 function _fillFunc(context) {
     context.fillText(this.partialText, 0, 0);
 …
         context.setAttr('textAlign', 'left');
         context.save();
         var textDecoration = this.textDecoration();
         var fill = this.fill();
         var fontSize = this.fontSize();
         var glyphInfo = this.glyphInfo;
+        const textDecoration = this.textDecoration();
+        const fill = this.fill();
+        const fontSize = this.fontSize();
+        const glyphInfo = this.glyphInfo;
         if (textDecoration === 'underline') {
             context.beginPath();
+        }
         for (var i = 0; i < glyphInfo.length; i++) {
+        for (let i = 0; i < glyphInfo.length; i++) {
             context.save();
             var p0 = glyphInfo[i].p0;
+            const p0 = glyphInfo[i].p0;
             context.translate(p0.x, p0.y);
             context.rotate(glyphInfo[i].rotation);
 …
     _hitFunc(context) {
         context.beginPath();
         var glyphInfo = this.glyphInfo;
+        const glyphInfo = this.glyphInfo;
         if (glyphInfo.length >= 1) {
             var p0 = glyphInfo[0].p0;
+            const p0 = glyphInfo[0].p0;
             context.moveTo(p0.x, p0.y);
+        }
         for (var i = 0; i < glyphInfo.length; i++) {
             var p1 = glyphInfo[i].p1;
+        for (let i = 0; i < glyphInfo.length; i++) {
+            const p1 = glyphInfo[i].p1;
             context.lineTo(p1.x, p1.y);
+        }
 …
+    }
     _getTextSize(text) {
         var dummyCanvas = this.dummyCanvas;
         var _context = dummyCanvas.getContext('2d');
+        const dummyCanvas = this.dummyCanvas;
+        const _context = dummyCanvas.getContext('2d');
         _context.save();
         _context.font = this._getContextFont();
         var metrics = _context.measureText(text);
+        const metrics = _context.measureText(text);
         _context.restore();
         return {
 …
         const charArr = (0, Text_1.stringToArray)(this.text());
         let offsetToGlyph = offset;
         for (var i = 0; i < charArr.length; i++) {
+        for (let i = 0; i < charArr.length; i++) {
             const charStartPoint = this._getPointAtLength(offsetToGlyph);
             if (!charStartPoint)
 …
             };
+        }
         var points = [];
+        const points = [];
         this.glyphInfo.forEach(function (info) {
             points.push(info.p0.x);
 …
             points.push(info.p1.y);
         });
         var minX = points[0] || 0;
         var maxX = points[0] || 0;
         var minY = points[1] || 0;
         var maxY = points[1] || 0;
         var x, y;
         for (var i = 0; i < points.length / 2; i++) {
+        let minX = points[0] || 0;
+        let maxX = points[0] || 0;
+        let minY = points[1] || 0;
+        let maxY = points[1] || 0;
+        let x, y;
+        for (let i = 0; i < points.length / 2; i++) {
             x = points[i * 2];
             y = points[i * 2 + 1];
 …
             maxY = Math.max(maxY, y);
+        }
         var fontSize = this.fontSize();
+        const fontSize = this.fontSize();
         return {
             x: minX - fontSize / 2,

imaps-frontend/node_modules/konva/lib/shapes/Transformer.d.ts

rd565449	r0c6b92a
95	95	attrs: any;
96	96	className: string;
97		children?: ~~any[] \| undefined~~;
	97	children?: Array<any>;
98	98	};
99	99	clone(obj?: any): this;

imaps-frontend/node_modules/konva/lib/shapes/Transformer.js

-              rd565449
+              r0c6b92a
 const Validators_1 = require("../Validators");
 const Global_2 = require("../Global");
 var EVENTS_NAME = 'tr-konva';
 var ATTR_CHANGE_LIST = [
+const EVENTS_NAME = 'tr-konva';
+const ATTR_CHANGE_LIST = [
     'resizeEnabledChange',
     'rotateAnchorOffsetChange',
 …
     .map((e) => e + `.${EVENTS_NAME}`)
     .join(' ');
 var NODES_RECT = 'nodesRect';
 var TRANSFORM_CHANGE_STR = [
+const NODES_RECT = 'nodesRect';
+const TRANSFORM_CHANGE_STR = [
     'widthChange',
     'heightChange',
 …
     'strokeWidthChange',
 ];
 var ANGLES = {
+const ANGLES = {
     'top-left': -45,
     'top-center': 0,
 …
+    }
     rad += Util_1.Util.degToRad(ANGLES[anchorName] || 0);
     var angle = ((Util_1.Util.radToDeg(rad) % 360) + 360) % 360;
+    const angle = ((Util_1.Util.radToDeg(rad) % 360) + 360) % 360;
     if (Util_1.Util._inRange(angle, 315 + 22.5, 360) || Util_1.Util._inRange(angle, 0, 22.5)) {
         return 'ns-resize';
 …
+    }
+}
 var ANCHORS_NAMES = [
+const ANCHORS_NAMES = [
     'top-left',
     'top-center',
 …
     'bottom-right',
 ];
 var MAX_SAFE_INTEGER = 100000000;
+const MAX_SAFE_INTEGER = 100000000;
 function getCenter(shape) {
     return {
 …
         });
         this._resetTransformCache();
         var elementsCreated = !!this.findOne('.top-left');
+        const elementsCreated = !!this.findOne('.top-left');
         if (elementsCreated) {
             this.update();
 …
+    }
     __getNodeShape(node, rot = this.rotation(), relative) {
         var rect = node.getClientRect({
+        const rect = node.getClientRect({
             skipTransform: true,
             skipShadow: true,
             skipStroke: this.ignoreStroke(),
         });
         var absScale = node.getAbsoluteScale(relative);
         var absPos = node.getAbsolutePosition(relative);
         var dx = rect.x * absScale.x - node.offsetX() * absScale.x;
         var dy = rect.y * absScale.y - node.offsetY() * absScale.y;
+        const absScale = node.getAbsoluteScale(relative);
+        const absPos = node.getAbsolutePosition(relative);
+        const dx = rect.x * absScale.x - node.offsetX() * absScale.x;
+        const dy = rect.y * absScale.y - node.offsetY() * absScale.y;
         const rotation = (Global_1.Konva.getAngle(node.getAbsoluteRotation()) + Math.PI * 2) %
             (Math.PI * 2);
 …
+    }
     __getNodeRect() {
         var node = this.getNode();
+        const node = this.getNode();
         if (!node) {
             return {
 …
                 skipStroke: this.ignoreStroke(),
             });
             var points = [
+            const points = [
                 { x: box.x, y: box.y },
                 { x: box.x + box.width, y: box.y },
 …
                 { x: box.x, y: box.y + box.height },
             ];
             var trans = node.getAbsoluteTransform();
+            const trans = node.getAbsoluteTransform();
             points.forEach(function (point) {
                 var transformed = trans.point(point);
+                const transformed = trans.point(point);
                 totalPoints.push(transformed);
             });
 …
         const tr = new Util_1.Transform();
         tr.rotate(-Global_1.Konva.getAngle(this.rotation()));
         var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
         totalPoints.forEach(function (point) {
             var transformed = tr.point(point);
+            const transformed = tr.point(point);
             if (minX === undefined) {
                 minX = maxX = transformed.x;
 …
+    }
     _createAnchor(name) {
         var anchor = new Rect_1.Rect({
+        const anchor = new Rect_1.Rect({
             stroke: 'rgb(0, 161, 255)',
             fill: 'white',
 …
             hitStrokeWidth: TOUCH_DEVICE ? 10 : 'auto',
         });
         var self = this;
+        const self = this;
         anchor.on('mousedown touchstart', function (e) {
             self._handleMouseDown(e);
 …
         });
         anchor.on('mouseenter', () => {
             var rad = Global_1.Konva.getAngle(this.rotation());
             var rotateCursor = this.rotateAnchorCursor();
             var cursor = getCursor(name, rad, rotateCursor);
+            const rad = Global_1.Konva.getAngle(this.rotation());
+            const rotateCursor = this.rotateAnchorCursor();
+            const cursor = getCursor(name, rad, rotateCursor);
             anchor.getStage().content &&
                 (anchor.getStage().content.style.cursor = cursor);
 …
+    }
     _createBack() {
         var back = new Shape_1.Shape({
+        const back = new Shape_1.Shape({
             name: 'back',
             width: 0,
 …
             draggable: true,
             sceneFunc(ctx, shape) {
                 var tr = shape.getParent();
                 var padding = tr.padding();
+                const tr = shape.getParent();
+                const padding = tr.padding();
                 ctx.beginPath();
                 ctx.rect(-padding, -padding, shape.width() + padding * 2, shape.height() + padding * 2);
 …
                     return;
+                }
                 var padding = this.padding();
+                const padding = this.padding();
                 ctx.beginPath();
                 ctx.rect(-padding, -padding, shape.width() + padding * 2, shape.height() + padding * 2);
 …
+        }
         this._movingAnchorName = e.target.name().split(' ')[0];
         var attrs = this._getNodeRect();
         var width = attrs.width;
         var height = attrs.height;
         var hypotenuse = Math.sqrt(Math.pow(width, 2) + Math.pow(height, 2));
+        const attrs = this._getNodeRect();
+        const width = attrs.width;
+        const height = attrs.height;
+        const hypotenuse = Math.sqrt(Math.pow(width, 2) + Math.pow(height, 2));
         this.sin = Math.abs(height / hypotenuse);
         this.cos = Math.abs(width / hypotenuse);
 …
+        }
         this._transforming = true;
         var ap = e.target.getAbsolutePosition();
         var pos = e.target.getStage().getPointerPosition();
+        const ap = e.target.getAbsolutePosition();
+        const pos = e.target.getStage().getPointerPosition();
         this._anchorDragOffset = {
             x: pos.x - ap.x,
 …
+    }
     _handleMouseMove(e) {
         var x, y, newHypotenuse;
         var anchorNode = this.findOne('.' + this._movingAnchorName);
         var stage = anchorNode.getStage();
+        let x, y, newHypotenuse;
+        const anchorNode = this.findOne('.' + this._movingAnchorName);
+        const stage = anchorNode.getStage();
         stage.setPointersPositions(e);
         const pp = stage.getPointerPosition();
 …
+        }
         if (this._movingAnchorName === 'rotater') {
             var attrs = this._getNodeRect();
+            const attrs = this._getNodeRect();
             x = anchorNode.x() - attrs.width / 2;
             y = -anchorNode.y() + attrs.height / 2;
 …
                 delta -= Math.PI;
+            }
             var oldRotation = Global_1.Konva.getAngle(this.rotation());
+            const oldRotation = Global_1.Konva.getAngle(this.rotation());
             const newRotation = oldRotation + delta;
             const tol = Global_1.Konva.getAngle(this.rotationSnapTolerance());
 …
             return;
+        }
         var shiftBehavior = this.shiftBehavior();
         var keepProportion;
+        const shiftBehavior = this.shiftBehavior();
+        let keepProportion;
         if (shiftBehavior === 'inverted') {
             keepProportion = this.keepRatio() && !e.shiftKey;
 …
         var centeredScaling = this.centeredScaling() || e.altKey;
         if (centeredScaling) {
             var topLeft = this.findOne('.top-left');
             var bottomRight = this.findOne('.bottom-right');
             var topOffsetX = topLeft.x();
             var topOffsetY = topLeft.y();
             var bottomOffsetX = this.getWidth() - bottomRight.x();
             var bottomOffsetY = this.getHeight() - bottomRight.y();
+            const topLeft = this.findOne('.top-left');
+            const bottomRight = this.findOne('.bottom-right');
+            const topOffsetX = topLeft.x();
+            const topOffsetY = topLeft.y();
+            const bottomOffsetX = this.getWidth() - bottomRight.x();
+            const bottomOffsetY = this.getHeight() - bottomRight.y();
             bottomRight.move({
                 x: -topOffsetX,
 …
             });
+        }
         var absPos = this.findOne('.top-left').getAbsolutePosition();
+        const absPos = this.findOne('.top-left').getAbsolutePosition();
         x = absPos.x;
         y = absPos.y;
         var width = this.findOne('.bottom-right').x() - this.findOne('.top-left').x();
         var height = this.findOne('.bottom-right').y() - this.findOne('.top-left').y();
+        const width = this.findOne('.bottom-right').x() - this.findOne('.top-left').x();
+        const height = this.findOne('.bottom-right').y() - this.findOne('.top-left').y();
         this._fitNodesInto({
             x: x,
 …
                 window.removeEventListener('touchend', this._handleMouseUp, true);
+            }
             var node = this.getNode();
+            const node = this.getNode();
             activeTransformersCount--;
             this._fire('transformend', { evt: e, target: node });
 …
+    }
     _fitNodesInto(newAttrs, evt) {
         var oldAttrs = this._getNodeRect();
+        const oldAttrs = this._getNodeRect();
         const minSize = 1;
         if (Util_1.Util._inRange(newAttrs.width, -this.padding() * 2 - minSize, minSize)) {
 …
             return;
+        }
         var t = new Util_1.Transform();
+        const t = new Util_1.Transform();
         t.rotate(Global_1.Konva.getAngle(this.rotation()));
         if (this._movingAnchorName &&
 …
     update() {
         var _a;
         var attrs = this._getNodeRect();
+        const attrs = this._getNodeRect();
         this.rotation(Util_1.Util._getRotation(attrs.rotation));
         var width = attrs.width;
         var height = attrs.height;
         var enabledAnchors = this.enabledAnchors();
         var resizeEnabled = this.resizeEnabled();
         var padding = this.padding();
         var anchorSize = this.anchorSize();
+        const width = attrs.width;
+        const height = attrs.height;
+        const enabledAnchors = this.enabledAnchors();
+        const resizeEnabled = this.resizeEnabled();
+        const padding = this.padding();
+        const anchorSize = this.anchorSize();
         const anchors = this.find('._anchor');
         anchors.forEach((node) => {
 …
         if (this._transforming) {
             this._removeEvents();
             var anchorNode = this.findOne('.' + this._movingAnchorName);
+            const anchorNode = this.findOne('.' + this._movingAnchorName);
             if (anchorNode) {
                 anchorNode.stopDrag();
 …
+    }
     clone(obj) {
         var node = Node_1.Node.prototype.clone.call(this, obj);
+        const node = Node_1.Node.prototype.clone.call(this, obj);
         return node;
+    }

Context Navigation

Legend:

Download in other formats: