text: /* KUTE.js - The Light Tweening Engine
   * package - SVG Plugin
   * desc - draw SVG strokes, morph SVG and SVG transforms
   * by dnp_theme
   * Licensed under MIT-License
   */
  
  (function (root,factory) {
    if (typeof define === 'function' && define.amd) {
      define(['./kute.js'], factory);
    } else if(typeof module == 'object' && typeof require == 'function') {
      module.exports = factory(require('./kute.js'));
    } else if ( typeof root.KUTE !== 'undefined' ) {
      factory(root.KUTE);
    } else {
      throw new Error("SVG Plugin require KUTE.js.");
    }
  }(this, function(KUTE) {
    'use strict';
  
    var g = typeof global !== 'undefined' ? global : window, K = KUTE, // connect plugin to KUTE object and global
      DOM = K.dom, parseProperty = K.parseProperty, prepareStart = K.prepareStart, getCurrentStyle = K.getCurrentStyle,
      trueColor = K.truC, trueDimension = K.truD, crossCheck = K.crossCheck,
      number = g.Interpolate.number, unit = g.Interpolate.unit, color = g.Interpolate.color, // interpolate functions
      defaultOptions = K.defaultOptions, // default tween options since 1.6.1
  
      // browser detection
      isIE = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})").exec(navigator.userAgent) !== null ? parseFloat( RegExp.$1 ) : false;
  
    if (isIE&&isIE<9) {return;} // return if SVG API is not supported
  
    // here we go with the plugin
    var pathReg = /(m[^(h|v|l)]*|[vhl][^(v|h|l|z)]*)/gmi, ns = 'http://www.w3.org/2000/svg',
      // function(array1, array2, length, progress) for SVG morph
      coords = g.Interpolate.coords = function(a,b,l,v) {
        var points = [];
        for(var i=0;i<l;i++) { // for each point
          points[i] = [];
          for(var j=0;j<2;j++) { // each point coordinate
            points[i].push( ((a[i][j]+(b[i][j]-a[i][j])*v) * 1000 >> 0)/1000 );
          }
        }
        return points;
      };
  
  
    // SVG MORPH
    var getSegments = function(s,e,r){ // getSegments returns an array of points based on a sample size morphPrecision
        var s1 = [], e1 = [], le1 = s.getTotalLength(), le2 = e.getTotalLength(), ml = Math.max(le1,le2),
          d = r, ar = ml / r, j = 0, sl = ar*r; // sl = sample length
  
        while ( (j += r) < sl ) { // populate the points arrays based on morphPrecision as sample size
          s1.push( [s.getPointAtLength(j).x, s.getPointAtLength(j).y]);
          e1.push( [e.getPointAtLength(j).x, e.getPointAtLength(j).y]);
        }
        return [s1,e1];
      },
      getClosestPoint = function(p,t,s){ // utility for polygon paths, returns a close point from the original path (length,pointAtLength,smallest); // intervalLength
        var x, y, a = [], l = s.length, dx, nx, pr;
        for (var i=0; i<l; i++){
          x = Math.abs(s[i][0] - t.x);
          y = Math.abs(s[i][1] - t.y);
          a.push( Math.sqrt( x * x + y * y ) );
        }
        dx = a.indexOf(Math.min.apply(null,a));
        pr = !!s[dx-1] ? dx-1 : l-1;
        nx = !!s[dx+1] ? dx+1 : 0;
        return Math.abs(s[pr][0] - t.x) < p && Math.abs(s[pr][1] - t.y) < p ? s[pr]
        : Math.abs(s[nx][0] - t.x) < p && Math.abs(s[nx][1] - t.y) < p ? s[nx]
        : Math.abs(s[dx][0] - t.x) < p && Math.abs(s[dx][1] - t.y) < p ? s[dx]
        : [t.x,t.y];
      },
      pathToAbsolute = function(p) { // simple utility for polygons | this is still BETA / a work in progress
        var np = p.match(pathReg), wp = [], l = np.length, s, c, r, x = 0, y = 0;
        for (var i = 0; i<l; i++){
          np[i] = np[i]; c = np[i][0]; r = new RegExp(c+'[^\\d|\\-]*','i');
          np[i] = np[i].replace(/(^|[^,])\s*-/g, '$1,-').replace(/(\s+\,|\s|\,)/g,',').replace(r,'').split(',');
          np[i][0] = parseFloat(np[i][0]);
          np[i][1] = parseFloat(np[i][1]);
          if (i === 0) { x+=np[i][0]; y +=np[i][1]; }
          else {
            x = np[i-1][0];
            y = np[i-1][1];
            if (/l/i.test(c)) {
              np[i][0] = c === 'l' ? np[i][0] + x : np[i][0];
              np[i][1] = c === 'l' ? np[i][1] + y : np[i][1];
            } else if (/h/i.test(c)) {
              np[i][0] = c === 'h' ? np[i][0] + x : np[i][0];
              np[i][1] = y;
            } else if (/v/i.test(c)) {
              np[i][0] = x;
              np[i][1] = c === 'v' ? np[i][0] + y : np[i][0];
            }
          }
        }
        return np;
      },
      getOnePath = function(p){ return p.split(/z/i).shift() + 'z'; }, // we only tween first path only
      createPath = function (p){ // create a <path> when glyph
        var createdPath = document.createElementNS(ns,'path'), d = typeof p === 'object' ? p.getAttribute('d') : p;
        createdPath.setAttribute('d',d); return createdPath;
      },
      forcePath = function(p){ // forcePath for glyph elements
        if (p.tagName === 'glyph') { // perhaps we can also change other SVG tags in the future
          var c = createPath(p); p.parentNode.appendChild(c); return c;
        }
        return p;
      },
      clone = function(a) {
        var copy;
        if (a instanceof Array) {
          copy = [];
          for (var i = 0, len = a.length; i < len; i++) {
            copy[i] = clone(a[i]);
          }
          return copy;
        }
        return a;
      },
      getPath = function(e){ // get path d attribute or create a path from string value
        var p = {}, el = typeof e === 'object' ? e : /^\.|^\#/.test(e) ? document.querySelector(e) : null;
        if ( el && /path|glyph/.test(el.tagName) ) {
          p.e = forcePath(el);
          p.o = el.getAttribute('d');
  
        } else if (!el && /[a-z][^a-z]*/ig.test(e)) { // maybe it's a string path already
          p.e = createPath(e.trim());
          p.o = e;
        }
        return p;
      },
      computePathCross = function(s,e){ // pathCross
        var s1, e1, pointsArray, largerPathLength, smallerPath, largerPath, simulatedSmallerPath, nsm = [], sml, cl = [], len, tl, cs,
          index = this.options.morphIndex;
  
        if (!this._isPolygon) {
          s = createPath(s); e = createPath(e);
          pointsArray = getSegments(s,e,this.options.morphPrecision);
          s1 = pointsArray[0]; e1 = pointsArray[1]; largerPathLength = e1.length;
        } else {
          s = pathToAbsolute(s); e = pathToAbsolute(e);
  
          if ( s.length !== e.length ){
            largerPathLength = Math.max(s.length,e.length);
            if ( largerPathLength === e.length) { smallerPath = s; largerPath = e; } else { smallerPath = e; largerPath = s; }
            sml = smallerPath.length;
  
            simulatedSmallerPath = createPath('M'+smallerPath.join('L')+'z'); len = simulatedSmallerPath.getTotalLength() / largerPathLength;
            for (var i=0; i<largerPathLength; i++){
              tl = simulatedSmallerPath.getPointAtLength(len*i);
              cs = getClosestPoint(len,tl,smallerPath);
              nsm.push( [ cs[0], cs[1] ] );
            }
  
            if (largerPathLength === e.length) { e1 = largerPath; s1 = nsm; } else { s1 = largerPath; e1 = nsm; }
          } else {
            s1 = s; e1 = e;
          }
        }
  
        // reverse arrays
        if (this.options.reverseFirstPath) { s1.reverse(); }
        if (this.options.reverseSecondPath) { e1.reverse(); }
  
        // shift second array to for smallest tween distance
        if (index) {
          var e11 = e1.splice(index,largerPathLength-index);
          e1 = e11.concat(e1);
        }
  
        s = e = null;
        return [s1,e1]
      };
  
    // set default morphPrecision since 1.6.1
    defaultOptions.morphPrecision = 15;
  
    // process path object and also register the render function
    parseProperty.path = function(o,v) {
      if (!('path' in DOM)) {
        DOM.path = function(l,p,a,b,v){
          l.setAttribute("d", v === 1 ? b.o : 'M' + coords( a['d'],b['d'],b['d'].length,v ) + 'Z' );
        }
      }
      return getPath(v);
    };
  
    prepareStart.path = function(p){
      return this.element.getAttribute('d');
    };
  
    crossCheck.path = function() { // unlike other cases, the crossCheck apply to both to() and fromTo() methods
      var p1 = getOnePath(this.valuesStart.path.o), p2 = getOnePath(this.valuesEnd.path.o), paths;
  
      // path tween options
      this.options.morphPrecision = this.options && 'morphPrecision' in this.options ? parseInt(this.options.morphPrecision) : defaultOptions.morphPrecision;
      this._isPolygon = !/[CSQTA]/i.test(p1) && !/[CSQTA]/i.test(p2); // check if both shapes are polygons
  
      // begin processing paths
      paths = computePathCross.apply(this,[p1,p2]);
  
      this.valuesStart.path.d = paths[0];
      this.valuesEnd.path.d = paths[1];
    };
  
  
    // SVG DRAW
    var percent = function(v,l){ return parseFloat(v) / 100 * l; },
      // SVG DRAW UTILITITES
      // http://stackoverflow.com/a/30376660
      getRectLength = function(el){ // returns the length of a Rect
        var w = el.getAttribute('width');
        var h = el.getAttribute('height');
        return (w*2)+(h*2);
      },
      getPolyLength = function(el){ // getPolygonLength / getPolylineLength - return the length of the Polygon / Polyline
        var points = el.getAttribute('points').split(' '), len = 0;
        if (points.length > 1) {
          var coord = function (p) {
            var c = p.split(',');
            if (c.length != 2) { return; } // return undefined
            if (isNaN(c[0]) || isNaN(c[1])) { return; }
            return [parseFloat(c[0]), parseFloat(c[1])];
          };
  
          var dist = function (c1, c2) {
            if (c1 != undefined && c2 != undefined) {
              return Math.sqrt(Math.pow((c2[0]-c1[0]), 2) + Math.pow((c2[1]-c1[1]), 2));
            }
            return 0;
          };
  
          if (points.length > 2) {
            for (var i=0; i<points.length-1; i++) {
              len += dist(coord(points[i]), coord(points[i+1]));
            }
          }
          len += el.tagName === 'polygon' ? dist(coord(points[0]), coord(points[points.length - 1])) : 0;
        }
        return len;
      },
      getLineLength = function(el){ // return the length of the line
        var x1 = el.getAttribute('x1');
        var x2 = el.getAttribute('x2');
        var y1 = el.getAttribute('y1');
        var y2 = el.getAttribute('y2');
        return Math.sqrt(Math.pow((x2-x1), 2)+Math.pow((y2-y1),2));
      },
      getCircleLength = function(el){ // return the length of the circle
        var r = el.getAttribute('r');
        return 2 * Math.PI * r;
      },
      getEllipseLength = function(el) { // returns the length of an ellipse
        var rx = el.getAttribute('rx'), ry = el.getAttribute('ry'),
            len = 2*rx, wid = 2*ry;
        return ((Math.sqrt(.5 * ((len * len) + (wid * wid)))) * (Math.PI * 2)) / 2;
      },
      getTotalLength = function(el){ // returns the result of any of the below functions
        if (/rect/.test(el.tagName)) {
          return getRectLength(el);
        } else if (/circle/.test(el.tagName)) {
          return getCircleLength(el);
        } else if (/ellipse/.test(el.tagName)) {
          return getEllipseLength(el);
        } else if (/polygon|polyline/.test(el.tagName)) {
          return getPolyLength(el);
        } else if (/line/.test(el.tagName)) {
          return getLineLength(el);
        }
      },
      getDraw = function(e,v){
        var l = /path|glyph/.test(e.tagName) ? e.getTotalLength() : getTotalLength(e), start, end, d, o;
        if ( v instanceof Object ) {
          return v;
        } else if (typeof v === 'string') {
          v = v.split(/\,|\s/);
          start = /%/.test(v[0]) ? percent(v[0].trim(),l) : parseFloat(v[0]);
          end = /%/.test(v[1]) ? percent(v[1].trim(),l) : parseFloat(v[1]);
        } else if (typeof v === 'undefined') {
          o = parseFloat(getCurrentStyle(e,'stroke-dashoffset'));
          d = getCurrentStyle(e,'stroke-dasharray').split(/\,/);
  
          start = 0-o;
          end = parseFloat(d[0]) + start || l;
        }
        return { s: start, e: end, l: l }
      };
  
    parseProperty.draw = function(a,o){ // register the draw property
      if (!('draw' in DOM)) {
        DOM.draw = function(l,p,a,b,v){
          var pathLength = (a.l*100>>0)/100, start = (number(a.s,b.s,v)*100>>0)/100, end = (number(a.e,b.e,v)*100>>0)/100,
          offset = 0 - start, dashOne = end+offset;
          l.style.strokeDashoffset = offset +'px';
          l.style.strokeDasharray = (((dashOne <1 ? 0 : dashOne)*100>>0)/100) + 'px, ' + pathLength + 'px';
        }
      }
      return getDraw(this.element,o);
    }
  
    prepareStart.draw = function(){
      return getDraw(this.element);
    }
  
  
    // SVG Transform
    var parseStringOrigin = function(origin,box){
        return /[a-zA-Z]/.test(origin) && !/px/.test(origin) ? origin.replace(/top|left/,0).replace(/right|bottom/,100).replace(/center|middle/,50)
                                       : /%/.test(origin) ? (box.x + parseFloat(origin) * box.width / 100) : parseFloat(origin);
      },
      parseTransformString = function (a){ // helper function that turns transform value from string to object
        var d = a && /\)/.test(a) ? a.substring(0, a.length-1).split(/\)\s|\)/) : 'none', c = {};
  
        if (d instanceof Array) {
          for (var j=0, jl = d.length; j<jl; j++){
            var p = d[j].trim().split('('); c[p[0]] = p[1];
          }
        }
        return c;
      },
      parseTransformObject = function(v){
        var svgTransformObject = {}, bb = this.element.getBBox(),
          cx = bb.x + bb.width/2, cy = bb.y + bb.height/2, // by default the transformOrigin is "50% 50%" of the shape box
          origin = this.options.transformOrigin, translation;
  
        origin = !!origin ? (origin instanceof Array ? origin : origin.split(/\s/)) : [cx,cy];
  
        origin[0] = typeof origin[0] === 'number' ? origin[0] : parseStringOrigin(origin[0],bb);
        origin[1] = typeof origin[1] === 'number' ? origin[1] : parseStringOrigin(origin[1],bb);
  
        svgTransformObject.origin = origin;
  
        for ( var i in v ) { // populate the valuesStart and / or valuesEnd
          if (i === 'rotate'){
            svgTransformObject[i] = typeof v[i] === 'number' ? v[i] : v[i] instanceof Array ? v[i][0] : v[i].split(/\s/)[0]*1;
          } else if (i === 'translate'){
            translation = v[i] instanceof Array ? v[i] : /\,|\s/.test(v[i]) ? v[i].split(',') : [v[i],0];
            svgTransformObject[i] = [translation[0]*1||0, translation[1]*1||0];
          } else if (/skew/.test(i)) {
            svgTransformObject[i] = v[i]*1||0;
          } else if (i === 'scale'){
            svgTransformObject[i] = parseFloat(v[i])||1;
          }
        }
  
        return svgTransformObject;
      };
  
    parseProperty.svgTransform = function(p,v){
      // register the render function
      if (!('svgTransform' in DOM)) {
        DOM.svgTransform = function(l,p,a,b,v){
          var x = 0, y = 0, tmp, deg = Math.PI/180,
            scale = 'scale' in b ? number(a.scale,b.scale,v) : 1,
            rotate = 'rotate' in b ? number(a.rotate,b.rotate,v) : 0,
            sin = Math.sin(rotate*deg), cos = Math.cos(rotate*deg),
            skewX = 'skewX' in b ? number(a.skewX,b.skewX,v) : 0,
            skewY = 'skewY' in b ? number(a.skewY,b.skewY,v) : 0,
            complex = rotate||skewX||skewY||scale!==1 || 0;
  
          // start normalizing the translation, we start from last to first (from last chained translation)
          // the normalized translation will handle the transformOrigin tween option and makes sure to have a consistent transformation
          x -= complex ? b.origin[0] : 0; y -= complex ? b.origin[1] : 0; // we start with removing transformOrigin from translation
          x *= scale; y *= scale; // we now apply the scale
          y += skewY ? x*Math.tan(skewY*deg) : 0; x += skewX ? y*Math.tan(skewX*deg) : 0; // now we apply skews
          tmp = cos*x - sin*y; // apply rotation as well
          y = rotate ? sin*x + cos*y : y; x = rotate ? tmp : x;
          x += 'translate' in b ? number(a.translate[0],b.translate[0],v) : 0; // now we apply the actual translation
          y += 'translate' in b ? number(a.translate[1],b.translate[1],v) : 0;
          x += complex ? b.origin[0] : 0; y += complex ? b.origin[1] : 0; // normalizing ends with the addition of the transformOrigin to the translation
  
          // finally we apply the transform attribute value
          l.setAttribute('transform', ( x||y ? ('translate(' + (x*1000>>0)/1000 + ( y ? (',' + ((y*1000>>0)/1000)) : '') + ')') : '' )
                                      +( rotate ? 'rotate(' + (rotate*1000>>0)/1000 + ')' : '' )
                                      +( skewX ? 'skewX(' + (skewX*1000>>0)/1000 + ')' : '' )
                                      +( skewY ? 'skewY(' + (skewY*1000>>0)/1000 + ')' : '' )
                                      +( scale !== 1 ? 'scale(' + (scale*1000>>0)/1000 +')' : '' ) );
        }
      }
  
      // now prepare transform
      return parseTransformObject.call(this,v);
    }
  
    // returns an obect with current transform attribute value
    prepareStart.svgTransform = function(p,t) {
      var transformObject = {}, currentTransform = parseTransformString(this.element.getAttribute('transform'));
      for (var i in t) { transformObject[i] = i in currentTransform ? currentTransform[i] : (i==='scale'?1:0); } // find a value in current attribute value or add a default value
      return transformObject;
    }
  
    crossCheck.svgTransform = function() { // helper function that helps preserve current transform properties into the objects
      if (!this.options.rpr) return; // fix since 1.6.1 for fromTo() method
      var valuesStart = this.valuesStart.svgTransform, valuesEnd = this.valuesEnd.svgTransform,
        currentTransform = parseTransformObject.call(this, parseTransformString(this.element.getAttribute('transform')) );
  
      for ( var i in currentTransform ) { valuesStart[i] = currentTransform[i]; } // populate the valuesStart first
  
      // now try to determine the REAL translation
      var parentSVG = this.element.ownerSVGElement,
        newTransform = parentSVG.createSVGTransformFromMatrix(
          parentSVG.createSVGMatrix()
          .translate(-valuesStart.origin[0],-valuesStart.origin[1]) // - origin
          .translate('translate' in valuesStart ? valuesStart.translate[0] : 0,'translate' in valuesStart ? valuesStart.translate[1] : 0) // the current translate
          .rotate(valuesStart.rotate||0).skewX(valuesStart.skewX||0).skewY(valuesStart.skewY||0).scale(valuesStart.scale||1)// the other functions
          .translate(+valuesStart.origin[0],+valuesStart.origin[1]) // + origin
        );
  
      valuesStart.translate = [newTransform.matrix.e,newTransform.matrix.f]; // finally the translate we're looking for
  
      // copy existing and unused properties to the valuesEnd
      for ( var i in valuesStart) { if ( !(i in valuesEnd)) { valuesEnd[i] = valuesStart[i]; } }
    }
  
    return this;
  }));