shadow$provide.module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$buildCommands$buildLine = function(global, require, module, exports) {
  function square(x, y, nx, ny, innerWeight, outerWeight, clockwise, verts) {
    let eyy;
    clockwise ? (clockwise = ny, eyy = -nx) : (clockwise = -ny, eyy = nx);
    const eox = x + nx * outerWeight + clockwise;
    outerWeight = y + ny * outerWeight + eyy;
    verts.push(x - nx * innerWeight + clockwise, y - ny * innerWeight + eyy);
    verts.push(eox, outerWeight);
    return 2;
  }
  function round(cx, cy, sx, sy, ex, ey, verts, clockwise) {
    var cx2p0x = sx - cx, cy2p0y = sy - cy, angle0 = Math.atan2(cx2p0x, cy2p0y), angle1 = Math.atan2(ex - cx, ey - cy);
    clockwise && angle0 < angle1 ? angle0 += 2 * Math.PI : !clockwise && angle0 > angle1 && (angle1 += 2 * Math.PI);
    angle1 -= angle0;
    cx2p0x = Math.sqrt(cx2p0x * cx2p0x + cy2p0y * cy2p0y);
    cy2p0y = (15 * Math.abs(angle1) * Math.sqrt(cx2p0x) / Math.PI >> 0) + 1;
    angle1 /= cy2p0y;
    angle0 += angle1;
    if (clockwise) {
      verts.push(cx, cy);
      verts.push(sx, sy);
      for (let i = 1, angle = angle0; i < cy2p0y; i++, angle += angle1) {
        verts.push(cx, cy), verts.push(cx + Math.sin(angle) * cx2p0x, cy + Math.cos(angle) * cx2p0x);
      }
      verts.push(cx, cy);
      verts.push(ex, ey);
    } else {
      verts.push(sx, sy);
      verts.push(cx, cy);
      for (let i = 1, angle = angle0; i < cy2p0y; i++, angle += angle1) {
        verts.push(cx + Math.sin(angle) * cx2p0x, cy + Math.cos(angle) * cx2p0x), verts.push(cx, cy);
      }
      verts.push(ex, ey);
      verts.push(cx, cy);
    }
    return 2 * cy2p0y;
  }
  var Point = require("module$node_modules$pixi_DOT_js$lib$maths$point$Point"), _const = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$const"), getOrientationOfPoints = require("module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$utils$getOrientationOfPoints");
  "use strict";
  exports.buildLine = function(points, lineStyle, flipAlignment, closed, vertices, indices) {
    var eps = _const.closePointEps;
    if (0 !== points.length) {
      var alignment = lineStyle.alignment;
      if (0.5 !== lineStyle.alignment) {
        var orientation = getOrientationOfPoints.getOrientationOfPoints(points);
        flipAlignment && (orientation *= -1);
        alignment = (alignment - 0.5) * orientation + 0.5;
      }
      flipAlignment = new Point.Point(points[0], points[1]);
      orientation = new Point.Point(points[points.length - 2], points[points.length - 1]);
      eps = Math.abs(flipAlignment.x - orientation.x) < eps && Math.abs(flipAlignment.y - orientation.y) < eps;
      closed && (points = points.slice(), eps && (points.pop(), points.pop(), orientation.set(points[points.length - 2], points[points.length - 1])), eps = 0.5 * (flipAlignment.x + orientation.x), flipAlignment = 0.5 * (orientation.y + flipAlignment.y), points.unshift(eps, flipAlignment), points.push(eps, flipAlignment));
      var length = points.length / 2;
      eps = points.length;
      flipAlignment = vertices.length / 2;
      var width = lineStyle.width / 2, widthSquared = width * width, miterLimitSquared = lineStyle.miterLimit * lineStyle.miterLimit, x0 = points[0], y0 = points[1];
      orientation = points[2];
      var y1 = points[3], perpX = -(y0 - y1), perpY = x0 - orientation, dist = Math.sqrt(perpX * perpX + perpY * perpY);
      perpX = perpX / dist * width;
      perpY = perpY / dist * width;
      orientation = alignment;
      alignment = 2 * (1 - orientation);
      var outerWeight = 2 * orientation;
      closed || ("round" === lineStyle.cap ? eps += round(x0 - perpX * (alignment - outerWeight) * 0.5, y0 - perpY * (alignment - outerWeight) * 0.5, x0 - perpX * alignment, y0 - perpY * alignment, x0 + perpX * outerWeight, y0 + perpY * outerWeight, vertices, !0) + 2 : "square" === lineStyle.cap && (eps += square(x0, y0, perpX, perpY, alignment, outerWeight, !0, vertices)));
      vertices.push(x0 - perpX * alignment, y0 - perpY * alignment);
      vertices.push(x0 + perpX * outerWeight, y0 + perpY * outerWeight);
      for (let i = 1; i < length - 1; ++i) {
        x0 = points[2 * (i - 1)];
        y0 = points[2 * (i - 1) + 1];
        orientation = points[2 * i];
        y1 = points[2 * i + 1];
        var x2 = points[2 * (i + 1)];
        var y2 = points[2 * (i + 1) + 1];
        perpX = -(y0 - y1);
        perpY = x0 - orientation;
        dist = Math.sqrt(perpX * perpX + perpY * perpY);
        perpX /= dist;
        perpY /= dist;
        perpX *= width;
        perpY *= width;
        var perp1x = -(y1 - y2);
        var perp1y = orientation - x2;
        dist = Math.sqrt(perp1x * perp1x + perp1y * perp1y);
        perp1x /= dist;
        perp1y /= dist;
        perp1x *= width;
        perp1y *= width;
        dist = orientation - x0;
        const dy0 = y0 - y1, dx1 = orientation - x2, dy1 = y2 - y1;
        var dot = dist * dx1 + dy0 * dy1, cross = dy0 * dx1 - dy1 * dist;
        const clockwise = 0 > cross;
        Math.abs(cross) < 1e-3 * Math.abs(dot) ? (vertices.push(orientation - perpX * alignment, y1 - perpY * alignment), vertices.push(orientation + perpX * outerWeight, y1 + perpY * outerWeight), 0 <= dot && (eps = "round" === lineStyle.join ? eps + (round(orientation, y1, orientation - perpX * alignment, y1 - perpY * alignment, orientation - perp1x * alignment, y1 - perp1y * alignment, vertices, !1) + 4) : eps + 2, vertices.push(orientation - perp1x * outerWeight, y1 - perp1y * outerWeight), vertices.push(orientation + 
        perp1x * alignment, y1 + perp1y * alignment))) : (y0 = (-perpX + x0) * (-perpY + y1) - (-perpX + orientation) * (-perpY + y0), x2 = (-perp1x + x2) * (-perp1y + y1) - (-perp1x + orientation) * (-perp1y + y2), x0 = (dist * x2 - dx1 * y0) / cross, cross = (dy1 * y0 - dy0 * x2) / cross, y0 = (x0 - orientation) * (x0 - orientation) + (cross - y1) * (cross - y1), x2 = orientation + (x0 - orientation) * alignment, y2 = y1 + (cross - y1) * alignment, x0 = orientation - (x0 - orientation) * outerWeight, 
        cross = y1 - (cross - y1) * outerWeight, dot = clockwise ? alignment : outerWeight, y0 <= Math.min(dist * dist + dy0 * dy0, dx1 * dx1 + dy1 * dy1) + dot * dot * widthSquared ? "bevel" === lineStyle.join || y0 / widthSquared > miterLimitSquared ? (clockwise ? (vertices.push(x2, y2), vertices.push(orientation + perpX * outerWeight, y1 + perpY * outerWeight), vertices.push(x2, y2), vertices.push(orientation + perp1x * outerWeight, y1 + perp1y * outerWeight)) : (vertices.push(orientation - perpX * 
        alignment, y1 - perpY * alignment), vertices.push(x0, cross), vertices.push(orientation - perp1x * alignment, y1 - perp1y * alignment), vertices.push(x0, cross)), eps += 2) : "round" === lineStyle.join ? clockwise ? (vertices.push(x2, y2), vertices.push(orientation + perpX * outerWeight, y1 + perpY * outerWeight), eps += round(orientation, y1, orientation + perpX * outerWeight, y1 + perpY * outerWeight, orientation + perp1x * outerWeight, y1 + perp1y * outerWeight, vertices, !0) + 4, vertices.push(x2, 
        y2), vertices.push(orientation + perp1x * outerWeight, y1 + perp1y * outerWeight)) : (vertices.push(orientation - perpX * alignment, y1 - perpY * alignment), vertices.push(x0, cross), eps += round(orientation, y1, orientation - perpX * alignment, y1 - perpY * alignment, orientation - perp1x * alignment, y1 - perp1y * alignment, vertices, !1) + 4, vertices.push(orientation - perp1x * alignment, y1 - perp1y * alignment), vertices.push(x0, cross)) : (vertices.push(x2, y2), vertices.push(x0, 
        cross)) : (vertices.push(orientation - perpX * alignment, y1 - perpY * alignment), vertices.push(orientation + perpX * outerWeight, y1 + perpY * outerWeight), "round" === lineStyle.join ? eps = clockwise ? eps + (round(orientation, y1, orientation + perpX * outerWeight, y1 + perpY * outerWeight, orientation + perp1x * outerWeight, y1 + perp1y * outerWeight, vertices, !0) + 2) : eps + (round(orientation, y1, orientation - perpX * alignment, y1 - perpY * alignment, orientation - perp1x * alignment, 
        y1 - perp1y * alignment, vertices, !1) + 2) : "miter" === lineStyle.join && y0 / widthSquared <= miterLimitSquared && (clockwise ? (vertices.push(x0, cross), vertices.push(x0, cross)) : (vertices.push(x2, y2), vertices.push(x2, y2)), eps += 2), vertices.push(orientation - perp1x * alignment, y1 - perp1y * alignment), vertices.push(orientation + perp1x * outerWeight, y1 + perp1y * outerWeight), eps += 2));
      }
      x0 = points[2 * (length - 2)];
      y0 = points[2 * (length - 2) + 1];
      orientation = points[2 * (length - 1)];
      y1 = points[2 * (length - 1) + 1];
      perpX = -(y0 - y1);
      perpY = x0 - orientation;
      dist = Math.sqrt(perpX * perpX + perpY * perpY);
      perpX = perpX / dist * width;
      perpY = perpY / dist * width;
      vertices.push(orientation - perpX * alignment, y1 - perpY * alignment);
      vertices.push(orientation + perpX * outerWeight, y1 + perpY * outerWeight);
      closed || ("round" === lineStyle.cap ? eps += round(orientation - perpX * (alignment - outerWeight) * 0.5, y1 - perpY * (alignment - outerWeight) * 0.5, orientation - perpX * alignment, y1 - perpY * alignment, orientation + perpX * outerWeight, y1 + perpY * outerWeight, vertices, !1) + 2 : "square" === lineStyle.cap && (eps += square(orientation, y1, perpX, perpY, alignment, outerWeight, !1, vertices)));
      points = _const.curveEps * _const.curveEps;
      for (lineStyle = flipAlignment; lineStyle < eps + flipAlignment - 2; ++lineStyle) {
        x0 = vertices[2 * lineStyle], y0 = vertices[2 * lineStyle + 1], orientation = vertices[2 * (lineStyle + 1)], y1 = vertices[2 * (lineStyle + 1) + 1], x2 = vertices[2 * (lineStyle + 2)], y2 = vertices[2 * (lineStyle + 2) + 1], Math.abs(x0 * (y1 - y2) + orientation * (y2 - y0) + x2 * (y0 - y1)) < points || indices.push(lineStyle, lineStyle + 1, lineStyle + 2);
      }
    }
  };
};

//# sourceMappingURL=module$node_modules$pixi_DOT_js$lib$scene$graphics$shared$buildCommands$buildLine.js.map