vendor: 4,569 bytes, lines 1-3
1(function ($) { 2 3 !function (a, b) { "object" == typeof exports && "undefined" != typeof module ? b(exports) : "function" == typeof define && define.amd ? define(["exports"], b) : b((a = a || self).window = a.window || {}) }(this, function (a) { "use strict"; function k() { return "undefined" != typeof window } function f() { return i || k() && (i = window.gsap) && i.registerPlugin && i } function l(a) { return Math.round(1e4 * a) / 1e4 } function m(a) { return parseFloat(a) || 0 } function n(a, c) { var b = m(a); return ~a.indexOf("%") ? b / 100 * c : b } function o(a, b) { return m(a.getAttribute(b)) } function p(a, b, c, d, e, f) { return A(Math.pow((m(c) - m(a)) * e, 2) + Math.pow((m(d) - m(b)) * f, 2)) } function q(a) { return console.warn(a) } function r(a) { return "non-scaling-stroke" === a.getAttribute("vector-effect") } function g(c) { if (!(c = t(c)[0])) return 0; var e, m, d, v, h, n, s, b = c.tagName.toLowerCase(), u = c.style, i = 1, a = 1; r(c) && (i = A((a = c.getScreenCTM()).a * a.a + a.b * a.b), a = A(a.d * a.d + a.c * a.c)); try { m = c.getBBox() } catch (w) { q("Some browsers won't measure invisible elements (like display:none or masks inside defs).") } var j = m || { x: 0, y: 0, width: 0, height: 0 }, k = j.x, _ = j.y, f = j.width, g = j.height; if (m && (f || g) || !z[b] || (f = o(c, z[b][0]), g = o(c, z[b][1]), "rect" !== b && "line" !== b && (f *= 2, g *= 2), "line" === b && (k = o(c, "x1"), _ = o(c, "y1"), f = Math.abs(f - k), g = Math.abs(g - _))), "path" === b) v = u.strokeDasharray, u.strokeDasharray = "none", e = c.getTotalLength() || 0, l(i) !== l(a) && !x && (x = 1) && q("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled."), e *= (i + a) / 2, u.strokeDasharray = v; else if ("rect" === b) e = 2 * f * i + 2 * g * a; else if ("line" === b) e = p(k, _, k + f, _ + g, i, a); else if ("polyline" === b || "polygon" === b) for (d = c.getAttribute("points").match(y) || [], "polygon" === b && d.push(d[0], d[1]), e = 0, h = 2; h < d.length; h += 2)e += p(d[h - 2], d[h - 1], d[h], d[h + 1], i, a) || 0; else "circle" !== b && "ellipse" !== b || (e = Math.PI * (3 * ((n = f / 2 * i) + (s = g / 2 * a)) - A((3 * n + s) * (n + 3 * s)))); return e || 0 } function h(c, b) { if (!(c = t(c)[0])) return [0, 0]; b = b || g(c) + 1; var e = u.getComputedStyle(c), a = e.strokeDasharray || "", f = m(e.strokeDashoffset), d = a.indexOf(","); return d < 0 && (d = a.indexOf(" ")), b < (a = d < 0 ? b : m(a.substr(0, d))) && (a = b), [-f || 0, a - f || 0] } function s() { k() && (u = window, w = i = f(), t = i.utils.toArray, v = -1 !== ((u.navigator || {}).userAgent || "").indexOf("Edge")) } var d, b, e, i, t, u, v, w, x, y = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi, z = { rect: ["width", "height"], circle: ["r", "r"], ellipse: ["rx", "ry"], line: ["x2", "y2"] }, A = Math.sqrt, j = function () { return String.fromCharCode.apply(null, arguments) }(109), B = (d = "undefined" != typeof window ? window.location.host : "", window, b = [j], e = b.length, -1 !== d.indexOf(b[e]) || !0), c = { version: "3.10.4", name: "PaSvgDrawer", register: function (a) { i = a, s() }, init: function (b, a) { if (!b.getBBox) return !1; w || s(); var i, c, k, e, o, p, d, f, j, q = g(b); return this._style = b.style, this._target = b, a + "" == "true" ? a = "0 100%" : a ? -1 === (a + "").indexOf(" ") && (a = "0 " + a) : a = "0 0", c = (e = a, o = q, p = (i = h(b, q))[0], j = e.indexOf(" "), f = j < 0 ? (d = void 0 !== p ? p + "" : e, e) : (d = e.substr(0, j), e.substr(j + 1)), d = n(d, o), (f = n(f, o)) < d ? [f, d] : [d, f]), this._length = l(q), this._dash = l(i[1] - i[0]), this._offset = l(-i[0]), this._dashPT = this.add(this, "_dash", this._dash, l(c[1] - c[0])), this._offsetPT = this.add(this, "_offset", this._offset, l(-c[0])), v && (k = u.getComputedStyle(b)).strokeLinecap !== k.strokeLinejoin && (c = m(k.strokeMiterlimit), this.add(b.style, "strokeMiterlimit", c, c + .01)), this._live = r(b) || ~(a + "").indexOf("live"), this._nowrap = ~(a + "").indexOf("nowrap"), this._props.push("PaSvgDrawer"), B }, render: function (h, a) { var b, e, c, d, f = a._pt, i = a._style; if (f) { for (a._live && (b = g(a._target)) !== a._length && (e = b / a._length, a._length = b, a._offsetPT && (a._offsetPT.s *= e, a._offsetPT.c *= e), a._dashPT ? (a._dashPT.s *= e, a._dashPT.c *= e) : a._dash *= e); f;)f.r(h, f.d), f = f._next; c = a._dash || h && 1 !== h && 1e-4 || 0, b = a._length - c + .1, d = a._offset, c && d && c + Math.abs(d % a._length) >
vendor: 8,922 bytes, lines 3-233
3 a._length - .2 && (d += d < 0 ? .1 : -0.1) && (b += .1), i.strokeDashoffset = c ? d : d + .001, i.strokeDasharray = b < .2 ? "none" : c ? c + "px," + (a._nowrap ? 999999 : b) + "px" : "0px, 999999px" } }, getLength: g, getPosition: h }; f() && i.registerPlugin(c), a.PaSvgDrawer = c, a.default = c, "undefined" == typeof window || window !== a ? Object.defineProperty(a, "__esModule", { value: !0 }) : delete a.default }); 4 5 (function (global, factory) { 6 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : 7 typeof define === 'function' && define.amd ? define(['exports'], factory) : 8 (global = global || self, factory(global.window = global.window || {})); 9 }(this, (function (exports) { 10 'use strict'; 11 12 var _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 13 _numbersExp = /(?:(-)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, 14 _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig, 15 _selectorExp = /(^[#\.][a-z]|[a-y][a-z])/i, 16 _DEG2RAD = Math.PI / 180, 17 _RAD2DEG = 180 / Math.PI, 18 _sin = Math.sin, 19 _cos = Math.cos, 20 _abs = Math.abs, 21 _sqrt = Math.sqrt, 22 _atan2 = Math.atan2, 23 _largeNum = 1e8, 24 _isString = function _isString(value) { 25 return typeof value === "string"; 26 }, 27 _isNumber = function _isNumber(value) { 28 return typeof value === "number"; 29 }, 30 _isUndefined = function _isUndefined(value) { 31 return typeof value === "undefined"; 32 }, 33 _temp = {}, 34 _temp2 = {}, 35 _roundingNum = 1e5, 36 _wrapProgress = function _wrapProgress(progress) { 37 return Math.round((progress + _largeNum) % 1 * _roundingNum) / _roundingNum || (progress < 0 ? 0 : 1); 38 }, 39 _round = function _round(value) { 40 return Math.round(value * _roundingNum) / _roundingNum || 0; 41 }, 42 _roundPrecise = function _roundPrecise(value) { 43 return Math.round(value * 1e10) / 1e10 || 0; 44 }, 45 _splitSegment = function _splitSegment(rawPath, segIndex, i, t) { 46 var segment = rawPath[segIndex], 47 shift = t === 1 ? 6 : subdivideSegment(segment, i, t); 48 49 if (shift && shift + i + 2 < segment.length) { 50 rawPath.splice(segIndex, 0, segment.slice(0, i + shift + 2)); 51 segment.splice(0, i + shift); 52 return 1; 53 } 54 }, 55 _getSampleIndex = function _getSampleIndex(samples, length, progress) { 56 var l = samples.length, 57 i = ~~(progress * l); 58 59 if (samples[i] > length) { 60 while (--i && samples[i] > length) { } 61 62 i < 0 && (i = 0); 63 } else { 64 while (samples[++i] < length && i < l) { } 65 } 66 67 return i < l ? i : l - 1; 68 }, 69 _reverseRawPath = function _reverseRawPath(rawPath, skipOuter) { 70 var i = rawPath.length; 71 skipOuter || rawPath.reverse(); 72 73 while (i--) { 74 rawPath[i].reversed || reverseSegment(rawPath[i]); 75 } 76 }, 77 _copyMetaData = function _copyMetaData(source, copy) { 78 copy.totalLength = source.totalLength; 79 80 if (source.samples) { 81 copy.samples = source.samples.slice(0); 82 copy.lookup = source.lookup.slice(0); 83 copy.minLength = source.minLength; 84 copy.resolution = source.resolution; 85 } else if (source.totalPoints) { 86 copy.totalPoints = source.totalPoints; 87 } 88 89 return copy; 90 }, 91 _appendOrMerge = function _appendOrMerge(rawPath, segment) { 92 var index = rawPath.length, 93 prevSeg = rawPath[index - 1] || [], 94 l = prevSeg.length; 95 96 if (index && segment[0] === prevSeg[l - 2] && segment[1] === prevSeg[l - 1]) { 97 segment = prevSeg.concat(segment.slice(2)); 98 index--; 99 } 100 101 rawPath[index] = segment; 102 }; 103 104 function getRawPath(value) { 105 value = _isString(value) && _selectorExp.test(value) ? document.querySelector(value) || value : value; 106 var e = value.getAttribute ? value : 0, 107 rawPath; 108 109 if (e && (value = value.getAttribute("d"))) { 110 if (!e._gsPath) { 111 e._gsPath = {}; 112 } 113 114 rawPath = e._gsPath[value]; 115 return rawPath && !rawPath._dirty ? rawPath : e._gsPath[value] = stringToRawPath(value); 116 } 117 118 return !value ? console.warn("Expecting a <path> element or an SVG path data string") : _isString(value) ? stringToRawPath(value) : _isNumber(value[0]) ? [value] : value; 119 } 120 function copyRawPath(rawPath) { 121 var a = [], 122 i = 0; 123 124 for (; i < rawPath.length; i++) { 125 a[i] = _copyMetaData(rawPath[i], rawPath[i].slice(0)); 126 } 127 128 return _copyMetaData(rawPath, a); 129 } 130 function reverseSegment(segment) { 131 var i = 0, 132 y; 133 segment.reverse(); 134 135 for (; i < segment.length; i += 2) { 136 y = segment[i]; 137 segment[i] = segment[i + 1]; 138 segment[i + 1] = y; 139 } 140 141 segment.reversed = !segment.reversed; 142 } 143 144 var _createPath = function _createPath(e, ignore) { 145 var path = document.createElementNS("http://www.w3.org/2000/svg", "path"), 146 attr = [].slice.call(e.attributes), 147 i = attr.length, 148 name; 149 ignore = "," + ignore + ","; 150 151 while (--i > -1) { 152 name = attr[i].nodeName.toLowerCase(); 153 154 if (ignore.indexOf("," + name + ",") < 0) { 155 path.setAttributeNS(null, name, attr[i].nodeValue); 156 } 157 } 158 159 return path; 160 }, 161 _typeAttrs = { 162 rect: "rx,ry,x,y,width,height", 163 circle: "r,cx,cy", 164 ellipse: "rx,ry,cx,cy", 165 line: "x1,x2,y1,y2" 166 }, 167 _attrToObj = function _attrToObj(e, attrs) { 168 var props = attrs ? attrs.split(",") : [], 169 obj = {}, 170 i = props.length; 171 172 while (--i > -1) { 173 obj[props[i]] = +e.getAttribute(props[i]) || 0; 174 } 175 176 return obj; 177 }; 178 179 function convertToPath(element, swap) { 180 var type = element.tagName.toLowerCase(), 181 circ = 0.552284749831, 182 data, 183 x, 184 y, 185 r, 186 ry, 187 path, 188 rcirc, 189 rycirc, 190 points, 191 w, 192 h, 193 x2, 194 x3, 195 x4, 196 x5, 197 x6, 198 y2, 199 y3, 200 y4, 201 y5, 202 y6, 203 attr; 204 205 if (type === "path" || !element.getBBox) { 206 return element; 207 } 208 209 path = _createPath(element, "x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points"); 210 attr = _attrToObj(element, _typeAttrs[type]); 211 212 if (type === "rect") { 213 r = attr.rx; 214 ry = attr.ry || r; 215 x = attr.x; 216 y = attr.y; 217 w = attr.width - r * 2; 218 h = attr.height - ry * 2; 219 220 if (r || ry) { 221 x2 = x + r * (1 - circ); 222 x3 = x + r; 223 x4 = x3 + w; 224 x5 = x4 + r * circ; 225 x6 = x4 + r; 226 y2 = y + ry * (1 - circ); 227 y3 = y + ry; 228 y4 = y3 + h; 229 y5 = y4 + ry * circ; 230 y6 = y4 + ry; 231 data = "M" + x6 + "," + y3 + " V" + y4 + " C" + [x6, y5, x5, y6, x4, y6, x4 - (x4 - x3) / 3, y6, x3 + (x4 - x3) / 3, y6, x3, y6, x2, y6, x, y5, x, y4, x, y4 - (y4 - y3) / 3, x, y3 + (y4 - y3) / 3, x, y3, x, y2, x2, y, x3, y, x3 + (x4 - x3) / 3, y, x4 - (x4 - x3) / 3, y, x4, y, x5, y, x6, y2, x6, y3].join(",") + "z"; 232 } else { 233 data = "M" + (x + w) + "," + y + " v" + h + " h" + -w + " v" +
vendor: 9,248 bytes, lines 233-490
233-h + " h" + w + "z"; 234 } 235 } else if (type === "circle" || type === "ellipse") { 236 if (type === "circle") { 237 r = ry = attr.r; 238 rycirc = r * circ; 239 } else { 240 r = attr.rx; 241 ry = attr.ry; 242 rycirc = ry * circ; 243 } 244 245 x = attr.cx; 246 y = attr.cy; 247 rcirc = r * circ; 248 data = "M" + (x + r) + "," + y + " C" + [x + r, y + rycirc, x + rcirc, y + ry, x, y + ry, x - rcirc, y + ry, x - r, y + rycirc, x - r, y, x - r, y - rycirc, x - rcirc, y - ry, x, y - ry, x + rcirc, y - ry, x + r, y - rycirc, x + r, y].join(",") + "z"; 249 } else if (type === "line") { 250 data = "M" + attr.x1 + "," + attr.y1 + " L" + attr.x2 + "," + attr.y2; 251 } else if (type === "polyline" || type === "polygon") { 252 points = (element.getAttribute("points") + "").match(_numbersExp) || []; 253 x = points.shift(); 254 y = points.shift(); 255 data = "M" + x + "," + y + " L" + points.join(","); 256 257 if (type === "polygon") { 258 data += "," + x + "," + y + "z"; 259 } 260 } 261 262 path.setAttribute("d", rawPathToString(path._gsRawPath = stringToRawPath(data))); 263 264 if (swap && element.parentNode) { 265 element.parentNode.insertBefore(path, element); 266 element.parentNode.removeChild(element); 267 } 268 269 return path; 270 } 271 272 function getRotationAtBezierT(segment, i, t) { 273 var a = segment[i], 274 b = segment[i + 2], 275 c = segment[i + 4], 276 x; 277 a += (b - a) * t; 278 b += (c - b) * t; 279 a += (b - a) * t; 280 x = b + (c + (segment[i + 6] - c) * t - b) * t - a; 281 a = segment[i + 1]; 282 b = segment[i + 3]; 283 c = segment[i + 5]; 284 a += (b - a) * t; 285 b += (c - b) * t; 286 a += (b - a) * t; 287 return _round(_atan2(b + (c + (segment[i + 7] - c) * t - b) * t - a, x) * _RAD2DEG); 288 } 289 290 function sliceRawPath(rawPath, start, end) { 291 end = _isUndefined(end) ? 1 : _roundPrecise(end) || 0; 292 start = _roundPrecise(start) || 0; 293 var loops = Math.max(0, ~~(_abs(end - start) - 1e-8)), 294 path = copyRawPath(rawPath); 295 296 if (start > end) { 297 start = 1 - start; 298 end = 1 - end; 299 300 _reverseRawPath(path); 301 302 path.totalLength = 0; 303 } 304 305 if (start < 0 || end < 0) { 306 var offset = Math.abs(~~Math.min(start, end)) + 1; 307 start += offset; 308 end += offset; 309 } 310 311 path.totalLength || cacheRawPathMeasurements(path); 312 var wrap = end > 1, 313 s = getProgressData(path, start, _temp, true), 314 e = getProgressData(path, end, _temp2), 315 eSeg = e.segment, 316 sSeg = s.segment, 317 eSegIndex = e.segIndex, 318 sSegIndex = s.segIndex, 319 ei = e.i, 320 si = s.i, 321 sameSegment = sSegIndex === eSegIndex, 322 sameBezier = ei === si && sameSegment, 323 wrapsBehind, 324 sShift, 325 eShift, 326 i, 327 copy, 328 totalSegments, 329 l, 330 j; 331 332 if (wrap || loops) { 333 wrapsBehind = eSegIndex < sSegIndex || sameSegment && ei < si || sameBezier && e.t < s.t; 334 335 if (_splitSegment(path, sSegIndex, si, s.t)) { 336 sSegIndex++; 337 338 if (!wrapsBehind) { 339 eSegIndex++; 340 341 if (sameBezier) { 342 e.t = (e.t - s.t) / (1 - s.t); 343 ei = 0; 344 } else if (sameSegment) { 345 ei -= si; 346 } 347 } 348 } 349 350 if (Math.abs(1 - (end - start)) < 1e-5) { 351 eSegIndex = sSegIndex - 1; 352 } else if (!e.t && eSegIndex) { 353 eSegIndex--; 354 } else if (_splitSegment(path, eSegIndex, ei, e.t) && wrapsBehind) { 355 sSegIndex++; 356 } 357 358 if (s.t === 1) { 359 sSegIndex = (sSegIndex + 1) % path.length; 360 } 361 362 copy = []; 363 totalSegments = path.length; 364 l = 1 + totalSegments * loops; 365 j = sSegIndex; 366 l += (totalSegments - sSegIndex + eSegIndex) % totalSegments; 367 368 for (i = 0; i < l; i++) { 369 _appendOrMerge(copy, path[j++ % totalSegments]); 370 } 371 372 path = copy; 373 } else { 374 eShift = e.t === 1 ? 6 : subdivideSegment(eSeg, ei, e.t); 375 376 if (start !== end) { 377 sShift = subdivideSegment(sSeg, si, sameBezier ? s.t / e.t : s.t); 378 sameSegment && (eShift += sShift); 379 eSeg.splice(ei + eShift + 2); 380 (sShift || si) && sSeg.splice(0, si + sShift); 381 i = path.length; 382 383 while (i--) { 384 (i < sSegIndex || i > eSegIndex) && path.splice(i, 1); 385 } 386 } else { 387 eSeg.angle = getRotationAtBezierT(eSeg, ei + eShift, 0); 388 ei += eShift; 389 s = eSeg[ei]; 390 e = eSeg[ei + 1]; 391 eSeg.length = eSeg.totalLength = 0; 392 eSeg.totalPoints = path.totalPoints = 8; 393 eSeg.push(s, e, s, e, s, e, s, e); 394 } 395 } 396 397 path.totalLength = 0; 398 return path; 399 } 400 401 function measureSegment(segment, startIndex, bezierQty) { 402 startIndex = startIndex || 0; 403 404 if (!segment.samples) { 405 segment.samples = []; 406 segment.lookup = []; 407 } 408 409 var resolution = ~~segment.resolution || 12, 410 inc = 1 / resolution, 411 endIndex = bezierQty ? startIndex + bezierQty * 6 + 1 : segment.length, 412 x1 = segment[startIndex], 413 y1 = segment[startIndex + 1], 414 samplesIndex = startIndex ? startIndex / 6 * resolution : 0, 415 samples = segment.samples, 416 lookup = segment.lookup, 417 min = (startIndex ? segment.minLength : _largeNum) || _largeNum, 418 prevLength = samples[samplesIndex + bezierQty * resolution - 1], 419 length = startIndex ? samples[samplesIndex - 1] : 0, 420 i, 421 j, 422 x4, 423 x3, 424 x2, 425 xd, 426 xd1, 427 y4, 428 y3, 429 y2, 430 yd, 431 yd1, 432 inv, 433 t, 434 lengthIndex, 435 l, 436 segLength; 437 samples.length = lookup.length = 0; 438 439 for (j = startIndex + 2; j < endIndex; j += 6) { 440 x4 = segment[j + 4] - x1; 441 x3 = segment[j + 2] - x1; 442 x2 = segment[j] - x1; 443 y4 = segment[j + 5] - y1; 444 y3 = segment[j + 3] - y1; 445 y2 = segment[j + 1] - y1; 446 xd = xd1 = yd = yd1 = 0; 447 448 if (_abs(x4) < .01 && _abs(y4) < .01 && _abs(x2) + _abs(y2) < .01) { 449 if (segment.length > 8) { 450 segment.splice(j, 6); 451 j -= 6; 452 endIndex -= 6; 453 } 454 } else { 455 for (i = 1; i <= resolution; i++) { 456 t = inc * i; 457 inv = 1 - t; 458 xd = xd1 - (xd1 = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t); 459 yd = yd1 - (yd1 = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t); 460 l = _sqrt(yd * yd + xd * xd); 461 462 if (l < min) { 463 min = l; 464 } 465 466 length += l; 467 samples[samplesIndex++] = length; 468 } 469 } 470 471 x1 += x4; 472 y1 += y4; 473 } 474 475 if (prevLength) { 476 prevLength -= length; 477 478 for (; samplesIndex < samples.length; samplesIndex++) { 479 samples[samplesIndex] += prevLength; 480 } 481 } 482 483 if (samples.length && min) { 484 segment.totalLength = segLength = samples[samples.length - 1] || 0; 485 segment.minLength = min; 486 487 if (segLength / min < 9999) { 488 l = lengthIndex = 0; 489 490 for (i = 0; i < segLength; i += min) {
vendor: 5,594 bytes, lines 491-648
491 lookup[l++] = samples[lengthIndex] < i ? ++lengthIndex : lengthIndex; 492 } 493 } 494 } else { 495 segment.totalLength = samples[0] = 0; 496 } 497 498 return startIndex ? length - samples[startIndex / 2 - 1] : length; 499 } 500 501 function cacheRawPathMeasurements(rawPath, resolution) { 502 var pathLength, points, i; 503 504 for (i = pathLength = points = 0; i < rawPath.length; i++) { 505 rawPath[i].resolution = ~~resolution || 12; 506 points += rawPath[i].length; 507 pathLength += measureSegment(rawPath[i]); 508 } 509 510 rawPath.totalPoints = points; 511 rawPath.totalLength = pathLength; 512 return rawPath; 513 } 514 function subdivideSegment(segment, i, t) { 515 if (t <= 0 || t >= 1) { 516 return 0; 517 } 518 519 var ax = segment[i], 520 ay = segment[i + 1], 521 cp1x = segment[i + 2], 522 cp1y = segment[i + 3], 523 cp2x = segment[i + 4], 524 cp2y = segment[i + 5], 525 bx = segment[i + 6], 526 by = segment[i + 7], 527 x1a = ax + (cp1x - ax) * t, 528 x2 = cp1x + (cp2x - cp1x) * t, 529 y1a = ay + (cp1y - ay) * t, 530 y2 = cp1y + (cp2y - cp1y) * t, 531 x1 = x1a + (x2 - x1a) * t, 532 y1 = y1a + (y2 - y1a) * t, 533 x2a = cp2x + (bx - cp2x) * t, 534 y2a = cp2y + (by - cp2y) * t; 535 x2 += (x2a - x2) * t; 536 y2 += (y2a - y2) * t; 537 segment.splice(i + 2, 4, _round(x1a), _round(y1a), _round(x1), _round(y1), _round(x1 + (x2 - x1) * t), _round(y1 + (y2 - y1) * t), _round(x2), _round(y2), _round(x2a), _round(y2a)); 538 segment.samples && segment.samples.splice(i / 6 * segment.resolution | 0, 0, 0, 0, 0, 0, 0, 0); 539 return 6; 540 } 541 542 function getProgressData(rawPath, progress, decoratee, pushToNextIfAtEnd) { 543 decoratee = decoratee || {}; 544 rawPath.totalLength || cacheRawPathMeasurements(rawPath); 545 546 if (progress < 0 || progress > 1) { 547 progress = _wrapProgress(progress); 548 } 549 550 var segIndex = 0, 551 segment = rawPath[0], 552 samples, 553 resolution, 554 length, 555 min, 556 max, 557 i, 558 t; 559 560 if (!progress) { 561 t = i = segIndex = 0; 562 segment = rawPath[0]; 563 } else if (progress === 1) { 564 t = 1; 565 segIndex = rawPath.length - 1; 566 segment = rawPath[segIndex]; 567 i = segment.length - 8; 568 } else { 569 if (rawPath.length > 1) { 570 length = rawPath.totalLength * progress; 571 max = i = 0; 572 573 while ((max += rawPath[i++].totalLength) < length) { 574 segIndex = i; 575 } 576 577 segment = rawPath[segIndex]; 578 min = max - segment.totalLength; 579 progress = (length - min) / (max - min) || 0; 580 } 581 582 samples = segment.samples; 583 resolution = segment.resolution; 584 length = segment.totalLength * progress; 585 i = segment.lookup.length ? segment.lookup[~~(length / segment.minLength)] || 0 : _getSampleIndex(samples, length, progress); 586 min = i ? samples[i - 1] : 0; 587 max = samples[i]; 588 589 if (max < length) { 590 min = max; 591 max = samples[++i]; 592 } 593 594 t = 1 / resolution * ((length - min) / (max - min) + i % resolution); 595 i = ~~(i / resolution) * 6; 596 597 if (pushToNextIfAtEnd && t === 1) { 598 if (i + 6 < segment.length) { 599 i += 6; 600 t = 0; 601 } else if (segIndex + 1 < rawPath.length) { 602 i = t = 0; 603 segment = rawPath[++segIndex]; 604 } 605 } 606 } 607 608 decoratee.t = t; 609 decoratee.i = i; 610 decoratee.path = rawPath; 611 decoratee.segment = segment; 612 decoratee.segIndex = segIndex; 613 return decoratee; 614 } 615 616 function getPositionOnPath(rawPath, progress, includeAngle, point) { 617 var segment = rawPath[0], 618 result = point || {}, 619 samples, 620 resolution, 621 length, 622 min, 623 max, 624 i, 625 t, 626 a, 627 inv; 628 629 if (progress < 0 || progress > 1) { 630 progress = _wrapProgress(progress); 631 } 632 633 if (rawPath.length > 1) { 634 length = rawPath.totalLength * progress; 635 max = i = 0; 636 637 while ((max += rawPath[i++].totalLength) < length) { 638 segment = rawPath[i]; 639 } 640 641 min = max - segment.totalLength; 642 progress = (length - min) / (max - min) || 0; 643 } 644 645 samples = segment.samples; 646 resolution = segment.resolution; 647 length = segment.totalLength * progress; 648 i = segment.lookup.length ? segment.lookup[progress < 1 ? ~~(length /
vendor: 4,443 bytes, lines 648-767
648segment.minLength) : segment.lookup.length - 1] || 0 : _getSampleIndex(samples, length, progress); 649 min = i ? samples[i - 1] : 0; 650 max = samples[i]; 651 652 if (max < length) { 653 min = max; 654 max = samples[++i]; 655 } 656 657 t = 1 / resolution * ((length - min) / (max - min) + i % resolution) || 0; 658 inv = 1 - t; 659 i = ~~(i / resolution) * 6; 660 a = segment[i]; 661 result.x = _round((t * t * (segment[i + 6] - a) + 3 * inv * (t * (segment[i + 4] - a) + inv * (segment[i + 2] - a))) * t + a); 662 result.y = _round((t * t * (segment[i + 7] - (a = segment[i + 1])) + 3 * inv * (t * (segment[i + 5] - a) + inv * (segment[i + 3] - a))) * t + a); 663 664 if (includeAngle) { 665 result.angle = segment.totalLength ? getRotationAtBezierT(segment, i, t >= 1 ? 1 - 1e-9 : t ? t : 1e-9) : segment.angle || 0; 666 } 667 668 return result; 669 } 670 function transformRawPath(rawPath, a, b, c, d, tx, ty) { 671 var j = rawPath.length, 672 segment, 673 l, 674 i, 675 x, 676 y; 677 678 while (--j > -1) { 679 segment = rawPath[j]; 680 l = segment.length; 681 682 for (i = 0; i < l; i += 2) { 683 x = segment[i]; 684 y = segment[i + 1]; 685 segment[i] = x * a + y * c + tx; 686 segment[i + 1] = x * b + y * d + ty; 687 } 688 } 689 690 rawPath._dirty = 1; 691 return rawPath; 692 } 693 694 function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) { 695 if (lastX === x && lastY === y) { 696 return; 697 } 698 699 rx = _abs(rx); 700 ry = _abs(ry); 701 702 var angleRad = angle % 360 * _DEG2RAD, 703 cosAngle = _cos(angleRad), 704 sinAngle = _sin(angleRad), 705 PI = Math.PI, 706 TWOPI = PI * 2, 707 dx2 = (lastX - x) / 2, 708 dy2 = (lastY - y) / 2, 709 x1 = cosAngle * dx2 + sinAngle * dy2, 710 y1 = -sinAngle * dx2 + cosAngle * dy2, 711 x1_sq = x1 * x1, 712 y1_sq = y1 * y1, 713 radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry); 714 715 if (radiiCheck > 1) { 716 rx = _sqrt(radiiCheck) * rx; 717 ry = _sqrt(radiiCheck) * ry; 718 } 719 720 var rx_sq = rx * rx, 721 ry_sq = ry * ry, 722 sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq); 723 724 if (sq < 0) { 725 sq = 0; 726 } 727 728 var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq), 729 cx1 = coef * (rx * y1 / ry), 730 cy1 = coef * -(ry * x1 / rx), 731 sx2 = (lastX + x) / 2, 732 sy2 = (lastY + y) / 2, 733 cx = sx2 + (cosAngle * cx1 - sinAngle * cy1), 734 cy = sy2 + (sinAngle * cx1 + cosAngle * cy1), 735 ux = (x1 - cx1) / rx, 736 uy = (y1 - cy1) / ry, 737 vx = (-x1 - cx1) / rx, 738 vy = (-y1 - cy1) / ry, 739 temp = ux * ux + uy * uy, 740 angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)), 741 angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy))); 742 743 isNaN(angleExtent) && (angleExtent = PI); 744 745 if (!sweepFlag && angleExtent > 0) { 746 angleExtent -= TWOPI; 747 } else if (sweepFlag && angleExtent < 0) { 748 angleExtent += TWOPI; 749 } 750 751 angleStart %= TWOPI; 752 angleExtent %= TWOPI; 753 754 var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)), 755 rawPath = [], 756 angleIncrement = angleExtent / segments, 757 controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)), 758 ma = cosAngle * rx, 759 mb = sinAngle * rx, 760 mc = sinAngle * -ry, 761 md = cosAngle * ry, 762 i; 763 764 for (i = 0; i < segments; i++) { 765 angle = angleStart + i * angleIncrement; 766 x1 = _cos(angle); 767 y1 = _sin(angle);
vendor: 9,034 bytes, lines 768-1022
768 ux = _cos(angle += angleIncrement); 769 uy = _sin(angle); 770 rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy); 771 } 772 773 for (i = 0; i < rawPath.length; i += 2) { 774 x1 = rawPath[i]; 775 y1 = rawPath[i + 1]; 776 rawPath[i] = x1 * ma + y1 * mc + cx; 777 rawPath[i + 1] = x1 * mb + y1 * md + cy; 778 } 779 780 rawPath[i - 2] = x; 781 rawPath[i - 1] = y; 782 return rawPath; 783 } 784 785 function stringToRawPath(d) { 786 var a = (d + "").replace(_scientific, function (m) { 787 var n = +m; 788 return n < 0.0001 && n > -0.0001 ? 0 : n; 789 }).match(_svgPathExp) || [], 790 path = [], 791 relativeX = 0, 792 relativeY = 0, 793 twoThirds = 2 / 3, 794 elements = a.length, 795 points = 0, 796 errorMessage = "ERROR: malformed path: " + d, 797 i, 798 j, 799 x, 800 y, 801 command, 802 isRelative, 803 segment, 804 startX, 805 startY, 806 difX, 807 difY, 808 beziers, 809 prevCommand, 810 flag1, 811 flag2, 812 line = function line(sx, sy, ex, ey) { 813 difX = (ex - sx) / 3; 814 difY = (ey - sy) / 3; 815 segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey); 816 }; 817 818 if (!d || !isNaN(a[0]) || isNaN(a[1])) { 819 console.log(errorMessage); 820 return path; 821 } 822 823 for (i = 0; i < elements; i++) { 824 prevCommand = command; 825 826 if (isNaN(a[i])) { 827 command = a[i].toUpperCase(); 828 isRelative = command !== a[i]; 829 } else { 830 i--; 831 } 832 833 x = +a[i + 1]; 834 y = +a[i + 2]; 835 836 if (isRelative) { 837 x += relativeX; 838 y += relativeY; 839 } 840 841 if (!i) { 842 startX = x; 843 startY = y; 844 } 845 846 if (command === "M") { 847 if (segment) { 848 if (segment.length < 8) { 849 path.length -= 1; 850 } else { 851 points += segment.length; 852 } 853 } 854 855 relativeX = startX = x; 856 relativeY = startY = y; 857 segment = [x, y]; 858 path.push(segment); 859 i += 2; 860 command = "L"; 861 } else if (command === "C") { 862 if (!segment) { 863 segment = [0, 0]; 864 } 865 866 if (!isRelative) { 867 relativeX = relativeY = 0; 868 } 869 870 segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1); 871 i += 6; 872 } else if (command === "S") { 873 difX = relativeX; 874 difY = relativeY; 875 876 if (prevCommand === "C" || prevCommand === "S") { 877 difX += relativeX - segment[segment.length - 4]; 878 difY += relativeY - segment[segment.length - 3]; 879 } 880 881 if (!isRelative) { 882 relativeX = relativeY = 0; 883 } 884 885 segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1); 886 i += 4; 887 } else if (command === "Q") { 888 difX = relativeX + (x - relativeX) * twoThirds; 889 difY = relativeY + (y - relativeY) * twoThirds; 890 891 if (!isRelative) { 892 relativeX = relativeY = 0; 893 } 894 895 relativeX += a[i + 3] * 1; 896 relativeY += a[i + 4] * 1; 897 segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY); 898 i += 4; 899 } else if (command === "T") { 900 difX = relativeX - segment[segment.length - 4]; 901 difY = relativeY - segment[segment.length - 3]; 902 segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y); 903 i += 2; 904 } else if (command === "H") { 905 line(relativeX, relativeY, relativeX = x, relativeY); 906 i += 1; 907 } else if (command === "V") { 908 line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0)); 909 i += 1; 910 } else if (command === "L" || command === "Z") { 911 if (command === "Z") { 912 x = startX; 913 y = startY; 914 segment.closed = true; 915 } 916 917 if (command === "L" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) { 918 line(relativeX, relativeY, x, y); 919 920 if (command === "L") { 921 i += 2; 922 } 923 } 924 925 relativeX = x; 926 relativeY = y; 927 } else if (command === "A") { 928 flag1 = a[i + 4]; 929 flag2 = a[i + 5]; 930 difX = a[i + 6]; 931 difY = a[i + 7]; 932 j = 7; 933 934 if (flag1.length > 1) { 935 if (flag1.length < 3) { 936 difY = difX; 937 difX = flag2; 938 j--; 939 } else { 940 difY = flag2; 941 difX = flag1.substr(2); 942 j -= 2; 943 } 944 945 flag2 = flag1.charAt(1); 946 flag1 = flag1.charAt(0); 947 } 948 949 beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1); 950 i += j; 951 952 if (beziers) { 953 for (j = 0; j < beziers.length; j++) { 954 segment.push(beziers[j]); 955 } 956 } 957 958 relativeX = segment[segment.length - 2]; 959 relativeY = segment[segment.length - 1]; 960 } else { 961 console.log(errorMessage); 962 } 963 } 964 965 i = segment.length; 966 967 if (i < 6) { 968 path.pop(); 969 i = 0; 970 } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) { 971 segment.closed = true; 972 } 973 974 path.totalPoints = points + i; 975 return path; 976 } 977 function flatPointsToSegment(points, curviness) { 978 if (curviness === void 0) { 979 curviness = 1; 980 } 981 982 var x = points[0], 983 y = 0, 984 segment = [x, y], 985 i = 2; 986 987 for (; i < points.length; i += 2) { 988 segment.push(x, y, points[i], y = (points[i] - x) * curviness / 2, x = points[i], -y); 989 } 990 991 return segment; 992 } 993 function pointsToSegment(points, curviness) { 994 _abs(points[0] - points[2]) < 1e-4 && _abs(points[1] - points[3]) < 1e-4 && (points = points.slice(2)); 995 var l = points.length - 2, 996 x = +points[0], 997 y = +points[1], 998 nextX = +points[2], 999 nextY = +points[3], 1000 segment = [x, y, x, y], 1001 dx2 = nextX - x, 1002 dy2 = nextY - y, 1003 closed = Math.abs(points[l] - x) < 0.001 && Math.abs(points[l + 1] - y) < 0.001, 1004 prevX, 1005 prevY, 1006 i, 1007 dx1, 1008 dy1, 1009 r1, 1010 r2, 1011 r3, 1012 tl, 1013 mx1, 1014 mx2, 1015 mxm, 1016 my1, 1017 my2, 1018 mym; 1019 1020 if (closed) { 1021 points.push(nextX, nextY); 1022 nextX = x;
vendor: 4,238 bytes, lines 1023-1140
1023 nextY = y; 1024 x = points[l - 2]; 1025 y = points[l - 1]; 1026 points.unshift(x, y); 1027 l += 4; 1028 } 1029 1030 curviness = curviness || curviness === 0 ? +curviness : 1; 1031 1032 for (i = 2; i < l; i += 2) { 1033 prevX = x; 1034 prevY = y; 1035 x = nextX; 1036 y = nextY; 1037 nextX = +points[i + 2]; 1038 nextY = +points[i + 3]; 1039 1040 if (x === nextX && y === nextY) { 1041 continue; 1042 } 1043 1044 dx1 = dx2; 1045 dy1 = dy2; 1046 dx2 = nextX - x; 1047 dy2 = nextY - y; 1048 r1 = _sqrt(dx1 * dx1 + dy1 * dy1); 1049 r2 = _sqrt(dx2 * dx2 + dy2 * dy2); 1050 r3 = _sqrt(Math.pow(dx2 / r2 + dx1 / r1, 2) + Math.pow(dy2 / r2 + dy1 / r1, 2)); 1051 tl = (r1 + r2) * curviness * 0.25 / r3; 1052 mx1 = x - (x - prevX) * (r1 ? tl / r1 : 0); 1053 mx2 = x + (nextX - x) * (r2 ? tl / r2 : 0); 1054 mxm = x - (mx1 + ((mx2 - mx1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0)); 1055 my1 = y - (y - prevY) * (r1 ? tl / r1 : 0); 1056 my2 = y + (nextY - y) * (r2 ? tl / r2 : 0); 1057 mym = y - (my1 + ((my2 - my1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0)); 1058 1059 if (x !== prevX || y !== prevY) { 1060 segment.push(_round(mx1 + mxm), _round(my1 + mym), _round(x), _round(y), _round(mx2 + mxm), _round(my2 + mym)); 1061 } 1062 } 1063 1064 x !== nextX || y !== nextY || segment.length < 4 ? segment.push(_round(nextX), _round(nextY), _round(nextX), _round(nextY)) : segment.length -= 2; 1065 1066 if (segment.length === 2) { 1067 segment.push(x, y, x, y, x, y); 1068 } else if (closed) { 1069 segment.splice(0, 6); 1070 segment.length = segment.length - 6; 1071 } 1072 1073 return segment; 1074 } 1075 function rawPathToString(rawPath) { 1076 if (_isNumber(rawPath[0])) { 1077 rawPath = [rawPath]; 1078 } 1079 1080 var result = "", 1081 l = rawPath.length, 1082 sl, 1083 s, 1084 i, 1085 segment; 1086 1087 for (s = 0; s < l; s++) { 1088 segment = rawPath[s]; 1089 result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C"; 1090 sl = segment.length; 1091 1092 for (i = 2; i < sl; i++) { 1093 result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " "; 1094 } 1095 1096 if (segment.closed) { 1097 result += "z"; 1098 } 1099 } 1100 1101 return result; 1102 } 1103 1104 var _doc, 1105 _win, 1106 _docElement, 1107 _body, 1108 _divContainer, 1109 _svgContainer, 1110 _identityMatrix, 1111 _gEl, 1112 _transformProp = "transform", 1113 _transformOriginProp = _transformProp + "Origin", 1114 _hasOffsetBug, 1115 _setDoc = function _setDoc(element) { 1116 var doc = element.ownerDocument || element; 1117 1118 if (!(_transformProp in element.style) && "msTransform" in element.style) { 1119 _transformProp = "msTransform"; 1120 _transformOriginProp = _transformProp + "Origin"; 1121 } 1122 1123 while (doc.parentNode && (doc = doc.parentNode)) { } 1124 1125 _win = window; 1126 _identityMatrix = new Matrix2D(); 1127 1128 if (doc) { 1129 _doc = doc; 1130 _docElement = doc.documentElement; 1131 _body = doc.body; 1132 _gEl = _doc.createElementNS("http://www.w3.org/2000/svg", "g"); 1133 _gEl.style.transform = "none"; 1134 var d1 = doc.createElement("div"), 1135 d2 = doc.createElement("div"); 1136 1137 _body.appendChild(d1); 1138 1139 d1.appendChild(d2); 1140 d1.style.position = "static";
vendor: 6,255 bytes, lines 1141-1290
1141 d1.style[_transformProp] = "translate3d(0,0,1px)"; 1142 _hasOffsetBug = d2.offsetParent !== d1; 1143 1144 _body.removeChild(d1); 1145 } 1146 1147 return doc; 1148 }, 1149 _forceNonZeroScale = function _forceNonZeroScale(e) { 1150 var a, cache; 1151 1152 while (e && e !== _body) { 1153 cache = e._gsap; 1154 cache && cache.uncache && cache.get(e, "x"); 1155 1156 if (cache && !cache.scaleX && !cache.scaleY && cache.renderTransform) { 1157 cache.scaleX = cache.scaleY = 1e-4; 1158 cache.renderTransform(1, cache); 1159 a ? a.push(cache) : a = [cache]; 1160 } 1161 1162 e = e.parentNode; 1163 } 1164 1165 return a; 1166 }, 1167 _svgTemps = [], 1168 _divTemps = [], 1169 _getDocScrollTop = function _getDocScrollTop() { 1170 return _win.pageYOffset || _doc.scrollTop || _docElement.scrollTop || _body.scrollTop || 0; 1171 }, 1172 _getDocScrollLeft = function _getDocScrollLeft() { 1173 return _win.pageXOffset || _doc.scrollLeft || _docElement.scrollLeft || _body.scrollLeft || 0; 1174 }, 1175 _svgOwner = function _svgOwner(element) { 1176 return element.ownerSVGElement || ((element.tagName + "").toLowerCase() === "svg" ? element : null); 1177 }, 1178 _isFixed = function _isFixed(element) { 1179 if (_win.getComputedStyle(element).position === "fixed") { 1180 return true; 1181 } 1182 1183 element = element.parentNode; 1184 1185 if (element && element.nodeType === 1) { 1186 return _isFixed(element); 1187 } 1188 }, 1189 _createSibling = function _createSibling(element, i) { 1190 if (element.parentNode && (_doc || _setDoc(element))) { 1191 var svg = _svgOwner(element), 1192 ns = svg ? svg.getAttribute("xmlns") || "http://www.w3.org/2000/svg" : "http://www.w3.org/1999/xhtml", 1193 type = svg ? i ? "rect" : "g" : "div", 1194 x = i !== 2 ? 0 : 100, 1195 y = i === 3 ? 100 : 0, 1196 css = "position:absolute;display:block;pointer-events:none;margin:0;padding:0;", 1197 e = _doc.createElementNS ? _doc.createElementNS(ns.replace(/^https/, "http"), type) : _doc.createElement(type); 1198 1199 if (i) { 1200 if (!svg) { 1201 if (!_divContainer) { 1202 _divContainer = _createSibling(element); 1203 _divContainer.style.cssText = css; 1204 } 1205 1206 e.style.cssText = css + "width:0.1px;height:0.1px;top:" + y + "px;left:" + x + "px"; 1207 1208 _divContainer.appendChild(e); 1209 } else { 1210 _svgContainer || (_svgContainer = _createSibling(element)); 1211 e.setAttribute("width", 0.01); 1212 e.setAttribute("height", 0.01); 1213 e.setAttribute("transform", "translate(" + x + "," + y + ")"); 1214 1215 _svgContainer.appendChild(e); 1216 } 1217 } 1218 1219 return e; 1220 } 1221 1222 throw "Need document and parent."; 1223 }, 1224 _consolidate = function _consolidate(m) { 1225 var c = new Matrix2D(), 1226 i = 0; 1227 1228 for (; i < m.numberOfItems; i++) { 1229 c.multiply(m.getItem(i).matrix); 1230 } 1231 1232 return c; 1233 }, 1234 _getCTM = function _getCTM(svg) { 1235 var m = svg.getCTM(), 1236 transform; 1237 1238 if (!m) { 1239 transform = svg.style[_transformProp]; 1240 svg.style[_transformProp] = "none"; 1241 svg.appendChild(_gEl); 1242 m = _gEl.getCTM(); 1243 svg.removeChild(_gEl); 1244 transform ? svg.style[_transformProp] = transform : svg.style.removeProperty(_transformProp.replace(/([A-Z])/g, "-$1").toLowerCase()); 1245 } 1246 1247 return m || _identityMatrix.clone(); 1248 }, 1249 _placeSiblings = function _placeSiblings(element, adjustGOffset) { 1250 var svg = _svgOwner(element), 1251 isRootSVG = element === svg, 1252 siblings = svg ? _svgTemps : _divTemps, 1253 parent = element.parentNode, 1254 container, 1255 m, 1256 b, 1257 x, 1258 y, 1259 cs; 1260 1261 if (element === _win) { 1262 return element; 1263 } 1264 1265 siblings.length || siblings.push(_createSibling(element, 1), _createSibling(element, 2), _createSibling(element, 3)); 1266 container = svg ? _svgContainer : _divContainer; 1267 1268 if (svg) { 1269 if (isRootSVG) { 1270 b = _getCTM(element); 1271 x = -b.e / b.a; 1272 y = -b.f / b.d; 1273 m = _identityMatrix; 1274 } else if (element.getBBox) { 1275 b = element.getBBox(); 1276 m = element.transform ? element.transform.baseVal : {}; 1277 m = !m.numberOfItems ? _identityMatrix : m.numberOfItems > 1 ? _consolidate(m) : m.getItem(0).matrix; 1278 x = m.a * b.x + m.c * b.y; 1279 y = m.b * b.x + m.d * b.y; 1280 } else { 1281 m = new Matrix2D(); 1282 x = y = 0; 1283 } 1284 1285 if (adjustGOffset && element.tagName.toLowerCase() === "g") { 1286 x = y = 0; 1287 } 1288 1289 (isRootSVG ? svg : parent).appendChild(container); 1290 container.setAttribute("transform", "matrix("
vendor: 9,109 bytes, lines 1290-1529
1290+ m.a + "," + m.b + "," + m.c + "," + m.d + "," + (m.e + x) + "," + (m.f + y) + ")"); 1291 } else { 1292 x = y = 0; 1293 1294 if (_hasOffsetBug) { 1295 m = element.offsetParent; 1296 b = element; 1297 1298 while (b && (b = b.parentNode) && b !== m && b.parentNode) { 1299 if ((_win.getComputedStyle(b)[_transformProp] + "").length > 4) { 1300 x = b.offsetLeft; 1301 y = b.offsetTop; 1302 b = 0; 1303 } 1304 } 1305 } 1306 1307 cs = _win.getComputedStyle(element); 1308 1309 if (cs.position !== "absolute" && cs.position !== "fixed") { 1310 m = element.offsetParent; 1311 1312 while (parent && parent !== m) { 1313 x += parent.scrollLeft || 0; 1314 y += parent.scrollTop || 0; 1315 parent = parent.parentNode; 1316 } 1317 } 1318 1319 b = container.style; 1320 b.top = element.offsetTop - y + "px"; 1321 b.left = element.offsetLeft - x + "px"; 1322 b[_transformProp] = cs[_transformProp]; 1323 b[_transformOriginProp] = cs[_transformOriginProp]; 1324 b.position = cs.position === "fixed" ? "fixed" : "absolute"; 1325 element.parentNode.appendChild(container); 1326 } 1327 1328 return container; 1329 }, 1330 _setMatrix = function _setMatrix(m, a, b, c, d, e, f) { 1331 m.a = a; 1332 m.b = b; 1333 m.c = c; 1334 m.d = d; 1335 m.e = e; 1336 m.f = f; 1337 return m; 1338 }; 1339 1340 var Matrix2D = function () { 1341 function Matrix2D(a, b, c, d, e, f) { 1342 if (a === void 0) { 1343 a = 1; 1344 } 1345 1346 if (b === void 0) { 1347 b = 0; 1348 } 1349 1350 if (c === void 0) { 1351 c = 0; 1352 } 1353 1354 if (d === void 0) { 1355 d = 1; 1356 } 1357 1358 if (e === void 0) { 1359 e = 0; 1360 } 1361 1362 if (f === void 0) { 1363 f = 0; 1364 } 1365 1366 _setMatrix(this, a, b, c, d, e, f); 1367 } 1368 1369 var _proto = Matrix2D.prototype; 1370 1371 _proto.inverse = function inverse() { 1372 var a = this.a, 1373 b = this.b, 1374 c = this.c, 1375 d = this.d, 1376 e = this.e, 1377 f = this.f, 1378 determinant = a * d - b * c || 1e-10; 1379 return _setMatrix(this, d / determinant, -b / determinant, -c / determinant, a / determinant, (c * f - d * e) / determinant, -(a * f - b * e) / determinant); 1380 }; 1381 1382 _proto.multiply = function multiply(matrix) { 1383 var a = this.a, 1384 b = this.b, 1385 c = this.c, 1386 d = this.d, 1387 e = this.e, 1388 f = this.f, 1389 a2 = matrix.a, 1390 b2 = matrix.c, 1391 c2 = matrix.b, 1392 d2 = matrix.d, 1393 e2 = matrix.e, 1394 f2 = matrix.f; 1395 return _setMatrix(this, a2 * a + c2 * c, a2 * b + c2 * d, b2 * a + d2 * c, b2 * b + d2 * d, e + e2 * a + f2 * c, f + e2 * b + f2 * d); 1396 }; 1397 1398 _proto.clone = function clone() { 1399 return new Matrix2D(this.a, this.b, this.c, this.d, this.e, this.f); 1400 }; 1401 1402 _proto.equals = function equals(matrix) { 1403 var a = this.a, 1404 b = this.b, 1405 c = this.c, 1406 d = this.d, 1407 e = this.e, 1408 f = this.f; 1409 return a === matrix.a && b === matrix.b && c === matrix.c && d === matrix.d && e === matrix.e && f === matrix.f; 1410 }; 1411 1412 _proto.apply = function apply(point, decoratee) { 1413 if (decoratee === void 0) { 1414 decoratee = {}; 1415 } 1416 1417 var x = point.x, 1418 y = point.y, 1419 a = this.a, 1420 b = this.b, 1421 c = this.c, 1422 d = this.d, 1423 e = this.e, 1424 f = this.f; 1425 decoratee.x = x * a + y * c + e || 0; 1426 decoratee.y = x * b + y * d + f || 0; 1427 return decoratee; 1428 }; 1429 1430 return Matrix2D; 1431 }(); 1432 function getGlobalMatrix(element, inverse, adjustGOffset, includeScrollInFixed) { 1433 if (!element || !element.parentNode || (_doc || _setDoc(element)).documentElement === element) { 1434 return new Matrix2D(); 1435 } 1436 1437 var zeroScales = _forceNonZeroScale(element), 1438 svg = _svgOwner(element), 1439 temps = svg ? _svgTemps : _divTemps, 1440 container = _placeSiblings(element, adjustGOffset), 1441 b1 = temps[0].getBoundingClientRect(), 1442 b2 = temps[1].getBoundingClientRect(), 1443 b3 = temps[2].getBoundingClientRect(), 1444 parent = container.parentNode, 1445 isFixed = !includeScrollInFixed && _isFixed(element), 1446 m = new Matrix2D((b2.left - b1.left) / 100, (b2.top - b1.top) / 100, (b3.left - b1.left) / 100, (b3.top - b1.top) / 100, b1.left + (isFixed ? 0 : _getDocScrollLeft()), b1.top + (isFixed ? 0 : _getDocScrollTop())); 1447 1448 parent.removeChild(container); 1449 1450 if (zeroScales) { 1451 b1 = zeroScales.length; 1452 1453 while (b1--) { 1454 b2 = zeroScales[b1]; 1455 b2.scaleX = b2.scaleY = 0; 1456 b2.renderTransform(1, b2); 1457 } 1458 } 1459 1460 return inverse ? m.inverse() : m; 1461 } 1462 1463 /*! 1464 * MotionPathPlugin 3.10.4 1465 * https://greensock.com 1466 * 1467 * @license Copyright 2008-2022, GreenSock. All rights reserved. 1468 * Subject to the terms at https://greensock.com/standard-license or for 1469 * Club GreenSock members, the agreement issued with that membership. 1470 * @author: Jack Doyle, [email protected] 1471 */ 1472 1473 var _xProps = "x,translateX,left,marginLeft,xPercent".split(","), 1474 _yProps = "y,translateY,top,marginTop,yPercent".split(","), 1475 _DEG2RAD$1 = Math.PI / 180, 1476 gsap, 1477 PropTween, 1478 _getUnit, 1479 _toArray, 1480 _getGSAP = function _getGSAP() { 1481 return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap; 1482 }, 1483 _populateSegmentFromArray = function _populateSegmentFromArray(segment, values, property, mode) { 1484 var l = values.length, 1485 si = mode === 2 ? 0 : mode, 1486 i = 0, 1487 v; 1488 1489 for (; i < l; i++) { 1490 segment[si] = v = parseFloat(values[i][property]); 1491 mode === 2 && (segment[si + 1] = 0); 1492 si += 2; 1493 } 1494 1495 return segment; 1496 }, 1497 _getPropNum = function _getPropNum(target, prop, unit) { 1498 return parseFloat(target._gsap.get(target, prop, unit || "px")) || 0; 1499 }, 1500 _relativize = function _relativize(segment) { 1501 var x = segment[0], 1502 y = segment[1], 1503 i; 1504 1505 for (i = 2; i < segment.length; i += 2) { 1506 x = segment[i] += x; 1507 y = segment[i + 1] += y; 1508 } 1509 }, 1510 _segmentToRawPath = function _segmentToRawPath(plugin, segment, target, x, y, slicer, vars, unitX, unitY) { 1511 if (vars.type === "cubic") { 1512 segment = [segment]; 1513 } else { 1514 vars.fromCurrent !== false && segment.unshift(_getPropNum(target, x, unitX), y ? _getPropNum(target, y, unitY) : 0); 1515 vars.relative && _relativize(segment); 1516 var pointFunc = y ? pointsToSegment : flatPointsToSegment; 1517 segment = [pointFunc(segment, vars.curviness)]; 1518 } 1519 1520 segment = slicer(_align(segment, target, vars)); 1521 1522 _addDimensionalPropTween(plugin, target, x, segment, "x", unitX); 1523 1524 y && _addDimensionalPropTween(plugin, target, y, segment, "y", unitY); 1525 return cacheRawPathMeasurements(segment, vars.resolution || (vars.curviness === 0 ? 20 : 12)); 1526 }, 1527 _emptyFunc = function _emptyFunc(v) { 1528 return v; 1529 },
vendor: 4,590 bytes, lines 1530-1634
1530 _numExp = /[-+\.]*\d+\.?(?:e-|e\+)?\d*/g, 1531 _originToPoint = function _originToPoint(element, origin, parentMatrix) { 1532 var m = getGlobalMatrix(element), 1533 x = 0, 1534 y = 0, 1535 svg; 1536 1537 if ((element.tagName + "").toLowerCase() === "svg") { 1538 svg = element.viewBox.baseVal; 1539 svg.width || (svg = { 1540 width: +element.getAttribute("width"), 1541 height: +element.getAttribute("height") 1542 }); 1543 } else { 1544 svg = origin && element.getBBox && element.getBBox(); 1545 } 1546 1547 if (origin && origin !== "auto") { 1548 x = origin.push ? origin[0] * (svg ? svg.width : element.offsetWidth || 0) : origin.x; 1549 y = origin.push ? origin[1] * (svg ? svg.height : element.offsetHeight || 0) : origin.y; 1550 } 1551 1552 return parentMatrix.apply(x || y ? m.apply({ 1553 x: x, 1554 y: y 1555 }) : { 1556 x: m.e, 1557 y: m.f 1558 }); 1559 }, 1560 _getAlignMatrix = function _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin) { 1561 var parentMatrix = getGlobalMatrix(fromElement.parentNode, true, true), 1562 m = parentMatrix.clone().multiply(getGlobalMatrix(toElement)), 1563 fromPoint = _originToPoint(fromElement, fromOrigin, parentMatrix), 1564 _originToPoint2 = _originToPoint(toElement, toOrigin, parentMatrix), 1565 x = _originToPoint2.x, 1566 y = _originToPoint2.y, 1567 p; 1568 1569 m.e = m.f = 0; 1570 1571 if (toOrigin === "auto" && toElement.getTotalLength && toElement.tagName.toLowerCase() === "path") { 1572 p = toElement.getAttribute("d").match(_numExp) || []; 1573 p = m.apply({ 1574 x: +p[0], 1575 y: +p[1] 1576 }); 1577 x += p.x; 1578 y += p.y; 1579 } 1580 1581 if (p || toElement.getBBox && fromElement.getBBox && toElement.ownerSVGElement === fromElement.ownerSVGElement) { 1582 p = m.apply(toElement.getBBox()); 1583 x -= p.x; 1584 y -= p.y; 1585 } 1586 1587 m.e = x - fromPoint.x; 1588 m.f = y - fromPoint.y; 1589 return m; 1590 }, 1591 _align = function _align(rawPath, target, _ref) { 1592 var align = _ref.align, 1593 matrix = _ref.matrix, 1594 offsetX = _ref.offsetX, 1595 offsetY = _ref.offsetY, 1596 alignOrigin = _ref.alignOrigin; 1597 1598 var x = rawPath[0][0], 1599 y = rawPath[0][1], 1600 curX = _getPropNum(target, "x"), 1601 curY = _getPropNum(target, "y"), 1602 alignTarget, 1603 m, 1604 p; 1605 1606 if (!rawPath || !rawPath.length) { 1607 return getRawPath("M0,0L0,0"); 1608 } 1609 1610 if (align) { 1611 if (align === "self" || (alignTarget = _toArray(align)[0] || target) === target) { 1612 transformRawPath(rawPath, 1, 0, 0, 1, curX - x, curY - y); 1613 } else { 1614 if (alignOrigin && alignOrigin[2] !== false) { 1615 gsap.set(target, { 1616 transformOrigin: alignOrigin[0] * 100 + "% " + alignOrigin[1] * 100 + "%" 1617 }); 1618 } else { 1619 alignOrigin = [_getPropNum(target, "xPercent") / -100, _getPropNum(target, "yPercent") / -100]; 1620 } 1621 1622 m = _getAlignMatrix(target, alignTarget, alignOrigin, "auto"); 1623 p = m.apply({ 1624 x: x, 1625 y: y 1626 }); 1627 transformRawPath(rawPath, m.a, m.b, m.c, m.d, curX + m.e - (p.x - m.e), curY + m.f - (p.y - m.f)); 1628 } 1629 } 1630 1631 if (matrix) { 1632 transformRawPath(rawPath, matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f); 1633 } else if (offsetX || offsetY) { 1634 transformRawPath(rawPath, 1, 0, 0, 1, offsetX || 0, offsetY || 0
vendor: 5,287 bytes, lines 1634-1757
1634); 1635 } 1636 1637 return rawPath; 1638 }, 1639 _addDimensionalPropTween = function _addDimensionalPropTween(plugin, target, property, rawPath, pathProperty, forceUnit) { 1640 var cache = target._gsap, 1641 harness = cache.harness, 1642 alias = harness && harness.aliases && harness.aliases[property], 1643 prop = alias && alias.indexOf(",") < 0 ? alias : property, 1644 pt = plugin._pt = new PropTween(plugin._pt, target, prop, 0, 0, _emptyFunc, 0, cache.set(target, prop, plugin)); 1645 pt.u = _getUnit(cache.get(target, prop, forceUnit)) || 0; 1646 pt.path = rawPath; 1647 pt.pp = pathProperty; 1648 1649 plugin._props.push(prop); 1650 }, 1651 _sliceModifier = function _sliceModifier(start, end) { 1652 return function (rawPath) { 1653 return start || end !== 1 ? sliceRawPath(rawPath, start, end) : rawPath; 1654 }; 1655 }; 1656 1657 var MotionPathPlugin = { 1658 version: "3.10.4", 1659 name: "motionPath", 1660 register: function register(core, Plugin, propTween) { 1661 gsap = core; 1662 _getUnit = gsap.utils.getUnit; 1663 _toArray = gsap.utils.toArray; 1664 PropTween = propTween; 1665 }, 1666 init: function init(target, vars) { 1667 if (!gsap) { 1668 console.warn("Please gsap.registerPlugin(MotionPathPlugin)"); 1669 return false; 1670 } 1671 1672 if (!(typeof vars === "object" && !vars.style) || !vars.path) { 1673 vars = { 1674 path: vars 1675 }; 1676 } 1677 1678 var rawPaths = [], 1679 _vars = vars, 1680 path = _vars.path, 1681 autoRotate = _vars.autoRotate, 1682 unitX = _vars.unitX, 1683 unitY = _vars.unitY, 1684 x = _vars.x, 1685 y = _vars.y, 1686 firstObj = path[0], 1687 slicer = _sliceModifier(vars.start, "end" in vars ? vars.end : 1), 1688 rawPath, 1689 p; 1690 1691 this.rawPaths = rawPaths; 1692 this.target = target; 1693 1694 if (this.rotate = autoRotate || autoRotate === 0) { 1695 this.rOffset = parseFloat(autoRotate) || 0; 1696 this.radians = !!vars.useRadians; 1697 this.rProp = vars.rotation || "rotation"; 1698 this.rSet = target._gsap.set(target, this.rProp, this); 1699 this.ru = _getUnit(target._gsap.get(target, this.rProp)) || 0; 1700 } 1701 1702 if (Array.isArray(path) && !("closed" in path) && typeof firstObj !== "number") { 1703 for (p in firstObj) { 1704 if (!x && ~_xProps.indexOf(p)) { 1705 x = p; 1706 } else if (!y && ~_yProps.indexOf(p)) { 1707 y = p; 1708 } 1709 } 1710 1711 if (x && y) { 1712 rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray(_populateSegmentFromArray([], path, x, 0), path, y, 1), target, x, y, slicer, vars, unitX || _getUnit(path[0][x]), unitY || _getUnit(path[0][y]))); 1713 } else { 1714 x = y = 0; 1715 } 1716 1717 for (p in firstObj) { 1718 p !== x && p !== y && rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray([], path, p, 2), target, p, 0, slicer, vars, _getUnit(path[0][p]))); 1719 } 1720 } else { 1721 rawPath = slicer(_align(getRawPath(vars.path), target, vars)); 1722 cacheRawPathMeasurements(rawPath, vars.resolution); 1723 rawPaths.push(rawPath); 1724 1725 _addDimensionalPropTween(this, target, vars.x || "x", rawPath, "x", vars.unitX || "px"); 1726 1727 _addDimensionalPropTween(this, target, vars.y || "y", rawPath, "y", vars.unitY || "px"); 1728 } 1729 }, 1730 render: function render(ratio, data) { 1731 var rawPaths = data.rawPaths, 1732 i = rawPaths.length, 1733 pt = data._pt; 1734 1735 if (ratio > 1) { 1736 ratio = 1; 1737 } else if (ratio < 0) { 1738 ratio = 0; 1739 } 1740 1741 while (i--) { 1742 getPositionOnPath(rawPaths[i], ratio, !i && data.rotate, rawPaths[i]); 1743 } 1744 1745 while (pt) { 1746 pt.set(pt.t, pt.p, pt.path[pt.pp] + pt.u, pt.d, ratio); 1747 pt = pt._next; 1748 } 1749 1750 data.rotate && data.rSet(data.target, data.rProp, rawPaths[0].angle * (data.radians ? _DEG2RAD$1 : 1) + data.rOffset + data.ru, data, ratio); 1751 }, 1752 getLength: function getLength(path) { 1753 return cacheRawPathMeasurements(getRawPath(path)).totalLength; 1754 }, 1755 sliceRawPath: sliceRawPath, 1756 getRawPath: getRawPath, 1757 pointsToSegment: pointsToSegment,
vendor: 2,150 bytes, lines 1758-1806
1758 stringToRawPath: stringToRawPath, 1759 rawPathToString: rawPathToString, 1760 transformRawPath: transformRawPath, 1761 getGlobalMatrix: getGlobalMatrix, 1762 getPositionOnPath: getPositionOnPath, 1763 cacheRawPathMeasurements: cacheRawPathMeasurements, 1764 convertToPath: function convertToPath$1(targets, swap) { 1765 return _toArray(targets).map(function (target) { 1766 return convertToPath(target, swap !== false); 1767 }); 1768 }, 1769 convertCoordinates: function convertCoordinates(fromElement, toElement, point) { 1770 var m = getGlobalMatrix(toElement, true, true).multiply(getGlobalMatrix(fromElement)); 1771 return point ? m.apply(point) : m; 1772 }, 1773 getAlignMatrix: _getAlignMatrix, 1774 getRelativePosition: function getRelativePosition(fromElement, toElement, fromOrigin, toOrigin) { 1775 var m = _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin); 1776 1777 return { 1778 x: m.e, 1779 y: m.f 1780 }; 1781 }, 1782 arrayToRawPath: function arrayToRawPath(value, vars) { 1783 vars = vars || {}; 1784 1785 var segment = _populateSegmentFromArray(_populateSegmentFromArray([], value, vars.x || "x", 0), value, vars.y || "y", 1); 1786 1787 vars.relative && _relativize(segment); 1788 return [vars.type === "cubic" ? segment : pointsToSegment(segment, vars.curviness)]; 1789 } 1790 }; 1791 _getGSAP() && gsap.registerPlugin(MotionPathPlugin); 1792 1793 // exports.MotionPathPlugin = MotionPathPlugin; 1794 // exports.default = MotionPathPlugin; 1795 1796 // Object.defineProperty(exports, '__esModule', { value: true }); 1797 1798 }))); 1799 1800 1801 window.PremiumSvgDrawerHandler = function ($scope, $, addonSpeed) { 1802 1803 var isContainer = "widget" !== $scope.data("element_type"), 1804 isParallax = $scope.hasClass("premium-parallax-yes"), 1805 isInsideTemplate = !elementorFrontend.isEditMode() && $scope.closest('.draw-triggered').length > 0; 1806
1807 //If the $scope is inside a parent template, then we don't want to trigger things again. Why? because the draw has already been triggered for the parent element. 1808 // For example, off canvas widget, the function already is triggered for the $scope of the widget itself. So, no need to trigger it again for child elements inside the template. 1809 if (isInsideTemplate) 1810 return; 1811 1812 if (isContainer && !isParallax) 1813 return; 1814 1815 var $svgIcons = $scope.find((isParallax ? ".premium-parallax-layer " : "") + ".premium-svg-drawer"), 1816 totalPaths = 0; 1817 1818 //Used to unwrap the SVGs to fix styling issues coming from "> svg" selectors. 1819 setTimeout(function () { 1820 1821 if ($scope.hasClass("elementor-widget-premium-addon-tabs")) { 1822 $scope.find(".premium-tab-link div.premium-svg-drawer svg").addClass("premium-title-icon").unwrap(); 1823 } else if ($scope.hasClass("elementor-widget-premium-image-accordion")) { 1824 $scope.find(".premium-accordion-li div[class*='premium-svg-'] svg").addClass("premium-accordion-icon premium-svg-drawer").unwrap(); 1825 } else if ($scope.hasClass("elementor-widget-premium-addon-image-hotspots")) { 1826 $scope.find(".premium-image-hotspots-main-icons div[class*='premium-svg-'] svg").addClass("premium-image-hotspots-icon premium-svg-drawer").unwrap(); 1827 } 1828 1829 //These are handled from their files JS files. 1830 $scope.not('.elementor-widget-premium-notifications, .elementor-widget-premium-notbar').find(".elementor-invisible").removeClass("elementor-invisible"); 1831 1832 //Remove only for the icon, not for the posts containers. 1833 if ($scope.hasClass('elementor-widget-premium-notifications')) { 1834 $scope.find('.pa-recent-notification').removeClass('elementor-invisible'); 1835 } 1836 1837 }, 50); 1838 1839 1840 if (!$svgIcons.length) 1841 return; 1842 1843 //We don't want to take "Draw In Sequence" option if itmes are fewer than 2. 1844 if ($svgIcons.length < 2) 1845 $scope.removeClass("pa-svg-draw-seq-yes"); 1846 1847 if ($scope.hasClass("pa-svg-draw-seq-yes")) { 1848 1849 var timeLine = new TimelineMax({ 1850 yoyo: $scope.hasClass("pa-svg-draw-yoyo-yes") ? true : false, 1851 repeat: $scope.hasClass("pa-svg-draw-loop-yes") ? -1 : 0, 1852 }); 1853 } 1854 1855 $scope.addClass('draw-triggered'); 1856 1857 $svgIcons.each(function (index, item) { 1858 1859 var $item = $(item), 1860 drawSettings = $item.data(), 1861 targettimeLine = null, 1862 pathsToAdd = totalPaths, 1863 isPricingTable = $(item).closest(".premium-pricing-icon-container").length > 0; 1864 1865 //remove title HTML tag 1866 $item.find("title").remove(); 1867 1868 1869 //Check if we want to create a standalone timeline. 1870 if (!$scope.hasClass("pa-svg-draw-seq-yes") || drawSettings.svgHover || isPricingTable) { 1871 1872 var individualTimeLine = new TimelineMax({ 1873 paused: true, 1874 yoyo: drawSettings.svgYoyo ? true : false, 1875 repeat: drawSettings.svgLoop ? -1 : 0, 1876 onReverseComplete: function () { 1877 if (drawSettings.svgRestart && individualTimeLine.stop) 1878 individualTimeLine.stop(); 1879 } 1880 }); 1881 1882 pathsToAdd = 0; 1883 targettimeLine = individualTimeLine; 1884 } else { 1885 targettimeLine = timeLine; 1886 } 1887 1888 1889 var fromOrTo = !drawSettings.svgReverse ? 'from' : 'to', 1890 $paths = $item.find("path, circle, rect, square, ellipse, polyline, polygon, line"), 1891 lastPathIndex = 0, 1892 startOnEndPoint = drawSettings.svgPoint, 1893 setToTransparent = true; 1894 1895 if ('' == drawSettings.svgTrans) 1896 setToTransparent = false; 1897 1898 $paths.each(function (pathIndex, path) { 1899 1900 var $path = $(path); 1901 1902 if (setToTransparent) 1903 $path.attr("fill", "transparent"); 1904 1905 if (drawSettings.svgSync) 1906 pathIndex = 0; 1907 1908 //Used with fill after draw color. 1909 lastPathIndex = pathIndex; 1910 1911 targettimeLine[fromOrTo]($path, {
1912 PaSvgDrawer: (startOnEndPoint || 0) + "% 0", 1913 }, pathIndex + pathsToAdd); 1914 1915 }); 1916 1917 if (drawSettings.svgFill || drawSettings.svgStroke) { 1918 1919 //If all paths drawn together is enabled, then fill after all paths are drawn. 1920 if (lastPathIndex == 0) { 1921 lastPathIndex = pathsToAdd + 1; 1922 } else { 1923 //If not synced, fill with the last path. 1924 lastPathIndex = pathsToAdd + lastPathIndex; 1925 } 1926 1927 targettimeLine.to($paths, 1, { 1928 //To remove the transition that causes the fill draw to take much time and being not seen. 1929 onStart: function () { 1930 $paths.addClass("no-transition"); 1931 }, 1932 fill: drawSettings.svgFill, 1933 stroke: drawSettings.svgStroke, 1934 onComplete: function () { 1935 if (!drawSettings.svgLoop && !drawSettings.svgYoyo) 1936 $paths.removeClass("no-transition"); 1937 } 1938 }, lastPathIndex); 1939 } 1940 1941 if ((!$scope.hasClass("pa-svg-draw-seq-yes") || drawSettings.svgHover) && drawSettings.svgFrames) { 1942 targettimeLine.duration(drawSettings.svgFrames); 1943 } else { 1944 1945 if (!addonSpeed) 1946 addonSpeed = $scope.find(".premium-img-layers-wrapper, .premium-tabs, .premium-pricing-table-container, .premium-bullet-list-box").data("speed"); 1947 1948 targettimeLine.duration(addonSpeed); 1949 1950 } 1951 1952 1953 //If this item is animated on hover, then we don't want to take it into consideration. 1954 if ($scope.hasClass("pa-svg-draw-seq-yes") && !drawSettings.svgHover) 1955 totalPaths = totalPaths + (drawSettings.svgSync ? 1 : $paths.length); 1956 1957 if ($scope.hasClass('elementor-widget-premium-addon-magic-section')) { 1958 1959 targettimeLine.play(); 1960 1961 } else if (drawSettings.svgHover) { 1962 1963 if (!isParallax) { 1964 if ($scope.hasClass("elementor-widget-premium-addon-icon-box") || $scope.find(".premium-drawer-hover").length) { 1965 $item = $scope; 1966 } else if ($scope.hasClass("elementor-widget-premium-icon-list")) { 1967 $item = $item.closest(".premium-bullet-list-content"); 1968 } else if ($scope.hasClass("elementor-widget-premium-addon-tabs")) { 1969 $item = $item.closest(".premium-tabs-nav-list-item"); 1970 } else if ($scope.hasClass("elementor-widget-premium-image-accordion")) { 1971 $item = $item.closest(".premium-accordion-li"); 1972 } 1973 } 1974 1975 $item.hover( 1976 function () { 1977 targettimeLine.play(); 1978 }, 1979 function () { 1980 targettimeLine.pause(); 1981 }); 1982 } else { 1983 // Using IntersectionObserverAPI. 1984 var eleObserver = new IntersectionObserver(function (entries) { 1985 entries.forEach(function (entry, index) { 1986 1987 if (entry.isIntersecting) { 1988 1989 targettimeLine.play(); 1990 1991 if ("up" === window.paDirection && drawSettings.svgRestart) { 1992 targettimeLine.reverse(); 1993 } 1994 } 1995 }); 1996 }, { 1997 threshold: parseFloat((drawSettings.svgAnimOffset || "50%")) / 100 1998 }); 1999 2000 eleObserver.observe($scope[0]); 2001 2002 // elementorFrontend.waypoint($scope, function (direction) { 2003 // targettimeLine.play(); 2004 2005 // if ("up" === direction && drawSettings.svgRestart) { 2006 // targettimeLine.reverse(); 2007 2008 // } 2009 2010 // }, { 2011 // offset: drawSettings.svgAnimOffset || "50%", 2012 // triggerOnce: false 2013 // }); 2014 } 2015 2016 }); 2017 2018 }; 2019 2020 $(window).on("elementor/frontend/init", function () { 2021 2022 elementorFrontend.hooks.addAction("frontend/element_ready/widget", window.PremiumSvgDrawerHandler); 2023 2024 2025 }); 2026 2027})(jQuery);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.