@safe-engine/pixi 8.10.2 → 8.10.4

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildAdaptiveQuadratic.js

@@ -1,89 +0,0 @@
-// thanks to https://github.com/mattdesl/adaptive-quadratic-curve
-// for the original code!
-import { GraphicsContextSystem } from '../GraphicsContextSystem';
-const RECURSION_LIMIT = 8;
-const FLT_EPSILON = 1.19209290e-7;
-const PATH_DISTANCE_EPSILON = 1.0;
-const curveAngleToleranceEpsilon = 0.01;
-const mAngleTolerance = 0;
-/**
- * @param points
- * @param sX
- * @param sY
- * @param cp1x
- * @param cp1y
- * @param eX
- * @param eY
- * @param smoothness
- * @internal
- */
-export function buildAdaptiveQuadratic(points, sX, sY, cp1x, cp1y, eX, eY, smoothness) {
-    const scale = 1.0;
-    const smoothing = Math.min(0.99, // a value of 1.0 actually inverts smoothing, so we cap it at 0.99
-    Math.max(0, smoothness !== null && smoothness !== void 0 ? smoothness : GraphicsContextSystem.defaultOptions.bezierSmoothness));
-    let distanceTolerance = (PATH_DISTANCE_EPSILON - smoothing) / scale;
-    distanceTolerance *= distanceTolerance;
-    begin(sX, sY, cp1x, cp1y, eX, eY, points, distanceTolerance);
-    return points;
-}
-// //// Based on:
-// //// https://github.com/pelson/antigrain/blob/master/agg-2.4/src/agg_curves.cpp
-function begin(sX, sY, cp1x, cp1y, eX, eY, points, distanceTolerance) {
-    recursive(points, sX, sY, cp1x, cp1y, eX, eY, distanceTolerance, 0);
-    points.push(eX, eY);
-}
-function recursive(points, x1, y1, x2, y2, x3, y3, distanceTolerance, level) {
-    if (level > RECURSION_LIMIT) {
-        return;
-    }
-    const pi = Math.PI;
-    // Calculate all the mid-points of the line segments
-    // ----------------------
-    const x12 = (x1 + x2) / 2;
-    const y12 = (y1 + y2) / 2;
-    const x23 = (x2 + x3) / 2;
-    const y23 = (y2 + y3) / 2;
-    const x123 = (x12 + x23) / 2;
-    const y123 = (y12 + y23) / 2;
-    let dx = x3 - x1;
-    let dy = y3 - y1;
-    const d = Math.abs((((x2 - x3) * dy) - ((y2 - y3) * dx)));
-    if (d > FLT_EPSILON) {
-        // Regular care
-        // -----------------
-        if (d * d <= distanceTolerance * ((dx * dx) + (dy * dy))) {
-            // If the curvature doesn't exceed the distance_tolerance value
-            // we tend to finish subdivisions.
-            // ----------------------
-            if (mAngleTolerance < curveAngleToleranceEpsilon) {
-                points.push(x123, y123);
-                return;
-            }
-            // Angle & Cusp Condition
-            // ----------------------
-            let da = Math.abs(Math.atan2(y3 - y2, x3 - x2) - Math.atan2(y2 - y1, x2 - x1));
-            if (da >= pi)
-                da = (2 * pi) - da;
-            if (da < mAngleTolerance) {
-                // Finally we can stop the recursion
-                // ----------------------
-                points.push(x123, y123);
-                return;
-            }
-        }
-    }
-    else {
-        // Collinear case
-        // -----------------
-        dx = x123 - ((x1 + x3) / 2);
-        dy = y123 - ((y1 + y3) / 2);
-        if ((dx * dx) + (dy * dy) <= distanceTolerance) {
-            points.push(x123, y123);
-            return;
-        }
-    }
-    // Continue subdivision
-    // ----------------------
-    recursive(points, x1, y1, x12, y12, x123, y123, distanceTolerance, level + 1);
-    recursive(points, x123, y123, x23, y23, x3, y3, distanceTolerance, level + 1);
-}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArc.d.ts

@@ -1,13 +0,0 @@
-/**
- * @param points
- * @param x
- * @param y
- * @param radius
- * @param start
- * @param end
- * @param clockwise
- * @param steps
- * @internal
- */
-export declare function buildArc(points: number[], x: number, y: number, radius: number, start: number, end: number, clockwise: boolean, steps?: number): void;
-//# sourceMappingURL=buildArc.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildArc.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/buildCommands/buildArc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACpB,MAAM,EAAE,MAAM,EAAE,EAChB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,OAAO,EAClB,KAAK,CAAC,EAAE,MAAM,QAyCjB"}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArc.js

@@ -1,38 +0,0 @@
-/**
- * @param points
- * @param x
- * @param y
- * @param radius
- * @param start
- * @param end
- * @param clockwise
- * @param steps
- * @internal
- */
-export function buildArc(points, x, y, radius, start, end, clockwise, steps) {
-    // determine distance between the two angles
-    // ...probably a nicer way of writing this
-    let dist = Math.abs(start - end);
-    if (!clockwise && start > end) {
-        dist = (2 * Math.PI) - dist;
-    }
-    else if (clockwise && end > start) {
-        dist = (2 * Math.PI) - dist;
-    }
-    // approximate the # of steps using the cube root of the radius
-    steps || (steps = Math.max(6, Math.floor(6 * Math.pow(radius, 1 / 3) * (dist / (Math.PI)))));
-    // ensure we have at least 3 steps..
-    steps = Math.max(steps, 3);
-    let f = dist / (steps);
-    let t = start;
-    // modify direction
-    f *= clockwise ? -1 : 1;
-    for (let i = 0; i < steps + 1; i++) {
-        const cs = Math.cos(t);
-        const sn = Math.sin(t);
-        const nx = x + (cs * radius);
-        const ny = y + (sn * radius);
-        points.push(nx, ny);
-        t += f;
-    }
-}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcTo.d.ts

@@ -1,14 +0,0 @@
-/**
- * The arcTo() method creates an arc/curve between two tangents on the canvas.
- *
- * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
- * @param points
- * @param x1
- * @param y1
- * @param x2
- * @param y2
- * @param radius
- * @internal
- */
-export declare function buildArcTo(points: number[], x1: number, y1: number, x2: number, y2: number, radius: number): void;
-//# sourceMappingURL=buildArcTo.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcTo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildArcTo.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcTo.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACtB,MAAM,EAAE,MAAM,EAAE,EAChB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EACtB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,GACf,IAAI,CA6CN"}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcTo.js

@@ -1,44 +0,0 @@
-import { buildArc } from './buildArc';
-/**
- * The arcTo() method creates an arc/curve between two tangents on the canvas.
- *
- * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
- * @param points
- * @param x1
- * @param y1
- * @param x2
- * @param y2
- * @param radius
- * @internal
- */
-export function buildArcTo(points, x1, y1, x2, y2, radius) {
-    const fromX = points[points.length - 2];
-    const fromY = points[points.length - 1];
-    const a1 = fromY - y1;
-    const b1 = fromX - x1;
-    const a2 = y2 - y1;
-    const b2 = x2 - x1;
-    const mm = Math.abs((a1 * b2) - (b1 * a2));
-    if (mm < 1.0e-8 || radius === 0) {
-        if (points[points.length - 2] !== x1 || points[points.length - 1] !== y1) {
-            points.push(x1, y1);
-        }
-        return;
-    }
-    const dd = (a1 * a1) + (b1 * b1);
-    const cc = (a2 * a2) + (b2 * b2);
-    const tt = (a1 * a2) + (b1 * b2);
-    const k1 = radius * Math.sqrt(dd) / mm;
-    const k2 = radius * Math.sqrt(cc) / mm;
-    const j1 = k1 * tt / dd;
-    const j2 = k2 * tt / cc;
-    const cx = (k1 * b2) + (k2 * b1);
-    const cy = (k1 * a2) + (k2 * a1);
-    const px = b1 * (k2 + j1);
-    const py = a1 * (k2 + j1);
-    const qx = b2 * (k1 + j2);
-    const qy = a2 * (k1 + j2);
-    const startAngle = Math.atan2(py - cy, px - cx);
-    const endAngle = Math.atan2(qy - cy, qx - cx);
-    buildArc(points, (cx + x1), (cy + y1), radius, startAngle, endAngle, b1 * a2 > b2 * a1);
-}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcToSvg.d.ts

@@ -1,15 +0,0 @@
-/**
- * @param points
- * @param px
- * @param py
- * @param cx
- * @param cy
- * @param rx
- * @param ry
- * @param xAxisRotation
- * @param largeArcFlag
- * @param sweepFlag
- * @internal
- */
-export declare function buildArcToSvg(points: number[], px: number, py: number, cx: number, cy: number, rx: number, ry: number, xAxisRotation?: number, largeArcFlag?: number, sweepFlag?: number): void;
-//# sourceMappingURL=buildArcToSvg.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcToSvg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildArcToSvg.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcToSvg.ts"],"names":[],"mappings":"AAmJA;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,MAAM,EAAE,EAChB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,aAAa,SAAI,EACjB,YAAY,SAAI,EAChB,SAAS,SAAI,GACd,IAAI,CAuFN"}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildArcToSvg.js

@@ -1,144 +0,0 @@
-import { buildAdaptiveBezier } from './buildAdaptiveBezier';
-const TAU = Math.PI * 2;
-const out = {
-    centerX: 0,
-    centerY: 0,
-    ang1: 0,
-    ang2: 0
-};
-const mapToEllipse = ({ x, y }, rx, ry, cosPhi, sinPhi, centerX, centerY, out) => {
-    x *= rx;
-    y *= ry;
-    const xp = (cosPhi * x) - (sinPhi * y);
-    const yp = (sinPhi * x) + (cosPhi * y);
-    out.x = xp + centerX;
-    out.y = yp + centerY;
-    return out;
-};
-function approxUnitArc(ang1, ang2) {
-    // If 90 degree circular arc, use a constant
-    // as derived from http://spencermortensen.com/articles/bezier-circle
-    const a1 = ang2 === -1.5707963267948966 ? -0.551915024494 : 4 / 3 * Math.tan(ang2 / 4);
-    const a = ang2 === 1.5707963267948966 ? 0.551915024494 : a1;
-    const x1 = Math.cos(ang1);
-    const y1 = Math.sin(ang1);
-    const x2 = Math.cos(ang1 + ang2);
-    const y2 = Math.sin(ang1 + ang2);
-    return [
-        {
-            x: x1 - (y1 * a),
-            y: y1 + (x1 * a)
-        },
-        {
-            x: x2 + (y2 * a),
-            y: y2 - (x2 * a)
-        },
-        {
-            x: x2,
-            y: y2
-        }
-    ];
-}
-const vectorAngle = (ux, uy, vx, vy) => {
-    const sign = ((ux * vy) - (uy * vx) < 0) ? -1 : 1;
-    let dot = (ux * vx) + (uy * vy);
-    if (dot > 1) {
-        dot = 1;
-    }
-    if (dot < -1) {
-        dot = -1;
-    }
-    return sign * Math.acos(dot);
-};
-const getArcCenter = (px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinPhi, cosPhi, pxp, pyp, out
-// eslint-disable-next-line max-params
-) => {
-    const rxSq = Math.pow(rx, 2);
-    const rySq = Math.pow(ry, 2);
-    const pxpSq = Math.pow(pxp, 2);
-    const pypSq = Math.pow(pyp, 2);
-    let radicant = (rxSq * rySq) - (rxSq * pypSq) - (rySq * pxpSq);
-    if (radicant < 0) {
-        radicant = 0;
-    }
-    radicant /= (rxSq * pypSq) + (rySq * pxpSq);
-    radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
-    const centerXp = radicant * rx / ry * pyp;
-    const centerYp = radicant * -ry / rx * pxp;
-    const centerX = (cosPhi * centerXp) - (sinPhi * centerYp) + ((px + cx) / 2);
-    const centerY = (sinPhi * centerXp) + (cosPhi * centerYp) + ((py + cy) / 2);
-    const vx1 = (pxp - centerXp) / rx;
-    const vy1 = (pyp - centerYp) / ry;
-    const vx2 = (-pxp - centerXp) / rx;
-    const vy2 = (-pyp - centerYp) / ry;
-    const ang1 = vectorAngle(1, 0, vx1, vy1);
-    let ang2 = vectorAngle(vx1, vy1, vx2, vy2);
-    if (sweepFlag === 0 && ang2 > 0) {
-        ang2 -= TAU;
-    }
-    if (sweepFlag === 1 && ang2 < 0) {
-        ang2 += TAU;
-    }
-    out.centerX = centerX;
-    out.centerY = centerY;
-    out.ang1 = ang1;
-    out.ang2 = ang2;
-};
-/**
- * @param points
- * @param px
- * @param py
- * @param cx
- * @param cy
- * @param rx
- * @param ry
- * @param xAxisRotation
- * @param largeArcFlag
- * @param sweepFlag
- * @internal
- */
-export function buildArcToSvg(points, px, py, cx, cy, rx, ry, xAxisRotation = 0, largeArcFlag = 0, sweepFlag = 0) {
-    if (rx === 0 || ry === 0) {
-        return;
-    }
-    const sinPhi = Math.sin(xAxisRotation * TAU / 360);
-    const cosPhi = Math.cos(xAxisRotation * TAU / 360);
-    const pxp = (cosPhi * (px - cx) / 2) + (sinPhi * (py - cy) / 2);
-    const pyp = (-sinPhi * (px - cx) / 2) + (cosPhi * (py - cy) / 2);
-    if (pxp === 0 && pyp === 0) {
-        return;
-    }
-    rx = Math.abs(rx);
-    ry = Math.abs(ry);
-    const lambda = (Math.pow(pxp, 2) / Math.pow(rx, 2)) + (Math.pow(pyp, 2) / Math.pow(ry, 2));
-    if (lambda > 1) {
-        rx *= Math.sqrt(lambda);
-        ry *= Math.sqrt(lambda);
-    }
-    getArcCenter(px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinPhi, cosPhi, pxp, pyp, out);
-    let { ang1, ang2 } = out;
-    const { centerX, centerY } = out;
-    // If 'ang2' == 90.0000000001, then `ratio` will devalue to
-    // 1.0000000001. This causes `segments` to be greater than one, which is an
-    // unnecessary split, and adds extra points to the bezier curve. To alleviate
-    // this issue, we round to 1.0 when the ratio is close to 1.0.
-    let ratio = Math.abs(ang2) / (TAU / 4);
-    if (Math.abs(1.0 - ratio) < 0.0000001) {
-        ratio = 1.0;
-    }
-    const segments = Math.max(Math.ceil(ratio), 1);
-    ang2 /= segments;
-    let lastX = points[points.length - 2];
-    let lastY = points[points.length - 1];
-    const outCurvePoint = { x: 0, y: 0 };
-    for (let i = 0; i < segments; i++) {
-        const curve = approxUnitArc(ang1, ang2);
-        const { x: x1, y: y1 } = mapToEllipse(curve[0], rx, ry, cosPhi, sinPhi, centerX, centerY, outCurvePoint);
-        const { x: x2, y: y2 } = mapToEllipse(curve[1], rx, ry, cosPhi, sinPhi, centerX, centerY, outCurvePoint);
-        const { x, y } = mapToEllipse(curve[2], rx, ry, cosPhi, sinPhi, centerX, centerY, outCurvePoint);
-        buildAdaptiveBezier(points, lastX, lastY, x1, y1, x2, y2, x, y);
-        lastX = x;
-        lastY = y;
-        ang1 += ang2;
-    }
-}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildCircle.d.ts

@@ -1,36 +0,0 @@
-import { ExtensionType } from '../../../../extensions/Extensions';
-import type { Circle } from '../../../../maths/shapes/Circle';
-import type { Ellipse } from '../../../../maths/shapes/Ellipse';
-import type { RoundedRectangle } from '../../../../maths/shapes/RoundedRectangle';
-import type { ShapeBuildCommand } from './ShapeBuildCommand';
-/** @internal */
-type RoundedShape = Circle | Ellipse | RoundedRectangle;
-/**
- * Builds a rectangle to draw
- *
- * Ignored from docs since it is not directly exposed.
- * @internal
- */
-export declare const buildCircle: ShapeBuildCommand<RoundedShape>;
-/** @internal */
-export declare const buildEllipse: {
-    extension: {
-        name: string;
-        type: ExtensionType | ExtensionType[];
-        priority?: number;
-    };
-    build(shape: RoundedShape, points: number[]): boolean;
-    triangulate(points: number[], vertices: number[], verticesStride: number, verticesOffset: number, indices: number[], indicesOffset: number): void;
-};
-/** @internal */
-export declare const buildRoundedRectangle: {
-    extension: {
-        name: string;
-        type: ExtensionType | ExtensionType[];
-        priority?: number;
-    };
-    build(shape: RoundedShape, points: number[]): boolean;
-    triangulate(points: number[], vertices: number[], verticesStride: number, verticesOffset: number, indices: number[], indicesOffset: number): void;
-};
-export {};
-//# sourceMappingURL=buildCircle.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildCircle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildCircle.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/buildCommands/buildCircle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,gBAAgB;AAChB,KAAK,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,iBAAiB,CAAC,YAAY,CAqMvD,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,YAAY;;;;;;;;CAA+E,CAAC;AACzG,gBAAgB;AAChB,eAAO,MAAM,qBAAqB;;;;;;;;CAAwF,CAAC"}

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildCircle.js

@@ -1,160 +0,0 @@
-import { ExtensionType } from '../../../../extensions/Extensions';
-/**
- * Builds a rectangle to draw
- *
- * Ignored from docs since it is not directly exposed.
- * @internal
- */
-export const buildCircle = {
-    extension: {
-        type: ExtensionType.ShapeBuilder,
-        name: 'circle',
-    },
-    build(shape, points) {
-        let x;
-        let y;
-        let dx;
-        let dy;
-        let rx;
-        let ry;
-        if (shape.type === 'circle') {
-            const circle = shape;
-            rx = ry = circle.radius;
-            if (rx <= 0) {
-                return false;
-            }
-            x = circle.x;
-            y = circle.y;
-            dx = dy = 0;
-        }
-        else if (shape.type === 'ellipse') {
-            const ellipse = shape;
-            rx = ellipse.halfWidth;
-            ry = ellipse.halfHeight;
-            if (rx <= 0 || ry <= 0) { // skip zero ellipse
-                return false;
-            }
-            x = ellipse.x;
-            y = ellipse.y;
-            dx = dy = 0;
-        }
-        else {
-            const roundedRect = shape;
-            const halfWidth = roundedRect.width / 2;
-            const halfHeight = roundedRect.height / 2;
-            x = roundedRect.x + halfWidth;
-            y = roundedRect.y + halfHeight;
-            rx = ry = Math.max(0, Math.min(roundedRect.radius, Math.min(halfWidth, halfHeight)));
-            dx = halfWidth - rx;
-            dy = halfHeight - ry;
-        }
-        if (dx < 0 || dy < 0) {
-            return false;
-        }
-        // Choose a number of segments such that the maximum absolute deviation from the circle is approximately 0.029
-        const n = Math.ceil(2.3 * Math.sqrt(rx + ry));
-        const m = (n * 8) + (dx ? 4 : 0) + (dy ? 4 : 0);
-        if (m === 0) {
-            return false;
-        }
-        if (n === 0) {
-            points[0] = points[6] = x + dx;
-            points[1] = points[3] = y + dy;
-            points[2] = points[4] = x - dx;
-            points[5] = points[7] = y - dy;
-            return true;
-        }
-        let j1 = 0;
-        let j2 = (n * 4) + (dx ? 2 : 0) + 2;
-        let j3 = j2;
-        let j4 = m;
-        let x0 = dx + rx;
-        let y0 = dy;
-        let x1 = x + x0;
-        let x2 = x - x0;
-        let y1 = y + y0;
-        points[j1++] = x1;
-        points[j1++] = y1;
-        points[--j2] = y1;
-        points[--j2] = x2;
-        if (dy) {
-            const y2 = y - y0;
-            points[j3++] = x2;
-            points[j3++] = y2;
-            points[--j4] = y2;
-            points[--j4] = x1;
-        }
-        for (let i = 1; i < n; i++) {
-            const a = Math.PI / 2 * (i / n);
-            const x0 = dx + (Math.cos(a) * rx);
-            const y0 = dy + (Math.sin(a) * ry);
-            const x1 = x + x0;
-            const x2 = x - x0;
-            const y1 = y + y0;
-            const y2 = y - y0;
-            points[j1++] = x1;
-            points[j1++] = y1;
-            points[--j2] = y1;
-            points[--j2] = x2;
-            points[j3++] = x2;
-            points[j3++] = y2;
-            points[--j4] = y2;
-            points[--j4] = x1;
-        }
-        x0 = dx;
-        y0 = dy + ry;
-        x1 = x + x0;
-        x2 = x - x0;
-        y1 = y + y0;
-        const y2 = y - y0;
-        points[j1++] = x1;
-        points[j1++] = y1;
-        points[--j4] = y2;
-        points[--j4] = x1;
-        if (dx) {
-            points[j1++] = x2;
-            points[j1++] = y1;
-            points[--j4] = y2;
-            points[--j4] = x2;
-        }
-        return true;
-    },
-    triangulate(points, vertices, verticesStride, verticesOffset, indices, indicesOffset) {
-        if (points.length === 0) {
-            return;
-        }
-        // Compute center (average of all points)
-        let centerX = 0;
-        let centerY = 0;
-        for (let i = 0; i < points.length; i += 2) {
-            centerX += points[i];
-            centerY += points[i + 1];
-        }
-        centerX /= (points.length / 2);
-        centerY /= (points.length / 2);
-        // Set center vertex
-        let count = verticesOffset;
-        vertices[count * verticesStride] = centerX;
-        vertices[(count * verticesStride) + 1] = centerY;
-        const centerIndex = count++;
-        // Set edge vertices and indices
-        for (let i = 0; i < points.length; i += 2) {
-            vertices[count * verticesStride] = points[i];
-            vertices[(count * verticesStride) + 1] = points[i + 1];
-            if (i > 0) { // Skip first point for indices
-                indices[indicesOffset++] = count;
-                indices[indicesOffset++] = centerIndex;
-                indices[indicesOffset++] = count - 1;
-            }
-            count++;
-        }
-        // Connect last point to the first edge point
-        indices[indicesOffset++] = centerIndex + 1;
-        indices[indicesOffset++] = centerIndex;
-        indices[indicesOffset++] = count - 1;
-    }
-};
-/** @internal */
-export const buildEllipse = Object.assign(Object.assign({}, buildCircle), { extension: Object.assign(Object.assign({}, buildCircle.extension), { name: 'ellipse' }) });
-/** @internal */
-export const buildRoundedRectangle = Object.assign(Object.assign({}, buildCircle), { extension: Object.assign(Object.assign({}, buildCircle.extension), { name: 'roundedRectangle' }) });

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildLine.d.ts

@@ -1,13 +0,0 @@
-import type { StrokeAttributes } from '../FillTypes';
-/**
- * Builds a line to draw using the polygon method.
- * @param points
- * @param lineStyle
- * @param flipAlignment
- * @param closed
- * @param vertices
- * @param indices
- * @internal
- */
-export declare function buildLine(points: number[], lineStyle: StrokeAttributes, flipAlignment: boolean, closed: boolean, vertices: number[], indices: number[]): void;
-//# sourceMappingURL=buildLine.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/buildCommands/buildLine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildLine.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/buildCommands/buildLine.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAoJrD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACrB,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,gBAAgB,EAC3B,aAAa,EAAE,OAAO,EACtB,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,IAAI,CA+XN"}