@visactor/vstory 0.0.8-alpha.8 → 0.0.8

package/cjs/animate/util/paths.js

@@ -1,368 +0,0 @@
-"use strict";
-
-/*!
- * paths 3.12.5
- * https://gsap.com
- *
- * Copyright 2008-2024, GreenSock. All rights reserved.
- * Subject to the terms at https://gsap.com/standard-license or for
- * Club GSAP members, the agreement issued with that membership.
- * @author: Jack Doyle, jack@greensock.com
- */ Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), exports.rawPathToString = exports.subdivideSegmentNear = exports.getClosestData = exports.simplifyPoints = exports.pointsToSegment = exports.flatPointsToSegment = exports.bezierToPoints = exports.stringToRawPath = exports.transformRawPath = exports.getPositionOnPath = exports.subdivideSegment = exports.cacheRawPathMeasurements = exports.sliceRawPath = exports.getRotationAtProgress = exports.convertToPath = exports.reverseSegment = exports.copyRawPath = exports.getRawPath = void 0;
-
-let _bestDistance, _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi, _numbersExp = /(?:(-)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi, _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/gi, _selectorExp = /(^[#\.][a-z]|[a-y][a-z])/i, _DEG2RAD = Math.PI / 180, _RAD2DEG = 180 / Math.PI, _sin = Math.sin, _cos = Math.cos, _abs = Math.abs, _sqrt = Math.sqrt, _atan2 = Math.atan2, _largeNum = 1e8, _isString = value => "string" == typeof value, _isNumber = value => "number" == typeof value, _isUndefined = value => void 0 === value, _temp = {}, _temp2 = {}, _roundingNum = 1e5, _wrapProgress = progress => Math.round((progress + _largeNum) % 1 * _roundingNum) / _roundingNum || (progress < 0 ? 0 : 1), _round = value => Math.round(value * _roundingNum) / _roundingNum || 0, _roundPrecise = value => Math.round(1e10 * value) / 1e10 || 0, _splitSegment = (rawPath, segIndex, i, t) => {
-    let segment = rawPath[segIndex], shift = 1 === t ? 6 : subdivideSegment(segment, i, t);
-    if ((shift || !t) && shift + i + 2 < segment.length) return rawPath.splice(segIndex, 0, segment.slice(0, i + shift + 2)), 
-    segment.splice(0, i + shift), 1;
-}, _getSampleIndex = (samples, length, progress) => {
-    let l = samples.length, i = ~~(progress * l);
-    if (samples[i] > length) {
-        for (;--i && samples[i] > length; ) ;
-        i < 0 && (i = 0);
-    } else for (;samples[++i] < length && i < l; ) ;
-    return i < l ? i : l - 1;
-}, _reverseRawPath = (rawPath, skipOuter) => {
-    let i = rawPath.length;
-    for (skipOuter || rawPath.reverse(); i--; ) rawPath[i].reversed || reverseSegment(rawPath[i]);
-}, _copyMetaData = (source, copy) => (copy.totalLength = source.totalLength, source.samples ? (copy.samples = source.samples.slice(0), 
-copy.lookup = source.lookup.slice(0), copy.minLength = source.minLength, copy.resolution = source.resolution) : source.totalPoints && (copy.totalPoints = source.totalPoints), 
-copy), _appendOrMerge = (rawPath, segment) => {
-    let index = rawPath.length, prevSeg = rawPath[index - 1] || [], l = prevSeg.length;
-    index && segment[0] === prevSeg[l - 2] && segment[1] === prevSeg[l - 1] && (segment = prevSeg.concat(segment.slice(2)), 
-    index--), rawPath[index] = segment;
-};
-
-function getRawPath(value) {
-    let rawPath, e = (value = _isString(value) && _selectorExp.test(value) && document.querySelector(value) || value).getAttribute ? value : 0;
-    return e && (value = value.getAttribute("d")) ? (e._gsPath || (e._gsPath = {}), 
-    rawPath = e._gsPath[value], rawPath && !rawPath._dirty ? rawPath : e._gsPath[value] = stringToRawPath(value)) : value ? _isString(value) ? stringToRawPath(value) : _isNumber(value[0]) ? [ value ] : value : console.warn("Expecting a <path> element or an SVG path data string");
-}
-
-function copyRawPath(rawPath) {
-    let a = [], i = 0;
-    for (;i < rawPath.length; i++) a[i] = _copyMetaData(rawPath[i], rawPath[i].slice(0));
-    return _copyMetaData(rawPath, a);
-}
-
-function reverseSegment(segment) {
-    let y, i = 0;
-    for (segment.reverse(); i < segment.length; i += 2) y = segment[i], segment[i] = segment[i + 1], 
-    segment[i + 1] = y;
-    segment.reversed = !segment.reversed;
-}
-
-exports.getRawPath = getRawPath, exports.copyRawPath = copyRawPath, exports.reverseSegment = reverseSegment;
-
-let _createPath = (e, ignore) => {
-    let name, path = document.createElementNS("http://www.w3.org/2000/svg", "path"), attr = [].slice.call(e.attributes), i = attr.length;
-    for (ignore = "," + ignore + ","; --i > -1; ) name = attr[i].nodeName.toLowerCase(), 
-    ignore.indexOf("," + name + ",") < 0 && path.setAttributeNS(null, name, attr[i].nodeValue);
-    return path;
-}, _typeAttrs = {
-    rect: "rx,ry,x,y,width,height",
-    circle: "r,cx,cy",
-    ellipse: "rx,ry,cx,cy",
-    line: "x1,x2,y1,y2"
-}, _attrToObj = (e, attrs) => {
-    let props = attrs ? attrs.split(",") : [], obj = {}, i = props.length;
-    for (;--i > -1; ) obj[props[i]] = +e.getAttribute(props[i]) || 0;
-    return obj;
-};
-
-function convertToPath(element, swap) {
-    let data, x, y, r, ry, path, rcirc, rycirc, points, w, h, x2, x3, x4, x5, x6, y2, y3, y4, y5, y6, attr, type = element.tagName.toLowerCase(), circ = .552284749831;
-    return "path" !== type && element.getBBox ? (path = _createPath(element, "x,y,width,height,cx,cy,rx,ry,r,x1,x2,y1,y2,points"), 
-    attr = _attrToObj(element, _typeAttrs[type]), "rect" === type ? (r = attr.rx, ry = attr.ry || r, 
-    x = attr.x, y = attr.y, w = attr.width - 2 * r, h = attr.height - 2 * ry, r || ry ? (x2 = x + r * (1 - circ), 
-    x3 = x + r, x4 = x3 + w, x5 = x4 + r * circ, x6 = x4 + r, y2 = y + ry * (1 - circ), 
-    y3 = y + ry, y4 = y3 + h, y5 = y4 + ry * circ, y6 = y4 + ry, 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") : data = "M" + (x + w) + "," + y + " v" + h + " h" + -w + " v" + -h + " h" + w + "z") : "circle" === type || "ellipse" === type ? ("circle" === type ? (r = ry = attr.r, 
-    rycirc = r * circ) : (r = attr.rx, ry = attr.ry, rycirc = ry * circ), x = attr.cx, 
-    y = attr.cy, rcirc = r * circ, 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") : "line" === type ? data = "M" + attr.x1 + "," + attr.y1 + " L" + attr.x2 + "," + attr.y2 : "polyline" !== type && "polygon" !== type || (points = (element.getAttribute("points") + "").match(_numbersExp) || [], 
-    x = points.shift(), y = points.shift(), data = "M" + x + "," + y + " L" + points.join(","), 
-    "polygon" === type && (data += "," + x + "," + y + "z")), path.setAttribute("d", rawPathToString(path._gsRawPath = stringToRawPath(data))), 
-    swap && element.parentNode && (element.parentNode.insertBefore(path, element), element.parentNode.removeChild(element)), 
-    path) : element;
-}
-
-function getRotationAtProgress(rawPath, progress) {
-    let d = getProgressData(rawPath, progress >= 1 ? 1 - 1e-9 : progress || 1e-9);
-    return getRotationAtBezierT(d.segment, d.i, d.t);
-}
-
-function getRotationAtBezierT(segment, i, t) {
-    let x, a = segment[i], b = segment[i + 2], c = segment[i + 4];
-    return a += (b - a) * t, b += (c - b) * t, a += (b - a) * t, x = b + (c + (segment[i + 6] - c) * t - b) * t - a, 
-    a = segment[i + 1], b = segment[i + 3], c = segment[i + 5], a += (b - a) * t, b += (c - b) * t, 
-    a += (b - a) * t, _round(_atan2(b + (c + (segment[i + 7] - c) * t - b) * t - a, x) * _RAD2DEG);
-}
-
-function sliceRawPath(rawPath, start, end) {
-    end = _isUndefined(end) ? 1 : _roundPrecise(end) || 0, start = _roundPrecise(start) || 0;
-    let loops = Math.max(0, ~~(_abs(end - start) - 1e-8)), path = copyRawPath(rawPath);
-    if (start > end && (start = 1 - start, end = 1 - end, _reverseRawPath(path), path.totalLength = 0), 
-    start < 0 || end < 0) {
-        let offset = Math.abs(~~Math.min(start, end)) + 1;
-        start += offset, end += offset;
-    }
-    path.totalLength || cacheRawPathMeasurements(path);
-    let wrapsBehind, sShift, eShift, i, copy, totalSegments, l, j, wrap = end > 1, s = getProgressData(path, start, _temp, !0), e = getProgressData(path, end, _temp2), eSeg = e.segment, sSeg = s.segment, eSegIndex = e.segIndex, sSegIndex = s.segIndex, ei = e.i, si = s.i, sameSegment = sSegIndex === eSegIndex, sameBezier = ei === si && sameSegment;
-    if (wrap || loops) {
-        for (wrapsBehind = eSegIndex < sSegIndex || sameSegment && ei < si || sameBezier && e.t < s.t, 
-        _splitSegment(path, sSegIndex, si, s.t) && (sSegIndex++, wrapsBehind || (eSegIndex++, 
-        sameBezier ? (e.t = (e.t - s.t) / (1 - s.t), ei = 0) : sameSegment && (ei -= si))), 
-        Math.abs(1 - (end - start)) < 1e-5 ? eSegIndex = sSegIndex - 1 : !e.t && eSegIndex ? eSegIndex-- : _splitSegment(path, eSegIndex, ei, e.t) && wrapsBehind && sSegIndex++, 
-        1 === s.t && (sSegIndex = (sSegIndex + 1) % path.length), copy = [], totalSegments = path.length, 
-        l = 1 + totalSegments * loops, j = sSegIndex, l += (totalSegments - sSegIndex + eSegIndex) % totalSegments, 
-        i = 0; i < l; i++) _appendOrMerge(copy, path[j++ % totalSegments]);
-        path = copy;
-    } else if (eShift = 1 === e.t ? 6 : subdivideSegment(eSeg, ei, e.t), start !== end) for (sShift = subdivideSegment(sSeg, si, sameBezier ? s.t / e.t : s.t), 
-    sameSegment && (eShift += sShift), eSeg.splice(ei + eShift + 2), (sShift || si) && sSeg.splice(0, si + sShift), 
-    i = path.length; i--; ) (i < sSegIndex || i > eSegIndex) && path.splice(i, 1); else eSeg.angle = getRotationAtBezierT(eSeg, ei + eShift, 0), 
-    ei += eShift, s = eSeg[ei], e = eSeg[ei + 1], eSeg.length = eSeg.totalLength = 0, 
-    eSeg.totalPoints = path.totalPoints = 8, eSeg.push(s, e, s, e, s, e, s, e);
-    return path.totalLength = 0, path;
-}
-
-function measureSegment(segment, startIndex, bezierQty) {
-    startIndex = startIndex || 0, segment.samples || (segment.samples = [], segment.lookup = []);
-    let i, j, x4, x3, x2, xd, xd1, y4, y3, y2, yd, yd1, inv, t, lengthIndex, l, segLength, resolution = ~~segment.resolution || 12, inc = 1 / resolution, endIndex = bezierQty ? startIndex + 6 * bezierQty + 1 : segment.length, x1 = segment[startIndex], y1 = segment[startIndex + 1], samplesIndex = startIndex ? startIndex / 6 * resolution : 0, samples = segment.samples, lookup = segment.lookup, min = (startIndex ? segment.minLength : _largeNum) || _largeNum, prevLength = samples[samplesIndex + bezierQty * resolution - 1], length = startIndex ? samples[samplesIndex - 1] : 0;
-    for (samples.length = lookup.length = 0, j = startIndex + 2; j < endIndex; j += 6) {
-        if (x4 = segment[j + 4] - x1, x3 = segment[j + 2] - x1, x2 = segment[j] - x1, y4 = segment[j + 5] - y1, 
-        y3 = segment[j + 3] - y1, y2 = segment[j + 1] - y1, xd = xd1 = yd = yd1 = 0, _abs(x4) < .01 && _abs(y4) < .01 && _abs(x2) + _abs(y2) < .01) segment.length > 8 && (segment.splice(j, 6), 
-        j -= 6, endIndex -= 6); else for (i = 1; i <= resolution; i++) t = inc * i, inv = 1 - t, 
-        xd = xd1 - (xd1 = (t * t * x4 + 3 * inv * (t * x3 + inv * x2)) * t), yd = yd1 - (yd1 = (t * t * y4 + 3 * inv * (t * y3 + inv * y2)) * t), 
-        l = _sqrt(yd * yd + xd * xd), l < min && (min = l), length += l, samples[samplesIndex++] = length;
-        x1 += x4, y1 += y4;
-    }
-    if (prevLength) for (prevLength -= length; samplesIndex < samples.length; samplesIndex++) samples[samplesIndex] += prevLength;
-    if (samples.length && min) {
-        if (segment.totalLength = segLength = samples[samples.length - 1] || 0, segment.minLength = min, 
-        segLength / min < 9999) for (l = lengthIndex = 0, i = 0; i < segLength; i += min) lookup[l++] = samples[lengthIndex] < i ? ++lengthIndex : lengthIndex;
-    } else segment.totalLength = samples[0] = 0;
-    return startIndex ? length - samples[startIndex / 2 - 1] : length;
-}
-
-function cacheRawPathMeasurements(rawPath, resolution) {
-    let pathLength, points, i;
-    for (i = pathLength = points = 0; i < rawPath.length; i++) rawPath[i].resolution = ~~resolution || 12, 
-    points += rawPath[i].length, pathLength += measureSegment(rawPath[i]);
-    return rawPath.totalPoints = points, rawPath.totalLength = pathLength, rawPath;
-}
-
-function subdivideSegment(segment, i, t) {
-    if (t <= 0 || t >= 1) return 0;
-    let ax = segment[i], ay = segment[i + 1], cp1x = segment[i + 2], cp1y = segment[i + 3], cp2x = segment[i + 4], cp2y = segment[i + 5], x1a = ax + (cp1x - ax) * t, x2 = cp1x + (cp2x - cp1x) * t, y1a = ay + (cp1y - ay) * t, y2 = cp1y + (cp2y - cp1y) * t, x1 = x1a + (x2 - x1a) * t, y1 = y1a + (y2 - y1a) * t, x2a = cp2x + (segment[i + 6] - cp2x) * t, y2a = cp2y + (segment[i + 7] - cp2y) * t;
-    return x2 += (x2a - x2) * t, y2 += (y2a - y2) * t, 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)), 
-    segment.samples && segment.samples.splice(i / 6 * segment.resolution | 0, 0, 0, 0, 0, 0, 0, 0), 
-    6;
-}
-
-function getProgressData(rawPath, progress, decoratee, pushToNextIfAtEnd) {
-    decoratee = decoratee || {}, rawPath.totalLength || cacheRawPathMeasurements(rawPath), 
-    (progress < 0 || progress > 1) && (progress = _wrapProgress(progress));
-    let samples, resolution, length, min, max, i, t, segIndex = 0, segment = rawPath[0];
-    if (progress) if (1 === progress) t = 1, segIndex = rawPath.length - 1, segment = rawPath[segIndex], 
-    i = segment.length - 8; else {
-        if (rawPath.length > 1) {
-            for (length = rawPath.totalLength * progress, max = i = 0; (max += rawPath[i++].totalLength) < length; ) segIndex = i;
-            segment = rawPath[segIndex], min = max - segment.totalLength, progress = (length - min) / (max - min) || 0;
-        }
-        samples = segment.samples, resolution = segment.resolution, length = segment.totalLength * progress, 
-        i = segment.lookup.length ? segment.lookup[~~(length / segment.minLength)] || 0 : _getSampleIndex(samples, length, progress), 
-        min = i ? samples[i - 1] : 0, max = samples[i], max < length && (min = max, max = samples[++i]), 
-        t = 1 / resolution * ((length - min) / (max - min) + i % resolution), i = 6 * ~~(i / resolution), 
-        pushToNextIfAtEnd && 1 === t && (i + 6 < segment.length ? (i += 6, t = 0) : segIndex + 1 < rawPath.length && (i = t = 0, 
-        segment = rawPath[++segIndex]));
-    } else t = i = segIndex = 0, segment = rawPath[0];
-    return decoratee.t = t, decoratee.i = i, decoratee.path = rawPath, decoratee.segment = segment, 
-    decoratee.segIndex = segIndex, decoratee;
-}
-
-function getPositionOnPath(rawPath, progress, includeAngle, point) {
-    let samples, resolution, length, min, max, i, t, a, inv, segment = rawPath[0], result = point || {};
-    if ((progress < 0 || progress > 1) && (progress = _wrapProgress(progress)), segment.lookup || cacheRawPathMeasurements(rawPath), 
-    rawPath.length > 1) {
-        for (length = rawPath.totalLength * progress, max = i = 0; (max += rawPath[i++].totalLength) < length; ) segment = rawPath[i];
-        min = max - segment.totalLength, progress = (length - min) / (max - min) || 0;
-    }
-    return samples = segment.samples, resolution = segment.resolution, length = segment.totalLength * progress, 
-    i = segment.lookup.length ? segment.lookup[progress < 1 ? ~~(length / segment.minLength) : segment.lookup.length - 1] || 0 : _getSampleIndex(samples, length, progress), 
-    min = i ? samples[i - 1] : 0, max = samples[i], max < length && (min = max, max = samples[++i]), 
-    t = 1 / resolution * ((length - min) / (max - min) + i % resolution) || 0, inv = 1 - t, 
-    i = 6 * ~~(i / resolution), a = segment[i], result.x = _round((t * t * (segment[i + 6] - a) + 3 * inv * (t * (segment[i + 4] - a) + inv * (segment[i + 2] - a))) * t + a), 
-    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), 
-    includeAngle && (result.angle = segment.totalLength ? getRotationAtBezierT(segment, i, t >= 1 ? 1 - 1e-9 : t || 1e-9) : segment.angle || 0), 
-    result;
-}
-
-function transformRawPath(rawPath, a, b, c, d, tx, ty) {
-    let segment, l, i, x, y, j = rawPath.length;
-    for (;--j > -1; ) for (segment = rawPath[j], l = segment.length, i = 0; i < l; i += 2) x = segment[i], 
-    y = segment[i + 1], segment[i] = x * a + y * c + tx, segment[i + 1] = x * b + y * d + ty;
-    return rawPath._dirty = 1, rawPath;
-}
-
-function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
-    if (lastX === x && lastY === y) return;
-    rx = _abs(rx), ry = _abs(ry);
-    let angleRad = angle % 360 * _DEG2RAD, cosAngle = _cos(angleRad), sinAngle = _sin(angleRad), PI = Math.PI, TWOPI = 2 * PI, dx2 = (lastX - x) / 2, dy2 = (lastY - y) / 2, x1 = cosAngle * dx2 + sinAngle * dy2, y1 = -sinAngle * dx2 + cosAngle * dy2, x1_sq = x1 * x1, y1_sq = y1 * y1, radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
-    radiiCheck > 1 && (rx = _sqrt(radiiCheck) * rx, ry = _sqrt(radiiCheck) * ry);
-    let rx_sq = rx * rx, ry_sq = ry * ry, sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
-    sq < 0 && (sq = 0);
-    let coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq), cx1 = coef * (rx * y1 / ry), cy1 = coef * (-ry * x1 / rx), cx = (lastX + x) / 2 + (cosAngle * cx1 - sinAngle * cy1), cy = (lastY + y) / 2 + (sinAngle * cx1 + cosAngle * cy1), ux = (x1 - cx1) / rx, uy = (y1 - cy1) / ry, vx = (-x1 - cx1) / rx, vy = (-y1 - cy1) / ry, temp = ux * ux + uy * uy, angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)), angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));
-    isNaN(angleExtent) && (angleExtent = PI), !sweepFlag && angleExtent > 0 ? angleExtent -= TWOPI : sweepFlag && angleExtent < 0 && (angleExtent += TWOPI), 
-    angleStart %= TWOPI, angleExtent %= TWOPI;
-    let i, segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)), rawPath = [], angleIncrement = angleExtent / segments, controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)), ma = cosAngle * rx, mb = sinAngle * rx, mc = sinAngle * -ry, md = cosAngle * ry;
-    for (i = 0; i < segments; i++) x1 = _cos(angle = angleStart + i * angleIncrement), 
-    y1 = _sin(angle), ux = _cos(angle += angleIncrement), uy = _sin(angle), rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
-    for (i = 0; i < rawPath.length; i += 2) x1 = rawPath[i], y1 = rawPath[i + 1], rawPath[i] = x1 * ma + y1 * mc + cx, 
-    rawPath[i + 1] = x1 * mb + y1 * md + cy;
-    return rawPath[i - 2] = x, rawPath[i - 1] = y, rawPath;
-}
-
-function stringToRawPath(d) {
-    let i, j, x, y, command, isRelative, segment, startX, startY, difX, difY, beziers, prevCommand, flag1, flag2, a = (d + "").replace(_scientific, (m => {
-        let n = +m;
-        return n < 1e-4 && n > -1e-4 ? 0 : n;
-    })).match(_svgPathExp) || [], path = [], relativeX = 0, relativeY = 0, twoThirds = 2 / 3, elements = a.length, points = 0, errorMessage = "ERROR: malformed path: " + d, line = function(sx, sy, ex, ey) {
-        difX = (ex - sx) / 3, difY = (ey - sy) / 3, segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
-    };
-    if (!d || !isNaN(a[0]) || isNaN(a[1])) return console.log(errorMessage), path;
-    for (i = 0; i < elements; i++) if (prevCommand = command, isNaN(a[i]) ? (command = a[i].toUpperCase(), 
-    isRelative = command !== a[i]) : i--, x = +a[i + 1], y = +a[i + 2], isRelative && (x += relativeX, 
-    y += relativeY), i || (startX = x, startY = y), "M" === command) segment && (segment.length < 8 ? path.length -= 1 : points += segment.length), 
-    relativeX = startX = x, relativeY = startY = y, segment = [ x, y ], path.push(segment), 
-    i += 2, command = "L"; else if ("C" === command) segment || (segment = [ 0, 0 ]), 
-    isRelative || (relativeX = relativeY = 0), segment.push(x, y, relativeX + 1 * a[i + 3], relativeY + 1 * a[i + 4], relativeX += 1 * a[i + 5], relativeY += 1 * a[i + 6]), 
-    i += 6; else if ("S" === command) difX = relativeX, difY = relativeY, "C" !== prevCommand && "S" !== prevCommand || (difX += relativeX - segment[segment.length - 4], 
-    difY += relativeY - segment[segment.length - 3]), isRelative || (relativeX = relativeY = 0), 
-    segment.push(difX, difY, x, y, relativeX += 1 * a[i + 3], relativeY += 1 * a[i + 4]), 
-    i += 4; else if ("Q" === command) difX = relativeX + (x - relativeX) * twoThirds, 
-    difY = relativeY + (y - relativeY) * twoThirds, isRelative || (relativeX = relativeY = 0), 
-    relativeX += 1 * a[i + 3], relativeY += 1 * a[i + 4], segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY), 
-    i += 4; else if ("T" === command) difX = relativeX - segment[segment.length - 4], 
-    difY = relativeY - segment[segment.length - 3], segment.push(relativeX + difX, relativeY + difY, x + (relativeX + 1.5 * difX - x) * twoThirds, y + (relativeY + 1.5 * difY - y) * twoThirds, relativeX = x, relativeY = y), 
-    i += 2; else if ("H" === command) line(relativeX, relativeY, relativeX = x, relativeY), 
-    i += 1; else if ("V" === command) line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0)), 
-    i += 1; else if ("L" === command || "Z" === command) "Z" === command && (x = startX, 
-    y = startY, segment.closed = !0), ("L" === command || _abs(relativeX - x) > .5 || _abs(relativeY - y) > .5) && (line(relativeX, relativeY, x, y), 
-    "L" === command && (i += 2)), relativeX = x, relativeY = y; else if ("A" === command) {
-        if (flag1 = a[i + 4], flag2 = a[i + 5], difX = a[i + 6], difY = a[i + 7], j = 7, 
-        flag1.length > 1 && (flag1.length < 3 ? (difY = difX, difX = flag2, j--) : (difY = flag2, 
-        difX = flag1.substr(2), j -= 2), flag2 = flag1.charAt(1), flag1 = flag1.charAt(0)), 
-        beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + 1 * difX, (isRelative ? relativeY : 0) + 1 * difY), 
-        i += j, beziers) for (j = 0; j < beziers.length; j++) segment.push(beziers[j]);
-        relativeX = segment[segment.length - 2], relativeY = segment[segment.length - 1];
-    } else console.log(errorMessage);
-    return i = segment.length, i < 6 ? (path.pop(), i = 0) : segment[0] === segment[i - 2] && segment[1] === segment[i - 1] && (segment.closed = !0), 
-    path.totalPoints = points + i, path;
-}
-
-function bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
-    let length, x12 = (x1 + x2) / 2, y12 = (y1 + y2) / 2, x23 = (x2 + x3) / 2, y23 = (y2 + y3) / 2, x34 = (x3 + x4) / 2, y34 = (y3 + y4) / 2, x123 = (x12 + x23) / 2, y123 = (y12 + y23) / 2, x234 = (x23 + x34) / 2, y234 = (y23 + y34) / 2, x1234 = (x123 + x234) / 2, y1234 = (y123 + y234) / 2, dx = x4 - x1, dy = y4 - y1, d2 = _abs((x2 - x4) * dy - (y2 - y4) * dx), d3 = _abs((x3 - x4) * dy - (y3 - y4) * dx);
-    return points || (points = [ x1, y1, x4, y4 ], index = 2), points.splice(index || points.length - 2, 0, x1234, y1234), 
-    (d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy) && (length = points.length, 
-    bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index), 
-    bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 2 + (points.length - length))), 
-    points;
-}
-
-function flatPointsToSegment(points, curviness = 1) {
-    let x = points[0], y = 0, segment = [ x, y ], i = 2;
-    for (;i < points.length; i += 2) segment.push(x, y, points[i], y = (points[i] - x) * curviness / 2, x = points[i], -y);
-    return segment;
-}
-
-function pointsToSegment(points, curviness) {
-    _abs(points[0] - points[2]) < 1e-4 && _abs(points[1] - points[3]) < 1e-4 && (points = points.slice(2));
-    let prevX, prevY, i, dx1, dy1, r1, r2, r3, tl, mx1, mx2, mxm, my1, my2, mym, l = points.length - 2, x = +points[0], y = +points[1], nextX = +points[2], nextY = +points[3], segment = [ x, y, x, y ], dx2 = nextX - x, dy2 = nextY - y, closed = Math.abs(points[l] - x) < .001 && Math.abs(points[l + 1] - y) < .001;
-    for (closed && (points.push(nextX, nextY), nextX = x, nextY = y, x = points[l - 2], 
-    y = points[l - 1], points.unshift(x, y), l += 4), curviness = curviness || 0 === curviness ? +curviness : 1, 
-    i = 2; i < l; i += 2) prevX = x, prevY = y, x = nextX, y = nextY, nextX = +points[i + 2], 
-    nextY = +points[i + 3], x === nextX && y === nextY || (dx1 = dx2, dy1 = dy2, dx2 = nextX - x, 
-    dy2 = nextY - y, r1 = _sqrt(dx1 * dx1 + dy1 * dy1), r2 = _sqrt(dx2 * dx2 + dy2 * dy2), 
-    r3 = _sqrt((dx2 / r2 + dx1 / r1) ** 2 + (dy2 / r2 + dy1 / r1) ** 2), tl = (r1 + r2) * curviness * .25 / r3, 
-    mx1 = x - (x - prevX) * (r1 ? tl / r1 : 0), mx2 = x + (nextX - x) * (r2 ? tl / r2 : 0), 
-    mxm = x - (mx1 + ((mx2 - mx1) * (3 * r1 / (r1 + r2) + .5) / 4 || 0)), my1 = y - (y - prevY) * (r1 ? tl / r1 : 0), 
-    my2 = y + (nextY - y) * (r2 ? tl / r2 : 0), mym = y - (my1 + ((my2 - my1) * (3 * r1 / (r1 + r2) + .5) / 4 || 0)), 
-    x === prevX && y === prevY || segment.push(_round(mx1 + mxm), _round(my1 + mym), _round(x), _round(y), _round(mx2 + mxm), _round(my2 + mym)));
-    return x !== nextX || y !== nextY || segment.length < 4 ? segment.push(_round(nextX), _round(nextY), _round(nextX), _round(nextY)) : segment.length -= 2, 
-    2 === segment.length ? segment.push(x, y, x, y, x, y) : closed && (segment.splice(0, 6), 
-    segment.length = segment.length - 6), segment;
-}
-
-function pointToSegDist(x, y, x1, y1, x2, y2) {
-    let t, dx = x2 - x1, dy = y2 - y1;
-    return (dx || dy) && (t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy), 
-    t > 1 ? (x1 = x2, y1 = y2) : t > 0 && (x1 += dx * t, y1 += dy * t)), (x - x1) ** 2 + (y - y1) ** 2;
-}
-
-function simplifyStep(points, first, last, tolerance, simplified) {
-    let index, i, d, maxSqDist = tolerance, firstX = points[first], firstY = points[first + 1], lastX = points[last], lastY = points[last + 1];
-    for (i = first + 2; i < last; i += 2) d = pointToSegDist(points[i], points[i + 1], firstX, firstY, lastX, lastY), 
-    d > maxSqDist && (index = i, maxSqDist = d);
-    maxSqDist > tolerance && (index - first > 2 && simplifyStep(points, first, index, tolerance, simplified), 
-    simplified.push(points[index], points[index + 1]), last - index > 2 && simplifyStep(points, index, last, tolerance, simplified));
-}
-
-function simplifyPoints(points, tolerance) {
-    let i, x, y, dx, dy, result, last, prevX = parseFloat(points[0]), prevY = parseFloat(points[1]), temp = [ prevX, prevY ], l = points.length - 2;
-    for (tolerance = (tolerance || 1) ** 2, i = 2; i < l; i += 2) x = parseFloat(points[i]), 
-    y = parseFloat(points[i + 1]), dx = prevX - x, dy = prevY - y, dx * dx + dy * dy > tolerance && (temp.push(x, y), 
-    prevX = x, prevY = y);
-    return temp.push(parseFloat(points[l]), parseFloat(points[l + 1])), last = temp.length - 2, 
-    result = [ temp[0], temp[1] ], simplifyStep(temp, 0, last, tolerance, result), result.push(temp[last], temp[last + 1]), 
-    result;
-}
-
-function getClosestProgressOnBezier(iterations, px, py, start, end, slices, x0, y0, x1, y1, x2, y2, x3, y3) {
-    let x, y, d, dx, dy, inv, inc = (end - start) / slices, best = 0, t = start;
-    for (_bestDistance = _largeNum; t <= end; ) inv = 1 - t, x = inv * inv * inv * x0 + 3 * inv * inv * t * x1 + 3 * inv * t * t * x2 + t * t * t * x3, 
-    y = inv * inv * inv * y0 + 3 * inv * inv * t * y1 + 3 * inv * t * t * y2 + t * t * t * y3, 
-    dx = x - px, dy = y - py, d = dx * dx + dy * dy, d < _bestDistance && (_bestDistance = d, 
-    best = t), t += inc;
-    return iterations > 1 ? getClosestProgressOnBezier(iterations - 1, px, py, Math.max(best - inc, 0), Math.min(best + inc, 1), slices, x0, y0, x1, y1, x2, y2, x3, y3) : best;
-}
-
-function getClosestData(rawPath, x, y, slices) {
-    let i, j, t, segment, closest = {
-        j: 0,
-        i: 0,
-        t: 0
-    }, bestDistance = _largeNum;
-    for (j = 0; j < rawPath.length; j++) for (segment = rawPath[j], i = 0; i < segment.length; i += 6) t = getClosestProgressOnBezier(1, x, y, 0, 1, slices || 20, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]), 
-    bestDistance > _bestDistance && (bestDistance = _bestDistance, closest.j = j, closest.i = i, 
-    closest.t = t);
-    return closest;
-}
-
-function subdivideSegmentNear(x, y, segment, slices, iterations) {
-    let t, i, l = segment.length, bestDistance = _largeNum, bestT = 0, bestSegmentIndex = 0;
-    for (slices = slices || 20, iterations = iterations || 3, i = 0; i < l; i += 6) t = getClosestProgressOnBezier(1, x, y, 0, 1, slices, segment[i], segment[i + 1], segment[i + 2], segment[i + 3], segment[i + 4], segment[i + 5], segment[i + 6], segment[i + 7]), 
-    bestDistance > _bestDistance && (bestDistance = _bestDistance, bestT = t, bestSegmentIndex = i);
-    return t = getClosestProgressOnBezier(iterations, x, y, bestT - .05, bestT + .05, slices, segment[bestSegmentIndex], segment[bestSegmentIndex + 1], segment[bestSegmentIndex + 2], segment[bestSegmentIndex + 3], segment[bestSegmentIndex + 4], segment[bestSegmentIndex + 5], segment[bestSegmentIndex + 6], segment[bestSegmentIndex + 7]), 
-    subdivideSegment(segment, bestSegmentIndex, t), bestSegmentIndex + 6;
-}
-
-function rawPathToString(rawPath) {
-    _isNumber(rawPath[0]) && (rawPath = [ rawPath ]);
-    let sl, s, i, segment, result = "", l = rawPath.length;
-    for (s = 0; s < l; s++) {
-        for (segment = rawPath[s], result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C", 
-        sl = segment.length, i = 2; i < sl; i++) result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " ";
-        segment.closed && (result += "z");
-    }
-    return result;
-}
-
-exports.convertToPath = convertToPath, exports.getRotationAtProgress = getRotationAtProgress, 
-exports.sliceRawPath = sliceRawPath, exports.cacheRawPathMeasurements = cacheRawPathMeasurements, 
-exports.subdivideSegment = subdivideSegment, exports.getPositionOnPath = getPositionOnPath, 
-exports.transformRawPath = transformRawPath, exports.stringToRawPath = stringToRawPath, 
-exports.bezierToPoints = bezierToPoints, exports.flatPointsToSegment = flatPointsToSegment, 
-exports.pointsToSegment = pointsToSegment, exports.simplifyPoints = simplifyPoints, 
-exports.getClosestData = getClosestData, exports.subdivideSegmentNear = subdivideSegmentNear, 
-exports.rawPathToString = rawPathToString;
-//# sourceMappingURL=paths.js.map