Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

LiteSpeed

System:

Linux 4.18.0-553.54.1.lve.el8.x86_64

PHP Version:

7.3.33

User:

u435171512

Directory:

/home/u435171512/domains/ssmedicalcentre.com/public_html/js

Free Space:

4.08 TB

🔧 Quick Actions

✏️ Editing: kinetic.js

/*! KineticJS v5.1.0 2014-03-27 http://www.kineticjs.com by Eric Rowell @ericdrowell - MIT License https://github.com/ericdrowell/KineticJS/wiki/License*/
var Kinetic = {};
! function(a) {
    var b = Math.PI / 180;
    Kinetic = {
        version: "5.1.0",
        stages: [],
        idCounter: 0,
        ids: {},
        names: {},
        shapes: {},
        listenClickTap: !1,
        inDblClickWindow: !1,
        enableTrace: !1,
        traceArrMax: 100,
        dblClickWindow: 400,
        pixelRatio: void 0,
        dragDistance: 0,
        angleDeg: !0,
        UA: function() {
            var b = a.navigator && a.navigator.userAgent || "",
                c = b.toLowerCase(),
                d = /(chrome)[ \/]([\w.]+)/.exec(c) || /(webkit)[ \/]([\w.]+)/.exec(c) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(c) || /(msie) ([\w.]+)/.exec(c) || c.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(c) || [],
                e = !!b.match(/Android|BlackBerry|iPhone|iPad|iPod|Opera Mini|IEMobile/i);
            return {
                browser: d[1] || "",
                version: d[2] || "0",
                mobile: e
            }
        }(),
        Filters: {},
        Node: function(a) {
            this._init(a)
        },
        Shape: function(a) {
            this.__init(a)
        },
        Container: function(a) {
            this.__init(a)
        },
        Stage: function(a) {
            this.___init(a)
        },
        BaseLayer: function(a) {
            this.___init(a)
        },
        Layer: function(a) {
            this.____init(a)
        },
        FastLayer: function(a) {
            this.____init(a)
        },
        Group: function(a) {
            this.___init(a)
        },
        isDragging: function() {
            var a = Kinetic.DD;
            return a ? a.isDragging : !1
        },
        isDragReady: function() {
            var a = Kinetic.DD;
            return a ? !!a.node : !1
        },
        _addId: function(a, b) {
            void 0 !== b && (this.ids[b] = a)
        },
        _removeId: function(a) {
            void 0 !== a && delete this.ids[a]
        },
        _addName: function(a, b) {
            void 0 !== b && (void 0 === this.names[b] && (this.names[b] = []), this.names[b].push(a))
        },
        _removeName: function(a, b) {
            if (void 0 !== a) {
                var c = this.names[a];
                if (void 0 !== c) {
                    for (var d = 0; d < c.length; d++) {
                        var e = c[d];
                        e._id === b && c.splice(d, 1)
                    }
                    0 === c.length && delete this.names[a]
                }
            }
        },
        getAngle: function(a) {
            return this.angleDeg ? a * b : a
        }
    }
}(this),
function(a, b) {
    if ("object" == typeof exports) {
        var c = require("canvas"),
            d = require("jsdom").jsdom,
            e = d("<!DOCTYPE html><html><head></head><body></body></html>"),
            f = b();
        return Kinetic.document = e, Kinetic.window = Kinetic.document.createWindow(), Kinetic.window.Image = c.Image, Kinetic.root = a, Kinetic._nodeCanvas = c, void(module.exports = f)
    }
    "function" == typeof define && define.amd && define(b), Kinetic.document = document, Kinetic.window = window, Kinetic.root = a
}((1, eval)("this"), function() {
    return Kinetic
}),
function() {
    Kinetic.Collection = function() {
        var a = [].slice.call(arguments),
            b = a.length,
            c = 0;
        for (this.length = b; b > c; c++) this[c] = a[c];
        return this
    }, Kinetic.Collection.prototype = [], Kinetic.Collection.prototype.each = function(a) {
        for (var b = 0; b < this.length; b++) a(this[b], b)
    }, Kinetic.Collection.prototype.toArray = function() {
        var a, b = [],
            c = this.length;
        for (a = 0; c > a; a++) b.push(this[a]);
        return b
    }, Kinetic.Collection.toCollection = function(a) {
        var b, c = new Kinetic.Collection,
            d = a.length;
        for (b = 0; d > b; b++) c.push(a[b]);
        return c
    }, Kinetic.Collection._mapMethod = function(a) {
        Kinetic.Collection.prototype[a] = function() {
            var b, c = this.length,
                d = [].slice.call(arguments);
            for (b = 0; c > b; b++) this[b][a].apply(this[b], d);
            return this
        }
    }, Kinetic.Collection.mapMethods = function(a) {
        var b = a.prototype;
        for (var c in b) Kinetic.Collection._mapMethod(c)
    }, Kinetic.Transform = function(a) {
        this.m = a && a.slice() || [1, 0, 0, 1, 0, 0]
    }, Kinetic.Transform.prototype = {
        copy: function() {
            return new Kinetic.Transform(this.m)
        },
        point: function(a) {
            var b = this.m;
            return {
                x: b[0] * a.x + b[2] * a.y + b[4],
                y: b[1] * a.x + b[3] * a.y + b[5]
            }
        },
        translate: function(a, b) {
            return this.m[4] += this.m[0] * a + this.m[2] * b, this.m[5] += this.m[1] * a + this.m[3] * b, this
        },
        scale: function(a, b) {
            return this.m[0] *= a, this.m[1] *= a, this.m[2] *= b, this.m[3] *= b, this
        },
        rotate: function(a) {
            var b = Math.cos(a),
                c = Math.sin(a),
                d = this.m[0] * b + this.m[2] * c,
                e = this.m[1] * b + this.m[3] * c,
                f = this.m[0] * -c + this.m[2] * b,
                g = this.m[1] * -c + this.m[3] * b;
            return this.m[0] = d, this.m[1] = e, this.m[2] = f, this.m[3] = g, this
        },
        getTranslation: function() {
            return {
                x: this.m[4],
                y: this.m[5]
            }
        },
        skew: function(a, b) {
            var c = this.m[0] + this.m[2] * b,
                d = this.m[1] + this.m[3] * b,
                e = this.m[2] + this.m[0] * a,
                f = this.m[3] + this.m[1] * a;
            return this.m[0] = c, this.m[1] = d, this.m[2] = e, this.m[3] = f, this
        },
        multiply: function(a) {
            var b = this.m[0] * a.m[0] + this.m[2] * a.m[1],
                c = this.m[1] * a.m[0] + this.m[3] * a.m[1],
                d = this.m[0] * a.m[2] + this.m[2] * a.m[3],
                e = this.m[1] * a.m[2] + this.m[3] * a.m[3],
                f = this.m[0] * a.m[4] + this.m[2] * a.m[5] + this.m[4],
                g = this.m[1] * a.m[4] + this.m[3] * a.m[5] + this.m[5];
            return this.m[0] = b, this.m[1] = c, this.m[2] = d, this.m[3] = e, this.m[4] = f, this.m[5] = g, this
        },
        invert: function() {
            var a = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]),
                b = this.m[3] * a,
                c = -this.m[1] * a,
                d = -this.m[2] * a,
                e = this.m[0] * a,
                f = a * (this.m[2] * this.m[5] - this.m[3] * this.m[4]),
                g = a * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
            return this.m[0] = b, this.m[1] = c, this.m[2] = d, this.m[3] = e, this.m[4] = f, this.m[5] = g, this
        },
        getMatrix: function() {
            return this.m
        },
        setAbsolutePosition: function(a, b) {
            var c = this.m[0],
                d = this.m[1],
                e = this.m[2],
                f = this.m[3],
                g = this.m[4],
                h = this.m[5],
                i = (c * (b - h) - d * (a - g)) / (c * f - d * e),
                j = (a - g - e * i) / c;
            return this.translate(j, i)
        }
    };
    var a = "2d",
        b = "[object Array]",
        c = "[object Number]",
        d = "[object String]",
        e = Math.PI / 180,
        f = 180 / Math.PI,
        g = "#",
        h = "",
        i = "0",
        j = "Kinetic warning: ",
        k = "Kinetic error: ",
        l = "rgb(",
        m = { 
            aqua: [136, 214, 49],
            lime: [136, 214, 49],
            silver: [136, 214, 49],
            black: [136, 214, 49],
            maroon: [136, 214, 49],
            teal: [136, 214, 49],
            blue: [136, 214, 49],
            navy: [136, 214, 49],
            white: [136, 214, 49],
            fuchsia: [136, 214, 49],
            olive: [136, 214, 49],
            yellow: [136, 214, 49],
            orange: [136, 214, 49],
            gray: [136, 214, 49],
            purple: [136, 214, 49],
            green: [136, 214, 49],
            red: [136, 214, 49],
            pink: [136, 214, 49],
            cyan: [136, 214, 49],
            transparent: [255, 255, 255, 0]
        },
        n = /rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)/;
    Kinetic.Util = {
        _isElement: function(a) {
            return !(!a || 1 != a.nodeType)
        },
        _isFunction: function(a) {
            return !!(a && a.constructor && a.call && a.apply)
        },
        _isObject: function(a) {
            return !!a && a.constructor == Object
        },
        _isArray: function(a) {
            return Object.prototype.toString.call(a) == b
        },
        _isNumber: function(a) {
            return Object.prototype.toString.call(a) == c
        },
        _isString: function(a) {
            return Object.prototype.toString.call(a) == d
        },
        _throttle: function(a, b, c) {
            var d, e, f, g = null,
                h = 0;
            c || (c = {});
            var i = function() {
                h = c.leading === !1 ? 0 : (new Date).getTime(), g = null, f = a.apply(d, e), d = e = null
            };
            return function() {
                var j = (new Date).getTime();
                h || c.leading !== !1 || (h = j);
                var k = b - (j - h);
                return d = this, e = arguments, 0 >= k ? (clearTimeout(g), g = null, h = j, f = a.apply(d, e), d = e = null) : g || c.trailing === !1 || (g = setTimeout(i, k)), f
            }
        },
        _hasMethods: function(a) {
            var b, c = [];
            for (b in a) this._isFunction(a[b]) && c.push(b);
            return c.length > 0
        },
        createCanvasElement: function() {
            var a = Kinetic.document.createElement("canvas");
            return a.style = a.style || {}, a
        },
        isBrowser: function() {
            return "object" != typeof exports
        },
        _isInDocument: function(a) {
            for (; a = a.parentNode;)
                if (a == Kinetic.document) return !0;
            return !1
        },
        _simplifyArray: function(a) {
            var b, c, d = [],
                e = a.length,
                f = Kinetic.Util;
            for (b = 0; e > b; b++) c = a[b], f._isNumber(c) ? c = Math.round(1e3 * c) / 1e3 : f._isString(c) || (c = c.toString()), d.push(c);
            return d
        },
        _getImage: function(b, c) {
            var d, e;
            if (b)
                if (this._isElement(b)) c(b);
                else if (this._isString(b)) d = new Kinetic.window.Image, d.onload = function() {
                c(d)
            }, d.src = b;
            else if (b.data) {
                e = Kinetic.Util.createCanvasElement(), e.width = b.width, e.height = b.height;
                var f = e.getContext(a);
                f.putImageData(b, 0, 0), this._getImage(e.toDataURL(), c)
            } else c(null);
            else c(null)
        },
        _getRGBAString: function(a) {
            var b = a.red || 0,
                c = a.green || 0,
                d = a.blue || 0,
                e = a.alpha || 1;
            return ["rgba(", b, ",", c, ",", d, ",", e, ")"].join(h)
        },
        _rgbToHex: function(a, b, c) {
            return ((1 << 24) + (a << 16) + (b << 8) + c).toString(16).slice(1)
        },
        _hexToRgb: function(a) {
            a = a.replace(g, h);
            var b = parseInt(a, 16);
            return {
                r: b >> 16 & 255,
                g: b >> 8 & 255,
                b: 255 & b
            }
        },
        getRandomColor: function() {
            for (var a = (16777215 * Math.random() << 0).toString(16); a.length < 6;) a = i + a;
            return g + a
        },
        get: function(a, b) {
            return void 0 === a ? b : a
        },
        getRGB: function(a) {
            var b;
            return a in m ? (b = m[a], {
                r: b[0],
                g: b[1],
                b: b[2]
            }) : a[0] === g ? this._hexToRgb(a.substring(1)) : a.substr(0, 4) === l ? (b = n.exec(a.replace(/ /g, "")), {
                r: parseInt(b[1], 10),
                g: parseInt(b[2], 10),
                b: parseInt(b[3], 10)
            }) : {
                r: 0,
                g: 0,
                b: 0
            }
        },
        _merge: function(a, b) {
            var c = this._clone(b);
            for (var d in a) c[d] = this._isObject(a[d]) ? this._merge(a[d], c[d]) : a[d];
            return c
        },
        cloneObject: function(a) {
            var b = {};
            for (var c in a) b[c] = this._isObject(a[c]) ? this.cloneObject(a[c]) : this._isArray(a[c]) ? this.cloneArray(a[c]) : a[c];
            return b
        },
        cloneArray: function(a) {
            return a.slice(0)
        },
        _degToRad: function(a) {
            return a * e
        },
        _radToDeg: function(a) {
            return a * f
        },
        _capitalize: function(a) {
            return a.charAt(0).toUpperCase() + a.slice(1)
        },
        error: function(a) {
            throw new Error(k + a)
        },
        warn: function(a) {
            Kinetic.root.console && console.warn && console.warn(j + a)
        },
        extend: function(a, b) {
            for (var c in b.prototype) c in a.prototype || (a.prototype[c] = b.prototype[c])
        },
        addMethods: function(a, b) {
            var c;
            for (c in b) a.prototype[c] = b[c]
        },
        _getControlPoints: function(a, b, c, d, e, f, g) {
            var h = Math.sqrt(Math.pow(c - a, 2) + Math.pow(d - b, 2)),
                i = Math.sqrt(Math.pow(e - c, 2) + Math.pow(f - d, 2)),
                j = g * h / (h + i),
                k = g * i / (h + i),
                l = c - j * (e - a),
                m = d - j * (f - b),
                n = c + k * (e - a),
                o = d + k * (f - b);
            return [l, m, n, o]
        },
        _expandPoints: function(a, b) {
            var c, d, e = a.length,
                f = [];
            for (c = 2; e - 2 > c; c += 2) d = Kinetic.Util._getControlPoints(a[c - 2], a[c - 1], a[c], a[c + 1], a[c + 2], a[c + 3], b), f.push(d[0]), f.push(d[1]), f.push(a[c]), f.push(a[c + 1]), f.push(d[2]), f.push(d[3]);
            return f
        },
        _removeLastLetter: function(a) {
            return a.substring(0, a.length - 1)
        }
    }
}(),
function() {
    var a = Kinetic.Util.createCanvasElement(),
        b = a.getContext("2d"),
        c = Kinetic.UA.mobile ? function() {
            var a = window.devicePixelRatio || 1,
                c = b.webkitBackingStorePixelRatio || b.mozBackingStorePixelRatio || b.msBackingStorePixelRatio || b.oBackingStorePixelRatio || b.backingStorePixelRatio || 1;
            return a / c
        }() : 1;
    Kinetic.Canvas = function(a) {
        this.init(a)
    }, Kinetic.Canvas.prototype = {
        init: function(a) {
            a = a || {};
            var b = a.pixelRatio || Kinetic.pixelRatio || c;
            this.pixelRatio = b, this._canvas = Kinetic.Util.createCanvasElement(), this._canvas.style.padding = 0, this._canvas.style.margin = 0, this._canvas.style.border = 0, this._canvas.style.background = "transparent", this._canvas.style.position = "absolute", this._canvas.style.top = 0, this._canvas.style.left = 0
        },
        getContext: function() {
            return this.context
        },
        getPixelRatio: function() {
            return this.pixelRatio
        },
        setPixelRatio: function(a) {
            this.pixelRatio = a, this.setSize(this.getWidth(), this.getHeight())
        },
        setWidth: function(a) {
            this.width = this._canvas.width = a * this.pixelRatio, this._canvas.style.width = a + "px"
        },
        setHeight: function(a) {
            this.height = this._canvas.height = a * this.pixelRatio, this._canvas.style.height = a + "px"
        },
        getWidth: function() {
            return this.width
        },
        getHeight: function() {
            return this.height
        },
        setSize: function(a, b) {
            this.setWidth(a), this.setHeight(b)
        },
        toDataURL: function(a, b) {
            try {
                return this._canvas.toDataURL(a, b)
            } catch (c) {
                try {
                    return this._canvas.toDataURL()
                } catch (d) {
                    return Kinetic.Util.warn("Unable to get data URL. " + d.message), ""
                }
            }
        }
    }, Kinetic.SceneCanvas = function(a) {
        a = a || {};
        var b = a.width || 0,
            c = a.height || 0;
        Kinetic.Canvas.call(this, a), this.context = new Kinetic.SceneContext(this), this.setSize(b, c)
    }, Kinetic.SceneCanvas.prototype = {
        setWidth: function(a) {
            var b = this.pixelRatio,
                c = this.getContext()._context;
            Kinetic.Canvas.prototype.setWidth.call(this, a), c.scale(b, b)
        },
        setHeight: function(a) {
            var b = this.pixelRatio,
                c = this.getContext()._context;
            Kinetic.Canvas.prototype.setHeight.call(this, a), c.scale(b, b)
        }
    }, Kinetic.Util.extend(Kinetic.SceneCanvas, Kinetic.Canvas), Kinetic.HitCanvas = function(a) {
        a = a || {};
        var b = a.width || 0,
            c = a.height || 0;
        Kinetic.Canvas.call(this, a), this.context = new Kinetic.HitContext(this), this.setSize(b, c)
    }, Kinetic.Util.extend(Kinetic.HitCanvas, Kinetic.Canvas)
}(),
function() {
    var a = ",",
        b = "(",
        c = ")",
        d = "([",
        e = "])",
        f = ";",
        g = "()",
        h = "=",
        i = ["arc", "arcTo", "beginPath", "bezierCurveTo", "clearRect", "clip", "closePath", "createLinearGradient", "createPattern", "createRadialGradient", "drawImage", "fill", "fillText", "getImageData", "createImageData", "lineTo", "moveTo", "putImageData", "quadraticCurveTo", "rect", "restore", "rotate", "save", "scale", "setLineDash", "setTransform", "stroke", "strokeText", "transform", "translate"];
    Kinetic.Context = function(a) {
        this.init(a)
    }, Kinetic.Context.prototype = {
        init: function(a) {
            this.canvas = a, this._context = a._canvas.getContext("2d"), Kinetic.enableTrace && (this.traceArr = [], this._enableTrace())
        },
        fillShape: function(a) {
            a.getFillEnabled() && this._fill(a)
        },
        strokeShape: function(a) {
            a.getStrokeEnabled() && this._stroke(a)
        },
        fillStrokeShape: function(a) {
            var b = a.getFillEnabled();
            b && this._fill(a), a.getStrokeEnabled() && this._stroke(a)
        },
        getTrace: function(i) {
            var j, k, l, m, n = this.traceArr,
                o = n.length,
                p = "";
            for (j = 0; o > j; j++) k = n[j], l = k.method, l ? (m = k.args, p += l, p += i ? g : Kinetic.Util._isArray(m[0]) ? d + m.join(a) + e : b + m.join(a) + c) : (p += k.property, i || (p += h + k.val)), p += f;
            return p
        },
        clearTrace: function() {
            this.traceArr = []
        },
        _trace: function(a) {
            var b, c = this.traceArr;
            c.push(a), b = c.length, b >= Kinetic.traceArrMax && c.shift()
        },
        reset: function() {
            var a = this.getCanvas().getPixelRatio();
            this.setTransform(1 * a, 0, 0, 1 * a, 0, 0)
        },
        getCanvas: function() {
            return this.canvas
        },
        clear: function(a) {
            var b = this.getCanvas();
            a ? this.clearRect(a.x || 0, a.y || 0, a.width || 0, a.height || 0) : this.clearRect(0, 0, b.getWidth(), b.getHeight())
        },
        _applyLineCap: function(a) {
            var b = a.getLineCap();
            b && this.setAttr("lineCap", b)
        },
        _applyOpacity: function(a) {
            var b = a.getAbsoluteOpacity();
            1 !== b && this.setAttr("globalAlpha", b)
        },
        _applyLineJoin: function(a) {
            var b = a.getLineJoin();
            b && this.setAttr("lineJoin", b)
        },
        setAttr: function(a, b) {
            this._context[a] = b
        },
        arc: function() {
            var a = arguments;
            this._context.arc(a[0], a[1], a[2], a[3], a[4], a[5])
        },
        beginPath: function() {
            this._context.beginPath()
        },
        bezierCurveTo: function() {
            var a = arguments;
            this._context.bezierCurveTo(a[0], a[1], a[2], a[3], a[4], a[5])
        },
        clearRect: function() {
            var a = arguments;
            this._context.clearRect(a[0], a[1], a[2], a[3])
        },
        clip: function() {
            this._context.clip()
        },
        closePath: function() {
            this._context.closePath()
        },
        createImageData: function() {
            var a = arguments;
            return 2 === a.length ? this._context.createImageData(a[0], a[1]) : 1 === a.length ? this._context.createImageData(a[0]) : void 0
        },
        createLinearGradient: function() {
            var a = arguments;
            return this._context.createLinearGradient(a[0], a[1], a[2], a[3])
        },
        createPattern: function() {
            var a = arguments;
            return this._context.createPattern(a[0], a[1])
        },
        createRadialGradient: function() {
            var a = arguments;
            return this._context.createRadialGradient(a[0], a[1], a[2], a[3], a[4], a[5])
        },
        drawImage: function() {
            var a = arguments,
                b = this._context;
            3 === a.length ? b.drawImage(a[0], a[1], a[2]) : 5 === a.length ? b.drawImage(a[0], a[1], a[2], a[3], a[4]) : 9 === a.length && b.drawImage(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8])
        },
        fill: function() {
            this._context.fill()
        },
        fillText: function() {
            var a = arguments;
            this._context.fillText(a[0], a[1], a[2])
        },
        getImageData: function() {
            var a = arguments;
            return this._context.getImageData(a[0], a[1], a[2], a[3])
        },
        lineTo: function() {
            var a = arguments;
            this._context.lineTo(a[0], a[1])
        },
        moveTo: function() {
            var a = arguments;
            this._context.moveTo(a[0], a[1])
        },
        rect: function() {
            var a = arguments;
            this._context.rect(a[0], a[1], a[2], a[3])
        },
        putImageData: function() {
            var a = arguments;
            this._context.putImageData(a[0], a[1], a[2])
        },
        quadraticCurveTo: function() {
            var a = arguments;
            this._context.quadraticCurveTo(a[0], a[1], a[2], a[3])
        },
        restore: function() {
            this._context.restore()
        },
        rotate: function() {
            var a = arguments;
            this._context.rotate(a[0])
        },
        save: function() {
            this._context.save()
        },
        scale: function() {
            var a = arguments;
            this._context.scale(a[0], a[1])
        },
        setLineDash: function() {
            var a = arguments,
                b = this._context;
            this._context.setLineDash ? b.setLineDash(a[0]) : "mozDash" in b ? b.mozDash = a[0] : "webkitLineDash" in b && (b.webkitLineDash = a[0])
        },
        setTransform: function() {
            var a = arguments;
            this._context.setTransform(a[0], a[1], a[2], a[3], a[4], a[5])
        },
        stroke: function() {
            this._context.stroke()
        },
        strokeText: function() {
            var a = arguments;
            this._context.strokeText(a[0], a[1], a[2])
        },
        transform: function() {
            var a = arguments;
            this._context.transform(a[0], a[1], a[2], a[3], a[4], a[5])
        },
        translate: function() {
            var a = arguments;
            this._context.translate(a[0], a[1])
        },
        _enableTrace: function() {
            var a, b, c = this,
                d = i.length,
                e = Kinetic.Util._simplifyArray,
                f = this.setAttr,
                g = function(a) {
                    var d, f = c[a];
                    c[a] = function() {
                        return b = e(Array.prototype.slice.call(arguments, 0)), d = f.apply(c, arguments), c._trace({
                            method: a,
                            args: b
                        }), d
                    }
                };
            for (a = 0; d > a; a++) g(i[a]);
            c.setAttr = function() {
                f.apply(c, arguments), c._trace({
                    property: arguments[0],
                    val: arguments[1]
                })
            }
        }
    }, Kinetic.SceneContext = function(a) {
        Kinetic.Context.call(this, a)
    }, Kinetic.SceneContext.prototype = {
        _fillColor: function(a) {
            var b = a.fill() || Kinetic.Util._getRGBAString({
                red: a.fillRed(),
                green: a.fillGreen(),
                blue: a.fillBlue(),
                alpha: a.fillAlpha()
            });
            this.setAttr("fillStyle", b), a._fillFunc(this)
        },
        _fillPattern: function(a) {
            var b = a.getFillPatternImage(),
                c = a.getFillPatternX(),
                d = a.getFillPatternY(),
                e = a.getFillPatternScale(),
                f = Kinetic.getAngle(a.getFillPatternRotation()),
                g = a.getFillPatternOffset(),
                h = a.getFillPatternRepeat();
            (c || d) && this.translate(c || 0, d || 0), f && this.rotate(f), e && this.scale(e.x, e.y), g && this.translate(-1 * g.x, -1 * g.y), this.setAttr("fillStyle", this.createPattern(b, h || "repeat")), this.fill()
        },
        _fillLinearGradient: function(a) {
            var b = a.getFillLinearGradientStartPoint(),
                c = a.getFillLinearGradientEndPoint(),
                d = a.getFillLinearGradientColorStops(),
                e = this.createLinearGradient(b.x, b.y, c.x, c.y);
            if (d) {
                for (var f = 0; f < d.length; f += 2) e.addColorStop(d[f], d[f + 1]);
                this.setAttr("fillStyle", e), this.fill()
            }
        },
        _fillRadialGradient: function(a) {
            for (var b = a.getFillRadialGradientStartPoint(), c = a.getFillRadialGradientEndPoint(), d = a.getFillRadialGradientStartRadius(), e = a.getFillRadialGradientEndRadius(), f = a.getFillRadialGradientColorStops(), g = this.createRadialGradient(b.x, b.y, d, c.x, c.y, e), h = 0; h < f.length; h += 2) g.addColorStop(f[h], f[h + 1]);
            this.setAttr("fillStyle", g), this.fill()
        },
        _fill: function(a) {
            var b = a.fill() || a.fillRed() || a.fillGreen() || a.fillBlue(),
                c = a.getFillPatternImage(),
                d = a.getFillLinearGradientColorStops(),
                e = a.getFillRadialGradientColorStops(),
                f = a.getFillPriority();
            b && "color" === f ? this._fillColor(a) : c && "pattern" === f ? this._fillPattern(a) : d && "linear-gradient" === f ? this._fillLinearGradient(a) : e && "radial-gradient" === f ? this._fillRadialGradient(a) : b ? this._fillColor(a) : c ? this._fillPattern(a) : d ? this._fillLinearGradient(a) : e && this._fillRadialGradient(a)
        },
        _stroke: function(a) {
            var b = a.dash(),
                c = a.getStrokeScaleEnabled();
            a.hasStroke() && (c || (this.save(), this.setTransform(1, 0, 0, 1, 0, 0)), this._applyLineCap(a), b && a.dashEnabled() && this.setLineDash(b), this.setAttr("lineWidth", a.strokeWidth()), this.setAttr("strokeStyle", a.stroke() || Kinetic.Util._getRGBAString({
                red: a.strokeRed(),
                green: a.strokeGreen(),
                blue: a.strokeBlue(),
                alpha: a.strokeAlpha()
            })), a._strokeFunc(this), c || this.restore())
        },
        _applyShadow: function(a) {
            var b = Kinetic.Util,
                c = a.getAbsoluteOpacity(),
                d = b.get(a.getShadowColor(), "black"),
                e = b.get(a.getShadowBlur(), 5),
                f = b.get(a.getShadowOpacity(), 1),
                g = b.get(a.getShadowOffset(), {
                    x: 0,
                    y: 0
                });
            f && this.setAttr("globalAlpha", f * c), this.setAttr("shadowColor", d), this.setAttr("shadowBlur", e), this.setAttr("shadowOffsetX", g.x), this.setAttr("shadowOffsetY", g.y)
        }
    }, Kinetic.Util.extend(Kinetic.SceneContext, Kinetic.Context), Kinetic.HitContext = function(a) {
        Kinetic.Context.call(this, a)
    }, Kinetic.HitContext.prototype = {
        _fill: function(a) {
            this.save(), this.setAttr("fillStyle", a.colorKey), a._fillFuncHit(this), this.restore()
        },
        _stroke: function(a) {
            a.hasStroke() && (this._applyLineCap(a), this.setAttr("lineWidth", a.strokeWidth()), this.setAttr("strokeStyle", a.colorKey), a._strokeFuncHit(this))
        }
    }, Kinetic.Util.extend(Kinetic.HitContext, Kinetic.Context)
}(),
function() {
    var a = "get",
        b = "set";
    Kinetic.Factory = {
        addGetterSetter: function(a, b, c, d, e) {
            this.addGetter(a, b, c), this.addSetter(a, b, d, e), this.addOverloadedGetterSetter(a, b)
        },
        addGetter: function(b, c, d) {
            var e = a + Kinetic.Util._capitalize(c);
            b.prototype[e] = function() {
                var a = this.attrs[c];
                return void 0 === a ? d : a
            }
        },
        addSetter: function(a, c, d, e) {
            var f = b + Kinetic.Util._capitalize(c);
            a.prototype[f] = function(a) {
                return d && (a = d.call(this, a)), this._setAttr(c, a), e && e.call(this), this
            }
        },
        addComponentsGetterSetter: function(c, d, e, f, g) {
            var h, i, j = e.length,
                k = Kinetic.Util._capitalize,
                l = a + k(d),
                m = b + k(d);
            c.prototype[l] = function() {
                var a = {};
                for (h = 0; j > h; h++) i = e[h], a[i] = this.getAttr(d + k(i));
                return a
            }, c.prototype[m] = function(a) {
                var b, c = this.attrs[d];
                f && (a = f.call(this, a));
                for (b in a) this._setAttr(d + k(b), a[b]);
                return this._fireChangeEvent(d, c, a), g && g.call(this), this
            }, this.addOverloadedGetterSetter(c, d)
        },
        addOverloadedGetterSetter: function(c, d) {
            var e = Kinetic.Util._capitalize(d),
                f = b + e,
                g = a + e;
            c.prototype[d] = function() {
                return arguments.length ? (this[f](arguments[0]), this) : this[g]()
            }
        },
        backCompat: function(a, b) {
            var c;
            for (c in b) a.prototype[c] = a.prototype[b[c]]
        },
        afterSetFilter: function() {
            this._filterUpToDate = !1
        }
    }, Kinetic.Validators = {
        RGBComponent: function(a) {
            return a > 255 ? 255 : 0 > a ? 0 : Math.round(a)
        },
        alphaComponent: function(a) {
            return a > 1 ? 1 : 1e-4 > a ? 1e-4 : a
        }
    }
}(),
function() {
    var a = "absoluteOpacity",
        b = "absoluteTransform",
        c = "Change",
        d = "children",
        e = ".",
        f = "",
        g = "get",
        h = "id",
        i = "kinetic",
        j = "listening",
        k = "mouseenter",
        l = "mouseleave",
        m = "name",
        n = "set",
        o = "Shape",
        p = " ",
        q = "stage",
        r = "transform",
        s = "Stage",
        t = "visible",
        u = ["id"],
        v = ["xChange.kinetic", "yChange.kinetic", "scaleXChange.kinetic", "scaleYChange.kinetic", "skewXChange.kinetic", "skewYChange.kinetic", "rotationChange.kinetic", "offsetXChange.kinetic", "offsetYChange.kinetic", "transformsEnabledChange.kinetic"].join(p);
    Kinetic.Util.addMethods(Kinetic.Node, {
        _init: function(c) {
            var d = this;
            this._id = Kinetic.idCounter++, this.eventListeners = {}, this.attrs = {}, this._cache = {}, this._filterUpToDate = !1, this.setAttrs(c), this.on(v, function() {
                this._clearCache(r), d._clearSelfAndDescendantCache(b)
            }), this.on("visibleChange.kinetic", function() {
                d._clearSelfAndDescendantCache(t)
            }), this.on("listeningChange.kinetic", function() {
                d._clearSelfAndDescendantCache(j)
            }), this.on("opacityChange.kinetic", function() {
                d._clearSelfAndDescendantCache(a)
            })
        },
        _clearCache: function(a) {
            a ? delete this._cache[a] : this._cache = {}
        },
        _getCache: function(a, b) {
            var c = this._cache[a];
            return void 0 === c && (this._cache[a] = b.call(this)), this._cache[a]
        },
        _clearSelfAndDescendantCache: function(a) {
            this._clearCache(a), this.children && this.getChildren().each(function(b) {
                b._clearSelfAndDescendantCache(a)
            })
        },
        clearCache: function() {
            return delete this._cache.canvas, this._filterUpToDate = !1, this
        },
        cache: function(a) {
            {
                var b = a || {},
                    c = b.x || 0,
                    d = b.y || 0,
                    e = b.width || this.width(),
                    f = b.height || this.height(),
                    g = b.drawBorder || !1;
                this.getLayer()
            }
            if (0 === e || 0 === f) return void Kinetic.Util.warn("Width or height of caching configuration equals 0. Cache is ignored.");
            var h = new Kinetic.SceneCanvas({
                    pixelRatio: 1,
                    width: e,
                    height: f
                }),
                i = new Kinetic.SceneCanvas({
                    pixelRatio: 1,
                    width: e,
                    height: f
                }),
                j = new Kinetic.HitCanvas({
                    width: e,
                    height: f
                }),
                k = (this.transformsEnabled(), this.x(), this.y(), h.getContext()),
                l = j.getContext();
            return this.clearCache(), k.save(), l.save(), g && (k.save(), k.beginPath(), k.rect(0, 0, e, f), k.closePath(), k.setAttr("strokeStyle", "red"), k.setAttr("lineWidth", 5), k.stroke(), k.restore()), k.translate(-1 * c, -1 * d), l.translate(-1 * c, -1 * d), "Shape" === this.nodeType && (k.translate(-1 * this.x(), -1 * this.y()), l.translate(-1 * this.x(), -1 * this.y())), this.drawScene(h, this), this.drawHit(j, this), k.restore(), l.restore(), this._cache.canvas = {
                scene: h,
                filter: i,
                hit: j
            }, this
        },
        _drawCachedSceneCanvas: function(a) {
            a.save(), this.getLayer()._applyTransform(this, a), a.drawImage(this._getCachedSceneCanvas()._canvas, 0, 0), a.restore()
        },
        _getCachedSceneCanvas: function() {
            var a, b, c, d, e = this.filters(),
                f = this._cache.canvas,
                g = f.scene,
                h = f.filter,
                i = h.getContext();
            if (e) {
                if (!this._filterUpToDate) {
                    try {
                        for (a = e.length, i.clear(), i.drawImage(g._canvas, 0, 0), b = i.getImageData(0, 0, h.getWidth(), h.getHeight()), c = 0; a > c; c++) d = e[c], d.call(this, b), i.putImageData(b, 0, 0)
                    } catch (j) {
                        Kinetic.Util.warn("Unable to apply filter. " + j.message)
                    }
                    this._filterUpToDate = !0
                }
                return h
            }
            return g
        },
        _drawCachedHitCanvas: function(a) {
            var b = this._cache.canvas,
                c = b.hit;
            a.save(), this.getLayer()._applyTransform(this, a), a.drawImage(c._canvas, 0, 0), a.restore()
        },
        on: function(a, b) {
            var c, d, g, h, i, j = a.split(p),
                k = j.length;
            for (c = 0; k > c; c++) d = j[c], g = d.split(e), h = g[0], i = g[1] || f, this.eventListeners[h] || (this.eventListeners[h] = []), this.eventListeners[h].push({
                name: i,
                handler: b
            });
            return this
        },
        off: function(a) {
            var b, c, d, f, g, h, i = a.split(p),
                j = i.length;
            for (b = 0; j > b; b++)
                if (d = i[b], f = d.split(e), g = f[0], h = f[1], g) this.eventListeners[g] && this._off(g, h);
                else
                    for (c in this.eventListeners) this._off(c, h);
            return this
        },
        dispatchEvent: function(a) {
            var b = {
                target: this,
                type: a.type,
                evt: a
            };
            this.fire(a.type, b)
        },
        addEventListener: function(a, b) {
            this.on(a, function(a) {
                b.call(this, a.evt)
            })
        },
        remove: function() {
            var c = this.getParent();
            return c && c.children && (c.children.splice(this.index, 1), c._setChildrenIndices(), delete this.parent), this._clearSelfAndDescendantCache(q), this._clearSelfAndDescendantCache(b), this._clearSelfAndDescendantCache(t), this._clearSelfAndDescendantCache(j), this._clearSelfAndDescendantCache(a), this
        },
        destroy: function() {
            Kinetic._removeId(this.getId()), Kinetic._removeName(this.getName(), this._id), this.remove()
        },
        getAttr: function(a) {
            var b = g + Kinetic.Util._capitalize(a);
            return Kinetic.Util._isFunction(this[b]) ? this[b]() : this.attrs[a]
        },
        getAncestors: function() {
            for (var a = this.getParent(), b = new Kinetic.Collection; a;) b.push(a), a = a.getParent();
            return b
        },
        getAttrs: function() {
            return this.attrs || {}
        },
        setAttrs: function(a) {
            var b, c;
            if (a)
                for (b in a) b === d || (c = n + Kinetic.Util._capitalize(b), Kinetic.Util._isFunction(this[c]) ? this[c](a[b]) : this._setAttr(b, a[b]));
            return this
        },
        isListening: function() {
            return this._getCache(j, this._isListening)
        },
        _isListening: function() {
            var a = this.getListening(),
                b = this.getParent();
            return "inherit" === a ? b ? b.isListening() : !0 : a
        },
        isVisible: function() {
            return this._getCache(t, this._isVisible)
        },
        _isVisible: function() {
            var a = this.getVisible(),
                b = this.getParent();
            return "inherit" === a ? b ? b.isVisible() : !0 : a
        },
        shouldDrawHit: function() {
            var a = this.getLayer();
            return a && a.hitGraphEnabled() && this.isListening() && this.isVisible() && !Kinetic.isDragging()
        },
        show: function() {
            return this.setVisible(!0), this
        },
        hide: function() {
            return this.setVisible(!1), this
        },
        getZIndex: function() {
            return this.index || 0
        },
        getAbsoluteZIndex: function() {
            function a(i) {
                for (b = [], c = i.length, d = 0; c > d; d++) e = i[d], h++, e.nodeType !== o && (b = b.concat(e.getChildren().toArray())), e._id === g._id && (d = c);
                b.length > 0 && b[0].getDepth() <= f && a(b)
            }
            var b, c, d, e, f = this.getDepth(),
                g = this,
                h = 0;
            return g.nodeType !== s && a(g.getStage().getChildren()), h
        },
        getDepth: function() {
            for (var a = 0, b = this.parent; b;) a++, b = b.parent;
            return a
        },
        setPosition: function(a) {
            return this.setX(a.x), this.setY(a.y), this
        },
        getPosition: function() {
            return {
                x: this.getX(),
                y: this.getY()
            }
        },
        getAbsolutePosition: function() {
            var a = this.getAbsoluteTransform().getMatrix(),
                b = new Kinetic.Transform,
                c = this.offset();
            return b.m = a.slice(), b.translate(c.x, c.y), b.getTranslation()
        },
        setAbsolutePosition: function(a) {
            var b, c = this._clearTransform();
            return this.attrs.x = c.x, this.attrs.y = c.y, delete c.x, delete c.y, b = this.getAbsoluteTransform(), b.invert(), b.translate(a.x, a.y), a = {
                x: this.attrs.x + b.getTranslation().x,
                y: this.attrs.y + b.getTranslation().y
            }, this.setPosition({
                x: a.x,
                y: a.y
            }), this._setTransform(c), this
        },
        _setTransform: function(a) {
            var c;
            for (c in a) this.attrs[c] = a[c];
            this._clearCache(r), this._clearSelfAndDescendantCache(b)
        },
        _clearTransform: function() {
            var a = {
                x: this.getX(),
                y: this.getY(),
                rotation: this.getRotation(),
                scaleX: this.getScaleX(),
                scaleY: this.getScaleY(),
                offsetX: this.getOffsetX(),
                offsetY: this.getOffsetY(),
                skewX: this.getSkewX(),
                skewY: this.getSkewY()
            };
            return this.attrs.x = 0, this.attrs.y = 0, this.attrs.rotation = 0, this.attrs.scaleX = 1, this.attrs.scaleY = 1, this.attrs.offsetX = 0, this.attrs.offsetY = 0, this.attrs.skewX = 0, this.attrs.skewY = 0, this._clearCache(r), this._clearSelfAndDescendantCache(b), a
        },
        move: function(a) {
            var b = a.x,
                c = a.y,
                d = this.getX(),
                e = this.getY();
            return void 0 !== b && (d += b), void 0 !== c && (e += c), this.setPosition({
                x: d,
                y: e
            }), this
        },
        _eachAncestorReverse: function(a, b) {
            var c, d, e = [],
                f = this.getParent();
            if (b && b._id === this._id) return a(this), !0;
            for (e.unshift(this); f && (!b || f._id !== b._id);) e.unshift(f), f = f.parent;
            for (c = e.length, d = 0; c > d; d++) a(e[d])
        },
        rotate: function(a) {
            return this.setRotation(this.getRotation() + a), this
        },
        moveToTop: function() {
            if (!this.parent) return void Kinetic.Util.warn("Node has no parent. moveToTop function is ignored.");
            var a = this.index;
            return this.parent.children.splice(a, 1), this.parent.children.push(this), this.parent._setChildrenIndices(), !0
        },
        moveUp: function() {
            if (!this.parent) return void Kinetic.Util.warn("Node has no parent. moveUp function is ignored.");
            var a = this.index,
                b = this.parent.getChildren().length;
            return b - 1 > a ? (this.parent.children.splice(a, 1), this.parent.children.splice(a + 1, 0, this), this.parent._setChildrenIndices(), !0) : !1
        },
        moveDown: function() {
            if (!this.parent) return void Kinetic.Util.warn("Node has no parent. moveDown function is ignored.");
            var a = this.index;
            return a > 0 ? (this.parent.children.splice(a, 1), this.parent.children.splice(a - 1, 0, this), this.parent._setChildrenIndices(), !0) : !1
        },
        moveToBottom: function() {
            if (!this.parent) return void Kinetic.Util.warn("Node has no parent. moveToBottom function is ignored.");
            var a = this.index;
            return a > 0 ? (this.parent.children.splice(a, 1), this.parent.children.unshift(this), this.parent._setChildrenIndices(), !0) : !1
        },
        setZIndex: function(a) {
            if (!this.parent) return void Kinetic.Util.warn("Node has no parent. zIndex parameter is ignored.");
            var b = this.index;
            return this.parent.children.splice(b, 1), this.parent.children.splice(a, 0, this), this.parent._setChildrenIndices(), this
        },
        getAbsoluteOpacity: function() {
            return this._getCache(a, this._getAbsoluteOpacity)
        },
        _getAbsoluteOpacity: function() {
            var a = this.getOpacity();
            return this.getParent() && (a *= this.getParent().getAbsoluteOpacity()), a
        },
        moveTo: function(a) {
            return Kinetic.Node.prototype.remove.call(this), a.add(this), this
        },
        toObject: function() {
            var a, b, c, d, e = Kinetic.Util,
                f = {},
                g = this.getAttrs();
            f.attrs = {};
            for (a in g) b = g[a], e._isFunction(b) || e._isElement(b) || e._isObject(b) && e._hasMethods(b) || (c = this[a], delete g[a], d = c ? c.call(this) : null, g[a] = b, d !== b && (f.attrs[a] = b));
            return f.className = this.getClassName(), f
        },
        toJSON: function() {
            return JSON.stringify(this.toObject())
        },
        getParent: function() {
            return this.parent
        },
        getLayer: function() {
            var a = this.getParent();
            return a ? a.getLayer() : null
        },
        getStage: function() {
            return this._getCache(q, this._getStage)
        },
        _getStage: function() {
            var a = this.getParent();
            return a ? a.getStage() : void 0
        },
        fire: function(a, b, c) {
            return c ? this._fireAndBubble(a, b || {}) : this._fire(a, b || {}), this
        },
        getAbsoluteTransform: function(a) {
            return a ? this._getAbsoluteTransform(a) : this._getCache(b, this._getAbsoluteTransform)
        },
        _getAbsoluteTransform: function(a) {
            var b, c, d = new Kinetic.Transform;
            return this._eachAncestorReverse(function(a) {
                b = a.transformsEnabled(), c = a.getTransform(), "all" === b ? d.multiply(c) : "position" === b && d.translate(a.x(), a.y())
            }, a), d
        },
        getTransform: function() {
            return this._getCache(r, this._getTransform)
        },
        _getTransform: function() {
            var a = new Kinetic.Transform,
                b = this.getX(),
                c = this.getY(),
                d = Kinetic.getAngle(this.getRotation()),
                e = this.getScaleX(),
                f = this.getScaleY(),
                g = this.getSkewX(),
                h = this.getSkewY(),
                i = this.getOffsetX(),
                j = this.getOffsetY();
            return (0 !== b || 0 !== c) && a.translate(b, c), 0 !== d && a.rotate(d), (0 !== g || 0 !== h) && a.skew(g, h), (1 !== e || 1 !== f) && a.scale(e, f), (0 !== i || 0 !== j) && a.translate(-1 * i, -1 * j), a
        },
        clone: function(a) {
            var b, c, d, e, f, g = this.getClassName(),
                h = Kinetic.Util.cloneObject(this.attrs);
            for (var j in u) {
                var k = u[j];
                delete h[k]
            }
            for (b in a) h[b] = a[b];
            var l = new Kinetic[g](h);
            for (b in this.eventListeners)
                for (c = this.eventListeners[b], d = c.length, e = 0; d > e; e++) f = c[e], f.name.indexOf(i) < 0 && (l.eventListeners[b] || (l.eventListeners[b] = []), l.eventListeners[b].push(f));
            return l
        },
        toDataURL: function(a) {
            a = a || {};
            var b = a.mimeType || null,
                c = a.quality || null,
                d = this.getStage(),
                e = a.x || 0,
                f = a.y || 0,
                g = new Kinetic.SceneCanvas({
                    width: a.width || this.getWidth() || (d ? d.getWidth() : 0),
                    height: a.height || this.getHeight() || (d ? d.getHeight() : 0),
                    pixelRatio: 1
                }),
                h = g.getContext();
            return h.save(), (e || f) && h.translate(-1 * e, -1 * f), this.drawScene(g), h.restore(), g.toDataURL(b, c)
        },
        toImage: function(a) {
            Kinetic.Util._getImage(this.toDataURL(a), function(b) {
                a.callback(b)
            })
        },
        setSize: function(a) {
            return this.setWidth(a.width), this.setHeight(a.height), this
        },
        getSize: function() {
            return {
                width: this.getWidth(),
                height: this.getHeight()
            }
        },
        getWidth: function() {
            return this.attrs.width || 0
        },
        getHeight: function() {
            return this.attrs.height || 0
        },
        getClassName: function() {
            return this.className || this.nodeType
        },
        getType: function() {
            return this.nodeType
        },
        getDragDistance: function() {
            return void 0 !== this.attrs.dragDistance ? this.attrs.dragDistance : this.parent ? this.parent.getDragDistance() : Kinetic.dragDistance
        },
        _get: function(a) {
            return this.nodeType === a ? [this] : []
        },
        _off: function(a, b) {
            var c, d, e = this.eventListeners[a];
            for (c = 0; c < e.length; c++)
                if (d = e[c].name, !("kinetic" === d && "kinetic" !== b || b && d !== b)) {
                    if (e.splice(c, 1), 0 === e.length) {
                        delete this.eventListeners[a];
                        break
                    }
                    c--
                }
        },
        _fireChangeEvent: function(a, b, d) {
            this._fire(a + c, {
                oldVal: b,
                newVal: d
            })
        },
        setId: function(a) {
            var b = this.getId();
            return Kinetic._removeId(b), Kinetic._addId(this, a), this._setAttr(h, a), this
        },
        setName: function(a) {
            var b = this.getName();
            return Kinetic._removeName(b, this._id), Kinetic._addName(this, a), this._setAttr(m, a), this
        },
        setAttr: function() {
            var a = Array.prototype.slice.call(arguments),
                b = a[0],
                c = a[1],
                d = n + Kinetic.Util._capitalize(b),
                e = this[d];
            return Kinetic.Util._isFunction(e) ? e.call(this, c) : this._setAttr(b, c), this
        },
        _setAttr: function(a, b) {
            var c;
            void 0 !== b && (c = this.attrs[a], this.attrs[a] = b, this._fireChangeEvent(a, c, b))
        },
        _setComponentAttr: function(a, b, c) {
            var d;
            void 0 !== c && (d = this.attrs[a], d || (this.attrs[a] = this.getAttr(a)), this.attrs[a][b] = c, this._fireChangeEvent(a, d, c))
        },
        _fireAndBubble: function(a, b, c) {
            var d = !0;
            b && this.nodeType === o && (b.target = this), a === k && c && this._id === c._id ? d = !1 : a === l && c && this._id === c._id && (d = !1), d && (this._fire(a, b), b && !b.cancelBubble && this.parent && (c && c.parent ? this._fireAndBubble.call(this.parent, a, b, c.parent) : this._fireAndBubble.call(this.parent, a, b)))
        },
        _fire: function(a, b) {
            var c, d = this.eventListeners[a];
            if (b.type = a, d)
                for (c = 0; c < d.length; c++) d[c].handler.call(this, b)
        },
        draw: function() {
            return this.drawScene(), this.drawHit(), this
        }
    }), Kinetic.Node.create = function(a, b) {
        return this._createNode(JSON.parse(a), b)
    }, Kinetic.Node._createNode = function(a, b) {
        var c, d, e, f = Kinetic.Node.prototype.getClassName.call(a),
            g = a.children;
        if (b && (a.attrs.container = b), c = new Kinetic[f](a.attrs), g)
            for (d = g.length, e = 0; d > e; e++) c.add(this._createNode(g[e]));
        return c
    }, Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "position"), Kinetic.Factory.addGetterSetter(Kinetic.Node, "x", 0), Kinetic.Factory.addGetterSetter(Kinetic.Node, "y", 0), Kinetic.Factory.addGetterSetter(Kinetic.Node, "opacity", 1), Kinetic.Factory.addGetter(Kinetic.Node, "name"), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "name"), Kinetic.Factory.addGetter(Kinetic.Node, "id"), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "id"), Kinetic.Factory.addGetterSetter(Kinetic.Node, "rotation", 0), Kinetic.Factory.addComponentsGetterSetter(Kinetic.Node, "scale", ["x", "y"]), Kinetic.Factory.addGetterSetter(Kinetic.Node, "scaleX", 1), Kinetic.Factory.addGetterSetter(Kinetic.Node, "scaleY", 1), Kinetic.Factory.addComponentsGetterSetter(Kinetic.Node, "skew", ["x", "y"]), Kinetic.Factory.addGetterSetter(Kinetic.Node, "skewX", 0), Kinetic.Factory.addGetterSetter(Kinetic.Node, "skewY", 0), Kinetic.Factory.addComponentsGetterSetter(Kinetic.Node, "offset", ["x", "y"]), Kinetic.Factory.addGetterSetter(Kinetic.Node, "offsetX", 0), Kinetic.Factory.addGetterSetter(Kinetic.Node, "offsetY", 0), Kinetic.Factory.addSetter(Kinetic.Node, "dragDistance"), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "dragDistance"), Kinetic.Factory.addSetter(Kinetic.Node, "width", 0), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "width"), Kinetic.Factory.addSetter(Kinetic.Node, "height", 0), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "height"), Kinetic.Factory.addGetterSetter(Kinetic.Node, "listening", "inherit"), Kinetic.Factory.addGetterSetter(Kinetic.Node, "filters", void 0, function(a) {
        return this._filterUpToDate = !1, a
    }), Kinetic.Factory.addGetterSetter(Kinetic.Node, "visible", "inherit"), Kinetic.Factory.addGetterSetter(Kinetic.Node, "transformsEnabled", "all"), Kinetic.Factory.addOverloadedGetterSetter(Kinetic.Node, "size"), Kinetic.Factory.backCompat(Kinetic.Node, {
        rotateDeg: "rotate",
        setRotationDeg: "setRotation",
        getRotationDeg: "getRotation"
    }), Kinetic.Collection.mapMethods(Kinetic.Node)
}(),
function() {
    Kinetic.Filters.Grayscale = function(a) {
        var b, c, d = a.data,
            e = d.length;
        for (b = 0; e > b; b += 4) c = .34 * d[b] + .5 * d[b + 1] + .16 * d[b + 2], d[b] = c, d[b + 1] = c, d[b + 2] = c
    }
}(),
function() {
    Kinetic.Filters.Brighten = function(a) {
        var b, c = 255 * this.brightness(),
            d = a.data,
            e = d.length;
        for (b = 0; e > b; b += 4) d[b] += c, d[b + 1] += c, d[b + 2] += c
    }, Kinetic.Factory.addGetterSetter(Kinetic.Node, "brightness", 0, null, Kinetic.Factory.afterSetFilter)
}(),
function() {
    Kinetic.Filters.Invert = function(a) {
        var b, c = a.data,
            d = c.length;
        for (b = 0; d > b; b += 4) c[b] = 255 - c[b], c[b + 1] = 255 - c[b + 1], c[b + 2] = 255 - c[b + 2]
    }
}(),
function() {
    function a() {
        this.r = 0, this.g = 0, this.b = 0, this.a = 0, this.next = null
    }

function b(a, b) {
        return Math.sqrt(Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2) + Math.pow(a[2] - b[2], 2))
    }

function c(a) {
        for (var b = [0, 0, 0], c = 0; c < a.length; c++) b[0] += a[c][0], b[1] += a[c][1], b[2] += a[c][2];
        return b[0] /= a.length, b[1] /= a.length, b[2] /= a.length, b
    }

function e(a, b) {
        for (var c = 0; c < a.width * a.height; c++) a.data[4 * c + 3] = b[c]
    }

function b(a) {
        a.stroke()
    }

function c(a) {
        a.fill()
    }

function d(a) {
        a.stroke()
    }

function k(a) {
            return 3 * a * a * (1 - a)
        }

function l(a) {
            return 3 * a * (1 - a) * (1 - a)
        }

function m(a) {
            return (1 - a) * (1 - a) * (1 - a)
        }
        var n = h * j(a) + f * k(a) + d * l(a) + b * m(a),
            o = i * j(a) + g * k(a) + e * l(a) + c * m(a);
        return {
            x: n,
            y: o
        }
    }, Kinetic.Path.getPointOnQuadraticBezier = function(a, b, c, d, e, f, g) {
        function h(a) {
            return a * a
        }

function i(a) {
            return 2 * a * (1 - a)
        }

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: kinetic.js

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation