{"version":3,"sources":["jsdelivr-header.js","/npm/path-intersection@4.1.0/intersect.js"],"names":[],"mappings":"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","file":"/npm/path-intersection@4.1.0/intersect.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/path-intersection@4.1.0/intersect.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * This file contains source code adapted from Snap.svg (licensed Apache-2.0).\n *\n * @see https://github.com/adobe-webplatform/Snap.svg/blob/master/src/path.js\n */\n\n/* eslint no-fallthrough: \"off\" */\n\n/**\n * @typedef { import('./intersect.js').Path } Path\n * @typedef { import('./intersect.js').PathComponent } PathComponent\n */\n\n\nvar p2s = /,?([a-z]),?/gi,\n    toFloat = parseFloat,\n    math = Math,\n    PI = math.PI,\n    mmin = math.min,\n    mmax = math.max,\n    pow = math.pow,\n    abs = math.abs,\n    pathCommand = /([a-z])[\\s,]*((-?\\d*\\.?\\d*(?:e[-+]?\\d+)?[\\s]*,?[\\s]*)+)/ig,\n    pathValues = /(-?\\d*\\.?\\d*(?:e[-+]?\\d+)?)[\\s]*,?[\\s]*/ig;\n\nvar isArray = Array.isArray || function(o) { return o instanceof Array; };\n\nfunction hasProperty(obj, property) {\n  return Object.prototype.hasOwnProperty.call(obj, property);\n}\n\nfunction repush(array, item) {\n  for (var i = 0, ii = array.length; i < ii; i++) if (array[i] === item) {\n    return array.push(array.splice(i, 1)[0]);\n  }\n}\n\nfunction cacher(f) {\n\n  function newf() {\n\n    var arg = Array.prototype.slice.call(arguments, 0),\n        args = arg.join('\\u2400'),\n        cache = newf.cache = newf.cache || {},\n        count = newf.count = newf.count || [];\n\n    if (hasProperty(cache, args)) {\n      repush(count, args);\n      return cache[args];\n    }\n\n    count.length >= 1e3 && delete cache[count.shift()];\n    count.push(args);\n    cache[args] = f(...arguments);\n\n    return cache[args];\n  }\n  return newf;\n}\n\n/**\n * Parse SVG path string and return an array of path components.\n *\n * @param {string} pathString\n *\n * @return {PathComponent[]}\n */\nfunction parsePathString(pathString) {\n\n  if (!pathString) {\n    return null;\n  }\n\n  var paramCounts = { a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 },\n      pathComponents = [];\n\n  String(pathString).replace(pathCommand, function(a, b, c) {\n    var params = [],\n        name = b.toLowerCase();\n\n    c.replace(pathValues, function(a, b) {\n      b && params.push(+b);\n    });\n\n    if (name == 'm' && params.length > 2) {\n      pathComponents.push([ b, ...params.splice(0, 2) ]);\n      name = 'l';\n      b = b == 'm' ? 'l' : 'L';\n    }\n\n    while (params.length >= paramCounts[name]) {\n      pathComponents.push([ b, ...params.splice(0, paramCounts[name]) ]);\n      if (!paramCounts[name]) {\n        break;\n      }\n    }\n  });\n\n  pathComponents.toString = pathToString;\n\n  return pathComponents;\n}\n\n/**\n * Checks if a path is already in absolute format.\n * An absolute path has all uppercase commands.\n *\n * @param {PathComponent[]} pathComponents\n * @return {boolean}\n */\nfunction isPathAbsolute(pathComponents) {\n  for (var i = 0, ii = pathComponents.length; i < ii; i++) {\n    var command = pathComponents[i][0];\n    if (typeof command === 'string' && command !== command.toUpperCase()) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Checks if a path is already in curve format.\n * A curve path only contains 'M' and 'C' commands.\n *\n * @param {PathComponent[]} pathComponents\n *\n * @return {boolean}\n */\nfunction isPathCurve(pathComponents) {\n  for (var i = 0, ii = pathComponents.length; i < ii; i++) {\n    var command = pathComponents[i][0];\n    if (command !== 'M' && command !== 'C') {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction rectBBox(x, y, width, height) {\n\n  if (arguments.length === 1) {\n    y = x.y;\n    width = x.width;\n    height = x.height;\n    x = x.x;\n  }\n\n  return {\n    x: x,\n    y: y,\n    width: width,\n    height: height,\n    x2: x + width,\n    y2: y + height\n  };\n}\n\nfunction pathToString() {\n  return this.join(',').replace(p2s, '$1');\n}\n\n/**\n * @param {PathComponent[]} pathComponents\n *\n * @return {PathComponent[]}\n */\nfunction pathClone(pathComponents) {\n\n  var pathComponentsClone = new Array(pathComponents.length);\n\n  for (var i = 0, ii = pathComponents.length; i < ii; i++) {\n    var component = pathComponents[i];\n    var componentClone = pathComponentsClone[i] = new Array(component.length);\n\n    for (var j = 0, jj = component.length; j < jj; j++) {\n      componentClone[j] = component[j];\n    }\n  }\n\n  pathComponentsClone.toString = pathToString;\n\n  return pathComponentsClone;\n}\n\nfunction findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {\n  var t1 = 1 - t,\n      t13 = pow(t1, 3),\n      t12 = pow(t1, 2),\n      t2 = t * t,\n      t3 = t2 * t,\n      x = t13 * p1x + t12 * 3 * t * c1x + t1 * 3 * t * t * c2x + t3 * p2x,\n      y = t13 * p1y + t12 * 3 * t * c1y + t1 * 3 * t * t * c2y + t3 * p2y;\n\n  return {\n    x: fixError(x),\n    y: fixError(y)\n  };\n}\n\nfunction bezierBBox(points) {\n\n  var bbox = curveBBox(...points);\n\n  return rectBBox(\n    bbox.x0,\n    bbox.y0,\n    bbox.x1 - bbox.x0,\n    bbox.y1 - bbox.y0\n  );\n}\n\nfunction isPointInsideBBox(bbox, x, y) {\n  return x >= bbox.x &&\n    x <= bbox.x + bbox.width &&\n    y >= bbox.y &&\n    y <= bbox.y + bbox.height;\n}\n\nfunction isBBoxIntersect(bbox1, bbox2) {\n  bbox1 = rectBBox(bbox1);\n  bbox2 = rectBBox(bbox2);\n  return isPointInsideBBox(bbox2, bbox1.x, bbox1.y)\n    || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y)\n    || isPointInsideBBox(bbox2, bbox1.x, bbox1.y2)\n    || isPointInsideBBox(bbox2, bbox1.x2, bbox1.y2)\n    || isPointInsideBBox(bbox1, bbox2.x, bbox2.y)\n    || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y)\n    || isPointInsideBBox(bbox1, bbox2.x, bbox2.y2)\n    || isPointInsideBBox(bbox1, bbox2.x2, bbox2.y2)\n    || (bbox1.x < bbox2.x2 && bbox1.x > bbox2.x\n        || bbox2.x < bbox1.x2 && bbox2.x > bbox1.x)\n    && (bbox1.y < bbox2.y2 && bbox1.y > bbox2.y\n        || bbox2.y < bbox1.y2 && bbox2.y > bbox1.y);\n}\n\nfunction base3(t, p1, p2, p3, p4) {\n  var t1 = -3 * p1 + 9 * p2 - 9 * p3 + 3 * p4,\n      t2 = t * t1 + 6 * p1 - 12 * p2 + 6 * p3;\n  return t * t2 - 3 * p1 + 3 * p2;\n}\n\nfunction bezlen(x1, y1, x2, y2, x3, y3, x4, y4, z) {\n\n  if (z == null) {\n    z = 1;\n  }\n\n  z = z > 1 ? 1 : z < 0 ? 0 : z;\n\n  var z2 = z / 2,\n      n = 12,\n      Tvalues = [ -.1252,.1252,-.3678,.3678,-.5873,.5873,-.7699,.7699,-.9041,.9041,-.9816,.9816 ],\n      Cvalues = [ 0.2491,0.2491,0.2335,0.2335,0.2032,0.2032,0.1601,0.1601,0.1069,0.1069,0.0472,0.0472 ],\n      sum = 0;\n\n  for (var i = 0; i < n; i++) {\n    var ct = z2 * Tvalues[i] + z2,\n        xbase = base3(ct, x1, x2, x3, x4),\n        ybase = base3(ct, y1, y2, y3, y4),\n        comb = xbase * xbase + ybase * ybase;\n\n    sum += Cvalues[i] * math.sqrt(comb);\n  }\n\n  return z2 * sum;\n}\n\n\nfunction intersectLines(x1, y1, x2, y2, x3, y3, x4, y4) {\n\n  if (\n    mmax(x1, x2) < mmin(x3, x4) ||\n      mmin(x1, x2) > mmax(x3, x4) ||\n      mmax(y1, y2) < mmin(y3, y4) ||\n      mmin(y1, y2) > mmax(y3, y4)\n  ) {\n    return;\n  }\n\n  var nx = (x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4),\n      ny = (x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4),\n      denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);\n\n  if (!denominator) {\n    return;\n  }\n\n  var px = fixError(nx / denominator),\n      py = fixError(ny / denominator),\n      px2 = +px.toFixed(2),\n      py2 = +py.toFixed(2);\n\n  if (\n    px2 < +mmin(x1, x2).toFixed(2) ||\n      px2 > +mmax(x1, x2).toFixed(2) ||\n      px2 < +mmin(x3, x4).toFixed(2) ||\n      px2 > +mmax(x3, x4).toFixed(2) ||\n      py2 < +mmin(y1, y2).toFixed(2) ||\n      py2 > +mmax(y1, y2).toFixed(2) ||\n      py2 < +mmin(y3, y4).toFixed(2) ||\n      py2 > +mmax(y3, y4).toFixed(2)\n  ) {\n    return;\n  }\n\n  return { x: px, y: py };\n}\n\nfunction fixError(number) {\n  return Math.round(number * 100000000000) / 100000000000;\n}\n\nfunction findBezierIntersections(bez1, bez2, justCount) {\n  var bbox1 = bezierBBox(bez1),\n      bbox2 = bezierBBox(bez2);\n\n  if (!isBBoxIntersect(bbox1, bbox2)) {\n    return justCount ? 0 : [];\n  }\n\n  // As an optimization, lines will have only 1 segment\n\n  var l1 = bezlen(...bez1),\n      l2 = bezlen(...bez2),\n      // eslint-disable-next-line no-bitwise\n      n1 = isLine(bez1) ? 1 : ~~(l1 / 5) || 1,\n      // eslint-disable-next-line no-bitwise\n      n2 = isLine(bez2) ? 1 : ~~(l2 / 5) || 1,\n      dots1 = new Array(n1 + 1),\n      dots2 = new Array(n2 + 1),\n      xy = {},\n      res = justCount ? 0 : [],\n      i, j;\n\n  for (i = 0; i < n1 + 1; i++) {\n    var p = findDotsAtSegment(...bez1, i / n1);\n    dots1[i] = { x: p.x, y: p.y, t: i / n1 };\n  }\n\n  for (i = 0; i < n2 + 1; i++) {\n    p = findDotsAtSegment(...bez2, i / n2);\n    dots2[i] = { x: p.x, y: p.y, t: i / n2 };\n  }\n\n  for (i = 0; i < n1; i++) {\n\n    for (j = 0; j < n2; j++) {\n      var di = dots1[i],\n          di1 = dots1[i + 1],\n          dj = dots2[j],\n          dj1 = dots2[j + 1],\n          ci = abs(di1.x - di.x) < .01 ? 'y' : 'x',\n          cj = abs(dj1.x - dj.x) < .01 ? 'y' : 'x',\n          is = intersectLines(di.x, di.y, di1.x, di1.y, dj.x, dj.y, dj1.x, dj1.y),\n          key;\n\n      if (is) {\n        key = is.x.toFixed(9) + '#' + is.y.toFixed(9);\n\n        if (xy[key]) {\n          continue;\n        }\n\n        xy[key] = true;\n\n        var t1 = di.t + abs((is[ci] - di[ci]) / (di1[ci] - di[ci])) * (di1.t - di.t),\n            t2 = dj.t + abs((is[cj] - dj[cj]) / (dj1[cj] - dj[cj])) * (dj1.t - dj.t);\n\n        if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {\n\n          if (justCount) {\n            res++;\n          } else {\n            res.push({\n              x: is.x,\n              y: is.y,\n              t1: t1,\n              t2: t2\n            });\n          }\n        }\n      }\n    }\n  }\n\n  return res;\n}\n\n\n/**\n * Find or counts the intersections between two SVG paths.\n *\n * Returns a number in counting mode and a list of intersections otherwise.\n *\n * A single intersection entry contains the intersection coordinates (x, y)\n * as well as additional information regarding the intersecting segments\n * on each path (segment1, segment2) and the relative location of the\n * intersection on these segments (t1, t2).\n *\n * The path may be an SVG path string or an array of path components\n * such as `[ [ 'M', 0, 10 ], [ 'L', 20, 0 ] ]`.\n *\n * For performance optimization, pre-parsed paths can be passed directly,\n * {@link parsePath | the parsePath utility} can be used to pre-parse any path.\n *\n * @example\n *\n * import findPathIntersections from 'path-intersection';\n *\n * var intersections = findPathIntersections(\n *   'M0,0L100,100',\n *   [ [ 'M', 0, 100 ], [ 'L', 100, 0 ] ]\n * );\n *\n * // intersections = [\n * //   { x: 50, y: 50, segment1: 1, segment2: 1, t1: 0.5, t2: 0.5 }\n * // ]\n *\n * @param {Path} path1\n * @param {Path} path2\n * @param {boolean} [justCount=false]\n *\n * @return {Intersection[]|number}\n */\nexport default function findPathIntersections(path1, path2, justCount) {\n  path1 = pathToCurve(path1);\n  path2 = pathToCurve(path2);\n\n  var x1, y1, x2, y2, x1m, y1m, x2m, y2m, bez1, bez2,\n      res = justCount ? 0 : [];\n\n  for (var i = 0, ii = path1.length; i < ii; i++) {\n    var pi = path1[i];\n\n    if (pi[0] == 'M') {\n      x1 = x1m = pi[1];\n      y1 = y1m = pi[2];\n    } else {\n\n      if (pi[0] == 'C') {\n        bez1 = [ x1, y1, ...pi.slice(1) ];\n        x1 = bez1[6];\n        y1 = bez1[7];\n      } else {\n        bez1 = [ x1, y1, x1, y1, x1m, y1m, x1m, y1m ];\n        x1 = x1m;\n        y1 = y1m;\n      }\n\n      for (var j = 0, jj = path2.length; j < jj; j++) {\n        var pj = path2[j];\n\n        if (pj[0] == 'M') {\n          x2 = x2m = pj[1];\n          y2 = y2m = pj[2];\n        } else {\n\n          if (pj[0] == 'C') {\n            bez2 = [ x2, y2, ...pj.slice(1) ];\n            x2 = bez2[6];\n            y2 = bez2[7];\n          } else {\n            bez2 = [ x2, y2, x2, y2, x2m, y2m, x2m, y2m ];\n            x2 = x2m;\n            y2 = y2m;\n          }\n\n          var intr = findBezierIntersections(bez1, bez2, justCount);\n\n          if (justCount) {\n            res += intr;\n          } else {\n\n            for (var k = 0, kk = intr.length; k < kk; k++) {\n              intr[k].segment1 = i;\n              intr[k].segment2 = j;\n              intr[k].bez1 = bez1;\n              intr[k].bez2 = bez2;\n            }\n\n            res = res.concat(intr);\n          }\n        }\n      }\n    }\n  }\n\n  return res;\n}\n\n/**\n * Test if path is a set of path components of the form\n * `[ ['M', 0, 0 ], ['L', 100, 100], ...]`.\n *\n * @param {Path} path\n *\n * @return {boolean}\n */\nfunction isPathComponents(path) {\n  return isArray(path) && isArray(path[0]);\n}\n\n/**\n * @param {PathComponent[]} pathComponents\n *\n * @return {PathComponent[]}\n */\nfunction pathToAbsolute(pathComponents) {\n\n  if (isPathAbsolute(pathComponents)) {\n    return pathComponents;\n  }\n\n  var res = new Array(pathComponents.length),\n      x = 0,\n      y = 0,\n      mx = 0,\n      my = 0,\n      start = 0,\n      pa0;\n\n  if (pathComponents[0][0] == 'M') {\n    x = +pathComponents[0][1];\n    y = +pathComponents[0][2];\n    mx = x;\n    my = y;\n    start++;\n    res[0] = [ 'M', x, y ];\n  }\n\n  for (var r, pa, i = start, ii = pathComponents.length; i < ii; i++) {\n    pa = pathComponents[i];\n    pa0 = pa[0];\n    res[i] = (r = new Array(pa.length));\n\n    if (pa0 != pa0.toUpperCase()) {\n      r[0] = pa0.toUpperCase();\n\n      switch (r[0]) {\n      case 'A':\n        r[1] = pa[1];\n        r[2] = pa[2];\n        r[3] = pa[3];\n        r[4] = pa[4];\n        r[5] = pa[5];\n        r[6] = +pa[6] + x;\n        r[7] = +pa[7] + y;\n        break;\n      case 'V':\n        r[1] = +pa[1] + y;\n        break;\n      case 'H':\n        r[1] = +pa[1] + x;\n        break;\n      case 'M':\n        mx = +pa[1] + x;\n        my = +pa[2] + y;\n      default:\n        for (var j = 1, jj = pa.length; j < jj; j++) {\n          r[j] = +pa[j] + ((j % 2) ? x : y);\n        }\n      }\n    } else {\n      for (var k = 0, kk = pa.length; k < kk; k++) {\n        r[k] = pa[k];\n      }\n    }\n    pa0 = pa0.toUpperCase();\n\n    switch (r[0]) {\n    case 'Z':\n      x = +mx;\n      y = +my;\n      break;\n    case 'H':\n      x = r[1];\n      break;\n    case 'V':\n      y = r[1];\n      break;\n    case 'M':\n      mx = r[r.length - 2];\n      my = r[r.length - 1];\n    default:\n      x = r[r.length - 2];\n      y = r[r.length - 1];\n    }\n  }\n\n  res.toString = pathToString;\n\n  return res;\n}\n\nfunction isLine(bez) {\n  return (\n    bez[0] === bez[2] &&\n    bez[1] === bez[3] &&\n    bez[4] === bez[6] &&\n    bez[5] === bez[7]\n  );\n}\n\nfunction lineToCurve(x1, y1, x2, y2) {\n  return [\n    x1, y1, x2,\n    y2, x2, y2\n  ];\n}\n\nfunction qubicToCurve(x1, y1, ax, ay, x2, y2) {\n  var _13 = 1 / 3,\n      _23 = 2 / 3;\n\n  return [\n    _13 * x1 + _23 * ax,\n    _13 * y1 + _23 * ay,\n    _13 * x2 + _23 * ax,\n    _13 * y2 + _23 * ay,\n    x2,\n    y2\n  ];\n}\n\nfunction arcToCurve(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {\n\n  // for more information of where this math came from visit:\n  // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n  var _120 = PI * 120 / 180,\n      rad = PI / 180 * (+angle || 0),\n      res = [],\n      xy,\n      rotate = cacher(function(x, y, rad) {\n        var X = x * math.cos(rad) - y * math.sin(rad),\n            Y = x * math.sin(rad) + y * math.cos(rad);\n\n        return { x: X, y: Y };\n      });\n\n  if (!recursive) {\n    xy = rotate(x1, y1, -rad);\n    x1 = xy.x;\n    y1 = xy.y;\n    xy = rotate(x2, y2, -rad);\n    x2 = xy.x;\n    y2 = xy.y;\n\n    var x = (x1 - x2) / 2,\n        y = (y1 - y2) / 2;\n\n    var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n\n    if (h > 1) {\n      h = math.sqrt(h);\n      rx = h * rx;\n      ry = h * ry;\n    }\n\n    var rx2 = rx * rx,\n        ry2 = ry * ry,\n        k = (large_arc_flag == sweep_flag ? -1 : 1) *\n            math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),\n        cx = k * rx * y / ry + (x1 + x2) / 2,\n        cy = k * -ry * x / rx + (y1 + y2) / 2,\n        f1 = math.asin(((y1 - cy) / ry).toFixed(9)),\n        f2 = math.asin(((y2 - cy) / ry).toFixed(9));\n\n    f1 = x1 < cx ? PI - f1 : f1;\n    f2 = x2 < cx ? PI - f2 : f2;\n    f1 < 0 && (f1 = PI * 2 + f1);\n    f2 < 0 && (f2 = PI * 2 + f2);\n\n    if (sweep_flag && f1 > f2) {\n      f1 = f1 - PI * 2;\n    }\n    if (!sweep_flag && f2 > f1) {\n      f2 = f2 - PI * 2;\n    }\n  } else {\n    f1 = recursive[0];\n    f2 = recursive[1];\n    cx = recursive[2];\n    cy = recursive[3];\n  }\n\n  var df = f2 - f1;\n\n  if (abs(df) > _120) {\n    var f2old = f2,\n        x2old = x2,\n        y2old = y2;\n\n    f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);\n    x2 = cx + rx * math.cos(f2);\n    y2 = cy + ry * math.sin(f2);\n    res = arcToCurve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [ f2, f2old, cx, cy ]);\n  }\n\n  df = f2 - f1;\n\n  var c1 = math.cos(f1),\n      s1 = math.sin(f1),\n      c2 = math.cos(f2),\n      s2 = math.sin(f2),\n      t = math.tan(df / 4),\n      hx = 4 / 3 * rx * t,\n      hy = 4 / 3 * ry * t,\n      m1 = [ x1, y1 ],\n      m2 = [ x1 + hx * s1, y1 - hy * c1 ],\n      m3 = [ x2 + hx * s2, y2 - hy * c2 ],\n      m4 = [ x2, y2 ];\n\n  m2[0] = 2 * m1[0] - m2[0];\n  m2[1] = 2 * m1[1] - m2[1];\n\n  if (recursive) {\n    return [ m2, m3, m4 ].concat(res);\n  } else {\n    res = [ m2, m3, m4 ].concat(res).join().split(',');\n    var newres = [];\n\n    for (var i = 0, ii = res.length; i < ii; i++) {\n      newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;\n    }\n\n    return newres;\n  }\n}\n\n// Returns bounding box of cubic bezier curve.\n// Source: http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html\n// Original version: NISHIO Hirokazu\n// Modifications: https://github.com/timo22345\nfunction curveBBox(x0, y0, x1, y1, x2, y2, x3, y3) {\n  var tvalues = [],\n      bounds = [ [], [] ],\n      a, b, c, t, t1, t2, b2ac, sqrtb2ac;\n\n  for (var i = 0; i < 2; ++i) {\n\n    if (i == 0) {\n      b = 6 * x0 - 12 * x1 + 6 * x2;\n      a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;\n      c = 3 * x1 - 3 * x0;\n    } else {\n      b = 6 * y0 - 12 * y1 + 6 * y2;\n      a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;\n      c = 3 * y1 - 3 * y0;\n    }\n\n    if (abs(a) < 1e-12) {\n\n      if (abs(b) < 1e-12) {\n        continue;\n      }\n\n      t = -c / b;\n\n      if (0 < t && t < 1) {\n        tvalues.push(t);\n      }\n\n      continue;\n    }\n\n    b2ac = b * b - 4 * c * a;\n    sqrtb2ac = math.sqrt(b2ac);\n\n    if (b2ac < 0) {\n      continue;\n    }\n\n    t1 = (-b + sqrtb2ac) / (2 * a);\n\n    if (0 < t1 && t1 < 1) {\n      tvalues.push(t1);\n    }\n\n    t2 = (-b - sqrtb2ac) / (2 * a);\n\n    if (0 < t2 && t2 < 1) {\n      tvalues.push(t2);\n    }\n  }\n\n  var j = tvalues.length,\n      jlen = j,\n      mt;\n\n  while (j--) {\n    t = tvalues[j];\n    mt = 1 - t;\n    bounds[0][j] = (mt * mt * mt * x0) + (3 * mt * mt * t * x1) + (3 * mt * t * t * x2) + (t * t * t * x3);\n    bounds[1][j] = (mt * mt * mt * y0) + (3 * mt * mt * t * y1) + (3 * mt * t * t * y2) + (t * t * t * y3);\n  }\n\n  bounds[0][jlen] = x0;\n  bounds[1][jlen] = y0;\n  bounds[0][jlen + 1] = x3;\n  bounds[1][jlen + 1] = y3;\n  bounds[0].length = bounds[1].length = jlen + 2;\n\n  return {\n    x0: mmin(...bounds[0]),\n    y0: mmin(...bounds[1]),\n    x1: mmax(...bounds[0]),\n    y1: mmax(...bounds[1])\n  };\n}\n\n/**\n * Convert path to a curve.\n *\n * @param {Path} path\n *\n * @return {PathComponent[]}\n */\nfunction pathToCurve(path) {\n\n  if (!isPathComponents(path)) {\n    path = parsePathString(path);\n  }\n\n  if (isPathCurve(path)) {\n    return path;\n  }\n\n  var curvedPath = pathClone(pathToAbsolute(path)),\n      attrs = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },\n      processPath = function(path, d, pathCommand) {\n        var nx, ny;\n\n        if (!path) {\n          return [ 'C', d.x, d.y, d.x, d.y, d.x, d.y ];\n        }\n\n        !(path[0] in { T: 1, Q: 1 }) && (d.qx = d.qy = null);\n\n        switch (path[0]) {\n        case 'M':\n          d.X = path[1];\n          d.Y = path[2];\n          break;\n        case 'A':\n          path = [ 'C', ...arcToCurve(d.x, d.y, ...path.slice(1)) ];\n          break;\n        case 'S':\n          if (pathCommand == 'C' || pathCommand == 'S') {\n\n            // In 'S' case we have to take into account, if the previous command is C/S.\n            nx = d.x * 2 - d.bx;\n\n            // And reflect the previous\n            ny = d.y * 2 - d.by;\n\n            // command's control point relative to the current point.\n          }\n          else {\n\n            // or some else or nothing\n            nx = d.x;\n            ny = d.y;\n          }\n          path = [ 'C', nx, ny, ...path.slice(1) ];\n          break;\n        case 'T':\n          if (pathCommand == 'Q' || pathCommand == 'T') {\n\n            // In 'T' case we have to take into account, if the previous command is Q/T.\n            d.qx = d.x * 2 - d.qx;\n\n            // And make a reflection similar\n            d.qy = d.y * 2 - d.qy;\n\n            // to case 'S'.\n          }\n          else {\n\n            // or something else or nothing\n            d.qx = d.x;\n            d.qy = d.y;\n          }\n          path = [ 'C', ...qubicToCurve(d.x, d.y, d.qx, d.qy, path[1], path[2]) ];\n          break;\n        case 'Q':\n          d.qx = path[1];\n          d.qy = path[2];\n          path = [ 'C', ...qubicToCurve(d.x, d.y, path[1], path[2], path[3], path[4]) ];\n          break;\n        case 'L':\n          path = [ 'C', ...lineToCurve(d.x, d.y, path[1], path[2]) ];\n          break;\n        case 'H':\n          path = [ 'C', ...lineToCurve(d.x, d.y, path[1], d.y) ];\n          break;\n        case 'V':\n          path = [ 'C', ...lineToCurve(d.x, d.y, d.x, path[1]) ];\n          break;\n        case 'Z':\n          path = [ 'C', ...lineToCurve(d.x, d.y, d.X, d.Y) ];\n          break;\n        }\n\n        return path;\n      },\n\n      fixArc = function(pp, i) {\n\n        if (pp[i].length > 7) {\n          pp[i].shift();\n          var pi = pp[i];\n\n          while (pi.length) {\n            pathCommands[i] = 'A'; // if created multiple C:s, their original seg is saved\n            pp.splice(i++, 0, [ 'C', ...pi.splice(0, 6) ]);\n          }\n\n          pp.splice(i, 1);\n          ii = curvedPath.length;\n        }\n      },\n\n      pathCommands = [], // path commands of original path p\n      pfirst = '', // temporary holder for original path command\n      pathCommand = ''; // holder for previous path command of original path\n\n  for (var i = 0, ii = curvedPath.length; i < ii; i++) {\n    curvedPath[i] && (pfirst = curvedPath[i][0]); // save current path command\n\n    if (pfirst != 'C') // C is not saved yet, because it may be result of conversion\n    {\n      pathCommands[i] = pfirst; // Save current path command\n      i && (pathCommand = pathCommands[i - 1]); // Get previous path command pathCommand\n    }\n    curvedPath[i] = processPath(curvedPath[i], attrs, pathCommand); // Previous path command is inputted to processPath\n\n    if (pathCommands[i] != 'A' && pfirst == 'C') pathCommands[i] = 'C'; // A is the only command\n    // which may produce multiple C:s\n    // so we have to make sure that C is also C in original path\n\n    fixArc(curvedPath, i); // fixArc adds also the right amount of A:s to pathCommands\n\n    var seg = curvedPath[i],\n        seglen = seg.length;\n\n    attrs.x = seg[seglen - 2];\n    attrs.y = seg[seglen - 1];\n    attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;\n    attrs.by = toFloat(seg[seglen - 3]) || attrs.y;\n  }\n\n  return curvedPath;\n}\n\n/**\n * Parses a path to an optimized format. The result can be cached\n * and reused to maximize performance in subsequent intersection calculations.\n *\n * This is the recommended way to pre-parse paths for repeated use.\n * Paths parsed this way will not be re-parsed when passed to\n * {@link findPathIntersections | the intersect function}.\n *\n * @example\n *\n * import intersect, { parsePath } from 'path-intersection';\n *\n * // parse once\n * const path1 = parsePath('M0,0L100,100');\n * const path2 = parsePath('M0,100L100,0');\n *\n * // cache and reuse\n * const result1 = intersect(path1, parsedPath2);\n * const result2 = intersect(path2, parsedPath2);\n *\n * @param {Path} path - the path to parse\n *\n * @return {PathComponent[]} pre-parsed and optimized path\n */\nexport function parsePath(path) {\n  return pathToCurve(path);\n}"]}