@inweb/markup 26.9.2 → 26.9.4

package/dist/markup.js

@@ -1,3 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+// All rights reserved.
+// 
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+// 
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+//   All rights reserved.
+// 
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
 	typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -19,13 +42,12 @@
 	var Global = {};
 
 	var hasRequiredGlobal;
-
 	function requireGlobal () {
 		if (hasRequiredGlobal) return Global;
 		hasRequiredGlobal = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports._registerNode = exports.Konva = exports.glob = undefined;
+			exports._registerNode = exports.Konva = exports.glob = void 0;
 			const PI_OVER_180 = Math.PI / 180;
 			function detectBrowser() {
 			    return (typeof window !== 'undefined' &&
@@ -41,7 +63,7 @@
 			            : {};
 			exports.Konva = {
 			    _global: exports.glob,
-			    version: '9.3.18',
+			    version: '9.3.22',
 			    isBrowser: detectBrowser(),
 			    isUnminified: /param/.test(function (param) { }.toString()),
 			    dblClickWindow: 400,
@@ -73,7 +95,7 @@
 			    },
 			    isTransforming() {
 			        var _a;
-			        return (_a = exports.Konva['Transformer']) === null || _a === undefined ? undefined : _a.isTransforming();
+			        return (_a = exports.Konva['Transformer']) === null || _a === void 0 ? void 0 : _a.isTransforming();
 			    },
 			    isDragReady() {
 			        return !!exports.Konva['DD'].node;
@@ -88,7 +110,7 @@
 			    exports.Konva[NodeClass.prototype.getClassName()] = NodeClass;
 			};
 			exports._registerNode = _registerNode;
-			exports.Konva._injectGlobal(exports.Konva); 
+			exports.Konva._injectGlobal(exports.Konva);
 		} (Global));
 		return Global;
 	}
@@ -96,13 +118,12 @@
 	var Util = {};
 
 	var hasRequiredUtil;
-
 	function requireUtil () {
 		if (hasRequiredUtil) return Util;
 		hasRequiredUtil = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Util = exports.Transform = undefined;
+			exports.Util = exports.Transform = void 0;
 			const Global_1 = requireGlobal();
 			class Transform {
 			    constructor(m = [1, 0, 0, 1, 0, 0]) {
@@ -904,500 +925,162 @@
 			        context.lineTo(0, topLeft);
 			        context.arc(topLeft, topLeft, topLeft, Math.PI, (Math.PI * 3) / 2, false);
 			    },
-			}; 
+			};
 		} (Util));
 		return Util;
 	}
 
 	var Node = {};
 
-	var Factory = {};
-
-	var Validators = {};
+	var Canvas = {};
 
-	var hasRequiredValidators;
+	var Context = {};
 
-	function requireValidators () {
-		if (hasRequiredValidators) return Validators;
-		hasRequiredValidators = 1;
-		Object.defineProperty(Validators, "__esModule", { value: true });
-		Validators.RGBComponent = RGBComponent;
-		Validators.alphaComponent = alphaComponent;
-		Validators.getNumberValidator = getNumberValidator;
-		Validators.getNumberOrArrayOfNumbersValidator = getNumberOrArrayOfNumbersValidator;
-		Validators.getNumberOrAutoValidator = getNumberOrAutoValidator;
-		Validators.getStringValidator = getStringValidator;
-		Validators.getStringOrGradientValidator = getStringOrGradientValidator;
-		Validators.getFunctionValidator = getFunctionValidator;
-		Validators.getNumberArrayValidator = getNumberArrayValidator;
-		Validators.getBooleanValidator = getBooleanValidator;
-		Validators.getComponentValidator = getComponentValidator;
-		const Global_1 = requireGlobal();
+	var hasRequiredContext;
+	function requireContext () {
+		if (hasRequiredContext) return Context;
+		hasRequiredContext = 1;
+		Object.defineProperty(Context, "__esModule", { value: true });
+		Context.HitContext = Context.SceneContext = Context.Context = void 0;
 		const Util_1 = requireUtil();
-		function _formatValue(val) {
-		    if (Util_1.Util._isString(val)) {
-		        return '"' + val + '"';
-		    }
-		    if (Object.prototype.toString.call(val) === '[object Number]') {
-		        return val;
-		    }
-		    if (Util_1.Util._isBoolean(val)) {
-		        return val;
+		const Global_1 = requireGlobal();
+		function simplifyArray(arr) {
+		    const retArr = [], len = arr.length, util = Util_1.Util;
+		    for (let n = 0; n < len; n++) {
+		        let val = arr[n];
+		        if (util._isNumber(val)) {
+		            val = Math.round(val * 1000) / 1000;
+		        }
+		        else if (!util._isString(val)) {
+		            val = val + '';
+		        }
+		        retArr.push(val);
 		    }
-		    return Object.prototype.toString.call(val);
+		    return retArr;
 		}
-		function RGBComponent(val) {
-		    if (val > 255) {
-		        return 255;
+		const COMMA = ',', OPEN_PAREN = '(', CLOSE_PAREN = ')', OPEN_PAREN_BRACKET = '([', CLOSE_BRACKET_PAREN = '])', SEMICOLON = ';', DOUBLE_PAREN = '()', EQUALS = '=', CONTEXT_METHODS = [
+		    'arc',
+		    'arcTo',
+		    'beginPath',
+		    'bezierCurveTo',
+		    'clearRect',
+		    'clip',
+		    'closePath',
+		    'createLinearGradient',
+		    'createPattern',
+		    'createRadialGradient',
+		    'drawImage',
+		    'ellipse',
+		    'fill',
+		    'fillText',
+		    'getImageData',
+		    'createImageData',
+		    'lineTo',
+		    'moveTo',
+		    'putImageData',
+		    'quadraticCurveTo',
+		    'rect',
+		    'roundRect',
+		    'restore',
+		    'rotate',
+		    'save',
+		    'scale',
+		    'setLineDash',
+		    'setTransform',
+		    'stroke',
+		    'strokeText',
+		    'transform',
+		    'translate',
+		];
+		const CONTEXT_PROPERTIES = [
+		    'fillStyle',
+		    'strokeStyle',
+		    'shadowColor',
+		    'shadowBlur',
+		    'shadowOffsetX',
+		    'shadowOffsetY',
+		    'letterSpacing',
+		    'lineCap',
+		    'lineDashOffset',
+		    'lineJoin',
+		    'lineWidth',
+		    'miterLimit',
+		    'direction',
+		    'font',
+		    'textAlign',
+		    'textBaseline',
+		    'globalAlpha',
+		    'globalCompositeOperation',
+		    'imageSmoothingEnabled',
+		];
+		const traceArrMax = 100;
+		let Context$1 = class Context {
+		    constructor(canvas) {
+		        this.canvas = canvas;
+		        if (Global_1.Konva.enableTrace) {
+		            this.traceArr = [];
+		            this._enableTrace();
+		        }
 		    }
-		    else if (val < 0) {
-		        return 0;
+		    fillShape(shape) {
+		        if (shape.fillEnabled()) {
+		            this._fill(shape);
+		        }
 		    }
-		    return Math.round(val);
-		}
-		function alphaComponent(val) {
-		    if (val > 1) {
-		        return 1;
+		    _fill(shape) {
 		    }
-		    else if (val < 0.0001) {
-		        return 0.0001;
+		    strokeShape(shape) {
+		        if (shape.hasStroke()) {
+		            this._stroke(shape);
+		        }
 		    }
-		    return val;
-		}
-		function getNumberValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            if (!Util_1.Util._isNumber(val)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a number.');
-		            }
-		            return val;
-		        };
+		    _stroke(shape) {
 		    }
-		}
-		function getNumberOrArrayOfNumbersValidator(noOfElements) {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            let isNumber = Util_1.Util._isNumber(val);
-		            let isValidArray = Util_1.Util._isArray(val) && val.length == noOfElements;
-		            if (!isNumber && !isValidArray) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a number or Array<number>(' +
-		                    noOfElements +
-		                    ')');
-		            }
-		            return val;
-		        };
+		    fillStrokeShape(shape) {
+		        if (shape.attrs.fillAfterStrokeEnabled) {
+		            this.strokeShape(shape);
+		            this.fillShape(shape);
+		        }
+		        else {
+		            this.fillShape(shape);
+		            this.strokeShape(shape);
+		        }
 		    }
-		}
-		function getNumberOrAutoValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            var isNumber = Util_1.Util._isNumber(val);
-		            var isAuto = val === 'auto';
-		            if (!(isNumber || isAuto)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a number or "auto".');
+		    getTrace(relaxed, rounded) {
+		        let traceArr = this.traceArr, len = traceArr.length, str = '', n, trace, method, args;
+		        for (n = 0; n < len; n++) {
+		            trace = traceArr[n];
+		            method = trace.method;
+		            if (method) {
+		                args = trace.args;
+		                str += method;
+		                if (relaxed) {
+		                    str += DOUBLE_PAREN;
+		                }
+		                else {
+		                    if (Util_1.Util._isArray(args[0])) {
+		                        str += OPEN_PAREN_BRACKET + args.join(COMMA) + CLOSE_BRACKET_PAREN;
+		                    }
+		                    else {
+		                        if (rounded) {
+		                            args = args.map((a) => typeof a === 'number' ? Math.floor(a) : a);
+		                        }
+		                        str += OPEN_PAREN + args.join(COMMA) + CLOSE_PAREN;
+		                    }
+		                }
 		            }
-		            return val;
-		        };
-		    }
-		}
-		function getStringValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            if (!Util_1.Util._isString(val)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a string.');
+		            else {
+		                str += trace.property;
+		                if (!relaxed) {
+		                    str += EQUALS + trace.val;
+		                }
 		            }
-		            return val;
-		        };
+		            str += SEMICOLON;
+		        }
+		        return str;
 		    }
-		}
-		function getStringOrGradientValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            const isString = Util_1.Util._isString(val);
-		            const isGradient = Object.prototype.toString.call(val) === '[object CanvasGradient]' ||
-		                (val && val['addColorStop']);
-		            if (!(isString || isGradient)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a string or a native gradient.');
-		            }
-		            return val;
-		        };
-		    }
-		}
-		function getFunctionValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            if (!Util_1.Util._isFunction(val)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a function.');
-		            }
-		            return val;
-		        };
-		    }
-		}
-		function getNumberArrayValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            const TypedArray = Int8Array ? Object.getPrototypeOf(Int8Array) : null;
-		            if (TypedArray && val instanceof TypedArray) {
-		                return val;
-		            }
-		            if (!Util_1.Util._isArray(val)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a array of numbers.');
-		            }
-		            else {
-		                val.forEach(function (item) {
-		                    if (!Util_1.Util._isNumber(item)) {
-		                        Util_1.Util.warn('"' +
-		                            attr +
-		                            '" attribute has non numeric element ' +
-		                            item +
-		                            '. Make sure that all elements are numbers.');
-		                    }
-		                });
-		            }
-		            return val;
-		        };
-		    }
-		}
-		function getBooleanValidator() {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            var isBool = val === true || val === false;
-		            if (!isBool) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be a boolean.');
-		            }
-		            return val;
-		        };
-		    }
-		}
-		function getComponentValidator(components) {
-		    if (Global_1.Konva.isUnminified) {
-		        return function (val, attr) {
-		            if (val === undefined || val === null) {
-		                return val;
-		            }
-		            if (!Util_1.Util.isObject(val)) {
-		                Util_1.Util.warn(_formatValue(val) +
-		                    ' is a not valid value for "' +
-		                    attr +
-		                    '" attribute. The value should be an object with properties ' +
-		                    components);
-		            }
-		            return val;
-		        };
-		    }
-		}
-		return Validators;
-	}
-
-	var hasRequiredFactory;
-
-	function requireFactory () {
-		if (hasRequiredFactory) return Factory;
-		hasRequiredFactory = 1;
-		(function (exports) {
-			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Factory = undefined;
-			const Util_1 = requireUtil();
-			const Validators_1 = requireValidators();
-			const GET = 'get';
-			const SET = 'set';
-			exports.Factory = {
-			    addGetterSetter(constructor, attr, def, validator, after) {
-			        exports.Factory.addGetter(constructor, attr, def);
-			        exports.Factory.addSetter(constructor, attr, validator, after);
-			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
-			    },
-			    addGetter(constructor, attr, def) {
-			        var method = GET + Util_1.Util._capitalize(attr);
-			        constructor.prototype[method] =
-			            constructor.prototype[method] ||
-			                function () {
-			                    const val = this.attrs[attr];
-			                    return val === undefined ? def : val;
-			                };
-			    },
-			    addSetter(constructor, attr, validator, after) {
-			        var method = SET + Util_1.Util._capitalize(attr);
-			        if (!constructor.prototype[method]) {
-			            exports.Factory.overWriteSetter(constructor, attr, validator, after);
-			        }
-			    },
-			    overWriteSetter(constructor, attr, validator, after) {
-			        var method = SET + Util_1.Util._capitalize(attr);
-			        constructor.prototype[method] = function (val) {
-			            if (validator && val !== undefined && val !== null) {
-			                val = validator.call(this, val, attr);
-			            }
-			            this._setAttr(attr, val);
-			            if (after) {
-			                after.call(this);
-			            }
-			            return this;
-			        };
-			    },
-			    addComponentsGetterSetter(constructor, attr, components, validator, after) {
-			        const len = components.length, capitalize = Util_1.Util._capitalize, getter = GET + capitalize(attr), setter = SET + capitalize(attr);
-			        constructor.prototype[getter] = function () {
-			            const ret = {};
-			            for (let n = 0; n < len; n++) {
-			                const component = components[n];
-			                ret[component] = this.getAttr(attr + capitalize(component));
-			            }
-			            return ret;
-			        };
-			        const basicValidator = (0, Validators_1.getComponentValidator)(components);
-			        constructor.prototype[setter] = function (val) {
-			            const oldVal = this.attrs[attr];
-			            if (validator) {
-			                val = validator.call(this, val, attr);
-			            }
-			            if (basicValidator) {
-			                basicValidator.call(this, val, attr);
-			            }
-			            for (const key in val) {
-			                if (!val.hasOwnProperty(key)) {
-			                    continue;
-			                }
-			                this._setAttr(attr + capitalize(key), val[key]);
-			            }
-			            if (!val) {
-			                components.forEach((component) => {
-			                    this._setAttr(attr + capitalize(component), undefined);
-			                });
-			            }
-			            this._fireChangeEvent(attr, oldVal, val);
-			            if (after) {
-			                after.call(this);
-			            }
-			            return this;
-			        };
-			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
-			    },
-			    addOverloadedGetterSetter(constructor, attr) {
-			        var capitalizedAttr = Util_1.Util._capitalize(attr), setter = SET + capitalizedAttr, getter = GET + capitalizedAttr;
-			        constructor.prototype[attr] = function () {
-			            if (arguments.length) {
-			                this[setter](arguments[0]);
-			                return this;
-			            }
-			            return this[getter]();
-			        };
-			    },
-			    addDeprecatedGetterSetter(constructor, attr, def, validator) {
-			        Util_1.Util.error('Adding deprecated ' + attr);
-			        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);
-			            const val = this.attrs[attr];
-			            return val === undefined ? def : val;
-			        };
-			        exports.Factory.addSetter(constructor, attr, validator, function () {
-			            Util_1.Util.error(message);
-			        });
-			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
-			    },
-			    backCompat(constructor, methods) {
-			        Util_1.Util.each(methods, function (oldMethodName, newMethodName) {
-			            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);
-			                Util_1.Util.error('"' +
-			                    oldMethodName +
-			                    '" method is deprecated and will be removed soon. Use ""' +
-			                    newMethodName +
-			                    '" instead.');
-			            }
-			            constructor.prototype[oldMethodName] = deprecated;
-			            constructor.prototype[oldGetter] = deprecated;
-			            constructor.prototype[oldSetter] = deprecated;
-			        });
-			    },
-			    afterSetFilter() {
-			        this._filterUpToDate = false;
-			    },
-			}; 
-		} (Factory));
-		return Factory;
-	}
-
-	var Canvas = {};
-
-	var Context = {};
-
-	var hasRequiredContext;
-
-	function requireContext () {
-		if (hasRequiredContext) return Context;
-		hasRequiredContext = 1;
-		Object.defineProperty(Context, "__esModule", { value: true });
-		Context.HitContext = Context.SceneContext = Context.Context = undefined;
-		const Util_1 = requireUtil();
-		const Global_1 = requireGlobal();
-		function simplifyArray(arr) {
-		    const retArr = [], len = arr.length, util = Util_1.Util;
-		    for (let n = 0; n < len; n++) {
-		        let val = arr[n];
-		        if (util._isNumber(val)) {
-		            val = Math.round(val * 1000) / 1000;
-		        }
-		        else if (!util._isString(val)) {
-		            val = val + '';
-		        }
-		        retArr.push(val);
-		    }
-		    return retArr;
-		}
-		const COMMA = ',', OPEN_PAREN = '(', CLOSE_PAREN = ')', OPEN_PAREN_BRACKET = '([', CLOSE_BRACKET_PAREN = '])', SEMICOLON = ';', DOUBLE_PAREN = '()', EQUALS = '=', CONTEXT_METHODS = [
-		    'arc',
-		    'arcTo',
-		    'beginPath',
-		    'bezierCurveTo',
-		    'clearRect',
-		    'clip',
-		    'closePath',
-		    'createLinearGradient',
-		    'createPattern',
-		    'createRadialGradient',
-		    'drawImage',
-		    'ellipse',
-		    'fill',
-		    'fillText',
-		    'getImageData',
-		    'createImageData',
-		    'lineTo',
-		    'moveTo',
-		    'putImageData',
-		    'quadraticCurveTo',
-		    'rect',
-		    'roundRect',
-		    'restore',
-		    'rotate',
-		    'save',
-		    'scale',
-		    'setLineDash',
-		    'setTransform',
-		    'stroke',
-		    'strokeText',
-		    'transform',
-		    'translate',
-		];
-		const CONTEXT_PROPERTIES = [
-		    'fillStyle',
-		    'strokeStyle',
-		    'shadowColor',
-		    'shadowBlur',
-		    'shadowOffsetX',
-		    'shadowOffsetY',
-		    'letterSpacing',
-		    'lineCap',
-		    'lineDashOffset',
-		    'lineJoin',
-		    'lineWidth',
-		    'miterLimit',
-		    'direction',
-		    'font',
-		    'textAlign',
-		    'textBaseline',
-		    'globalAlpha',
-		    'globalCompositeOperation',
-		    'imageSmoothingEnabled',
-		];
-		const traceArrMax = 100;
-		let Context$1 = class Context {
-		    constructor(canvas) {
-		        this.canvas = canvas;
-		        if (Global_1.Konva.enableTrace) {
-		            this.traceArr = [];
-		            this._enableTrace();
-		        }
-		    }
-		    fillShape(shape) {
-		        if (shape.fillEnabled()) {
-		            this._fill(shape);
-		        }
-		    }
-		    _fill(shape) {
-		    }
-		    strokeShape(shape) {
-		        if (shape.hasStroke()) {
-		            this._stroke(shape);
-		        }
-		    }
-		    _stroke(shape) {
-		    }
-		    fillStrokeShape(shape) {
-		        if (shape.attrs.fillAfterStrokeEnabled) {
-		            this.strokeShape(shape);
-		            this.fillShape(shape);
-		        }
-		        else {
-		            this.fillShape(shape);
-		            this.strokeShape(shape);
-		        }
-		    }
-		    getTrace(relaxed, rounded) {
-		        let traceArr = this.traceArr, len = traceArr.length, str = '', n, trace, method, args;
-		        for (n = 0; n < len; n++) {
-		            trace = traceArr[n];
-		            method = trace.method;
-		            if (method) {
-		                args = trace.args;
-		                str += method;
-		                if (relaxed) {
-		                    str += DOUBLE_PAREN;
-		                }
-		                else {
-		                    if (Util_1.Util._isArray(args[0])) {
-		                        str += OPEN_PAREN_BRACKET + args.join(COMMA) + CLOSE_BRACKET_PAREN;
-		                    }
-		                    else {
-		                        if (rounded) {
-		                            args = args.map((a) => typeof a === 'number' ? Math.floor(a) : a);
-		                        }
-		                        str += OPEN_PAREN + args.join(COMMA) + CLOSE_PAREN;
-		                    }
-		                }
-		            }
-		            else {
-		                str += trace.property;
-		                if (!relaxed) {
-		                    str += EQUALS + trace.val;
-		                }
-		            }
-		            str += SEMICOLON;
-		        }
-		        return str;
-		    }
-		    clearTrace() {
-		        this.traceArr = [];
+		    clearTrace() {
+		        this.traceArr = [];
 		    }
 		    _trace(str) {
 		        let traceArr = this.traceArr, len;
@@ -1747,7 +1430,7 @@
 		    }
 		    _applyShadow(shape) {
 		        var _a, _b, _c;
-		        const color = (_a = shape.getShadowRGBA()) !== null && _a !== undefined ? _a : 'black', blur = (_b = shape.getShadowBlur()) !== null && _b !== undefined ? _b : 5, offset = (_c = shape.getShadowOffset()) !== null && _c !== undefined ? _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,
 		        }, scale = shape.getAbsoluteScale(), ratio = this.canvas.getPixelRatio(), scaleX = scale.x * ratio, scaleY = scale.y * ratio;
@@ -1801,17 +1484,14 @@
 	}
 
 	var hasRequiredCanvas;
-
 	function requireCanvas () {
 		if (hasRequiredCanvas) return Canvas;
 		hasRequiredCanvas = 1;
 		Object.defineProperty(Canvas, "__esModule", { value: true });
-		Canvas.HitCanvas = Canvas.SceneCanvas = Canvas.Canvas = undefined;
+		Canvas.HitCanvas = Canvas.SceneCanvas = Canvas.Canvas = void 0;
 		const Util_1 = requireUtil();
 		const Context_1 = requireContext();
 		const Global_1 = requireGlobal();
-		const Factory_1 = requireFactory();
-		const Validators_1 = requireValidators();
 		let _pixelRatio;
 		function getDevicePixelRatio() {
 		    if (_pixelRatio) {
@@ -1860,207 +1540,539 @@
 		        this.pixelRatio = pixelRatio;
 		        this.setSize(this.getWidth() / previousRatio, this.getHeight() / previousRatio);
 		    }
-		    setWidth(width) {
-		        this.width = this._canvas.width = width * this.pixelRatio;
-		        this._canvas.style.width = width + 'px';
-		        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
-		        _context.scale(pixelRatio, pixelRatio);
+		    setWidth(width) {
+		        this.width = this._canvas.width = width * this.pixelRatio;
+		        this._canvas.style.width = width + 'px';
+		        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+		        _context.scale(pixelRatio, pixelRatio);
+		    }
+		    setHeight(height) {
+		        this.height = this._canvas.height = height * this.pixelRatio;
+		        this._canvas.style.height = height + 'px';
+		        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
+		        _context.scale(pixelRatio, pixelRatio);
+		    }
+		    getWidth() {
+		        return this.width;
+		    }
+		    getHeight() {
+		        return this.height;
+		    }
+		    setSize(width, height) {
+		        this.setWidth(width || 0);
+		        this.setHeight(height || 0);
+		    }
+		    toDataURL(mimeType, quality) {
+		        try {
+		            return this._canvas.toDataURL(mimeType, quality);
+		        }
+		        catch (e) {
+		            try {
+		                return this._canvas.toDataURL();
+		            }
+		            catch (err) {
+		                Util_1.Util.error('Unable to get data URL. ' +
+		                    err.message +
+		                    ' For more info read https://konvajs.org/docs/posts/Tainted_Canvas.html.');
+		                return '';
+		            }
+		        }
+		    }
+		};
+		Canvas.Canvas = Canvas$1;
+		class SceneCanvas extends Canvas$1 {
+		    constructor(config = { width: 0, height: 0, willReadFrequently: false }) {
+		        super(config);
+		        this.context = new Context_1.SceneContext(this, {
+		            willReadFrequently: config.willReadFrequently,
+		        });
+		        this.setSize(config.width, config.height);
+		    }
+		}
+		Canvas.SceneCanvas = SceneCanvas;
+		class HitCanvas extends Canvas$1 {
+		    constructor(config = { width: 0, height: 0 }) {
+		        super(config);
+		        this.hitCanvas = true;
+		        this.context = new Context_1.HitContext(this);
+		        this.setSize(config.width, config.height);
+		    }
+		}
+		Canvas.HitCanvas = HitCanvas;
+		return Canvas;
+	}
+
+	var DragAndDrop = {};
+
+	var hasRequiredDragAndDrop;
+	function requireDragAndDrop () {
+		if (hasRequiredDragAndDrop) return DragAndDrop;
+		hasRequiredDragAndDrop = 1;
+		(function (exports) {
+			Object.defineProperty(exports, "__esModule", { value: true });
+			exports.DD = void 0;
+			const Global_1 = requireGlobal();
+			const Util_1 = requireUtil();
+			exports.DD = {
+			    get isDragging() {
+			        let flag = false;
+			        exports.DD._dragElements.forEach((elem) => {
+			            if (elem.dragStatus === 'dragging') {
+			                flag = true;
+			            }
+			        });
+			        return flag;
+			    },
+			    justDragged: false,
+			    get node() {
+			        let node;
+			        exports.DD._dragElements.forEach((elem) => {
+			            node = elem.node;
+			        });
+			        return node;
+			    },
+			    _dragElements: new Map(),
+			    _drag(evt) {
+			        const nodesToFireEvents = [];
+			        exports.DD._dragElements.forEach((elem, key) => {
+			            const { node } = elem;
+			            const stage = node.getStage();
+			            stage.setPointersPositions(evt);
+			            if (elem.pointerId === undefined) {
+			                elem.pointerId = Util_1.Util._getFirstPointerId(evt);
+			            }
+			            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
+			            if (!pos) {
+			                return;
+			            }
+			            if (elem.dragStatus !== 'dragging') {
+			                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;
+			                }
+			                node.startDrag({ evt });
+			                if (!node.isDragging()) {
+			                    return;
+			                }
+			            }
+			            node._setDragPosition(evt, elem);
+			            nodesToFireEvents.push(node);
+			        });
+			        nodesToFireEvents.forEach((node) => {
+			            node.fire('dragmove', {
+			                type: 'dragmove',
+			                target: node,
+			                evt: evt,
+			            }, true);
+			        });
+			    },
+			    _endDragBefore(evt) {
+			        const drawNodes = [];
+			        exports.DD._dragElements.forEach((elem) => {
+			            const { node } = elem;
+			            const stage = node.getStage();
+			            if (evt) {
+			                stage.setPointersPositions(evt);
+			            }
+			            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
+			            if (!pos) {
+			                return;
+			            }
+			            if (elem.dragStatus === 'dragging' || elem.dragStatus === 'stopped') {
+			                exports.DD.justDragged = true;
+			                Global_1.Konva._mouseListenClick = false;
+			                Global_1.Konva._touchListenClick = false;
+			                Global_1.Konva._pointerListenClick = false;
+			                elem.dragStatus = 'stopped';
+			            }
+			            const drawNode = elem.node.getLayer() ||
+			                (elem.node instanceof Global_1.Konva['Stage'] && elem.node);
+			            if (drawNode && drawNodes.indexOf(drawNode) === -1) {
+			                drawNodes.push(drawNode);
+			            }
+			        });
+			        drawNodes.forEach((drawNode) => {
+			            drawNode.draw();
+			        });
+			    },
+			    _endDragAfter(evt) {
+			        exports.DD._dragElements.forEach((elem, key) => {
+			            if (elem.dragStatus === 'stopped') {
+			                elem.node.fire('dragend', {
+			                    type: 'dragend',
+			                    target: elem.node,
+			                    evt: evt,
+			                }, true);
+			            }
+			            if (elem.dragStatus !== 'dragging') {
+			                exports.DD._dragElements.delete(key);
+			            }
+			        });
+			    },
+			};
+			if (Global_1.Konva.isBrowser) {
+			    window.addEventListener('mouseup', exports.DD._endDragBefore, true);
+			    window.addEventListener('touchend', exports.DD._endDragBefore, true);
+			    window.addEventListener('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);
+			}
+		} (DragAndDrop));
+		return DragAndDrop;
+	}
+
+	var Factory = {};
+
+	var Validators = {};
+
+	var hasRequiredValidators;
+	function requireValidators () {
+		if (hasRequiredValidators) return Validators;
+		hasRequiredValidators = 1;
+		Object.defineProperty(Validators, "__esModule", { value: true });
+		Validators.RGBComponent = RGBComponent;
+		Validators.alphaComponent = alphaComponent;
+		Validators.getNumberValidator = getNumberValidator;
+		Validators.getNumberOrArrayOfNumbersValidator = getNumberOrArrayOfNumbersValidator;
+		Validators.getNumberOrAutoValidator = getNumberOrAutoValidator;
+		Validators.getStringValidator = getStringValidator;
+		Validators.getStringOrGradientValidator = getStringOrGradientValidator;
+		Validators.getFunctionValidator = getFunctionValidator;
+		Validators.getNumberArrayValidator = getNumberArrayValidator;
+		Validators.getBooleanValidator = getBooleanValidator;
+		Validators.getComponentValidator = getComponentValidator;
+		const Global_1 = requireGlobal();
+		const Util_1 = requireUtil();
+		function _formatValue(val) {
+		    if (Util_1.Util._isString(val)) {
+		        return '"' + val + '"';
+		    }
+		    if (Object.prototype.toString.call(val) === '[object Number]') {
+		        return val;
+		    }
+		    if (Util_1.Util._isBoolean(val)) {
+		        return val;
+		    }
+		    return Object.prototype.toString.call(val);
+		}
+		function RGBComponent(val) {
+		    if (val > 255) {
+		        return 255;
+		    }
+		    else if (val < 0) {
+		        return 0;
+		    }
+		    return Math.round(val);
+		}
+		function alphaComponent(val) {
+		    if (val > 1) {
+		        return 1;
+		    }
+		    else if (val < 0.0001) {
+		        return 0.0001;
+		    }
+		    return val;
+		}
+		function getNumberValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            if (!Util_1.Util._isNumber(val)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a number.');
+		            }
+		            return val;
+		        };
+		    }
+		}
+		function getNumberOrArrayOfNumbersValidator(noOfElements) {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            let isNumber = Util_1.Util._isNumber(val);
+		            let isValidArray = Util_1.Util._isArray(val) && val.length == noOfElements;
+		            if (!isNumber && !isValidArray) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a number or Array<number>(' +
+		                    noOfElements +
+		                    ')');
+		            }
+		            return val;
+		        };
 		    }
-		    setHeight(height) {
-		        this.height = this._canvas.height = height * this.pixelRatio;
-		        this._canvas.style.height = height + 'px';
-		        const pixelRatio = this.pixelRatio, _context = this.getContext()._context;
-		        _context.scale(pixelRatio, pixelRatio);
+		}
+		function getNumberOrAutoValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            const isNumber = Util_1.Util._isNumber(val);
+		            const isAuto = val === 'auto';
+		            if (!(isNumber || isAuto)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a number or "auto".');
+		            }
+		            return val;
+		        };
 		    }
-		    getWidth() {
-		        return this.width;
+		}
+		function getStringValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            if (!Util_1.Util._isString(val)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a string.');
+		            }
+		            return val;
+		        };
 		    }
-		    getHeight() {
-		        return this.height;
+		}
+		function getStringOrGradientValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            const isString = Util_1.Util._isString(val);
+		            const isGradient = Object.prototype.toString.call(val) === '[object CanvasGradient]' ||
+		                (val && val['addColorStop']);
+		            if (!(isString || isGradient)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a string or a native gradient.');
+		            }
+		            return val;
+		        };
 		    }
-		    setSize(width, height) {
-		        this.setWidth(width || 0);
-		        this.setHeight(height || 0);
+		}
+		function getFunctionValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            if (!Util_1.Util._isFunction(val)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a function.');
+		            }
+		            return val;
+		        };
 		    }
-		    toDataURL(mimeType, quality) {
-		        try {
-		            return this._canvas.toDataURL(mimeType, quality);
-		        }
-		        catch (e) {
-		            try {
-		                return this._canvas.toDataURL();
+		}
+		function getNumberArrayValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            const TypedArray = Int8Array ? Object.getPrototypeOf(Int8Array) : null;
+		            if (TypedArray && val instanceof TypedArray) {
+		                return val;
 		            }
-		            catch (err) {
-		                Util_1.Util.error('Unable to get data URL. ' +
-		                    err.message +
-		                    ' For more info read https://konvajs.org/docs/posts/Tainted_Canvas.html.');
-		                return '';
+		            if (!Util_1.Util._isArray(val)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a array of numbers.');
 		            }
-		        }
+		            else {
+		                val.forEach(function (item) {
+		                    if (!Util_1.Util._isNumber(item)) {
+		                        Util_1.Util.warn('"' +
+		                            attr +
+		                            '" attribute has non numeric element ' +
+		                            item +
+		                            '. Make sure that all elements are numbers.');
+		                    }
+		                });
+		            }
+		            return val;
+		        };
 		    }
-		};
-		Canvas.Canvas = Canvas$1;
-		Factory_1.Factory.addGetterSetter(Canvas$1, 'pixelRatio', undefined, (0, Validators_1.getNumberValidator)());
-		class SceneCanvas extends Canvas$1 {
-		    constructor(config = { width: 0, height: 0, willReadFrequently: false }) {
-		        super(config);
-		        this.context = new Context_1.SceneContext(this, {
-		            willReadFrequently: config.willReadFrequently,
-		        });
-		        this.setSize(config.width, config.height);
+		}
+		function getBooleanValidator() {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            const isBool = val === true || val === false;
+		            if (!isBool) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be a boolean.');
+		            }
+		            return val;
+		        };
 		    }
 		}
-		Canvas.SceneCanvas = SceneCanvas;
-		class HitCanvas extends Canvas$1 {
-		    constructor(config = { width: 0, height: 0 }) {
-		        super(config);
-		        this.hitCanvas = true;
-		        this.context = new Context_1.HitContext(this);
-		        this.setSize(config.width, config.height);
+		function getComponentValidator(components) {
+		    if (Global_1.Konva.isUnminified) {
+		        return function (val, attr) {
+		            if (val === undefined || val === null) {
+		                return val;
+		            }
+		            if (!Util_1.Util.isObject(val)) {
+		                Util_1.Util.warn(_formatValue(val) +
+		                    ' is a not valid value for "' +
+		                    attr +
+		                    '" attribute. The value should be an object with properties ' +
+		                    components);
+		            }
+		            return val;
+		        };
 		    }
 		}
-		Canvas.HitCanvas = HitCanvas;
-		return Canvas;
+		return Validators;
 	}
 
-	var DragAndDrop = {};
-
-	var hasRequiredDragAndDrop;
-
-	function requireDragAndDrop () {
-		if (hasRequiredDragAndDrop) return DragAndDrop;
-		hasRequiredDragAndDrop = 1;
+	var hasRequiredFactory;
+	function requireFactory () {
+		if (hasRequiredFactory) return Factory;
+		hasRequiredFactory = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.DD = undefined;
-			const Global_1 = requireGlobal();
+			exports.Factory = void 0;
 			const Util_1 = requireUtil();
-			exports.DD = {
-			    get isDragging() {
-			        let flag = false;
-			        exports.DD._dragElements.forEach((elem) => {
-			            if (elem.dragStatus === 'dragging') {
-			                flag = true;
-			            }
-			        });
-			        return flag;
+			const Validators_1 = requireValidators();
+			const GET = 'get';
+			const SET = 'set';
+			exports.Factory = {
+			    addGetterSetter(constructor, attr, def, validator, after) {
+			        exports.Factory.addGetter(constructor, attr, def);
+			        exports.Factory.addSetter(constructor, attr, validator, after);
+			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
 			    },
-			    justDragged: false,
-			    get node() {
-			        let node;
-			        exports.DD._dragElements.forEach((elem) => {
-			            node = elem.node;
-			        });
-			        return node;
+			    addGetter(constructor, attr, def) {
+			        const method = GET + Util_1.Util._capitalize(attr);
+			        constructor.prototype[method] =
+			            constructor.prototype[method] ||
+			                function () {
+			                    const val = this.attrs[attr];
+			                    return val === undefined ? def : val;
+			                };
 			    },
-			    _dragElements: new Map(),
-			    _drag(evt) {
-			        const nodesToFireEvents = [];
-			        exports.DD._dragElements.forEach((elem, key) => {
-			            const { node } = elem;
-			            const stage = node.getStage();
-			            stage.setPointersPositions(evt);
-			            if (elem.pointerId === undefined) {
-			                elem.pointerId = Util_1.Util._getFirstPointerId(evt);
+			    addSetter(constructor, attr, validator, after) {
+			        const method = SET + Util_1.Util._capitalize(attr);
+			        if (!constructor.prototype[method]) {
+			            exports.Factory.overWriteSetter(constructor, attr, validator, after);
+			        }
+			    },
+			    overWriteSetter(constructor, attr, validator, after) {
+			        const method = SET + Util_1.Util._capitalize(attr);
+			        constructor.prototype[method] = function (val) {
+			            if (validator && val !== undefined && val !== null) {
+			                val = validator.call(this, val, attr);
+			            }
+			            this._setAttr(attr, val);
+			            if (after) {
+			                after.call(this);
+			            }
+			            return this;
+			        };
+			    },
+			    addComponentsGetterSetter(constructor, attr, components, validator, after) {
+			        const len = components.length, capitalize = Util_1.Util._capitalize, getter = GET + capitalize(attr), setter = SET + capitalize(attr);
+			        constructor.prototype[getter] = function () {
+			            const ret = {};
+			            for (let n = 0; n < len; n++) {
+			                const component = components[n];
+			                ret[component] = this.getAttr(attr + capitalize(component));
+			            }
+			            return ret;
+			        };
+			        const basicValidator = (0, Validators_1.getComponentValidator)(components);
+			        constructor.prototype[setter] = function (val) {
+			            const oldVal = this.attrs[attr];
+			            if (validator) {
+			                val = validator.call(this, val, attr);
 			            }
-			            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
-			            if (!pos) {
-			                return;
+			            if (basicValidator) {
+			                basicValidator.call(this, val, attr);
 			            }
-			            if (elem.dragStatus !== 'dragging') {
-			                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;
-			                }
-			                node.startDrag({ evt });
-			                if (!node.isDragging()) {
-			                    return;
+			            for (const key in val) {
+			                if (!val.hasOwnProperty(key)) {
+			                    continue;
 			                }
+			                this._setAttr(attr + capitalize(key), val[key]);
 			            }
-			            node._setDragPosition(evt, elem);
-			            nodesToFireEvents.push(node);
-			        });
-			        nodesToFireEvents.forEach((node) => {
-			            node.fire('dragmove', {
-			                type: 'dragmove',
-			                target: node,
-			                evt: evt,
-			            }, true);
-			        });
-			    },
-			    _endDragBefore(evt) {
-			        const drawNodes = [];
-			        exports.DD._dragElements.forEach((elem) => {
-			            const { node } = elem;
-			            const stage = node.getStage();
-			            if (evt) {
-			                stage.setPointersPositions(evt);
-			            }
-			            const pos = stage._changedPointerPositions.find((pos) => pos.id === elem.pointerId);
-			            if (!pos) {
-			                return;
+			            if (!val) {
+			                components.forEach((component) => {
+			                    this._setAttr(attr + capitalize(component), undefined);
+			                });
 			            }
-			            if (elem.dragStatus === 'dragging' || elem.dragStatus === 'stopped') {
-			                exports.DD.justDragged = true;
-			                Global_1.Konva._mouseListenClick = false;
-			                Global_1.Konva._touchListenClick = false;
-			                Global_1.Konva._pointerListenClick = false;
-			                elem.dragStatus = 'stopped';
+			            this._fireChangeEvent(attr, oldVal, val);
+			            if (after) {
+			                after.call(this);
 			            }
-			            const drawNode = elem.node.getLayer() ||
-			                (elem.node instanceof Global_1.Konva['Stage'] && elem.node);
-			            if (drawNode && drawNodes.indexOf(drawNode) === -1) {
-			                drawNodes.push(drawNode);
+			            return this;
+			        };
+			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
+			    },
+			    addOverloadedGetterSetter(constructor, attr) {
+			        const capitalizedAttr = Util_1.Util._capitalize(attr), setter = SET + capitalizedAttr, getter = GET + capitalizedAttr;
+			        constructor.prototype[attr] = function () {
+			            if (arguments.length) {
+			                this[setter](arguments[0]);
+			                return this;
 			            }
+			            return this[getter]();
+			        };
+			    },
+			    addDeprecatedGetterSetter(constructor, attr, def, validator) {
+			        Util_1.Util.error('Adding deprecated ' + attr);
+			        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);
+			            const val = this.attrs[attr];
+			            return val === undefined ? def : val;
+			        };
+			        exports.Factory.addSetter(constructor, attr, validator, function () {
+			            Util_1.Util.error(message);
 			        });
-			        drawNodes.forEach((drawNode) => {
-			            drawNode.draw();
-			        });
+			        exports.Factory.addOverloadedGetterSetter(constructor, attr);
 			    },
-			    _endDragAfter(evt) {
-			        exports.DD._dragElements.forEach((elem, key) => {
-			            if (elem.dragStatus === 'stopped') {
-			                elem.node.fire('dragend', {
-			                    type: 'dragend',
-			                    target: elem.node,
-			                    evt: evt,
-			                }, true);
-			            }
-			            if (elem.dragStatus !== 'dragging') {
-			                exports.DD._dragElements.delete(key);
+			    backCompat(constructor, methods) {
+			        Util_1.Util.each(methods, function (oldMethodName, newMethodName) {
+			            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);
+			                Util_1.Util.error('"' +
+			                    oldMethodName +
+			                    '" method is deprecated and will be removed soon. Use ""' +
+			                    newMethodName +
+			                    '" instead.');
 			            }
+			            constructor.prototype[oldMethodName] = deprecated;
+			            constructor.prototype[oldGetter] = deprecated;
+			            constructor.prototype[oldSetter] = deprecated;
 			        });
 			    },
+			    afterSetFilter() {
+			        this._filterUpToDate = false;
+			    },
 			};
-			if (Global_1.Konva.isBrowser) {
-			    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);
-			} 
-		} (DragAndDrop));
-		return DragAndDrop;
+		} (Factory));
+		return Factory;
 	}
 
 	var hasRequiredNode;
-
 	function requireNode () {
 		if (hasRequiredNode) return Node;
 		hasRequiredNode = 1;
 		Object.defineProperty(Node, "__esModule", { value: true });
-		Node.Node = undefined;
-		const Util_1 = requireUtil();
-		const Factory_1 = requireFactory();
+		Node.Node = void 0;
 		const Canvas_1 = requireCanvas();
-		const Global_1 = requireGlobal();
 		const DragAndDrop_1 = requireDragAndDrop();
+		const Factory_1 = requireFactory();
+		const Global_1 = requireGlobal();
+		const Util_1 = requireUtil();
 		const Validators_1 = requireValidators();
-		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', 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', POINTERENTER = 'pointerenter', POINTERLEAVE = 'pointerleave', TOUCHENTER = 'touchenter', TOUCHLEAVE = 'touchleave', SET = 'set', SHAPE = 'Shape', SPACE = ' ', STAGE = 'stage', TRANSFORM = 'transform', UPPER_STAGE = 'Stage', VISIBLE = 'visible', TRANSFORM_CHANGE_STR = [
 		    'xChange.konva',
 		    'yChange.konva',
 		    'scaleXChange.konva',
@@ -2139,8 +2151,8 @@
 		    }
 		    clearCache() {
 		        if (this._cache.has(CANVAS)) {
-		            const { scene, filter, hit } = this._cache.get(CANVAS);
-		            Util_1.Util.releaseCanvas(scene, filter, hit);
+		            const { scene, filter, hit, buffer } = this._cache.get(CANVAS);
+		            Util_1.Util.releaseCanvas(scene, filter, hit, buffer);
 		            this._cache.delete(CANVAS);
 		        }
 		        this._clearSelfAndDescendantCache();
@@ -2184,6 +2196,11 @@
 		            width: width,
 		            height: height,
 		        }), sceneContext = cachedSceneCanvas.getContext(), hitContext = cachedHitCanvas.getContext();
+		        const bufferCanvas = new Canvas_1.SceneCanvas({
+		            width: cachedSceneCanvas.width / cachedSceneCanvas.pixelRatio + Math.abs(x),
+		            height: cachedSceneCanvas.height / cachedSceneCanvas.pixelRatio + Math.abs(y),
+		            pixelRatio: cachedSceneCanvas.pixelRatio,
+		        }), bufferContext = bufferCanvas.getContext();
 		        cachedHitCanvas.isCache = true;
 		        cachedSceneCanvas.isCache = true;
 		        this._cache.delete(CANVAS);
@@ -2194,12 +2211,16 @@
 		        }
 		        sceneContext.save();
 		        hitContext.save();
+		        bufferContext.save();
 		        sceneContext.translate(-x, -y);
 		        hitContext.translate(-x, -y);
+		        bufferContext.translate(-x, -y);
+		        bufferCanvas.x = x;
+		        bufferCanvas.y = y;
 		        this._isUnderCache = true;
 		        this._clearSelfAndDescendantCache(ABSOLUTE_OPACITY);
 		        this._clearSelfAndDescendantCache(ABSOLUTE_SCALE);
-		        this.drawScene(cachedSceneCanvas, this);
+		        this.drawScene(cachedSceneCanvas, this, bufferCanvas);
 		        this.drawHit(cachedHitCanvas, this);
 		        this._isUnderCache = false;
 		        sceneContext.restore();
@@ -2218,6 +2239,7 @@
 		            scene: cachedSceneCanvas,
 		            filter: cachedFilterCanvas,
 		            hit: cachedHitCanvas,
+		            buffer: bufferCanvas,
 		            x: x,
 		            y: y,
 		        });
@@ -2310,23 +2332,22 @@
 		        return sceneCanvas;
 		    }
 		    on(evtStr, handler) {
-		        this._cache && this._cache.delete(ALL_LISTENERS);
+		        if (this._cache) {
+		            this._cache.delete(ALL_LISTENERS);
+		        }
 		        if (arguments.length === 3) {
 		            return this._delegate.apply(this, arguments);
 		        }
-		        let events = evtStr.split(SPACE), len = events.length, n, event, parts, baseEvent, name;
-		        for (n = 0; n < len; n++) {
-		            event = events[n];
-		            parts = event.split('.');
-		            baseEvent = parts[0];
-		            name = parts[1] || '';
+		        const events = evtStr.split(SPACE);
+		        for (let n = 0; n < events.length; n++) {
+		            const event = events[n];
+		            const parts = event.split('.');
+		            const baseEvent = parts[0];
+		            const name = parts[1] || '';
 		            if (!this.eventListeners[baseEvent]) {
 		                this.eventListeners[baseEvent] = [];
 		            }
-		            this.eventListeners[baseEvent].push({
-		                name: name,
-		                handler: handler,
-		            });
+		            this.eventListeners[baseEvent].push({ name, handler });
 		        }
 		        return this;
 		    }
@@ -2958,7 +2979,7 @@
 		        var _a, _b;
 		        const m = this._cache.get(TRANSFORM) || new Util_1.Transform();
 		        m.reset();
-		        const x = this.x(), y = this.y(), rotation = Global_1.Konva.getAngle(this.rotation()), scaleX = (_a = this.attrs.scaleX) !== null && _a !== undefined ? _a : 1, scaleY = (_b = this.attrs.scaleY) !== null && _b !== undefined ? _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);
 		        }
@@ -3160,7 +3181,7 @@
 		    _requestDraw() {
 		        if (Global_1.Konva.autoDrawEnabled) {
 		            const drawNode = this.getLayer() || this.getStage();
-		            drawNode === null || drawNode === undefined ? undefined : drawNode.batchDraw();
+		            drawNode === null || drawNode === void 0 ? void 0 : drawNode.batchDraw();
 		        }
 		    }
 		    _setAttr(key, val) {
@@ -3194,14 +3215,22 @@
 		        if (evt && this.nodeType === SHAPE) {
 		            evt.target = this;
 		        }
-		        const shouldStop = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
+		        const nonBubbling = [
+		            MOUSEENTER,
+		            MOUSELEAVE,
+		            POINTERENTER,
+		            POINTERLEAVE,
+		            TOUCHENTER,
+		            TOUCHLEAVE,
+		        ];
+		        const shouldStop = nonBubbling.indexOf(eventType) !== -1 &&
 		            ((compareShape &&
 		                (this === compareShape ||
 		                    (this.isAncestorOf && this.isAncestorOf(compareShape)))) ||
 		                (this.nodeType === 'Stage' && !compareShape));
 		        if (!shouldStop) {
 		            this._fire(eventType, evt);
-		            const stopBubble = (eventType === MOUSEENTER || eventType === MOUSELEAVE) &&
+		            const stopBubble = nonBubbling.indexOf(eventType) !== -1 &&
 		                compareShape &&
 		                compareShape.isAncestorOf &&
 		                compareShape.isAncestorOf(this) &&
@@ -3221,13 +3250,13 @@
 		    }
 		    _getProtoListeners(eventType) {
 		        var _a, _b, _c;
-		        const allListeners = (_a = this._cache.get(ALL_LISTENERS)) !== null && _a !== undefined ? _a : {};
-		        let events = allListeners === null || allListeners === undefined ? undefined : allListeners[eventType];
+		        const allListeners = (_a = this._cache.get(ALL_LISTENERS)) !== null && _a !== void 0 ? _a : {};
+		        let events = allListeners === null || allListeners === void 0 ? void 0 : allListeners[eventType];
 		        if (events === undefined) {
 		            events = [];
 		            let obj = Object.getPrototypeOf(this);
 		            while (obj) {
-		                const hierarchyEvents = (_c = (_b = obj.eventListeners) === null || _b === undefined ? undefined : _b[eventType]) !== null && _c !== undefined ? _c : [];
+		                const hierarchyEvents = (_c = (_b = obj.eventListeners) === null || _b === void 0 ? void 0 : _b[eventType]) !== null && _c !== void 0 ? _c : [];
 		                events.push(...hierarchyEvents);
 		                obj = Object.getPrototypeOf(obj);
 		            }
@@ -3242,13 +3271,13 @@
 		        evt.type = eventType;
 		        const topListeners = this._getProtoListeners(eventType);
 		        if (topListeners) {
-		            for (var i = 0; i < topListeners.length; i++) {
+		            for (let i = 0; i < topListeners.length; i++) {
 		                topListeners[i].handler.call(this, evt);
 		            }
 		        }
 		        const selfListeners = this.eventListeners[eventType];
 		        if (selfListeners) {
-		            for (var i = 0; i < selfListeners.length; i++) {
+		            for (let i = 0; i < selfListeners.length; i++) {
 		                selfListeners[i].handler.call(this, evt);
 		            }
 		        }
@@ -3488,12 +3517,11 @@
 	var Container = {};
 
 	var hasRequiredContainer;
-
 	function requireContainer () {
 		if (hasRequiredContainer) return Container;
 		hasRequiredContainer = 1;
 		Object.defineProperty(Container, "__esModule", { value: true });
-		Container.Container = undefined;
+		Container.Container = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -3503,17 +3531,11 @@
 		        this.children = [];
 		    }
 		    getChildren(filterFunc) {
-		        if (!filterFunc) {
-		            return this.children || [];
-		        }
 		        const children = this.children || [];
-		        const results = [];
-		        children.forEach(function (child) {
-		            if (filterFunc(child)) {
-		                results.push(child);
-		            }
-		        });
-		        return results;
+		        if (filterFunc) {
+		            return children.filter(filterFunc);
+		        }
+		        return children;
 		    }
 		    hasChildren() {
 		        return this.getChildren().length > 0;
@@ -3650,13 +3672,13 @@
 		        if (this.isCached()) {
 		            return;
 		        }
-		        (_a = this.children) === null || _a === undefined ? undefined : _a.forEach(function (node) {
+		        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (node) {
 		            node._clearSelfAndDescendantCache(attr);
 		        });
 		    }
 		    _setChildrenIndices() {
 		        var _a;
-		        (_a = this.children) === null || _a === undefined ? undefined : _a.forEach(function (child, n) {
+		        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child, n) {
 		            child.index = n;
 		        });
 		        this._requestDraw();
@@ -3727,7 +3749,7 @@
 		            context.save();
 		            context._applyGlobalCompositeOperation(this);
 		        }
-		        (_a = this.children) === null || _a === undefined ? undefined : _a.forEach(function (child) {
+		        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
 		            child[drawMethod](canvas, top, bufferCanvas);
 		        });
 		        if (hasComposition) {
@@ -3749,7 +3771,7 @@
 		            height: 0,
 		        };
 		        const that = this;
-		        (_a = this.children) === null || _a === undefined ? undefined : _a.forEach(function (child) {
+		        (_a = this.children) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
 		            if (!child.visible()) {
 		                return;
 		            }
@@ -3825,7 +3847,6 @@
 	var PointerEvents = {};
 
 	var hasRequiredPointerEvents;
-
 	function requirePointerEvents () {
 		if (hasRequiredPointerEvents) return PointerEvents;
 		hasRequiredPointerEvents = 1;
@@ -3875,13 +3896,12 @@
 	}
 
 	var hasRequiredStage;
-
 	function requireStage () {
 		if (hasRequiredStage) return Stage;
 		hasRequiredStage = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Stage = exports.stages = undefined;
+			exports.Stage = exports.stages = void 0;
 			const Util_1 = requireUtil();
 			const Factory_1 = requireFactory();
 			const Container_1 = requireContainer();
@@ -3907,6 +3927,7 @@
 			    [POINTERMOVE, '_pointermove'],
 			    [POINTERUP, '_pointerup'],
 			    [POINTERCANCEL, '_pointercancel'],
+			    [POINTERLEAVE, '_pointerleave'],
 			    [LOSTPOINTERCAPTURE, '_lostpointercapture'],
 			];
 			const EVENTS_MAP = {
@@ -4008,12 +4029,12 @@
 			    }
 			    setContainer(container) {
 			        if (typeof container === STRING) {
+			            let id;
 			            if (container.charAt(0) === '.') {
 			                const className = container.slice(1);
 			                container = document.getElementsByClassName(className)[0];
 			            }
 			            else {
-			                var id;
 			                if (container.charAt(0) !== '#') {
 			                    id = container;
 			                }
@@ -4582,7 +4603,7 @@
 			            stage.batchDraw();
 			        });
 			    });
-			} 
+			}
 		} (Stage));
 		return Stage;
 	}
@@ -4592,13 +4613,12 @@
 	var Shape = {};
 
 	var hasRequiredShape;
-
 	function requireShape () {
 		if (hasRequiredShape) return Shape;
 		hasRequiredShape = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Shape = exports.shapes = undefined;
+			exports.Shape = exports.shapes = void 0;
 			const Global_1 = requireGlobal();
 			const Util_1 = requireUtil();
 			const Factory_1 = requireFactory();
@@ -4831,7 +4851,7 @@
 			    }
 			    _useBufferCanvas(forceFill) {
 			        var _a;
-			        const perfectDrawEnabled = (_a = this.attrs.perfectDrawEnabled) !== null && _a !== undefined ? _a : true;
+			        const perfectDrawEnabled = (_a = this.attrs.perfectDrawEnabled) !== null && _a !== void 0 ? _a : true;
 			        if (!perfectDrawEnabled) {
 			            return false;
 			        }
@@ -4916,8 +4936,8 @@
 			    }
 			    drawScene(can, top, bufferCanvas) {
 			        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 canvas = can || layer.getCanvas(), context = canvas.getContext(), cachedCanvas = this._getCanvasCache(), drawFunc = this.getSceneFunc(), hasShadow = this.hasShadow();
+			        let stage;
 			        const cachingSelf = top === this;
 			        if (!this.isVisible() && !cachingSelf) {
 			            return this;
@@ -4934,14 +4954,14 @@
 			            return this;
 			        }
 			        context.save();
-			        if (this._useBufferCanvas() && !skipBuffer) {
+			        if (this._useBufferCanvas() && true) {
 			            stage = this.getStage();
 			            const bc = bufferCanvas || stage.bufferCanvas;
-			            bufferContext = bc.getContext();
+			            const bufferContext = bc.getContext();
 			            bufferContext.clear();
 			            bufferContext.save();
 			            bufferContext._applyLineJoin(this);
-			            var o = this.getAbsoluteTransform(top).getMatrix();
+			            const o = this.getAbsoluteTransform(top).getMatrix();
 			            bufferContext.transform(o[0], o[1], o[2], o[3], o[4], o[5]);
 			            drawFunc.call(this, bufferContext, this);
 			            bufferContext.restore();
@@ -4951,12 +4971,12 @@
 			            }
 			            context._applyOpacity(this);
 			            context._applyGlobalCompositeOperation(this);
-			            context.drawImage(bc._canvas, 0, 0, bc.width / ratio, bc.height / ratio);
+			            context.drawImage(bc._canvas, bc.x || 0, bc.y || 0, bc.width / ratio, bc.height / ratio);
 			        }
 			        else {
 			            context._applyLineJoin(this);
 			            if (!cachingSelf) {
-			                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]);
 			                context._applyOpacity(this);
 			                context._applyGlobalCompositeOperation(this);
@@ -5140,18 +5160,17 @@
 			    drawHitFunc: 'hitFunc',
 			    getDrawHitFunc: 'getHitFunc',
 			    setDrawHitFunc: 'setHitFunc',
-			}); 
+			});
 		} (Shape));
 		return Shape;
 	}
 
 	var hasRequiredLayer;
-
 	function requireLayer () {
 		if (hasRequiredLayer) return Layer;
 		hasRequiredLayer = 1;
 		Object.defineProperty(Layer, "__esModule", { value: true });
-		Layer.Layer = undefined;
+		Layer.Layer = void 0;
 		const Util_1 = requireUtil();
 		const Container_1 = requireContainer();
 		const Node_1 = requireNode();
@@ -5396,7 +5415,7 @@
 		        }
 		        return {};
 		    }
-		    drawScene(can, top) {
+		    drawScene(can, top, bufferCanvas) {
 		        const layer = this.getLayer(), canvas = can || (layer && layer.getCanvas());
 		        this._fire(BEFORE_DRAW, {
 		            node: this,
@@ -5404,7 +5423,7 @@
 		        if (this.clearBeforeDraw()) {
 		            canvas.getContext().clear();
 		        }
-		        Container_1.Container.prototype.drawScene.call(this, canvas, top);
+		        Container_1.Container.prototype.drawScene.call(this, canvas, top, bufferCanvas);
 		        this._fire(DRAW, {
 		            node: this,
 		        });
@@ -5464,12 +5483,11 @@
 	var FastLayer = {};
 
 	var hasRequiredFastLayer;
-
 	function requireFastLayer () {
 		if (hasRequiredFastLayer) return FastLayer;
 		hasRequiredFastLayer = 1;
 		Object.defineProperty(FastLayer, "__esModule", { value: true });
-		FastLayer.FastLayer = undefined;
+		FastLayer.FastLayer = void 0;
 		const Util_1 = requireUtil();
 		const Layer_1 = requireLayer();
 		const Global_1 = requireGlobal();
@@ -5489,12 +5507,11 @@
 	var Group = {};
 
 	var hasRequiredGroup;
-
 	function requireGroup () {
 		if (hasRequiredGroup) return Group;
 		hasRequiredGroup = 1;
 		Object.defineProperty(Group, "__esModule", { value: true });
-		Group.Group = undefined;
+		Group.Group = void 0;
 		const Util_1 = requireUtil();
 		const Container_1 = requireContainer();
 		const Global_1 = requireGlobal();
@@ -5515,12 +5532,11 @@
 	var Animation = {};
 
 	var hasRequiredAnimation;
-
 	function requireAnimation () {
 		if (hasRequiredAnimation) return Animation;
 		hasRequiredAnimation = 1;
 		Object.defineProperty(Animation, "__esModule", { value: true });
-		Animation.Animation = undefined;
+		Animation.Animation = void 0;
 		const Global_1 = requireGlobal();
 		const Util_1 = requireUtil();
 		const now = (function () {
@@ -5670,13 +5686,12 @@
 	var Tween = {};
 
 	var hasRequiredTween;
-
 	function requireTween () {
 		if (hasRequiredTween) return Tween;
 		hasRequiredTween = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Easings = exports.Tween = undefined;
+			exports.Easings = exports.Tween = void 0;
 			const Util_1 = requireUtil();
 			const Animation_1 = requireAnimation();
 			const Node_1 = requireNode();
@@ -6032,10 +6047,21 @@
 			    destroy() {
 			        const nodeId = this.node._id, thisId = this._id, attrs = Tween.tweens[nodeId];
 			        this.pause();
+			        if (this.anim) {
+			            this.anim.stop();
+			        }
 			        for (const key in attrs) {
 			            delete Tween.tweens[nodeId][key];
 			        }
 			        delete Tween.attrs[nodeId][thisId];
+			        if (Tween.tweens[nodeId]) {
+			            if (Object.keys(Tween.tweens[nodeId]).length === 0) {
+			                delete Tween.tweens[nodeId];
+			            }
+			            if (Object.keys(Tween.attrs[nodeId]).length === 0) {
+			                delete Tween.attrs[nodeId];
+			            }
+			        }
 			    }
 			}
 			exports.Tween = Tween;
@@ -6197,19 +6223,18 @@
 			    Linear(t, b, c, d) {
 			        return (c * t) / d + b;
 			    },
-			}; 
+			};
 		} (Tween));
 		return Tween;
 	}
 
 	var hasRequired_CoreInternals;
-
 	function require_CoreInternals () {
 		if (hasRequired_CoreInternals) return _CoreInternals;
 		hasRequired_CoreInternals = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.Konva = undefined;
+			exports.Konva = void 0;
 			const Global_1 = requireGlobal();
 			const Util_1 = requireUtil();
 			const Node_1 = requireNode();
@@ -6243,7 +6268,7 @@
 			    Context: Context_1.Context,
 			    Canvas: Canvas_1.Canvas,
 			});
-			exports.default = exports.Konva; 
+			exports.default = exports.Konva;
 		} (_CoreInternals));
 		return _CoreInternals;
 	}
@@ -6251,12 +6276,11 @@
 	var Arc = {};
 
 	var hasRequiredArc;
-
 	function requireArc () {
 		if (hasRequiredArc) return Arc;
 		hasRequiredArc = 1;
 		Object.defineProperty(Arc, "__esModule", { value: true });
-		Arc.Arc = undefined;
+		Arc.Arc = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Global_1 = requireGlobal();
@@ -6307,7 +6331,12 @@
 		Arc.Arc = Arc$1;
 		Arc$1.prototype._centroid = true;
 		Arc$1.prototype.className = 'Arc';
-		Arc$1.prototype._attrsAffectingSize = ['innerRadius', 'outerRadius'];
+		Arc$1.prototype._attrsAffectingSize = [
+		    'innerRadius',
+		    'outerRadius',
+		    'angle',
+		    'clockwise',
+		];
 		(0, Global_2._registerNode)(Arc$1);
 		Factory_1.Factory.addGetterSetter(Arc$1, 'innerRadius', 0, (0, Validators_1.getNumberValidator)());
 		Factory_1.Factory.addGetterSetter(Arc$1, 'outerRadius', 0, (0, Validators_1.getNumberValidator)());
@@ -6321,12 +6350,11 @@
 	var Line = {};
 
 	var hasRequiredLine;
-
 	function requireLine () {
 		if (hasRequiredLine) return Line;
 		hasRequiredLine = 1;
 		Object.defineProperty(Line, "__esModule", { value: true });
-		Line.Line = undefined;
+		Line.Line = void 0;
 		const Factory_1 = requireFactory();
 		const Global_1 = requireGlobal();
 		const Shape_1 = requireShape();
@@ -6359,15 +6387,16 @@
 		        });
 		    }
 		    _sceneFunc(context) {
-		        let points = this.points(), length = points.length, tension = this.tension(), closed = this.closed(), bezier = this.bezier(), tp, len, n;
+		        const points = this.points(), length = points.length, tension = this.tension(), closed = this.closed(), bezier = this.bezier();
 		        if (!length) {
 		            return;
 		        }
+		        let n = 0;
 		        context.beginPath();
 		        context.moveTo(points[0], points[1]);
 		        if (tension !== 0 && length > 4) {
-		            tp = this.getTensionPoints();
-		            len = tp.length;
+		            const tp = this.getTensionPoints();
+		            const len = tp.length;
 		            n = closed ? 0 : 4;
 		            if (!closed) {
 		                context.quadraticCurveTo(tp[0], tp[1], tp[2], tp[3]);
@@ -6491,13 +6520,12 @@
 	var BezierFunctions = {};
 
 	var hasRequiredBezierFunctions;
-
 	function requireBezierFunctions () {
 		if (hasRequiredBezierFunctions) return BezierFunctions;
 		hasRequiredBezierFunctions = 1;
 		(function (exports) {
 			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.t2length = exports.getQuadraticArcLength = exports.getCubicArcLength = exports.binomialCoefficients = exports.cValues = exports.tValues = undefined;
+			exports.t2length = exports.getQuadraticArcLength = exports.getCubicArcLength = exports.binomialCoefficients = exports.cValues = exports.tValues = void 0;
 			exports.tValues = [
 			    [],
 			    [],
@@ -7284,21 +7312,20 @@
 			    }
 			    return t;
 			};
-			exports.t2length = t2length; 
+			exports.t2length = t2length;
 		} (BezierFunctions));
 		return BezierFunctions;
 	}
 
 	var hasRequiredPath;
-
 	function requirePath () {
 		if (hasRequiredPath) return Path;
 		hasRequiredPath = 1;
 		Object.defineProperty(Path, "__esModule", { value: true });
-		Path.Path = undefined;
+		Path.Path = void 0;
 		const Factory_1 = requireFactory();
-		const Shape_1 = requireShape();
 		const Global_1 = requireGlobal();
+		const Shape_1 = requireShape();
 		const BezierFunctions_1 = requireBezierFunctions();
 		let Path$1 = class Path extends Shape_1.Shape {
 		    constructor(config) {
@@ -7335,10 +7362,10 @@
 		                    context.quadraticCurveTo(p[0], p[1], p[2], p[3]);
 		                    break;
 		                case 'A':
-		                    var cx = p[0], cy = p[1], rx = p[2], ry = p[3], theta = p[4], dTheta = p[5], psi = p[6], fs = p[7];
-		                    var r = rx > ry ? rx : ry;
-		                    var scaleX = rx > ry ? 1 : rx / ry;
-		                    var scaleY = rx > ry ? ry / rx : 1;
+		                    const cx = p[0], cy = p[1], rx = p[2], ry = p[3], theta = p[4], dTheta = p[5], psi = p[6], fs = p[7];
+		                    const r = rx > ry ? rx : ry;
+		                    const scaleX = rx > ry ? 1 : rx / ry;
+		                    const scaleY = rx > ry ? ry / rx : 1;
 		                    context.translate(cx, cy);
 		                    context.rotate(psi);
 		                    context.scale(scaleX, scaleY);
@@ -7451,11 +7478,20 @@
 		            };
 		        }
 		        if (length < 0.01) {
-		            points = dataArray[i].points.slice(0, 2);
-		            return {
-		                x: points[0],
-		                y: points[1],
-		            };
+		            const cmd = dataArray[i].command;
+		            if (cmd === 'M') {
+		                points = dataArray[i].points.slice(0, 2);
+		                return {
+		                    x: points[0],
+		                    y: points[1],
+		                };
+		            }
+		            else {
+		                return {
+		                    x: dataArray[i].start.x,
+		                    y: dataArray[i].start.y,
+		                };
+		            }
 		        }
 		        const cp = dataArray[i];
 		        const p = cp.points;
@@ -7471,15 +7507,16 @@
 		                    return (0, BezierFunctions_1.getQuadraticArcLength)([cp.start.x, p[0], p[2]], [cp.start.y, p[1], p[3]], i);
 		                }), cp.start.x, cp.start.y, p[0], p[1], p[2], p[3]);
 		            case 'A':
-		                var cx = p[0], cy = p[1], rx = p[2], ry = p[3], theta = p[4], dTheta = p[5], psi = p[6];
+		                const cx = p[0], cy = p[1], rx = p[2], ry = p[3], dTheta = p[5], psi = p[6];
+		                let theta = p[4];
 		                theta += (dTheta * length) / cp.pathLength;
 		                return Path.getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi);
 		        }
 		        return null;
 		    }
 		    static getPointOnLine(dist, P1x, P1y, P2x, P2y, fromX, fromY) {
-		        fromX = fromX !== null && fromX !== undefined ? fromX : P1x;
-		        fromY = fromY !== null && fromY !== undefined ? fromY : P1y;
+		        fromX = fromX !== null && fromX !== void 0 ? fromX : P1x;
+		        fromY = fromY !== null && fromY !== void 0 ? fromY : P1y;
 		        const len = this.getLineLength(P1x, P1y, P2x, P2y);
 		        if (len < 1e-10) {
 		            return { x: P1x, y: P1y };
@@ -7517,10 +7554,7 @@
 		        }
 		        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,
-		            y: y,
-		        };
+		        return { x, y };
 		    }
 		    static getPointOnQuadraticBezier(pct, P1x, P1y, P2x, P2y, P3x, P3y) {
 		        function QB1(t) {
@@ -7534,10 +7568,7 @@
 		        }
 		        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,
-		            y: y,
-		        };
+		        return { x, y };
 		    }
 		    static getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi) {
 		        const cosPsi = Math.cos(psi), sinPsi = Math.sin(psi);
@@ -7578,7 +7609,7 @@
 		            'A',
 		        ];
 		        cs = cs.replace(new RegExp(' ', 'g'), ',');
-		        for (var n = 0; n < cc.length; n++) {
+		        for (let n = 0; n < cc.length; n++) {
 		            cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);
 		        }
 		        const arr = cs.split('|');
@@ -7588,7 +7619,7 @@
 		        let cpy = 0;
 		        const re = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/gi;
 		        let match;
-		        for (n = 1; n < arr.length; n++) {
+		        for (let n = 1; n < arr.length; n++) {
 		            let str = arr[n];
 		            let c = str.charAt(0);
 		            str = str.slice(1);
@@ -7617,8 +7648,8 @@
 		                let cmd = '';
 		                let points = [];
 		                const startX = cpx, startY = cpy;
-		                var prevCmd, ctlPtx, ctlPty;
-		                var rx, ry, psi, fa, fs, x1, y1;
+		                let prevCmd, ctlPtx, ctlPty;
+		                let rx, ry, psi, fa, fs, x1, y1;
 		                switch (c) {
 		                    case 'l':
 		                        cpx += p.shift();
@@ -7632,8 +7663,8 @@
 		                        points.push(cpx, cpy);
 		                        break;
 		                    case 'm':
-		                        var dx = p.shift();
-		                        var dy = p.shift();
+		                        const dx = p.shift();
+		                        const dy = p.shift();
 		                        cpx += dx;
 		                        cpy += dy;
 		                        cmd = 'M';
@@ -7816,10 +7847,10 @@
 		                return (0, BezierFunctions_1.getQuadraticArcLength)([x, points[0], points[2]], [y, points[1], points[3]], 1);
 		            case 'A':
 		                len = 0.0;
-		                var start = points[4];
-		                var dTheta = points[5];
-		                var end = points[4] + dTheta;
-		                var inc = Math.PI / 180.0;
+		                const start = points[4];
+		                const dTheta = points[5];
+		                const end = points[4] + dTheta;
+		                let inc = Math.PI / 180.0;
 		                if (Math.abs(start - end) < inc) {
 		                    inc = Math.abs(start - end);
 		                }
@@ -7903,12 +7934,11 @@
 	}
 
 	var hasRequiredArrow;
-
 	function requireArrow () {
 		if (hasRequiredArrow) return Arrow;
 		hasRequiredArrow = 1;
 		Object.defineProperty(Arrow, "__esModule", { value: true });
-		Arrow.Arrow = undefined;
+		Arrow.Arrow = void 0;
 		const Factory_1 = requireFactory();
 		const Line_1 = requireLine();
 		const Validators_1 = requireValidators();
@@ -8015,12 +8045,11 @@
 	var Circle = {};
 
 	var hasRequiredCircle;
-
 	function requireCircle () {
 		if (hasRequiredCircle) return Circle;
 		hasRequiredCircle = 1;
 		Object.defineProperty(Circle, "__esModule", { value: true });
-		Circle.Circle = undefined;
+		Circle.Circle = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Validators_1 = requireValidators();
@@ -8061,12 +8090,11 @@
 	var Ellipse = {};
 
 	var hasRequiredEllipse;
-
 	function requireEllipse () {
 		if (hasRequiredEllipse) return Ellipse;
 		hasRequiredEllipse = 1;
 		Object.defineProperty(Ellipse, "__esModule", { value: true });
-		Ellipse.Ellipse = undefined;
+		Ellipse.Ellipse = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Validators_1 = requireValidators();
@@ -8111,12 +8139,11 @@
 	var Image$1 = {};
 
 	var hasRequiredImage;
-
 	function requireImage () {
 		if (hasRequiredImage) return Image$1;
 		hasRequiredImage = 1;
 		Object.defineProperty(Image$1, "__esModule", { value: true });
-		Image$1.Image = undefined;
+		Image$1.Image = void 0;
 		const Util_1 = requireUtil();
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
@@ -8125,7 +8152,11 @@
 		class Image extends Shape_1.Shape {
 		    constructor(attrs) {
 		        super(attrs);
-		        this.on('imageChange.konva', () => {
+		        this._loadListener = () => {
+		            this._requestDraw();
+		        };
+		        this.on('imageChange.konva', (props) => {
+		            this._removeImageLoad(props.oldVal);
 		            this._setImageLoad();
 		        });
 		        this._setImageLoad();
@@ -8139,11 +8170,19 @@
 		            return;
 		        }
 		        if (image && image['addEventListener']) {
-		            image['addEventListener']('load', () => {
-		                this._requestDraw();
-		            });
+		            image['addEventListener']('load', this._loadListener);
+		        }
+		    }
+		    _removeImageLoad(image) {
+		        if (image && image['removeEventListener']) {
+		            image['removeEventListener']('load', this._loadListener);
 		        }
 		    }
+		    destroy() {
+		        this._removeImageLoad(this.image());
+		        super.destroy();
+		        return this;
+		    }
 		    _useBufferCanvas() {
 		        const hasCornerRadius = !!this.cornerRadius();
 		        const hasShadow = this.hasShadow();
@@ -8207,11 +8246,11 @@
 		    }
 		    getWidth() {
 		        var _a, _b;
-		        return (_a = this.attrs.width) !== null && _a !== undefined ? _a : (_b = this.image()) === null || _b === undefined ? undefined : _b.width;
+		        return (_a = this.attrs.width) !== null && _a !== void 0 ? _a : (_b = this.image()) === null || _b === void 0 ? void 0 : _b.width;
 		    }
 		    getHeight() {
 		        var _a, _b;
-		        return (_a = this.attrs.height) !== null && _a !== undefined ? _a : (_b = this.image()) === null || _b === undefined ? undefined : _b.height;
+		        return (_a = this.attrs.height) !== null && _a !== void 0 ? _a : (_b = this.image()) === null || _b === void 0 ? void 0 : _b.height;
 		    }
 		    static fromURL(url, callback, onError = null) {
 		        const img = Util_1.Util.createImageElement();
@@ -8242,12 +8281,11 @@
 	var Label = {};
 
 	var hasRequiredLabel;
-
 	function requireLabel () {
 		if (hasRequiredLabel) return Label;
 		hasRequiredLabel = 1;
 		Object.defineProperty(Label, "__esModule", { value: true });
-		Label.Tag = Label.Label = undefined;
+		Label.Tag = Label.Label = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Group_1 = requireGroup();
@@ -8429,12 +8467,11 @@
 	var Rect = {};
 
 	var hasRequiredRect;
-
 	function requireRect () {
 		if (hasRequiredRect) return Rect;
 		hasRequiredRect = 1;
 		Object.defineProperty(Rect, "__esModule", { value: true });
-		Rect.Rect = undefined;
+		Rect.Rect = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Global_1 = requireGlobal();
@@ -8464,12 +8501,11 @@
 	var RegularPolygon = {};
 
 	var hasRequiredRegularPolygon;
-
 	function requireRegularPolygon () {
 		if (hasRequiredRegularPolygon) return RegularPolygon;
 		hasRequiredRegularPolygon = 1;
 		Object.defineProperty(RegularPolygon, "__esModule", { value: true });
-		RegularPolygon.RegularPolygon = undefined;
+		RegularPolygon.RegularPolygon = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Validators_1 = requireValidators();
@@ -8542,12 +8578,11 @@
 	var Ring = {};
 
 	var hasRequiredRing;
-
 	function requireRing () {
 		if (hasRequiredRing) return Ring;
 		hasRequiredRing = 1;
 		Object.defineProperty(Ring, "__esModule", { value: true });
-		Ring.Ring = undefined;
+		Ring.Ring = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Validators_1 = requireValidators();
@@ -8588,12 +8623,11 @@
 	var Sprite = {};
 
 	var hasRequiredSprite;
-
 	function requireSprite () {
 		if (hasRequiredSprite) return Sprite;
 		hasRequiredSprite = 1;
 		Object.defineProperty(Sprite, "__esModule", { value: true });
-		Sprite.Sprite = undefined;
+		Sprite.Sprite = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Animation_1 = requireAnimation();
@@ -8709,12 +8743,11 @@
 	var Star = {};
 
 	var hasRequiredStar;
-
 	function requireStar () {
 		if (hasRequiredStar) return Star;
 		hasRequiredStar = 1;
 		Object.defineProperty(Star, "__esModule", { value: true });
-		Star.Star = undefined;
+		Star.Star = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Validators_1 = requireValidators();
@@ -8760,12 +8793,11 @@
 	var Text = {};
 
 	var hasRequiredText;
-
 	function requireText () {
 		if (hasRequiredText) return Text;
 		hasRequiredText = 1;
 		Object.defineProperty(Text, "__esModule", { value: true });
-		Text.Text = undefined;
+		Text.Text = void 0;
 		Text.stringToArray = stringToArray;
 		const Util_1 = requireUtil();
 		const Factory_1 = requireFactory();
@@ -8878,8 +8910,6 @@
 		                (metrics.fontBoundingBoxAscent - metrics.fontBoundingBoxDescent) / 2 +
 		                    lineHeightPx / 2;
 		        }
-		        var lineTranslateX = 0;
-		        var lineTranslateY = 0;
 		        if (direction === RTL) {
 		            context.setAttr('direction', direction);
 		        }
@@ -8894,9 +8924,9 @@
 		        }
 		        context.translate(padding, alignY + padding);
 		        for (n = 0; n < textArrLen; n++) {
-		            var lineTranslateX = 0;
-		            var lineTranslateY = 0;
-		            var obj = textArr[n], text = obj.text, width = obj.width, lastLine = obj.lastInParagraph, spacesNumber, lineWidth;
+		            let lineTranslateX = 0;
+		            let lineTranslateY = 0;
+		            const obj = textArr[n], text = obj.text, width = obj.width, lastLine = obj.lastInParagraph;
 		            context.save();
 		            if (align === RIGHT) {
 		                lineTranslateX += totalWidth - width - padding * 2;
@@ -8913,9 +8943,7 @@
 		                const x = lineTranslateX;
 		                const y = translateY + lineTranslateY + yOffset;
 		                context.moveTo(x, y);
-		                spacesNumber = text.split(' ').length - 1;
-		                lineWidth =
-		                    align === JUSTIFY && !lastLine ? totalWidth - padding * 2 : width;
+		                const lineWidth = align === JUSTIFY && !lastLine ? totalWidth - padding * 2 : width;
 		                context.lineTo(x + Math.round(lineWidth), y);
 		                context.lineWidth = fontSize / 15;
 		                const gradient = this._getLinearGradient();
@@ -8928,9 +8956,7 @@
 		                context.beginPath();
 		                const yOffset = Global_1.Konva._fixTextRendering ? -Math.round(fontSize / 4) : 0;
 		                context.moveTo(lineTranslateX, translateY + lineTranslateY + yOffset);
-		                spacesNumber = text.split(' ').length - 1;
-		                lineWidth =
-		                    align === JUSTIFY && !lastLine ? totalWidth - padding * 2 : width;
+		                const lineWidth = align === JUSTIFY && !lastLine ? totalWidth - padding * 2 : width;
 		                context.lineTo(lineTranslateX + Math.round(lineWidth), translateY + lineTranslateY + yOffset);
 		                context.lineWidth = fontSize / 15;
 		                const gradient = this._getLinearGradient();
@@ -8939,7 +8965,7 @@
 		                context.restore();
 		            }
 		            if (direction !== RTL && (letterSpacing !== 0 || align === JUSTIFY)) {
-		                spacesNumber = text.split(' ').length - 1;
+		                const spacesNumber = text.split(' ').length - 1;
 		                const array = stringToArray(text);
 		                for (let li = 0; li < array.length; li++) {
 		                    const letter = array[li];
@@ -9011,17 +9037,17 @@
 		        _context.restore();
 		        const scaleFactor = fontSize / 100;
 		        return {
-		            actualBoundingBoxAscent: (_a = metrics.actualBoundingBoxAscent) !== null && _a !== undefined ? _a : 71.58203125 * scaleFactor,
-		            actualBoundingBoxDescent: (_b = metrics.actualBoundingBoxDescent) !== null && _b !== undefined ? _b : 0,
-		            actualBoundingBoxLeft: (_c = metrics.actualBoundingBoxLeft) !== null && _c !== undefined ? _c : -7.421875 * scaleFactor,
-		            actualBoundingBoxRight: (_d = metrics.actualBoundingBoxRight) !== null && _d !== undefined ? _d : 75.732421875 * scaleFactor,
-		            alphabeticBaseline: (_e = metrics.alphabeticBaseline) !== null && _e !== undefined ? _e : 0,
-		            emHeightAscent: (_f = metrics.emHeightAscent) !== null && _f !== undefined ? _f : 100 * scaleFactor,
-		            emHeightDescent: (_g = metrics.emHeightDescent) !== null && _g !== undefined ? _g : -20 * scaleFactor,
-		            fontBoundingBoxAscent: (_h = metrics.fontBoundingBoxAscent) !== null && _h !== undefined ? _h : 91 * scaleFactor,
-		            fontBoundingBoxDescent: (_j = metrics.fontBoundingBoxDescent) !== null && _j !== undefined ? _j : 21 * scaleFactor,
-		            hangingBaseline: (_k = metrics.hangingBaseline) !== null && _k !== undefined ? _k : 72.80000305175781 * scaleFactor,
-		            ideographicBaseline: (_l = metrics.ideographicBaseline) !== null && _l !== undefined ? _l : -21 * scaleFactor,
+		            actualBoundingBoxAscent: (_a = metrics.actualBoundingBoxAscent) !== null && _a !== void 0 ? _a : 71.58203125 * scaleFactor,
+		            actualBoundingBoxDescent: (_b = metrics.actualBoundingBoxDescent) !== null && _b !== void 0 ? _b : 0,
+		            actualBoundingBoxLeft: (_c = metrics.actualBoundingBoxLeft) !== null && _c !== void 0 ? _c : -7.421875 * scaleFactor,
+		            actualBoundingBoxRight: (_d = metrics.actualBoundingBoxRight) !== null && _d !== void 0 ? _d : 75.732421875 * scaleFactor,
+		            alphabeticBaseline: (_e = metrics.alphabeticBaseline) !== null && _e !== void 0 ? _e : 0,
+		            emHeightAscent: (_f = metrics.emHeightAscent) !== null && _f !== void 0 ? _f : 100 * scaleFactor,
+		            emHeightDescent: (_g = metrics.emHeightDescent) !== null && _g !== void 0 ? _g : -20 * scaleFactor,
+		            fontBoundingBoxAscent: (_h = metrics.fontBoundingBoxAscent) !== null && _h !== void 0 ? _h : 91 * scaleFactor,
+		            fontBoundingBoxDescent: (_j = metrics.fontBoundingBoxDescent) !== null && _j !== void 0 ? _j : 21 * scaleFactor,
+		            hangingBaseline: (_k = metrics.hangingBaseline) !== null && _k !== void 0 ? _k : 72.80000305175781 * scaleFactor,
+		            ideographicBaseline: (_l = metrics.ideographicBaseline) !== null && _l !== void 0 ? _l : -21 * scaleFactor,
 		            width: metrics.width,
 		            height: fontSize,
 		        };
@@ -9065,8 +9091,14 @@
 		                while (line.length > 0) {
 		                    let low = 0, high = stringToArray(line).length, match = '', matchWidth = 0;
 		                    while (low < high) {
-		                        const mid = (low + high) >>> 1, lineArray = stringToArray(line), substr = lineArray.slice(0, mid + 1).join(''), substrWidth = this._getTextWidth(substr) + additionalWidth;
-		                        if (substrWidth <= maxWidth) {
+		                        const mid = (low + high) >>> 1, lineArray = stringToArray(line), substr = lineArray.slice(0, mid + 1).join(''), substrWidth = this._getTextWidth(substr);
+		                        const shouldConsiderEllipsis = shouldAddEllipsis &&
+		                            fixedHeight &&
+		                            currentHeightPx + lineHeightPx > maxHeightPx;
+		                        const effectiveWidth = shouldConsiderEllipsis
+		                            ? substrWidth + additionalWidth
+		                            : substrWidth;
+		                        if (effectiveWidth <= maxWidth) {
 		                            low = mid + 1;
 		                            match = substr;
 		                            matchWidth = substrWidth;
@@ -9208,12 +9240,11 @@
 	var TextPath = {};
 
 	var hasRequiredTextPath;
-
 	function requireTextPath () {
 		if (hasRequiredTextPath) return TextPath;
 		hasRequiredTextPath = 1;
 		Object.defineProperty(TextPath, "__esModule", { value: true });
-		TextPath.TextPath = undefined;
+		TextPath.TextPath = void 0;
 		const Util_1 = requireUtil();
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
@@ -9458,12 +9489,11 @@
 	var Transformer = {};
 
 	var hasRequiredTransformer;
-
 	function requireTransformer () {
 		if (hasRequiredTransformer) return Transformer;
 		hasRequiredTransformer = 1;
 		Object.defineProperty(Transformer, "__esModule", { value: true });
-		Transformer.Transformer = undefined;
+		Transformer.Transformer = void 0;
 		const Util_1 = requireUtil();
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
@@ -9660,10 +9690,12 @@
 		                    this.update();
 		                }
 		            };
-		            const additionalEvents = node._attrsAffectingSize
-		                .map((prop) => prop + 'Change.' + this._getEventNamespace())
-		                .join(' ');
-		            node.on(additionalEvents, onChange);
+		            if (node._attrsAffectingSize.length) {
+		                const additionalEvents = node._attrsAffectingSize
+		                    .map((prop) => prop + 'Change.' + this._getEventNamespace())
+		                    .join(' ');
+		                node.on(additionalEvents, onChange);
+		            }
 		            node.on(TRANSFORM_CHANGE_STR.map((e) => e + `.${this._getEventNamespace()}`).join(' '), onChange);
 		            node.on(`absoluteTransformChange.${this._getEventNamespace()}`, onChange);
 		            this._proxyDrag(node);
@@ -9982,10 +10014,10 @@
 		        else {
 		            keepProportion = this.keepRatio() || e.shiftKey;
 		        }
-		        var centeredScaling = this.centeredScaling() || e.altKey;
+		        let centeredScaling = this.centeredScaling() || e.altKey;
 		        if (this._movingAnchorName === 'top-left') {
 		            if (keepProportion) {
-		                var comparePoint = centeredScaling
+		                const comparePoint = centeredScaling
 		                    ? {
 		                        x: this.width() / 2,
 		                        y: this.height() / 2,
@@ -9996,8 +10028,8 @@
 		                    };
 		                newHypotenuse = Math.sqrt(Math.pow(comparePoint.x - anchorNode.x(), 2) +
 		                    Math.pow(comparePoint.y - anchorNode.y(), 2));
-		                var reverseX = this.findOne('.top-left').x() > comparePoint.x ? -1 : 1;
-		                var reverseY = this.findOne('.top-left').y() > comparePoint.y ? -1 : 1;
+		                const reverseX = this.findOne('.top-left').x() > comparePoint.x ? -1 : 1;
+		                const reverseY = this.findOne('.top-left').y() > comparePoint.y ? -1 : 1;
 		                x = newHypotenuse * this.cos * reverseX;
 		                y = newHypotenuse * this.sin * reverseY;
 		                this.findOne('.top-left').x(comparePoint.x - x);
@@ -10009,7 +10041,7 @@
 		        }
 		        else if (this._movingAnchorName === 'top-right') {
 		            if (keepProportion) {
-		                var comparePoint = centeredScaling
+		                const comparePoint = centeredScaling
 		                    ? {
 		                        x: this.width() / 2,
 		                        y: this.height() / 2,
@@ -10020,8 +10052,8 @@
 		                    };
 		                newHypotenuse = Math.sqrt(Math.pow(anchorNode.x() - comparePoint.x, 2) +
 		                    Math.pow(comparePoint.y - anchorNode.y(), 2));
-		                var reverseX = this.findOne('.top-right').x() < comparePoint.x ? -1 : 1;
-		                var reverseY = this.findOne('.top-right').y() > comparePoint.y ? -1 : 1;
+		                const reverseX = this.findOne('.top-right').x() < comparePoint.x ? -1 : 1;
+		                const reverseY = this.findOne('.top-right').y() > comparePoint.y ? -1 : 1;
 		                x = newHypotenuse * this.cos * reverseX;
 		                y = newHypotenuse * this.sin * reverseY;
 		                this.findOne('.top-right').x(comparePoint.x + x);
@@ -10039,7 +10071,7 @@
 		        }
 		        else if (this._movingAnchorName === 'bottom-left') {
 		            if (keepProportion) {
-		                var comparePoint = centeredScaling
+		                const comparePoint = centeredScaling
 		                    ? {
 		                        x: this.width() / 2,
 		                        y: this.height() / 2,
@@ -10050,8 +10082,8 @@
 		                    };
 		                newHypotenuse = Math.sqrt(Math.pow(comparePoint.x - anchorNode.x(), 2) +
 		                    Math.pow(anchorNode.y() - comparePoint.y, 2));
-		                var reverseX = comparePoint.x < anchorNode.x() ? -1 : 1;
-		                var reverseY = anchorNode.y() < comparePoint.y ? -1 : 1;
+		                const reverseX = comparePoint.x < anchorNode.x() ? -1 : 1;
+		                const reverseY = anchorNode.y() < comparePoint.y ? -1 : 1;
 		                x = newHypotenuse * this.cos * reverseX;
 		                y = newHypotenuse * this.sin * reverseY;
 		                anchorNode.x(comparePoint.x - x);
@@ -10066,7 +10098,7 @@
 		        }
 		        else if (this._movingAnchorName === 'bottom-right') {
 		            if (keepProportion) {
-		                var comparePoint = centeredScaling
+		                const comparePoint = centeredScaling
 		                    ? {
 		                        x: this.width() / 2,
 		                        y: this.height() / 2,
@@ -10077,8 +10109,8 @@
 		                    };
 		                newHypotenuse = Math.sqrt(Math.pow(anchorNode.x() - comparePoint.x, 2) +
 		                    Math.pow(anchorNode.y() - comparePoint.y, 2));
-		                var reverseX = this.findOne('.bottom-right').x() < comparePoint.x ? -1 : 1;
-		                var reverseY = this.findOne('.bottom-right').y() < comparePoint.y ? -1 : 1;
+		                const reverseX = this.findOne('.bottom-right').x() < comparePoint.x ? -1 : 1;
+		                const reverseY = this.findOne('.bottom-right').y() < comparePoint.y ? -1 : 1;
 		                x = newHypotenuse * this.cos * reverseX;
 		                y = newHypotenuse * this.sin * reverseY;
 		                this.findOne('.bottom-right').x(comparePoint.x + x);
@@ -10089,7 +10121,7 @@
 		            console.error(new Error('Wrong position argument of selection resizer: ' +
 		                this._movingAnchorName));
 		        }
-		        var centeredScaling = this.centeredScaling() || e.altKey;
+		        centeredScaling = this.centeredScaling() || e.altKey;
 		        if (centeredScaling) {
 		            const topLeft = this.findOne('.top-left');
 		            const bottomRight = this.findOne('.bottom-right');
@@ -10138,12 +10170,12 @@
 		            const node = this.getNode();
 		            activeTransformersCount--;
 		            this._fire('transformend', { evt: e, target: node });
-		            (_a = this.getLayer()) === null || _a === undefined ? undefined : _a.batchDraw();
+		            (_a = this.getLayer()) === null || _a === void 0 ? void 0 : _a.batchDraw();
 		            if (node) {
 		                this._nodes.forEach((target) => {
 		                    var _a;
 		                    target._fire('transformend', { evt: e, target });
-		                    (_a = target.getLayer()) === null || _a === undefined ? undefined : _a.batchDraw();
+		                    (_a = target.getLayer()) === null || _a === void 0 ? void 0 : _a.batchDraw();
 		                });
 		            }
 		            this._movingAnchorName = null;
@@ -10256,7 +10288,7 @@
 		                .multiply(localTransform);
 		            const attrs = newLocalTransform.decompose();
 		            node.setAttrs(attrs);
-		            (_a = node.getLayer()) === null || _a === undefined ? undefined : _a.batchDraw();
+		            (_a = node.getLayer()) === null || _a === void 0 ? void 0 : _a.batchDraw();
 		        });
 		        this.rotation(Util_1.Util._getRotation(newAttrs.rotation));
 		        this._nodes.forEach((node) => {
@@ -10371,7 +10403,7 @@
 		                styleFunc(node);
 		            });
 		        }
-		        (_a = this.getLayer()) === null || _a === undefined ? undefined : _a.batchDraw();
+		        (_a = this.getLayer()) === null || _a === void 0 ? void 0 : _a.batchDraw();
 		    }
 		    isTransforming() {
 		        return this._transforming;
@@ -10473,12 +10505,11 @@
 	var Wedge = {};
 
 	var hasRequiredWedge;
-
 	function requireWedge () {
 		if (hasRequiredWedge) return Wedge;
 		hasRequiredWedge = 1;
 		Object.defineProperty(Wedge, "__esModule", { value: true });
-		Wedge.Wedge = undefined;
+		Wedge.Wedge = void 0;
 		const Factory_1 = requireFactory();
 		const Shape_1 = requireShape();
 		const Global_1 = requireGlobal();
@@ -10524,12 +10555,11 @@
 	var Blur = {};
 
 	var hasRequiredBlur;
-
 	function requireBlur () {
 		if (hasRequiredBlur) return Blur;
 		hasRequiredBlur = 1;
 		Object.defineProperty(Blur, "__esModule", { value: true });
-		Blur.Blur = undefined;
+		Blur.Blur = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -10577,10 +10607,10 @@
 		];
 		function filterGaussBlurRGBA(imageData, 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 p, 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;
 		    const div = radius + radius + 1, widthMinus1 = width - 1, heightMinus1 = height - 1, radiusPlus1 = radius + 1, sumFactor = (radiusPlus1 * (radiusPlus1 + 1)) / 2, stackStart = new BlurStack(), mul_sum = mul_table[radius], shg_sum = shg_table[radius];
 		    let stackEnd = null, stack = stackStart, stackIn = null, stackOut = null;
-		    for (i = 1; i < div; i++) {
+		    for (let i = 1; i < div; i++) {
 		        stack = stack.next = new BlurStack();
 		        if (i === radiusPlus1) {
 		            stackEnd = stack;
@@ -10588,7 +10618,7 @@
 		    }
 		    stack.next = stackStart;
 		    yw = yi = 0;
-		    for (y = 0; y < height; y++) {
+		    for (let y = 0; y < height; y++) {
 		        r_in_sum =
 		            g_in_sum =
 		                b_in_sum =
@@ -10607,14 +10637,14 @@
 		        b_sum += sumFactor * pb;
 		        a_sum += sumFactor * pa;
 		        stack = stackStart;
-		        for (i = 0; i < radiusPlus1; i++) {
+		        for (let i = 0; i < radiusPlus1; i++) {
 		            stack.r = pr;
 		            stack.g = pg;
 		            stack.b = pb;
 		            stack.a = pa;
 		            stack = stack.next;
 		        }
-		        for (i = 1; i < radiusPlus1; i++) {
+		        for (let i = 1; i < radiusPlus1; i++) {
 		            p = yi + ((widthMinus1 < i ? widthMinus1 : i) << 2);
 		            r_sum += (stack.r = pr = pixels[p]) * (rbs = radiusPlus1 - i);
 		            g_sum += (stack.g = pg = pixels[p + 1]) * rbs;
@@ -10628,7 +10658,7 @@
 		        }
 		        stackIn = stackStart;
 		        stackOut = stackEnd;
-		        for (x = 0; x < width; x++) {
+		        for (let x = 0; x < width; x++) {
 		            pixels[yi + 3] = pa = (a_sum * mul_sum) >> shg_sum;
 		            if (pa !== 0) {
 		                pa = 255 / pa;
@@ -10670,7 +10700,7 @@
 		        }
 		        yw += width;
 		    }
-		    for (x = 0; x < width; x++) {
+		    for (let x = 0; x < width; x++) {
 		        g_in_sum =
 		            b_in_sum =
 		                a_in_sum =
@@ -10690,15 +10720,15 @@
 		        b_sum += sumFactor * pb;
 		        a_sum += sumFactor * pa;
 		        stack = stackStart;
-		        for (i = 0; i < radiusPlus1; i++) {
+		        for (let i = 0; i < radiusPlus1; i++) {
 		            stack.r = pr;
 		            stack.g = pg;
 		            stack.b = pb;
 		            stack.a = pa;
 		            stack = stack.next;
 		        }
-		        yp = width;
-		        for (i = 1; i <= radius; i++) {
+		        let yp = width;
+		        for (let i = 1; i <= radius; i++) {
 		            yi = (yp + x) << 2;
 		            r_sum += (stack.r = pr = pixels[yi]) * (rbs = radiusPlus1 - i);
 		            g_sum += (stack.g = pg = pixels[yi + 1]) * rbs;
@@ -10716,7 +10746,7 @@
 		        yi = x;
 		        stackIn = stackStart;
 		        stackOut = stackEnd;
-		        for (y = 0; y < height; y++) {
+		        for (let y = 0; y < height; y++) {
 		            p = yi << 2;
 		            pixels[p + 3] = pa = (a_sum * mul_sum) >> shg_sum;
 		            if (pa > 0) {
@@ -10772,12 +10802,11 @@
 	var Brighten = {};
 
 	var hasRequiredBrighten;
-
 	function requireBrighten () {
 		if (hasRequiredBrighten) return Brighten;
 		hasRequiredBrighten = 1;
 		Object.defineProperty(Brighten, "__esModule", { value: true });
-		Brighten.Brighten = undefined;
+		Brighten.Brighten = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -10797,12 +10826,11 @@
 	var Contrast = {};
 
 	var hasRequiredContrast;
-
 	function requireContrast () {
 		if (hasRequiredContrast) return Contrast;
 		hasRequiredContrast = 1;
 		Object.defineProperty(Contrast, "__esModule", { value: true });
-		Contrast.Contrast = undefined;
+		Contrast.Contrast = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -10845,12 +10873,11 @@
 	var Emboss = {};
 
 	var hasRequiredEmboss;
-
 	function requireEmboss () {
 		if (hasRequiredEmboss) return Emboss;
 		hasRequiredEmboss = 1;
 		Object.defineProperty(Emboss, "__esModule", { value: true });
-		Emboss.Emboss = undefined;
+		Emboss.Emboss = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Util_1 = requireUtil();
@@ -10961,12 +10988,11 @@
 	var Enhance = {};
 
 	var hasRequiredEnhance;
-
 	function requireEnhance () {
 		if (hasRequiredEnhance) return Enhance;
 		hasRequiredEnhance = 1;
 		Object.defineProperty(Enhance, "__esModule", { value: true });
-		Enhance.Enhance = undefined;
+		Enhance.Enhance = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11024,7 +11050,7 @@
 		        bMax = 255;
 		        bMin = 0;
 		    }
-		    let rMid, rGoalMax, rGoalMin, gMid, gGoalMax, gGoalMin, bMid, bGoalMax, bGoalMin;
+		    let rGoalMax, rGoalMin, gGoalMax, gGoalMin, bGoalMax, bGoalMin;
 		    if (enhanceAmount > 0) {
 		        rGoalMax = rMax + enhanceAmount * (255 - rMax);
 		        rGoalMin = rMin - enhanceAmount * (rMin - 0);
@@ -11034,13 +11060,13 @@
 		        bGoalMin = bMin - enhanceAmount * (bMin - 0);
 		    }
 		    else {
-		        rMid = (rMax + rMin) * 0.5;
+		        const rMid = (rMax + rMin) * 0.5;
 		        rGoalMax = rMax + enhanceAmount * (rMax - rMid);
 		        rGoalMin = rMin + enhanceAmount * (rMin - rMid);
-		        gMid = (gMax + gMin) * 0.5;
+		        const gMid = (gMax + gMin) * 0.5;
 		        gGoalMax = gMax + enhanceAmount * (gMax - gMid);
 		        gGoalMin = gMin + enhanceAmount * (gMin - gMid);
-		        bMid = (bMax + bMin) * 0.5;
+		        const bMid = (bMax + bMin) * 0.5;
 		        bGoalMax = bMax + enhanceAmount * (bMax - bMid);
 		        bGoalMin = bMin + enhanceAmount * (bMin - bMid);
 		    }
@@ -11058,12 +11084,11 @@
 	var Grayscale = {};
 
 	var hasRequiredGrayscale;
-
 	function requireGrayscale () {
 		if (hasRequiredGrayscale) return Grayscale;
 		hasRequiredGrayscale = 1;
 		Object.defineProperty(Grayscale, "__esModule", { value: true });
-		Grayscale.Grayscale = undefined;
+		Grayscale.Grayscale = void 0;
 		const Grayscale$1 = function (imageData) {
 		    const data = imageData.data, len = data.length;
 		    for (let i = 0; i < len; i += 4) {
@@ -11080,12 +11105,11 @@
 	var HSL = {};
 
 	var hasRequiredHSL;
-
 	function requireHSL () {
 		if (hasRequiredHSL) return HSL;
 		hasRequiredHSL = 1;
 		Object.defineProperty(HSL, "__esModule", { value: true });
-		HSL.HSL = undefined;
+		HSL.HSL = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11117,12 +11141,11 @@
 	var HSV = {};
 
 	var hasRequiredHSV;
-
 	function requireHSV () {
 		if (hasRequiredHSV) return HSV;
 		hasRequiredHSV = 1;
 		Object.defineProperty(HSV, "__esModule", { value: true });
-		HSV.HSV = undefined;
+		HSV.HSV = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11132,12 +11155,11 @@
 		    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];
-		        b = data[i + 2];
-		        a = data[i + 3];
+		        const r = data[i + 0];
+		        const g = data[i + 1];
+		        const b = data[i + 2];
+		        const a = data[i + 3];
 		        data[i + 0] = rr * r + rg * g + rb * b;
 		        data[i + 1] = gr * r + gg * g + gb * b;
 		        data[i + 2] = br * r + bg * g + bb * b;
@@ -11154,12 +11176,11 @@
 	var Invert = {};
 
 	var hasRequiredInvert;
-
 	function requireInvert () {
 		if (hasRequiredInvert) return Invert;
 		hasRequiredInvert = 1;
 		Object.defineProperty(Invert, "__esModule", { value: true });
-		Invert.Invert = undefined;
+		Invert.Invert = void 0;
 		const Invert$1 = function (imageData) {
 		    const data = imageData.data, len = data.length;
 		    for (let i = 0; i < len; i += 4) {
@@ -11175,12 +11196,11 @@
 	var Kaleidoscope = {};
 
 	var hasRequiredKaleidoscope;
-
 	function requireKaleidoscope () {
 		if (hasRequiredKaleidoscope) return Kaleidoscope;
 		hasRequiredKaleidoscope = 1;
 		Object.defineProperty(Kaleidoscope, "__esModule", { value: true });
-		Kaleidoscope.Kaleidoscope = undefined;
+		Kaleidoscope.Kaleidoscope = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Util_1 = requireUtil();
@@ -11321,12 +11341,11 @@
 	var Mask = {};
 
 	var hasRequiredMask;
-
 	function requireMask () {
 		if (hasRequiredMask) return Mask;
 		hasRequiredMask = 1;
 		Object.defineProperty(Mask, "__esModule", { value: true });
-		Mask.Mask = undefined;
+		Mask.Mask = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11475,12 +11494,11 @@
 	var Noise = {};
 
 	var hasRequiredNoise;
-
 	function requireNoise () {
 		if (hasRequiredNoise) return Noise;
 		hasRequiredNoise = 1;
 		Object.defineProperty(Noise, "__esModule", { value: true });
-		Noise.Noise = undefined;
+		Noise.Noise = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11500,42 +11518,41 @@
 	var Pixelate = {};
 
 	var hasRequiredPixelate;
-
 	function requirePixelate () {
 		if (hasRequiredPixelate) return Pixelate;
 		hasRequiredPixelate = 1;
 		Object.defineProperty(Pixelate, "__esModule", { value: true });
-		Pixelate.Pixelate = undefined;
+		Pixelate.Pixelate = void 0;
 		const Factory_1 = requireFactory();
 		const Util_1 = requireUtil();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
 		const Pixelate$1 = function (imageData) {
-		    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;
+		    let pixelSize = Math.ceil(this.pixelSize()), width = imageData.width, height = imageData.height, nBinsX = Math.ceil(width / pixelSize), nBinsY = Math.ceil(height / pixelSize), data = imageData.data;
 		    if (pixelSize <= 0) {
 		        Util_1.Util.error('pixelSize value can not be <= 0');
 		        return;
 		    }
-		    for (xBin = 0; xBin < nBinsX; xBin += 1) {
-		        for (yBin = 0; yBin < nBinsY; yBin += 1) {
-		            red = 0;
-		            green = 0;
-		            blue = 0;
-		            alpha = 0;
-		            xBinStart = xBin * pixelSize;
-		            xBinEnd = xBinStart + pixelSize;
-		            yBinStart = yBin * pixelSize;
-		            yBinEnd = yBinStart + pixelSize;
-		            pixelsInBin = 0;
-		            for (x = xBinStart; x < xBinEnd; x += 1) {
+		    for (let xBin = 0; xBin < nBinsX; xBin += 1) {
+		        for (let yBin = 0; yBin < nBinsY; yBin += 1) {
+		            let red = 0;
+		            let green = 0;
+		            let blue = 0;
+		            let alpha = 0;
+		            const xBinStart = xBin * pixelSize;
+		            const xBinEnd = xBinStart + pixelSize;
+		            const yBinStart = yBin * pixelSize;
+		            const yBinEnd = yBinStart + pixelSize;
+		            let pixelsInBin = 0;
+		            for (let x = xBinStart; x < xBinEnd; x += 1) {
 		                if (x >= width) {
 		                    continue;
 		                }
-		                for (y = yBinStart; y < yBinEnd; y += 1) {
+		                for (let y = yBinStart; y < yBinEnd; y += 1) {
 		                    if (y >= height) {
 		                        continue;
 		                    }
-		                    i = (width * y + x) * 4;
+		                    const i = (width * y + x) * 4;
 		                    red += data[i + 0];
 		                    green += data[i + 1];
 		                    blue += data[i + 2];
@@ -11547,15 +11564,15 @@
 		            green = green / pixelsInBin;
 		            blue = blue / pixelsInBin;
 		            alpha = alpha / pixelsInBin;
-		            for (x = xBinStart; x < xBinEnd; x += 1) {
+		            for (let x = xBinStart; x < xBinEnd; x += 1) {
 		                if (x >= width) {
 		                    continue;
 		                }
-		                for (y = yBinStart; y < yBinEnd; y += 1) {
+		                for (let y = yBinStart; y < yBinEnd; y += 1) {
 		                    if (y >= height) {
 		                        continue;
 		                    }
-		                    i = (width * y + x) * 4;
+		                    const i = (width * y + x) * 4;
 		                    data[i + 0] = red;
 		                    data[i + 1] = green;
 		                    data[i + 2] = blue;
@@ -11573,12 +11590,11 @@
 	var Posterize = {};
 
 	var hasRequiredPosterize;
-
 	function requirePosterize () {
 		if (hasRequiredPosterize) return Posterize;
 		hasRequiredPosterize = 1;
 		Object.defineProperty(Posterize, "__esModule", { value: true });
-		Posterize.Posterize = undefined;
+		Posterize.Posterize = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11596,12 +11612,11 @@
 	var RGB = {};
 
 	var hasRequiredRGB;
-
 	function requireRGB () {
 		if (hasRequiredRGB) return RGB;
 		hasRequiredRGB = 1;
 		Object.defineProperty(RGB, "__esModule", { value: true });
-		RGB.RGB = undefined;
+		RGB.RGB = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11647,12 +11662,11 @@
 	var RGBA = {};
 
 	var hasRequiredRGBA;
-
 	function requireRGBA () {
 		if (hasRequiredRGBA) return RGBA;
 		hasRequiredRGBA = 1;
 		Object.defineProperty(RGBA, "__esModule", { value: true });
-		RGBA.RGBA = undefined;
+		RGBA.RGBA = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11709,12 +11723,11 @@
 	var Sepia = {};
 
 	var hasRequiredSepia;
-
 	function requireSepia () {
 		if (hasRequiredSepia) return Sepia;
 		hasRequiredSepia = 1;
 		Object.defineProperty(Sepia, "__esModule", { value: true });
-		Sepia.Sepia = undefined;
+		Sepia.Sepia = void 0;
 		const Sepia$1 = function (imageData) {
 		    const data = imageData.data, nPixels = data.length;
 		    for (let i = 0; i < nPixels; i += 4) {
@@ -11733,12 +11746,11 @@
 	var Solarize = {};
 
 	var hasRequiredSolarize;
-
 	function requireSolarize () {
 		if (hasRequiredSolarize) return Solarize;
 		hasRequiredSolarize = 1;
 		Object.defineProperty(Solarize, "__esModule", { value: true });
-		Solarize.Solarize = undefined;
+		Solarize.Solarize = void 0;
 		const Solarize$1 = function (imageData) {
 		    const data = imageData.data, w = imageData.width, h = imageData.height, w4 = w * 4;
 		    let y = h;
@@ -11772,12 +11784,11 @@
 	var Threshold = {};
 
 	var hasRequiredThreshold;
-
 	function requireThreshold () {
 		if (hasRequiredThreshold) return Threshold;
 		hasRequiredThreshold = 1;
 		Object.defineProperty(Threshold, "__esModule", { value: true });
-		Threshold.Threshold = undefined;
+		Threshold.Threshold = void 0;
 		const Factory_1 = requireFactory();
 		const Node_1 = requireNode();
 		const Validators_1 = requireValidators();
@@ -11793,12 +11804,11 @@
 	}
 
 	var hasRequired_FullInternals;
-
 	function require_FullInternals () {
 		if (hasRequired_FullInternals) return _FullInternals;
 		hasRequired_FullInternals = 1;
 		Object.defineProperty(_FullInternals, "__esModule", { value: true });
-		_FullInternals.Konva = undefined;
+		_FullInternals.Konva = void 0;
 		const _CoreInternals_1 = require_CoreInternals();
 		const Arc_1 = requireArc();
 		const Arrow_1 = requireArrow();
@@ -11881,9 +11891,7 @@
 	}
 
 	var lib = lib$1.exports;
-
 	var hasRequiredLib;
-
 	function requireLib () {
 		if (hasRequiredLib) return lib$1.exports;
 		hasRequiredLib = 1;
@@ -11896,28 +11904,6 @@
 	var libExports = requireLib();
 	var Konva = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class WorldTransform {
 	    screenToWorld(position) {
 	        return { x: position.x, y: position.y, z: 0 };
@@ -11930,62 +11916,16 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
-	/**
-	 * Defines the markup color helper object.
-	 */
 	class MarkupColor {
-	    /**
-	     * Creates an instance of the color.
-	     *
-	     * @param r - The `red` component of the color, as a number between 0 and 255.
-	     * @param g - The `green` component of the color, as a number between 0 and 255.
-	     * @param b - The `blue` component of the color, as a number between 0 and 255.
-	     */
 	    constructor(r, g, b) {
 	        this.setColor(r, g, b);
 	    }
-	    /**
-	     * Returns the color as a string in hexadecimal color syntax `#RGB` using its primary color components
-	     * (red, green, blue) written as hexadecimal numbers.
-	     */
 	    asHex() {
 	        return "#" + this.HEX;
 	    }
-	    /**
-	     * Returns the color as an {r, g, b} object.
-	     */
 	    asRGB() {
 	        return { r: this.R, g: this.G, b: this.B };
 	    }
-	    /**
-	     * Sets the color.
-	     *
-	     * @param r - The `red` component of the color, as a number between 0 and 255.
-	     * @param g - The `green` component of the color, as a number between 0 and 255.
-	     * @param b - The `blue` component of the color, as a number between 0 and 255.
-	     */
 	    setColor(r, g, b) {
 	        this.R = r;
 	        this.G = g;
@@ -12001,28 +11941,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	const LineTypeSpecs = new Map([
 	    ["solid", []],
 	    ["dot", [30, 30, 0.001, 30]],
@@ -12062,8 +11980,8 @@
 	            wcsPoints.push({ x: wcsPoint.x, y: wcsPoint.y, z: wcsPoint.z });
 	        });
 	        this._ref = new Konva.Line({
-	            stroke: (_a = params.color) !== null && _a !== undefined ? _a : "#ff0000",
-	            strokeWidth: (_b = params.width) !== null && _b !== undefined ? _b : 4,
+	            stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
+	            strokeWidth: (_b = params.width) !== null && _b !== void 0 ? _b : 4,
 	            globalCompositeOperation: "source-over",
 	            lineCap: "round",
 	            lineJoin: "round",
@@ -12195,28 +12113,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaText {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b, _c;
@@ -12240,12 +12136,12 @@
 	            x: params.position.x,
 	            y: params.position.y,
 	            text: params.text,
-	            fontSize: (_a = params.fontSize) !== null && _a !== undefined ? _a : 34,
+	            fontSize: (_a = params.fontSize) !== null && _a !== void 0 ? _a : 34,
 	            fontFamily: this.TEXT_FONT_FAMILY,
-	            fill: (_b = params.color) !== null && _b !== undefined ? _b : "#ff0000",
+	            fill: (_b = params.color) !== null && _b !== void 0 ? _b : "#ff0000",
 	            align: "left",
 	            draggable: true,
-	            rotation: (_c = params.rotation) !== null && _c !== undefined ? _c : 0,
+	            rotation: (_c = params.rotation) !== null && _c !== void 0 ? _c : 0,
 	        });
 	        this._ref.width(this._ref.getTextWidth());
 	        this._ref.setAttr("wcsStart", this._worldTransformer.screenToWorld({ x: params.position.x, y: params.position.y }));
@@ -12351,28 +12247,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaRectangle {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b, _c, _d;
@@ -12409,15 +12283,15 @@
 	            }
 	        }
 	        this._ref = new Konva.Rect({
-	            stroke: (_a = params.color) !== null && _a !== undefined ? _a : "#ff0000",
-	            strokeWidth: (_b = params.lineWidth) !== null && _b !== undefined ? _b : 4,
+	            stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
+	            strokeWidth: (_b = params.lineWidth) !== null && _b !== void 0 ? _b : 4,
 	            globalCompositeOperation: "source-over",
 	            lineCap: "round",
 	            lineJoin: "round",
 	            x: params.position.x,
 	            y: params.position.y,
-	            width: (_c = params.width) !== null && _c !== undefined ? _c : 200,
-	            height: (_d = params.height) !== null && _d !== undefined ? _d : 200,
+	            width: (_c = params.width) !== null && _c !== void 0 ? _c : 200,
+	            height: (_d = params.height) !== null && _d !== void 0 ? _d : 200,
 	            draggable: true,
 	            strokeScaleEnabled: false,
 	        });
@@ -12549,28 +12423,6 @@
 	    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaEllipse {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b, _c;
@@ -12596,7 +12448,7 @@
 	        if (!params.position)
 	            params.position = { x: 0, y: 0 };
 	        if (params.position2) {
-	            (_a = params.radius) !== null && _a !== undefined ? _a : (params.radius = { x: 0, y: 0 });
+	            (_a = params.radius) !== null && _a !== void 0 ? _a : (params.radius = { x: 0, y: 0 });
 	            params.radius.x = getDistanceIn2D(params.position, params.position2);
 	            if (params.position3)
 	                params.radius.y = getDistanceIn2D(params.position, params.position3);
@@ -12608,8 +12460,8 @@
 	                params.radius = { x: 25, y: 25 };
 	        }
 	        this._ref = new Konva.Ellipse({
-	            stroke: (_b = params.color) !== null && _b !== undefined ? _b : "#ff0000",
-	            strokeWidth: (_c = params.lineWidth) !== null && _c !== undefined ? _c : 4,
+	            stroke: (_b = params.color) !== null && _b !== void 0 ? _b : "#ff0000",
+	            strokeWidth: (_c = params.lineWidth) !== null && _c !== void 0 ? _c : 4,
 	            globalCompositeOperation: "source-over",
 	            lineCap: "round",
 	            lineJoin: "round",
@@ -12750,28 +12602,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaArrow {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b;
@@ -12793,8 +12623,8 @@
 	        if (!params.end)
 	            params.end = { x: 100, y: 100 };
 	        this._ref = new Konva.Arrow({
-	            stroke: (_a = params.color) !== null && _a !== undefined ? _a : "#ff0000",
-	            fill: (_b = params.color) !== null && _b !== undefined ? _b : "#ff0000",
+	            stroke: (_a = params.color) !== null && _a !== void 0 ? _a : "#ff0000",
+	            fill: (_b = params.color) !== null && _b !== void 0 ? _b : "#ff0000",
 	            strokeWidth: 4,
 	            globalCompositeOperation: "source-over",
 	            lineCap: "round",
@@ -12904,28 +12734,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaImage {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b;
@@ -12979,7 +12787,6 @@
 	                this._ref.height() <= this.EPSILON || this._ref.width() <= this.EPSILON
 	                    ? 1
 	                    : this._ref.height() / this._ref.width();
-	            // need to rescale only if input width and height are 0 - we do not loading Viewpoint with existing params
 	            if ((params.width <= this.EPSILON || params.height <= this.EPSILON) &&
 	                (params.maxWidth >= this.EPSILON || params.maxWidth >= this.EPSILON)) {
 	                const heightOutOfCanvas = params.maxHeight - this._canvasImage.height;
@@ -13010,8 +12817,8 @@
 	            x: params.position.x,
 	            y: params.position.y,
 	            image: this._canvasImage,
-	            width: (_a = params.width) !== null && _a !== undefined ? _a : 0,
-	            height: (_b = params.height) !== null && _b !== undefined ? _b : 0,
+	            width: (_a = params.width) !== null && _a !== void 0 ? _a : 0,
+	            height: (_b = params.height) !== null && _b !== void 0 ? _b : 0,
 	            draggable: true,
 	        });
 	        this._ref.setAttr("wcsStart", this._worldTransformer.screenToWorld({ x: params.position.x, y: params.position.y }));
@@ -13138,28 +12945,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	class KonvaCloud {
 	    constructor(params, ref = null, worldTransformer = new WorldTransform()) {
 	        var _a, _b, _c, _d;
@@ -13202,10 +12987,10 @@
 	        this._ref = new Konva.Shape({
 	            x: params.position.x,
 	            y: params.position.y,
-	            width: (_a = params.width) !== null && _a !== undefined ? _a : 200,
-	            height: (_b = params.height) !== null && _b !== undefined ? _b : 200,
-	            stroke: (_c = params.color) !== null && _c !== undefined ? _c : "#ff0000",
-	            strokeWidth: (_d = params.lineWidth) !== null && _d !== undefined ? _d : 4,
+	            width: (_a = params.width) !== null && _a !== void 0 ? _a : 200,
+	            height: (_b = params.height) !== null && _b !== void 0 ? _b : 200,
+	            stroke: (_c = params.color) !== null && _c !== void 0 ? _c : "#ff0000",
+	            strokeWidth: (_d = params.lineWidth) !== null && _d !== void 0 ? _d : 4,
 	            draggable: true,
 	            strokeScaleEnabled: false,
 	            globalCompositeOperation: "source-over",
@@ -13260,8 +13045,6 @@
 	                        }
 	                    }
 	                    context.closePath();
-	                    // (!) Konva specific method, it is very important
-	                    // it will apply are required styles
 	                    context.fillStrokeShape(shape);
 	                }
 	                function drawRectangle() {
@@ -13271,8 +13054,6 @@
 	                    context.lineTo(points[3].x, points[3].y);
 	                    context.lineTo(points[4].x, points[4].y);
 	                    context.closePath();
-	                    // (!) Konva specific method, it is very important
-	                    // it will apply are required styles
 	                    context.fillStrokeShape(shape);
 	                }
 	            },
@@ -13408,28 +13189,6 @@
 	    }
 	}
 
-	///////////////////////////////////////////////////////////////////////////////
-	// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
-	// All rights reserved.
-	//
-	// This software and its documentation and related materials are owned by
-	// the Alliance. The software may only be incorporated into application
-	// programs owned by members of the Alliance, subject to a signed
-	// Membership Agreement and Supplemental Software License Agreement with the
-	// Alliance. The structure and organization of this software are the valuable
-	// trade secrets of the Alliance and its suppliers. The software is also
-	// protected by copyright law and international treaty provisions. Application
-	// programs incorporating this software must include the following statement
-	// with their copyright notices:
-	//
-	//   This application incorporates Open Design Alliance software pursuant to a
-	//   license agreement with Open Design Alliance.
-	//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
-	//   All rights reserved.
-	//
-	// By use of this software, its documentation or related materials, you
-	// acknowledge and accept the above terms.
-	///////////////////////////////////////////////////////////////////////////////
 	const MarkupMode2Konva = {
 	    SelectMarkup: {
 	        name: "SelectMarkup",
@@ -13476,9 +13235,6 @@
 	        }, wait);
 	    };
 	}
-	/**
-	 * 2D markup core.
-	 */
 	class KonvaMarkup {
 	    constructor() {
 	        this._markupIsActive = false;
@@ -13503,7 +13259,7 @@
 	                return;
 	            const { width, height } = entries[0].contentRect;
 	            if (!width || !height)
-	                return; // <- invisible container, or container with parent removed
+	                return;
 	            if (!this._konvaStage)
 	                return;
 	            this._konvaStage.width(width);
@@ -13515,7 +13271,7 @@
 	        this.resizeViewer = (event) => {
 	            const { width, height } = event;
 	            if (!width || !height)
-	                return; // <- invisible container, or container with parent removed
+	                return;
 	            if (!this._konvaStage)
 	                return;
 	            this._konvaStage.width(width);
@@ -13539,12 +13295,8 @@
 	                this._viewer.emit(event);
 	        };
 	        this.getRelativePointPosition = (point, node) => {
-	            // the function will return pointer position relative to the passed node
 	            const transform = node.getAbsoluteTransform().copy();
-	            // to detect relative position we need to invert transform
 	            transform.invert();
-	            // get pointer (say mouse or touch) position
-	            // now we find relative point
 	            return transform.point(point);
 	        };
 	        this.getRelativePointerPosition = (node) => {
@@ -13555,14 +13307,14 @@
 	        if (!Konva)
 	            throw new Error('Markup error: Konva is not initialized. Forgot to add <script src="https://unpkg.com/konva@9/konva.min.js"></script> to your page?');
 	        this._viewer = viewer;
-	        this._worldTransformer = worldTransformer !== null && worldTransformer !== undefined ? worldTransformer : new WorldTransform();
+	        this._worldTransformer = worldTransformer !== null && worldTransformer !== void 0 ? worldTransformer : new WorldTransform();
 	        this._container = container;
 	        this._markupContainer = document.createElement("div");
 	        this._markupContainer.id = "markup-container";
 	        this._markupContainer.style.position = "absolute";
 	        this._markupContainer.style.top = "0px";
 	        this._markupContainer.style.left = "0px";
-	        this._markupContainer.style.outline = "0px"; // <- to eliminate grey box during delete elements
+	        this._markupContainer.style.outline = "0px";
 	        this._markupContainer.style.pointerEvents = "none";
 	        const parentDiv = this._container.parentElement;
 	        parentDiv.appendChild(this._markupContainer);
@@ -13586,9 +13338,9 @@
 	            this._viewer.removeEventListener("changeactivedragger", this.changeActiveDragger);
 	        }
 	        this.destroyKonva();
-	        (_a = this._resizeObserver) === null || _a === undefined ? undefined : _a.disconnect();
+	        (_a = this._resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
 	        this._resizeObserver = undefined;
-	        (_b = this._markupContainer) === null || _b === undefined ? undefined : _b.remove();
+	        (_b = this._markupContainer) === null || _b === void 0 ? void 0 : _b.remove();
 	        this._markupContainer = undefined;
 	        this._container = undefined;
 	        this._viewer = undefined;
@@ -13612,11 +13364,11 @@
 	    colorizeAllMarkup(r, g, b) {
 	        this.setMarkupColor(r, g, b);
 	        const hexColor = new MarkupColor(r, g, b).asHex();
-	        this.getObjects().filter((obj) => { var _a; return (_a = obj.setColor) === null || _a === undefined ? undefined : _a.call(obj, hexColor); });
+	        this.getObjects().filter((obj) => { var _a; return (_a = obj.setColor) === null || _a === void 0 ? void 0 : _a.call(obj, hexColor); });
 	    }
 	    colorizeSelectedMarkups(r, g, b) {
 	        const hexColor = new MarkupColor(r, g, b).asHex();
-	        this.getSelectedObjects().filter((obj) => { var _a; return (_a = obj.setColor) === null || _a === undefined ? undefined : _a.call(obj, hexColor); });
+	        this.getSelectedObjects().filter((obj) => { var _a; return (_a = obj.setColor) === null || _a === void 0 ? void 0 : _a.call(obj, hexColor); });
 	    }
 	    setViewpoint(viewpoint) {
 	        var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -13625,9 +13377,9 @@
 	        this.removeImageInput();
 	        this._konvaStage.scale({ x: 1, y: 1 });
 	        this._konvaStage.position({ x: 0, y: 0 });
-	        const markupColor = ((_a = viewpoint.custom_fields) === null || _a === undefined ? undefined : _a.markup_color) || { r: 255, g: 0, b: 0 };
+	        const markupColor = ((_a = viewpoint.custom_fields) === null || _a === void 0 ? void 0 : _a.markup_color) || { r: 255, g: 0, b: 0 };
 	        this.setMarkupColor(markupColor.r, markupColor.g, markupColor.b);
-	        (_b = viewpoint.lines) === null || _b === undefined ? undefined : _b.forEach((line) => {
+	        (_b = viewpoint.lines) === null || _b === void 0 ? void 0 : _b.forEach((line) => {
 	            const linePoints = [];
 	            line.points.forEach((point) => {
 	                const screenPoint = this._worldTransformer.worldToScreen(point);
@@ -13636,32 +13388,32 @@
 	            });
 	            this.addLine(linePoints, line.color, line.type, line.width, line.id);
 	        });
-	        (_c = viewpoint.texts) === null || _c === undefined ? undefined : _c.forEach((text) => {
+	        (_c = viewpoint.texts) === null || _c === void 0 ? void 0 : _c.forEach((text) => {
 	            const screenPoint = this._worldTransformer.worldToScreen(text.position);
 	            this.addText(text.text, screenPoint, text.angle, text.color, text.text_size, text.font_size, text.id);
 	        });
-	        (_d = viewpoint.rectangles) === null || _d === undefined ? undefined : _d.forEach((rect) => {
+	        (_d = viewpoint.rectangles) === null || _d === void 0 ? void 0 : _d.forEach((rect) => {
 	            const screenPoint = this._worldTransformer.worldToScreen(rect.position);
 	            const screenPoint2 = rect.position2 ? this._worldTransformer.worldToScreen(rect.position2) : null;
 	            this.addRectangle(screenPoint, screenPoint2, rect.width, rect.height, rect.line_width, rect.color, rect.id);
 	        });
-	        (_e = viewpoint.ellipses) === null || _e === undefined ? undefined : _e.forEach((ellipse) => {
+	        (_e = viewpoint.ellipses) === null || _e === void 0 ? void 0 : _e.forEach((ellipse) => {
 	            const screenPoint = this._worldTransformer.worldToScreen(ellipse.position);
 	            const screenPoint2 = ellipse.position2 ? this._worldTransformer.worldToScreen(ellipse.position2) : null;
 	            const screenPoint3 = ellipse.position3 ? this._worldTransformer.worldToScreen(ellipse.position3) : null;
 	            this.addEllipse(screenPoint, screenPoint2, screenPoint3, ellipse.radius, ellipse.line_width, ellipse.color, ellipse.id);
 	        });
-	        (_f = viewpoint.arrows) === null || _f === undefined ? undefined : _f.forEach((arrow) => {
+	        (_f = viewpoint.arrows) === null || _f === void 0 ? void 0 : _f.forEach((arrow) => {
 	            const startPoint = this._worldTransformer.worldToScreen(arrow.start);
 	            const endPoint = this._worldTransformer.worldToScreen(arrow.end);
 	            this.addArrow(startPoint, endPoint, arrow.color, arrow.id);
 	        });
-	        (_g = viewpoint.clouds) === null || _g === undefined ? undefined : _g.forEach((cloud) => {
+	        (_g = viewpoint.clouds) === null || _g === void 0 ? void 0 : _g.forEach((cloud) => {
 	            const screenPoint = this._worldTransformer.worldToScreen(cloud.position);
 	            const screenPoint2 = cloud.position2 ? this._worldTransformer.worldToScreen(cloud.position2) : null;
 	            this.addCloud(screenPoint, screenPoint2, cloud.width, cloud.height, cloud.line_width, cloud.color, cloud.id);
 	        });
-	        (_h = viewpoint.images) === null || _h === undefined ? undefined : _h.forEach((image) => {
+	        (_h = viewpoint.images) === null || _h === void 0 ? void 0 : _h.forEach((image) => {
 	            const screenPoint = this._worldTransformer.worldToScreen(image.position);
 	            const screenPoint2 = image.position2 ? this._worldTransformer.worldToScreen(image.position2) : null;
 	            this.addImage(screenPoint, screenPoint2, image.src, image.width, image.height, image.id);
@@ -13748,7 +13500,6 @@
 	        const konvaShape = MarkupMode2Konva[type];
 	        if (!konvaShape || !konvaShape.initializer)
 	            return [];
-	        // for "draggable" Konva uses Rectangles in Transformer. We need only Shapes from layer.
 	        return this._konvaLayer
 	            .find(konvaShape.name)
 	            .filter((ref) => ref.parent === this._konvaLayer ||
@@ -13757,7 +13508,6 @@
 	            ref.parent === this._groupTexts);
 	    }
 	    initializeKonva() {
-	        // first we need Konva core things: stage and layer
 	        const stage = new Konva.Stage({
 	            container: this._markupContainer,
 	            width: this._container.clientWidth,
@@ -13785,7 +13535,6 @@
 	        let mouseDownPos;
 	        let lastObj;
 	        stage.on("mousedown touchstart", (e) => {
-	            // do nothing if we mousedown on any shape
 	            if (!this._markupIsActive || e.target !== stage || this._markupMode === "Text" || this._markupMode === "Image")
 	                return;
 	            if (e.target === stage && transformer.nodes().length > 0) {
@@ -13796,7 +13545,6 @@
 	            mouseDownPos = pos;
 	            isPaint = ["Arrow", "Cloud", "Ellipse", "Line", "Rectangle"].some((m) => m === this._markupMode);
 	            if (this._markupMode === "Line") {
-	                // add point twice, so we have some drawings even on a simple click
 	                lastLine = this.addLine([pos.x, pos.y, pos.x, pos.y]);
 	            }
 	        });
@@ -13834,8 +13582,6 @@
 	            if (!isPaint) {
 	                return;
 	            }
-	            // prevent scrolling on touch devices
-	            //e.evt.preventDefault();
 	            const pos = this.getRelativePointerPosition(stage);
 	            const defParams = mouseDownPos && pos.x === mouseDownPos.x && pos.y === mouseDownPos.y;
 	            const startX = defParams ? mouseDownPos.x : Math.min(mouseDownPos.x, pos.x);
@@ -13879,11 +13625,9 @@
 	                    lastObj = this.addCloud({ x: startX, y: startY }, null, dX, dY);
 	            }
 	        });
-	        // clicks should select/deselect shapes
 	        stage.on("click tap", (e) => {
 	            if (!this._markupIsActive)
 	                return;
-	            // if click on empty area - remove all selections
 	            if (e.target === stage) {
 	                if (this._markupMode === "Text") {
 	                    if (this._textInputRef && this._textInputRef.value)
@@ -13936,32 +13680,23 @@
 	            else {
 	                transformer.rotateEnabled(true);
 	            }
-	            // do we pressed shift or ctrl?
 	            const metaPressed = e.evt.shiftKey || e.evt.ctrlKey || e.evt.metaKey;
 	            const isSelected = transformer.nodes().indexOf(e.target) >= 0;
 	            if (!metaPressed && !isSelected) {
-	                // if no key pressed and the node is not selected
-	                // select just one
 	                transformer.nodes([e.target]);
 	            }
 	            else if (metaPressed && isSelected) {
-	                // if we pressed keys and node was selected
-	                // we need to remove it from selection:
-	                const nodes = transformer.nodes().slice(); // use slice to have new copy of array
-	                // remove node from array
+	                const nodes = transformer.nodes().slice();
 	                nodes.splice(nodes.indexOf(e.target), 1);
 	                transformer.nodes(nodes);
 	            }
 	            else if (metaPressed && !isSelected) {
-	                // add the node into selection
 	                const nodes = transformer.nodes().concat([e.target]);
 	                transformer.nodes(nodes);
 	            }
 	        });
 	        const container = stage.container();
 	        container.tabIndex = 1;
-	        // focus it
-	        // also stage will be in focus on its click
 	        container.focus();
 	        container.addEventListener("keydown", (e) => {
 	            if (!this._markupIsActive)
@@ -13979,7 +13714,7 @@
 	        this.removeTextInput();
 	        this.removeImageInput();
 	        this.clearOverlay();
-	        (_a = this._konvaStage) === null || _a === undefined ? undefined : _a.destroy();
+	        (_a = this._konvaStage) === null || _a === void 0 ? void 0 : _a.destroy();
 	        this._groupImages = undefined;
 	        this._groupGeometry = undefined;
 	        this._groupTexts = undefined;
@@ -14075,7 +13810,6 @@
 	    getMarkupArrows() {
 	        const arrows = [];
 	        this.konvaLayerFind("Arrow").forEach((ref) => {
-	            // we need getAbsoluteTransform because inside Konva position starts from {0, 0}
 	            const wcsStart = ref.getAttr("wcsStart");
 	            const wcsEnd = ref.getAttr("wcsEnd");
 	            const shape = new KonvaArrow(null, ref, this._worldTransformer);
@@ -14196,7 +13930,7 @@
 	    }
 	    removeTextInput() {
 	        var _a;
-	        (_a = this._textInputRef) === null || _a === undefined ? undefined : _a.remove();
+	        (_a = this._textInputRef) === null || _a === void 0 ? void 0 : _a.remove();
 	        this._textInputRef = null;
 	        this._textInputPos = null;
 	        this._textInputAngle = 0;
@@ -14239,7 +13973,7 @@
 	    }
 	    removeImageInput() {
 	        var _a;
-	        (_a = this._imageInputRef) === null || _a === undefined ? undefined : _a.remove();
+	        (_a = this._imageInputRef) === null || _a === void 0 ? void 0 : _a.remove();
 	        this._imageInputRef = null;
 	        this._imageInputPos = null;
 	    }
@@ -14247,11 +13981,9 @@
 	        var _a;
 	        if (!text)
 	            return;
-	        // in case of edit - remove old Konva.Text object
-	        (_a = this.getSelectedObjects().at(0)) === null || _a === undefined ? undefined : _a.delete();
+	        (_a = this.getSelectedObjects().shift()) === null || _a === void 0 ? void 0 : _a.delete();
 	        this.clearSelected();
 	        this.removeTextInput();
-	        // in case we have old viewpoint without font_size
 	        const tolerance = 1.0e-6;
 	        if (textSize && textSize > tolerance && (!fontSize || fontSize < tolerance)) {
 	            const size = 0.02;
@@ -14330,8 +14062,7 @@
 	        var _a;
 	        if (!position || !src)
 	            return;
-	        // in case of edit - remove old Image placeholder object
-	        (_a = this.getSelectedObjects().at(0)) === null || _a === undefined ? undefined : _a.delete();
+	        (_a = this.getSelectedObjects().shift()) === null || _a === void 0 ? void 0 : _a.delete();
 	        this.clearSelected();
 	        this.removeImageInput();
 	        const konvaImage = new KonvaImage({