jnpf-web-datascreen-vue3-v6.x/node_modules/.pnpm-store/v3/files/36/f24667995ac63d7046dc6a23e1df441f13c40b550db67ee70f5dd2d28ad2aea33889cd57ddbb5e9b9bbf3432df0aeb38dc3709902e0777b95aff5de6a0bfe6

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
var bezierCurve = require('../lib/index')

window.bezierCurve = bezierCurve
},{"../lib/index":4}],2:[function(require,module,exports){
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.bezierCurveToPolyline = bezierCurveToPolyline;
exports.getBezierCurveLength = getBezierCurveLength;
exports["default"] = void 0;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var sqrt = Math.sqrt,
    pow = Math.pow,
    ceil = Math.ceil,
    abs = Math.abs; // Initialize the number of points per curve

var defaultSegmentPointsNum = 50;
/**
 * @example data structure of bezierCurve
 * bezierCurve = [
 *  // Starting point of the curve
 *  [10, 10],
 *  // BezierCurve segment data (controlPoint1, controlPoint2, endPoint)
 *  [
 *    [20, 20], [40, 20], [50, 10]
 *  ],
 *  ...
 * ]
 */

/**
 * @description               Abstract the curve as a polyline consisting of N points
 * @param {Array} bezierCurve bezierCurve data
 * @param {Number} precision  calculation accuracy. Recommended for 1-20. Default = 5
 * @return {Object}           Calculation results and related data
 * @return {Array}            Option.segmentPoints Point data that constitutes a polyline after calculation
 * @return {Number}           Option.cycles Number of iterations
 * @return {Number}           Option.rounds The number of recursions for the last iteration
 */

function abstractBezierCurveToPolyline(bezierCurve) {
  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
  var segmentsNum = bezierCurve.length - 1;
  var startPoint = bezierCurve[0];
  var endPoint = bezierCurve[segmentsNum][2];
  var segments = bezierCurve.slice(1);
  var getSegmentTPointFuns = segments.map(function (seg, i) {
    var beginPoint = i === 0 ? startPoint : segments[i - 1][2];
    return createGetBezierCurveTPointFun.apply(void 0, [beginPoint].concat((0, _toConsumableArray2["default"])(seg)));
  }); // Initialize the curve to a polyline

  var segmentPointsNum = new Array(segmentsNum).fill(defaultSegmentPointsNum);
  var segmentPoints = getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum); // Calculate uniformly distributed points by iteratively

  var result = calcUniformPointsByIteration(segmentPoints, getSegmentTPointFuns, segments, precision);
  result.segmentPoints.push(endPoint);
  return result;
}
/**
 * @description  Generate a method for obtaining corresponding point by t according to curve data
 * @param {Array} beginPoint    BezierCurve begin point. [x, y]
 * @param {Array} controlPoint1 BezierCurve controlPoint1. [x, y]
 * @param {Array} controlPoint2 BezierCurve controlPoint2. [x, y]
 * @param {Array} endPoint      BezierCurve end point. [x, y]
 * @return {Function} Expected function
 */


function createGetBezierCurveTPointFun(beginPoint, controlPoint1, controlPoint2, endPoint) {
  return function (t) {
    var tSubed1 = 1 - t;
    var tSubed1Pow3 = pow(tSubed1, 3);
    var tSubed1Pow2 = pow(tSubed1, 2);
    var tPow3 = pow(t, 3);
    var tPow2 = pow(t, 2);
    return [beginPoint[0] * tSubed1Pow3 + 3 * controlPoint1[0] * t * tSubed1Pow2 + 3 * controlPoint2[0] * tPow2 * tSubed1 + endPoint[0] * tPow3, beginPoint[1] * tSubed1Pow3 + 3 * controlPoint1[1] * t * tSubed1Pow2 + 3 * controlPoint2[1] * tPow2 * tSubed1 + endPoint[1] * tPow3];
  };
}
/**
 * @description Get the distance between two points
 * @param {Array} point1 BezierCurve begin point. [x, y]
 * @param {Array} point2 BezierCurve controlPoint1. [x, y]
 * @return {Number} Expected distance
 */


function getTwoPointDistance(_ref, _ref2) {
  var _ref3 = (0, _slicedToArray2["default"])(_ref, 2),
      ax = _ref3[0],
      ay = _ref3[1];

  var _ref4 = (0, _slicedToArray2["default"])(_ref2, 2),
      bx = _ref4[0],
      by = _ref4[1];

  return sqrt(pow(ax - bx, 2) + pow(ay - by, 2));
}
/**
 * @description Get the sum of the array of numbers
 * @param {Array} nums An array of numbers
 * @return {Number} Expected sum
 */


function getNumsSum(nums) {
  return nums.reduce(function (sum, num) {
    return sum + num;
  }, 0);
}
/**
 * @description Get the distance of multiple sets of points
 * @param {Array} segmentPoints Multiple sets of point data
 * @return {Array} Distance of multiple sets of point data
 */


function getSegmentPointsDistance(segmentPoints) {
  return segmentPoints.map(function (points, i) {
    return new Array(points.length - 1).fill(0).map(function (temp, j) {
      return getTwoPointDistance(points[j], points[j + 1]);
    });
  });
}
/**
 * @description Get the distance of multiple sets of points
 * @param {Array} segmentPoints Multiple sets of point data
 * @return {Array} Distance of multiple sets of point data
 */


function getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum) {
  return getSegmentTPointFuns.map(function (getSegmentTPointFun, i) {
    var tGap = 1 / segmentPointsNum[i];
    return new Array(segmentPointsNum[i]).fill('').map(function (foo, j) {
      return getSegmentTPointFun(j * tGap);
    });
  });
}
/**
 * @description Get the sum of deviations between line segment and the average length
 * @param {Array} segmentPointsDistance Segment length of polyline
 * @param {Number} avgLength            Average length of the line segment
 * @return {Number} Deviations
 */


function getAllDeviations(segmentPointsDistance, avgLength) {
  return segmentPointsDistance.map(function (seg) {
    return seg.map(function (s) {
      return abs(s - avgLength);
    });
  }).map(function (seg) {
    return getNumsSum(seg);
  }).reduce(function (total, v) {
    return total + v;
  }, 0);
}
/**
 * @description Calculate uniformly distributed points by iteratively
 * @param {Array} segmentPoints        Multiple setd of points that make up a polyline
 * @param {Array} getSegmentTPointFuns Functions of get a point on the curve with t
 * @param {Array} segments             BezierCurve data
 * @param {Number} precision           Calculation accuracy
 * @return {Object} Calculation results and related data
 * @return {Array}  Option.segmentPoints Point data that constitutes a polyline after calculation
 * @return {Number} Option.cycles Number of iterations
 * @return {Number} Option.rounds The number of recursions for the last iteration
 */


function calcUniformPointsByIteration(segmentPoints, getSegmentTPointFuns, segments, precision) {
  // The number of loops for the current iteration
  var rounds = 4; // Number of iterations

  var cycles = 1;

  var _loop = function _loop() {
    // Recalculate the number of points per curve based on the last iteration data
    var totalPointsNum = segmentPoints.reduce(function (total, seg) {
      return total + seg.length;
    }, 0); // Add last points of segment to calc exact segment length

    segmentPoints.forEach(function (seg, i) {
      return seg.push(segments[i][2]);
    });
    var segmentPointsDistance = getSegmentPointsDistance(segmentPoints);
    var lineSegmentNum = segmentPointsDistance.reduce(function (total, seg) {
      return total + seg.length;
    }, 0);
    var segmentlength = segmentPointsDistance.map(function (seg) {
      return getNumsSum(seg);
    });
    var totalLength = getNumsSum(segmentlength);
    var avgLength = totalLength / lineSegmentNum; // Check if precision is reached

    var allDeviations = getAllDeviations(segmentPointsDistance, avgLength);
    if (allDeviations <= precision) return "break";
    totalPointsNum = ceil(avgLength / precision * totalPointsNum * 1.1);
    var segmentPointsNum = segmentlength.map(function (length) {
      return ceil(length / totalLength * totalPointsNum);
    }); // Calculate the points after redistribution

    segmentPoints = getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum);
    totalPointsNum = segmentPoints.reduce(function (total, seg) {
      return total + seg.length;
    }, 0);
    var segmentPointsForLength = JSON.parse(JSON.stringify(segmentPoints));
    segmentPointsForLength.forEach(function (seg, i) {
      return seg.push(segments[i][2]);
    });
    segmentPointsDistance = getSegmentPointsDistance(segmentPointsForLength);
    lineSegmentNum = segmentPointsDistance.reduce(function (total, seg) {
      return total + seg.length;
    }, 0);
    segmentlength = segmentPointsDistance.map(function (seg) {
      return getNumsSum(seg);
    });
    totalLength = getNumsSum(segmentlength);
    avgLength = totalLength / lineSegmentNum;
    var stepSize = 1 / totalPointsNum / 10; // Recursively for each segment of the polyline

    getSegmentTPointFuns.forEach(function (getSegmentTPointFun, i) {
      var currentSegmentPointsNum = segmentPointsNum[i];
      var t = new Array(currentSegmentPointsNum).fill('').map(function (foo, j) {
        return j / segmentPointsNum[i];
      }); // Repeated recursive offset

      for (var r = 0; r < rounds; r++) {
        var distance = getSegmentPointsDistance([segmentPoints[i]])[0];
        var deviations = distance.map(function (d) {
          return d - avgLength;
        });
        var offset = 0;

        for (var j = 0; j < currentSegmentPointsNum; j++) {
          if (j === 0) return;
          offset += deviations[j - 1];
          t[j] -= stepSize * offset;
          if (t[j] > 1) t[j] = 1;
          if (t[j] < 0) t[j] = 0;
          segmentPoints[i][j] = getSegmentTPointFun(t[j]);
        }
      }
    });
    rounds *= 4;
    cycles++;
  };

  do {
    var _ret = _loop();

    if (_ret === "break") break;
  } while (rounds <= 1025);

  segmentPoints = segmentPoints.reduce(function (all, seg) {
    return all.concat(seg);
  }, []);
  return {
    segmentPoints: segmentPoints,
    cycles: cycles,
    rounds: rounds
  };
}
/**
 * @description Get the polyline corresponding to the Bezier curve
 * @param {Array} bezierCurve BezierCurve data
 * @param {Number} precision  Calculation accuracy. Recommended for 1-20. Default = 5
 * @return {Array|Boolean} Point data that constitutes a polyline after calculation (Invalid input will return false)
 */


function bezierCurveToPolyline(bezierCurve) {
  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;

  if (!bezierCurve) {
    console.error('bezierCurveToPolyline: Missing parameters!');
    return false;
  }

  if (!(bezierCurve instanceof Array)) {
    console.error('bezierCurveToPolyline: Parameter bezierCurve must be an array!');
    return false;
  }

  if (typeof precision !== 'number') {
    console.error('bezierCurveToPolyline: Parameter precision must be a number!');
    return false;
  }

  var _abstractBezierCurveT = abstractBezierCurveToPolyline(bezierCurve, precision),
      segmentPoints = _abstractBezierCurveT.segmentPoints;

  return segmentPoints;
}
/**
 * @description Get the bezier curve length
 * @param {Array} bezierCurve bezierCurve data
 * @param {Number} precision  calculation accuracy. Recommended for 5-10. Default = 5
 * @return {Number|Boolean} BezierCurve length (Invalid input will return false)
 */


function getBezierCurveLength(bezierCurve) {
  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;

  if (!bezierCurve) {
    console.error('getBezierCurveLength: Missing parameters!');
    return false;
  }

  if (!(bezierCurve instanceof Array)) {
    console.error('getBezierCurveLength: Parameter bezierCurve must be an array!');
    return false;
  }

  if (typeof precision !== 'number') {
    console.error('getBezierCurveLength: Parameter precision must be a number!');
    return false;
  }

  var _abstractBezierCurveT2 = abstractBezierCurveToPolyline(bezierCurve, precision),
      segmentPoints = _abstractBezierCurveT2.segmentPoints; // Calculate the total length of the points that make up the polyline


  var pointsDistance = getSegmentPointsDistance([segmentPoints])[0];
  var length = getNumsSum(pointsDistance);
  return length;
}

var _default = bezierCurveToPolyline;
exports["default"] = _default;
},{"@babel/runtime/helpers/interopRequireDefault":7,"@babel/runtime/helpers/slicedToArray":12,"@babel/runtime/helpers/toConsumableArray":13}],3:[function(require,module,exports){
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

/**
 * @description Abstract the polyline formed by N points into a set of bezier curve
 * @param {Array} polyline A set of points that make up a polyline
 * @param {Boolean} close  Closed curve
 * @param {Number} offsetA Smoothness
 * @param {Number} offsetB Smoothness
 * @return {Array|Boolean} A set of bezier curve (Invalid input will return false)
 */
function polylineToBezierCurve(polyline) {
  var close = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var offsetA = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.25;
  var offsetB = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.25;

  if (!(polyline instanceof Array)) {
    console.error('polylineToBezierCurve: Parameter polyline must be an array!');
    return false;
  }

  if (polyline.length <= 2) {
    console.error('polylineToBezierCurve: Converting to a curve requires at least 3 points!');
    return false;
  }

  var startPoint = polyline[0];
  var bezierCurveLineNum = polyline.length - 1;
  var bezierCurvePoints = new Array(bezierCurveLineNum).fill(0).map(function (foo, i) {
    return [].concat((0, _toConsumableArray2["default"])(getBezierCurveLineControlPoints(polyline, i, close, offsetA, offsetB)), [polyline[i + 1]]);
  });
  if (close) closeBezierCurve(bezierCurvePoints, startPoint);
  bezierCurvePoints.unshift(polyline[0]);
  return bezierCurvePoints;
}
/**
 * @description Get the control points of the Bezier curve
 * @param {Array} polyline A set of points that make up a polyline
 * @param {Number} index   The index of which get controls points's point in polyline
 * @param {Boolean} close  Closed curve
 * @param {Number} offsetA Smoothness
 * @param {Number} offsetB Smoothness
 * @return {Array} Control points
 */


function getBezierCurveLineControlPoints(polyline, index) {
  var close = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var offsetA = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.25;
  var offsetB = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.25;
  var pointNum = polyline.length;
  if (pointNum < 3 || index >= pointNum) return;
  var beforePointIndex = index - 1;
  if (beforePointIndex < 0) beforePointIndex = close ? pointNum + beforePointIndex : 0;
  var afterPointIndex = index + 1;
  if (afterPointIndex >= pointNum) afterPointIndex = close ? afterPointIndex - pointNum : pointNum - 1;
  var afterNextPointIndex = index + 2;
  if (afterNextPointIndex >= pointNum) afterNextPointIndex = close ? afterNextPointIndex - pointNum : pointNum - 1;
  var pointBefore = polyline[beforePointIndex];
  var pointMiddle = polyline[index];
  var pointAfter = polyline[afterPointIndex];
  var pointAfterNext = polyline[afterNextPointIndex];
  return [[pointMiddle[0] + offsetA * (pointAfter[0] - pointBefore[0]), pointMiddle[1] + offsetA * (pointAfter[1] - pointBefore[1])], [pointAfter[0] - offsetB * (pointAfterNext[0] - pointMiddle[0]), pointAfter[1] - offsetB * (pointAfterNext[1] - pointMiddle[1])]];
}
/**
 * @description Get the last curve of the closure
 * @param {Array} bezierCurve A set of sub-curve
 * @param {Array} startPoint  Start point
 * @return {Array} The last curve for closure
 */


function closeBezierCurve(bezierCurve, startPoint) {
  var firstSubCurve = bezierCurve[0];
  var lastSubCurve = bezierCurve.slice(-1)[0];
  bezierCurve.push([getSymmetryPoint(lastSubCurve[1], lastSubCurve[2]), getSymmetryPoint(firstSubCurve[0], startPoint), startPoint]);
  return bezierCurve;
}
/**
 * @description Get the symmetry point
 * @param {Array} point       Symmetric point
 * @param {Array} centerPoint Symmetric center
 * @return {Array} Symmetric point
 */


function getSymmetryPoint(point, centerPoint) {
  var _point = (0, _slicedToArray2["default"])(point, 2),
      px = _point[0],
      py = _point[1];

  var _centerPoint = (0, _slicedToArray2["default"])(centerPoint, 2),
      cx = _centerPoint[0],
      cy = _centerPoint[1];

  var minusX = cx - px;
  var minusY = cy - py;
  return [cx + minusX, cy + minusY];
}

var _default = polylineToBezierCurve;
exports["default"] = _default;
},{"@babel/runtime/helpers/interopRequireDefault":7,"@babel/runtime/helpers/slicedToArray":12,"@babel/runtime/helpers/toConsumableArray":13}],4:[function(require,module,exports){
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
Object.defineProperty(exports, "bezierCurveToPolyline", {
  enumerable: true,
  get: function get() {
    return _bezierCurveToPolyline.bezierCurveToPolyline;
  }
});
Object.defineProperty(exports, "getBezierCurveLength", {
  enumerable: true,
  get: function get() {
    return _bezierCurveToPolyline.getBezierCurveLength;
  }
});
Object.defineProperty(exports, "polylineToBezierCurve", {
  enumerable: true,
  get: function get() {
    return _polylineToBezierCurve["default"];
  }
});
exports["default"] = void 0;

var _bezierCurveToPolyline = require("./core/bezierCurveToPolyline");

var _polylineToBezierCurve = _interopRequireDefault(require("./core/polylineToBezierCurve"));

var _default = {
  bezierCurveToPolyline: _bezierCurveToPolyline.bezierCurveToPolyline,
  getBezierCurveLength: _bezierCurveToPolyline.getBezierCurveLength,
  polylineToBezierCurve: _polylineToBezierCurve["default"]
};
exports["default"] = _default;
},{"./core/bezierCurveToPolyline":2,"./core/polylineToBezierCurve":3,"@babel/runtime/helpers/interopRequireDefault":7}],5:[function(require,module,exports){
function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

module.exports = _arrayWithHoles;
},{}],6:[function(require,module,exports){
function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }
}

module.exports = _arrayWithoutHoles;
},{}],7:[function(require,module,exports){
function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}

module.exports = _interopRequireDefault;
},{}],8:[function(require,module,exports){
function _iterableToArray(iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}

module.exports = _iterableToArray;
},{}],9:[function(require,module,exports){
function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

  try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

module.exports = _iterableToArrayLimit;
},{}],10:[function(require,module,exports){
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

module.exports = _nonIterableRest;
},{}],11:[function(require,module,exports){
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
}

module.exports = _nonIterableSpread;
},{}],12:[function(require,module,exports){
var arrayWithHoles = require("./arrayWithHoles");

var iterableToArrayLimit = require("./iterableToArrayLimit");

var nonIterableRest = require("./nonIterableRest");

function _slicedToArray(arr, i) {
  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
}

module.exports = _slicedToArray;
},{"./arrayWithHoles":5,"./iterableToArrayLimit":9,"./nonIterableRest":10}],13:[function(require,module,exports){
var arrayWithoutHoles = require("./arrayWithoutHoles");

var iterableToArray = require("./iterableToArray");

var nonIterableSpread = require("./nonIterableSpread");

function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
}

module.exports = _toConsumableArray;
},{"./arrayWithoutHoles":6,"./iterableToArray":8,"./nonIterableSpread":11}]},{},[1])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","build/entry.js","lib/core/bezierCurveToPolyline.js","lib/core/polylineToBezierCurve.js","lib/index.js","node_modules/@babel/runtime/helpers/arrayWithHoles.js","node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","node_modules/@babel/runtime/helpers/interopRequireDefault.js","node_modules/@babel/runtime/helpers/iterableToArray.js","node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","node_modules/@babel/runtime/helpers/nonIterableRest.js","node_modules/@babel/runtime/helpers/nonIterableSpread.js","node_modules/@babel/runtime/helpers/slicedToArray.js","node_modules/@babel/runtime/helpers/toConsumableArray.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9UA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","var bezierCurve = require('../lib/index')\r\n\r\nwindow.bezierCurve = bezierCurve","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bezierCurveToPolyline = bezierCurveToPolyline;\nexports.getBezierCurveLength = getBezierCurveLength;\nexports[\"default\"] = void 0;\n\nvar _slicedToArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/slicedToArray\"));\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar sqrt = Math.sqrt,\n    pow = Math.pow,\n    ceil = Math.ceil,\n    abs = Math.abs; // Initialize the number of points per curve\n\nvar defaultSegmentPointsNum = 50;\n/**\r\n * @example data structure of bezierCurve\r\n * bezierCurve = [\r\n *  // Starting point of the curve\r\n *  [10, 10],\r\n *  // BezierCurve segment data (controlPoint1, controlPoint2, endPoint)\r\n *  [\r\n *    [20, 20], [40, 20], [50, 10]\r\n *  ],\r\n *  ...\r\n * ]\r\n */\n\n/**\r\n * @description               Abstract the curve as a polyline consisting of N points\r\n * @param {Array} bezierCurve bezierCurve data\r\n * @param {Number} precision  calculation accuracy. Recommended for 1-20. Default = 5\r\n * @return {Object}           Calculation results and related data\r\n * @return {Array}            Option.segmentPoints Point data that constitutes a polyline after calculation\r\n * @return {Number}           Option.cycles Number of iterations\r\n * @return {Number}           Option.rounds The number of recursions for the last iteration\r\n */\n\nfunction abstractBezierCurveToPolyline(bezierCurve) {\n  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;\n  var segmentsNum = bezierCurve.length - 1;\n  var startPoint = bezierCurve[0];\n  var endPoint = bezierCurve[segmentsNum][2];\n  var segments = bezierCurve.slice(1);\n  var getSegmentTPointFuns = segments.map(function (seg, i) {\n    var beginPoint = i === 0 ? startPoint : segments[i - 1][2];\n    return createGetBezierCurveTPointFun.apply(void 0, [beginPoint].concat((0, _toConsumableArray2[\"default\"])(seg)));\n  }); // Initialize the curve to a polyline\n\n  var segmentPointsNum = new Array(segmentsNum).fill(defaultSegmentPointsNum);\n  var segmentPoints = getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum); // Calculate uniformly distributed points by iteratively\n\n  var result = calcUniformPointsByIteration(segmentPoints, getSegmentTPointFuns, segments, precision);\n  result.segmentPoints.push(endPoint);\n  return result;\n}\n/**\r\n * @description  Generate a method for obtaining corresponding point by t according to curve data\r\n * @param {Array} beginPoint    BezierCurve begin point. [x, y]\r\n * @param {Array} controlPoint1 BezierCurve controlPoint1. [x, y]\r\n * @param {Array} controlPoint2 BezierCurve controlPoint2. [x, y]\r\n * @param {Array} endPoint      BezierCurve end point. [x, y]\r\n * @return {Function} Expected function\r\n */\n\n\nfunction createGetBezierCurveTPointFun(beginPoint, controlPoint1, controlPoint2, endPoint) {\n  return function (t) {\n    var tSubed1 = 1 - t;\n    var tSubed1Pow3 = pow(tSubed1, 3);\n    var tSubed1Pow2 = pow(tSubed1, 2);\n    var tPow3 = pow(t, 3);\n    var tPow2 = pow(t, 2);\n    return [beginPoint[0] * tSubed1Pow3 + 3 * controlPoint1[0] * t * tSubed1Pow2 + 3 * controlPoint2[0] * tPow2 * tSubed1 + endPoint[0] * tPow3, beginPoint[1] * tSubed1Pow3 + 3 * controlPoint1[1] * t * tSubed1Pow2 + 3 * controlPoint2[1] * tPow2 * tSubed1 + endPoint[1] * tPow3];\n  };\n}\n/**\r\n * @description Get the distance between two points\r\n * @param {Array} point1 BezierCurve begin point. [x, y]\r\n * @param {Array} point2 BezierCurve controlPoint1. [x, y]\r\n * @return {Number} Expected distance\r\n */\n\n\nfunction getTwoPointDistance(_ref, _ref2) {\n  var _ref3 = (0, _slicedToArray2[\"default\"])(_ref, 2),\n      ax = _ref3[0],\n      ay = _ref3[1];\n\n  var _ref4 = (0, _slicedToArray2[\"default\"])(_ref2, 2),\n      bx = _ref4[0],\n      by = _ref4[1];\n\n  return sqrt(pow(ax - bx, 2) + pow(ay - by, 2));\n}\n/**\r\n * @description Get the sum of the array of numbers\r\n * @param {Array} nums An array of numbers\r\n * @return {Number} Expected sum\r\n */\n\n\nfunction getNumsSum(nums) {\n  return nums.reduce(function (sum, num) {\n    return sum + num;\n  }, 0);\n}\n/**\r\n * @description Get the distance of multiple sets of points\r\n * @param {Array} segmentPoints Multiple sets of point data\r\n * @return {Array} Distance of multiple sets of point data\r\n */\n\n\nfunction getSegmentPointsDistance(segmentPoints) {\n  return segmentPoints.map(function (points, i) {\n    return new Array(points.length - 1).fill(0).map(function (temp, j) {\n      return getTwoPointDistance(points[j], points[j + 1]);\n    });\n  });\n}\n/**\r\n * @description Get the distance of multiple sets of points\r\n * @param {Array} segmentPoints Multiple sets of point data\r\n * @return {Array} Distance of multiple sets of point data\r\n */\n\n\nfunction getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum) {\n  return getSegmentTPointFuns.map(function (getSegmentTPointFun, i) {\n    var tGap = 1 / segmentPointsNum[i];\n    return new Array(segmentPointsNum[i]).fill('').map(function (foo, j) {\n      return getSegmentTPointFun(j * tGap);\n    });\n  });\n}\n/**\r\n * @description Get the sum of deviations between line segment and the average length\r\n * @param {Array} segmentPointsDistance Segment length of polyline\r\n * @param {Number} avgLength            Average length of the line segment\r\n * @return {Number} Deviations\r\n */\n\n\nfunction getAllDeviations(segmentPointsDistance, avgLength) {\n  return segmentPointsDistance.map(function (seg) {\n    return seg.map(function (s) {\n      return abs(s - avgLength);\n    });\n  }).map(function (seg) {\n    return getNumsSum(seg);\n  }).reduce(function (total, v) {\n    return total + v;\n  }, 0);\n}\n/**\r\n * @description Calculate uniformly distributed points by iteratively\r\n * @param {Array} segmentPoints        Multiple setd of points that make up a polyline\r\n * @param {Array} getSegmentTPointFuns Functions of get a point on the curve with t\r\n * @param {Array} segments             BezierCurve data\r\n * @param {Number} precision           Calculation accuracy\r\n * @return {Object} Calculation results and related data\r\n * @return {Array}  Option.segmentPoints Point data that constitutes a polyline after calculation\r\n * @return {Number} Option.cycles Number of iterations\r\n * @return {Number} Option.rounds The number of recursions for the last iteration\r\n */\n\n\nfunction calcUniformPointsByIteration(segmentPoints, getSegmentTPointFuns, segments, precision) {\n  // The number of loops for the current iteration\n  var rounds = 4; // Number of iterations\n\n  var cycles = 1;\n\n  var _loop = function _loop() {\n    // Recalculate the number of points per curve based on the last iteration data\n    var totalPointsNum = segmentPoints.reduce(function (total, seg) {\n      return total + seg.length;\n    }, 0); // Add last points of segment to calc exact segment length\n\n    segmentPoints.forEach(function (seg, i) {\n      return seg.push(segments[i][2]);\n    });\n    var segmentPointsDistance = getSegmentPointsDistance(segmentPoints);\n    var lineSegmentNum = segmentPointsDistance.reduce(function (total, seg) {\n      return total + seg.length;\n    }, 0);\n    var segmentlength = segmentPointsDistance.map(function (seg) {\n      return getNumsSum(seg);\n    });\n    var totalLength = getNumsSum(segmentlength);\n    var avgLength = totalLength / lineSegmentNum; // Check if precision is reached\n\n    var allDeviations = getAllDeviations(segmentPointsDistance, avgLength);\n    if (allDeviations <= precision) return \"break\";\n    totalPointsNum = ceil(avgLength / precision * totalPointsNum * 1.1);\n    var segmentPointsNum = segmentlength.map(function (length) {\n      return ceil(length / totalLength * totalPointsNum);\n    }); // Calculate the points after redistribution\n\n    segmentPoints = getSegmentPointsByNum(getSegmentTPointFuns, segmentPointsNum);\n    totalPointsNum = segmentPoints.reduce(function (total, seg) {\n      return total + seg.length;\n    }, 0);\n    var segmentPointsForLength = JSON.parse(JSON.stringify(segmentPoints));\n    segmentPointsForLength.forEach(function (seg, i) {\n      return seg.push(segments[i][2]);\n    });\n    segmentPointsDistance = getSegmentPointsDistance(segmentPointsForLength);\n    lineSegmentNum = segmentPointsDistance.reduce(function (total, seg) {\n      return total + seg.length;\n    }, 0);\n    segmentlength = segmentPointsDistance.map(function (seg) {\n      return getNumsSum(seg);\n    });\n    totalLength = getNumsSum(segmentlength);\n    avgLength = totalLength / lineSegmentNum;\n    var stepSize = 1 / totalPointsNum / 10; // Recursively for each segment of the polyline\n\n    getSegmentTPointFuns.forEach(function (getSegmentTPointFun, i) {\n      var currentSegmentPointsNum = segmentPointsNum[i];\n      var t = new Array(currentSegmentPointsNum).fill('').map(function (foo, j) {\n        return j / segmentPointsNum[i];\n      }); // Repeated recursive offset\n\n      for (var r = 0; r < rounds; r++) {\n        var distance = getSegmentPointsDistance([segmentPoints[i]])[0];\n        var deviations = distance.map(function (d) {\n          return d - avgLength;\n        });\n        var offset = 0;\n\n        for (var j = 0; j < currentSegmentPointsNum; j++) {\n          if (j === 0) return;\n          offset += deviations[j - 1];\n          t[j] -= stepSize * offset;\n          if (t[j] > 1) t[j] = 1;\n          if (t[j] < 0) t[j] = 0;\n          segmentPoints[i][j] = getSegmentTPointFun(t[j]);\n        }\n      }\n    });\n    rounds *= 4;\n    cycles++;\n  };\n\n  do {\n    var _ret = _loop();\n\n    if (_ret === \"break\") break;\n  } while (rounds <= 1025);\n\n  segmentPoints = segmentPoints.reduce(function (all, seg) {\n    return all.concat(seg);\n  }, []);\n  return {\n    segmentPoints: segmentPoints,\n    cycles: cycles,\n    rounds: rounds\n  };\n}\n/**\r\n * @description Get the polyline corresponding to the Bezier curve\r\n * @param {Array} bezierCurve BezierCurve data\r\n * @param {Number} precision  Calculation accuracy. Recommended for 1-20. Default = 5\r\n * @return {Array|Boolean} Point data that constitutes a polyline after calculation (Invalid input will return false)\r\n */\n\n\nfunction bezierCurveToPolyline(bezierCurve) {\n  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;\n\n  if (!bezierCurve) {\n    console.error('bezierCurveToPolyline: Missing parameters!');\n    return false;\n  }\n\n  if (!(bezierCurve instanceof Array)) {\n    console.error('bezierCurveToPolyline: Parameter bezierCurve must be an array!');\n    return false;\n  }\n\n  if (typeof precision !== 'number') {\n    console.error('bezierCurveToPolyline: Parameter precision must be a number!');\n    return false;\n  }\n\n  var _abstractBezierCurveT = abstractBezierCurveToPolyline(bezierCurve, precision),\n      segmentPoints = _abstractBezierCurveT.segmentPoints;\n\n  return segmentPoints;\n}\n/**\r\n * @description Get the bezier curve length\r\n * @param {Array} bezierCurve bezierCurve data\r\n * @param {Number} precision  calculation accuracy. Recommended for 5-10. Default = 5\r\n * @return {Number|Boolean} BezierCurve length (Invalid input will return false)\r\n */\n\n\nfunction getBezierCurveLength(bezierCurve) {\n  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;\n\n  if (!bezierCurve) {\n    console.error('getBezierCurveLength: Missing parameters!');\n    return false;\n  }\n\n  if (!(bezierCurve instanceof Array)) {\n    console.error('getBezierCurveLength: Parameter bezierCurve must be an array!');\n    return false;\n  }\n\n  if (typeof precision !== 'number') {\n    console.error('getBezierCurveLength: Parameter precision must be a number!');\n    return false;\n  }\n\n  var _abstractBezierCurveT2 = abstractBezierCurveToPolyline(bezierCurve, precision),\n      segmentPoints = _abstractBezierCurveT2.segmentPoints; // Calculate the total length of the points that make up the polyline\n\n\n  var pointsDistance = getSegmentPointsDistance([segmentPoints])[0];\n  var length = getNumsSum(pointsDistance);\n  return length;\n}\n\nvar _default = bezierCurveToPolyline;\nexports[\"default\"] = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _slicedToArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/slicedToArray\"));\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\n/**\r\n * @description Abstract the polyline formed by N points into a set of bezier curve\r\n * @param {Array} polyline A set of points that make up a polyline\r\n * @param {Boolean} close  Closed curve\r\n * @param {Number} offsetA Smoothness\r\n * @param {Number} offsetB Smoothness\r\n * @return {Array|Boolean} A set of bezier curve (Invalid input will return false)\r\n */\nfunction polylineToBezierCurve(polyline) {\n  var close = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  var offsetA = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.25;\n  var offsetB = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.25;\n\n  if (!(polyline instanceof Array)) {\n    console.error('polylineToBezierCurve: Parameter polyline must be an array!');\n    return false;\n  }\n\n  if (polyline.length <= 2) {\n    console.error('polylineToBezierCurve: Converting to a curve requires at least 3 points!');\n    return false;\n  }\n\n  var startPoint = polyline[0];\n  var bezierCurveLineNum = polyline.length - 1;\n  var bezierCurvePoints = new Array(bezierCurveLineNum).fill(0).map(function (foo, i) {\n    return [].concat((0, _toConsumableArray2[\"default\"])(getBezierCurveLineControlPoints(polyline, i, close, offsetA, offsetB)), [polyline[i + 1]]);\n  });\n  if (close) closeBezierCurve(bezierCurvePoints, startPoint);\n  bezierCurvePoints.unshift(polyline[0]);\n  return bezierCurvePoints;\n}\n/**\r\n * @description Get the control points of the Bezier curve\r\n * @param {Array} polyline A set of points that make up a polyline\r\n * @param {Number} index   The index of which get controls points's point in polyline\r\n * @param {Boolean} close  Closed curve\r\n * @param {Number} offsetA Smoothness\r\n * @param {Number} offsetB Smoothness\r\n * @return {Array} Control points\r\n */\n\n\nfunction getBezierCurveLineControlPoints(polyline, index) {\n  var close = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  var offsetA = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.25;\n  var offsetB = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.25;\n  var pointNum = polyline.length;\n  if (pointNum < 3 || index >= pointNum) return;\n  var beforePointIndex = index - 1;\n  if (beforePointIndex < 0) beforePointIndex = close ? pointNum + beforePointIndex : 0;\n  var afterPointIndex = index + 1;\n  if (afterPointIndex >= pointNum) afterPointIndex = close ? afterPointIndex - pointNum : pointNum - 1;\n  var afterNextPointIndex = index + 2;\n  if (afterNextPointIndex >= pointNum) afterNextPointIndex = close ? afterNextPointIndex - pointNum : pointNum - 1;\n  var pointBefore = polyline[beforePointIndex];\n  var pointMiddle = polyline[index];\n  var pointAfter = polyline[afterPointIndex];\n  var pointAfterNext = polyline[afterNextPointIndex];\n  return [[pointMiddle[0] + offsetA * (pointAfter[0] - pointBefore[0]), pointMiddle[1] + offsetA * (pointAfter[1] - pointBefore[1])], [pointAfter[0] - offsetB * (pointAfterNext[0] - pointMiddle[0]), pointAfter[1] - offsetB * (pointAfterNext[1] - pointMiddle[1])]];\n}\n/**\r\n * @description Get the last curve of the closure\r\n * @param {Array} bezierCurve A set of sub-curve\r\n * @param {Array} startPoint  Start point\r\n * @return {Array} The last curve for closure\r\n */\n\n\nfunction closeBezierCurve(bezierCurve, startPoint) {\n  var firstSubCurve = bezierCurve[0];\n  var lastSubCurve = bezierCurve.slice(-1)[0];\n  bezierCurve.push([getSymmetryPoint(lastSubCurve[1], lastSubCurve[2]), getSymmetryPoint(firstSubCurve[0], startPoint), startPoint]);\n  return bezierCurve;\n}\n/**\r\n * @description Get the symmetry point\r\n * @param {Array} point       Symmetric point\r\n * @param {Array} centerPoint Symmetric center\r\n * @return {Array} Symmetric point\r\n */\n\n\nfunction getSymmetryPoint(point, centerPoint) {\n  var _point = (0, _slicedToArray2[\"default\"])(point, 2),\n      px = _point[0],\n      py = _point[1];\n\n  var _centerPoint = (0, _slicedToArray2[\"default\"])(centerPoint, 2),\n      cx = _centerPoint[0],\n      cy = _centerPoint[1];\n\n  var minusX = cx - px;\n  var minusY = cy - py;\n  return [cx + minusX, cy + minusY];\n}\n\nvar _default = polylineToBezierCurve;\nexports[\"default\"] = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"bezierCurveToPolyline\", {\n  enumerable: true,\n  get: function get() {\n    return _bezierCurveToPolyline.bezierCurveToPolyline;\n  }\n});\nObject.defineProperty(exports, \"getBezierCurveLength\", {\n  enumerable: true,\n  get: function get() {\n    return _bezierCurveToPolyline.getBezierCurveLength;\n  }\n});\nObject.defineProperty(exports, \"polylineToBezierCurve\", {\n  enumerable: true,\n  get: function get() {\n    return _polylineToBezierCurve[\"default\"];\n  }\n});\nexports[\"default\"] = void 0;\n\nvar _bezierCurveToPolyline = require(\"./core/bezierCurveToPolyline\");\n\nvar _polylineToBezierCurve = _interopRequireDefault(require(\"./core/polylineToBezierCurve\"));\n\nvar _default = {\n  bezierCurveToPolyline: _bezierCurveToPolyline.bezierCurveToPolyline,\n  getBezierCurveLength: _bezierCurveToPolyline.getBezierCurveLength,\n  polylineToBezierCurve: _polylineToBezierCurve[\"default\"]\n};\nexports[\"default\"] = _default;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n\n    return arr2;\n  }\n}\n\nmodule.exports = _arrayWithoutHoles;","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;","function _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _iterableToArrayLimit(arr, i) {\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n}\n\nmodule.exports = _nonIterableRest;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nmodule.exports = _nonIterableSpread;","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;"]}