@safe-engine/pixi 8.10.1 → 8.10.2

package/dist/packages/pixijs/src/scene/graphics/shared/path/roundShape.js

@@ -0,0 +1,138 @@
+/**
+ * Typed and cleaned up version of:
+ * https://stackoverflow.com/questions/44855794/html5-canvas-triangle-with-rounded-corners/44856925#44856925
+ * @param g - Graphics to be drawn on.
+ * @param points - Corners of the shape to draw. Minimum length is 3.
+ * @param radius - Corners default radius.
+ * @ignore
+ */
+export function roundedShapeArc(g, points, radius) {
+    var _a;
+    const vecFrom = (p, pp) => {
+        const x = pp.x - p.x;
+        const y = pp.y - p.y;
+        const len = Math.sqrt((x * x) + (y * y));
+        const nx = x / len;
+        const ny = y / len;
+        return { len, nx, ny };
+    };
+    const sharpCorner = (i, p) => {
+        if (i === 0) {
+            g.moveTo(p.x, p.y);
+        }
+        else {
+            g.lineTo(p.x, p.y);
+        }
+    };
+    let p1 = points[points.length - 1];
+    for (let i = 0; i < points.length; i++) {
+        const p2 = points[i % points.length];
+        const pRadius = (_a = p2.radius) !== null && _a !== void 0 ? _a : radius;
+        if (pRadius <= 0) {
+            sharpCorner(i, p2);
+            p1 = p2;
+            continue;
+        }
+        const p3 = points[(i + 1) % points.length];
+        const v1 = vecFrom(p2, p1);
+        const v2 = vecFrom(p2, p3);
+        if (v1.len < 1e-4 || v2.len < 1e-4) {
+            sharpCorner(i, p2);
+            p1 = p2;
+            continue;
+        }
+        let angle = Math.asin((v1.nx * v2.ny) - (v1.ny * v2.nx));
+        let radDirection = 1;
+        let drawDirection = false;
+        if ((v1.nx * v2.nx) - (v1.ny * -v2.ny) < 0) {
+            if (angle < 0) {
+                angle = Math.PI + angle;
+            }
+            else {
+                angle = Math.PI - angle;
+                radDirection = -1;
+                drawDirection = true;
+            }
+        }
+        else if (angle > 0) {
+            radDirection = -1;
+            drawDirection = true;
+        }
+        const halfAngle = angle / 2;
+        let cRadius;
+        let lenOut = Math.abs((Math.cos(halfAngle) * pRadius) / Math.sin(halfAngle));
+        if (lenOut > Math.min(v1.len / 2, v2.len / 2)) {
+            lenOut = Math.min(v1.len / 2, v2.len / 2);
+            cRadius = Math.abs((lenOut * Math.sin(halfAngle)) / Math.cos(halfAngle));
+        }
+        else {
+            cRadius = pRadius;
+        }
+        const cX = p2.x + (v2.nx * lenOut) + (-v2.ny * cRadius * radDirection);
+        const cY = p2.y + (v2.ny * lenOut) + (v2.nx * cRadius * radDirection);
+        const startAngle = Math.atan2(v1.ny, v1.nx) + ((Math.PI / 2) * radDirection);
+        const endAngle = Math.atan2(v2.ny, v2.nx) - ((Math.PI / 2) * radDirection);
+        if (i === 0) {
+            g.moveTo(cX + (Math.cos(startAngle) * cRadius), cY + (Math.sin(startAngle) * cRadius));
+        }
+        g.arc(cX, cY, cRadius, startAngle, endAngle, drawDirection);
+        p1 = p2;
+    }
+}
+/**
+ * Typed and cleaned up version of:
+ * https://stackoverflow.com/questions/44855794/html5-canvas-triangle-with-rounded-corners/56214413#56214413
+ * @param g - Graphics to be drawn on.
+ * @param points - Corners of the shape to draw. Minimum length is 3.
+ * @param radius - Corners default radius.
+ * @ignore
+ */
+export function roundedShapeQuadraticCurve(g, points, radius, smoothness) {
+    var _a;
+    const distance = (p1, p2) => Math.sqrt((Math.pow((p1.x - p2.x), 2)) + (Math.pow((p1.y - p2.y), 2)));
+    const pointLerp = (p1, p2, t) => ({
+        x: p1.x + ((p2.x - p1.x) * t),
+        y: p1.y + ((p2.y - p1.y) * t),
+    });
+    const numPoints = points.length;
+    for (let i = 0; i < numPoints; i++) {
+        const thisPoint = points[(i + 1) % numPoints];
+        const pRadius = (_a = thisPoint.radius) !== null && _a !== void 0 ? _a : radius;
+        if (pRadius <= 0) {
+            if (i === 0) {
+                g.moveTo(thisPoint.x, thisPoint.y);
+            }
+            else {
+                g.lineTo(thisPoint.x, thisPoint.y);
+            }
+            continue;
+        }
+        const lastPoint = points[i];
+        const nextPoint = points[(i + 2) % numPoints];
+        const lastEdgeLength = distance(lastPoint, thisPoint);
+        let start;
+        if (lastEdgeLength < 1e-4) {
+            start = thisPoint;
+        }
+        else {
+            const lastOffsetDistance = Math.min(lastEdgeLength / 2, pRadius);
+            start = pointLerp(thisPoint, lastPoint, lastOffsetDistance / lastEdgeLength);
+        }
+        const nextEdgeLength = distance(nextPoint, thisPoint);
+        let end;
+        if (nextEdgeLength < 1e-4) {
+            end = thisPoint;
+        }
+        else {
+            const nextOffsetDistance = Math.min(nextEdgeLength / 2, pRadius);
+            end = pointLerp(thisPoint, nextPoint, nextOffsetDistance / nextEdgeLength);
+        }
+        if (i === 0) {
+            g.moveTo(start.x, start.y);
+        }
+        else {
+            g.lineTo(start.x, start.y);
+        }
+        g.quadraticCurveTo(thisPoint.x, thisPoint.y, end.x, end.y, smoothness);
+    }
+}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/SVGParser.d.ts

@@ -0,0 +1,25 @@
+import { GraphicsPath } from '../path/GraphicsPath';
+import type { FillGradient } from '../fill/FillGradient';
+import type { GraphicsContext } from '../GraphicsContext';
+/**
+ * Represents a session for SVG parsing. Contains the current state and resources needed during parsing.
+ * @internal
+ */
+export interface Session {
+    /** The graphics context to render to */
+    context: GraphicsContext;
+    /** The current path being constructed */
+    path: GraphicsPath;
+    /** Map of definitions by id */
+    defs: Record<string, FillGradient>;
+}
+/**
+ * Parses an SVG element or string and renders it to a graphics context.
+ * Handles both SVG strings and SVG DOM elements as input.
+ * @param svg - The SVG content to parse, either as a string or element
+ * @param graphicsContext - Optional graphics context to render to
+ * @returns The graphics context with the SVG rendered into it
+ * @internal
+ */
+export declare function SVGParser(svg: string | SVGElement | SVGSVGElement, graphicsContext?: GraphicsContext): GraphicsContext;
+//# sourceMappingURL=SVGParser.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/svg/SVGParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SVGParser.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/svg/SVGParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EACR,eAAe,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;GAGG;AACH,MAAM,WAAW,OAAO;IAEpB,wCAAwC;IACxC,OAAO,EAAE,eAAe,CAAC;IACzB,yCAAyC;IACzC,IAAI,EAAE,YAAY,CAAC;IACnB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACrB,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,aAAa,EACxC,eAAe,CAAC,EAAE,eAAe,GAClC,eAAe,CAoCjB"}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/SVGParser.js

@@ -0,0 +1,244 @@
+import { warn } from '../../../../utils/logging/warn';
+import { GraphicsPath } from '../path/GraphicsPath';
+import { parseSVGDefinitions } from './parseSVGDefinitions';
+import { parseSVGFloatAttribute } from './parseSVGFloatAttribute';
+import { parseSVGStyle } from './parseSVGStyle';
+import { checkForNestedPattern } from './utils/fillOperations';
+import { appendSVGPath, calculatePathArea, extractSubpaths } from './utils/pathOperations';
+/**
+ * Parses an SVG element or string and renders it to a graphics context.
+ * Handles both SVG strings and SVG DOM elements as input.
+ * @param svg - The SVG content to parse, either as a string or element
+ * @param graphicsContext - Optional graphics context to render to
+ * @returns The graphics context with the SVG rendered into it
+ * @internal
+ */
+export function SVGParser(svg, graphicsContext) {
+    // Convert string input to SVG element
+    if (typeof svg === 'string') {
+        // eslint-disable-next-line no-restricted-globals
+        const div = document.createElement('div');
+        div.innerHTML = svg.trim();
+        svg = div.querySelector('svg');
+    }
+    // Initialize parsing session
+    const session = {
+        context: graphicsContext,
+        defs: {},
+        path: new GraphicsPath(),
+    };
+    // Parse definitions (gradients, etc) first
+    parseSVGDefinitions(svg, session);
+    // Process all child elements except defs
+    const children = svg.children;
+    const { fillStyle, strokeStyle } = parseSVGStyle(svg, session);
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child.nodeName.toLowerCase() === 'defs')
+            continue;
+        renderChildren(child, session, fillStyle, strokeStyle);
+    }
+    return graphicsContext;
+}
+/**
+ * Recursively renders SVG elements and their children.
+ * Handles styling inheritance and different SVG shape types.
+ * @param svg - The SVG element to render
+ * @param session - The current parsing session
+ * @param fillStyle - The inherited fill style
+ * @param strokeStyle - The inherited stroke style
+ */
+function renderChildren(svg, session, fillStyle, strokeStyle) {
+    const children = svg.children;
+    // Parse element's style and merge with inherited styles
+    const { fillStyle: f1, strokeStyle: s1 } = parseSVGStyle(svg, session);
+    if (f1 && fillStyle) {
+        fillStyle = Object.assign(Object.assign({}, fillStyle), f1);
+    }
+    else if (f1) {
+        fillStyle = f1;
+    }
+    if (s1 && strokeStyle) {
+        strokeStyle = Object.assign(Object.assign({}, strokeStyle), s1);
+    }
+    else if (s1) {
+        strokeStyle = s1;
+    }
+    const noStyle = !fillStyle && !strokeStyle;
+    // Default to black fill if no styles specified
+    if (noStyle) {
+        fillStyle = { color: 0 };
+    }
+    // Variables for shape attributes
+    let x;
+    let y;
+    let x1;
+    let y1;
+    let x2;
+    let y2;
+    let cx;
+    let cy;
+    let r;
+    let rx;
+    let ry;
+    let points;
+    let pointsString;
+    let d;
+    let graphicsPath;
+    let width;
+    let height;
+    // Handle different SVG element types
+    switch (svg.nodeName.toLowerCase()) {
+        case 'path':
+            {
+                d = svg.getAttribute('d');
+                const fillRule = svg.getAttribute('fill-rule');
+                const subpaths = extractSubpaths(d);
+                const hasExplicitEvenodd = fillRule === 'evenodd';
+                const hasMultipleSubpaths = subpaths.length > 1;
+                const shouldProcessHoles = hasExplicitEvenodd && hasMultipleSubpaths;
+                if (shouldProcessHoles) {
+                    const subpathsWithArea = subpaths.map((subpath) => ({
+                        path: subpath,
+                        area: calculatePathArea(subpath)
+                    }));
+                    subpathsWithArea.sort((a, b) => b.area - a.area);
+                    // For complex cases, prefer multiple holes approach
+                    const useMultipleHolesApproach = subpaths.length > 3 || !checkForNestedPattern(subpathsWithArea);
+                    if (useMultipleHolesApproach) {
+                        // Multiple holes approach: first (largest) is fill, rest are holes
+                        for (let i = 0; i < subpathsWithArea.length; i++) {
+                            const subpath = subpathsWithArea[i];
+                            const isMainShape = i === 0;
+                            session.context.beginPath();
+                            const newPath = new GraphicsPath(undefined, true); // Always use evenodd for hole processing
+                            appendSVGPath(subpath.path, newPath);
+                            session.context.path(newPath);
+                            if (isMainShape) {
+                                if (fillStyle)
+                                    session.context.fill(fillStyle);
+                                if (strokeStyle)
+                                    session.context.stroke(strokeStyle);
+                            }
+                            else {
+                                session.context.cut();
+                            }
+                        }
+                    }
+                    else {
+                        // Nested holes approach: alternate between fill and cut
+                        for (let i = 0; i < subpathsWithArea.length; i++) {
+                            const subpath = subpathsWithArea[i];
+                            const isHole = i % 2 === 1; // Odd indices are holes
+                            session.context.beginPath();
+                            const newPath = new GraphicsPath(undefined, true); // Always use evenodd for hole processing
+                            appendSVGPath(subpath.path, newPath);
+                            session.context.path(newPath);
+                            if (isHole) {
+                                session.context.cut();
+                            }
+                            else {
+                                if (fillStyle)
+                                    session.context.fill(fillStyle);
+                                if (strokeStyle)
+                                    session.context.stroke(strokeStyle);
+                            }
+                        }
+                    }
+                }
+                else {
+                    const useEvenoddForGraphicsPath = fillRule ? (fillRule === 'evenodd') : true;
+                    graphicsPath = new GraphicsPath(d, useEvenoddForGraphicsPath);
+                    session.context.path(graphicsPath);
+                    if (fillStyle)
+                        session.context.fill(fillStyle);
+                    if (strokeStyle)
+                        session.context.stroke(strokeStyle);
+                }
+                break;
+            }
+        case 'circle':
+            cx = parseSVGFloatAttribute(svg, 'cx', 0);
+            cy = parseSVGFloatAttribute(svg, 'cy', 0);
+            r = parseSVGFloatAttribute(svg, 'r', 0);
+            session.context.ellipse(cx, cy, r, r);
+            if (fillStyle)
+                session.context.fill(fillStyle);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        case 'rect':
+            x = parseSVGFloatAttribute(svg, 'x', 0);
+            y = parseSVGFloatAttribute(svg, 'y', 0);
+            width = parseSVGFloatAttribute(svg, 'width', 0);
+            height = parseSVGFloatAttribute(svg, 'height', 0);
+            rx = parseSVGFloatAttribute(svg, 'rx', 0);
+            ry = parseSVGFloatAttribute(svg, 'ry', 0);
+            if (rx || ry) {
+                session.context.roundRect(x, y, width, height, rx || ry);
+            }
+            else {
+                session.context.rect(x, y, width, height);
+            }
+            if (fillStyle)
+                session.context.fill(fillStyle);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        case 'ellipse':
+            cx = parseSVGFloatAttribute(svg, 'cx', 0);
+            cy = parseSVGFloatAttribute(svg, 'cy', 0);
+            rx = parseSVGFloatAttribute(svg, 'rx', 0);
+            ry = parseSVGFloatAttribute(svg, 'ry', 0);
+            session.context.beginPath();
+            session.context.ellipse(cx, cy, rx, ry);
+            if (fillStyle)
+                session.context.fill(fillStyle);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        case 'line':
+            x1 = parseSVGFloatAttribute(svg, 'x1', 0);
+            y1 = parseSVGFloatAttribute(svg, 'y1', 0);
+            x2 = parseSVGFloatAttribute(svg, 'x2', 0);
+            y2 = parseSVGFloatAttribute(svg, 'y2', 0);
+            session.context.beginPath();
+            session.context.moveTo(x1, y1);
+            session.context.lineTo(x2, y2);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        case 'polygon':
+            pointsString = svg.getAttribute('points');
+            points = pointsString.match(/\d+/g).map((n) => parseInt(n, 10));
+            session.context.poly(points, true);
+            if (fillStyle)
+                session.context.fill(fillStyle);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        case 'polyline':
+            pointsString = svg.getAttribute('points');
+            points = pointsString.match(/\d+/g).map((n) => parseInt(n, 10));
+            session.context.poly(points, false);
+            if (strokeStyle)
+                session.context.stroke(strokeStyle);
+            break;
+        // Group elements - just process children
+        case 'g':
+        case 'svg':
+            break;
+        default: {
+            // Log unsupported elements
+            warn(`[SVG parser] <${svg.nodeName}> elements unsupported`);
+            break;
+        }
+    }
+    if (noStyle) {
+        fillStyle = null;
+    }
+    // Recursively process child elements
+    for (let i = 0; i < children.length; i++) {
+        renderChildren(children[i], session, fillStyle, strokeStyle);
+    }
+}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGDefinitions.d.ts

@@ -0,0 +1,10 @@
+import type { Session } from './SVGParser';
+/**
+ * Parses SVG gradient definitions and stores them in the session for later use.
+ * Currently supports linear gradients and has placeholder support for radial gradients.
+ * @param svg - The root SVG element to parse definitions from
+ * @param session - The parsing session to store definitions in
+ * @internal
+ */
+export declare function parseSVGDefinitions(svg: SVGElement, session: Session): void;
+//# sourceMappingURL=parseSVGDefinitions.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSVGDefinitions.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/svg/parseSVGDefinitions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA8B3E"}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGDefinitions.js

@@ -0,0 +1,72 @@
+import { Color } from '../../../../color/Color';
+import { warn } from '../../../../utils/logging/warn';
+import { FillGradient } from '../fill/FillGradient';
+import { parseSVGFloatAttribute } from './parseSVGFloatAttribute';
+/**
+ * Parses SVG gradient definitions and stores them in the session for later use.
+ * Currently supports linear gradients and has placeholder support for radial gradients.
+ * @param svg - The root SVG element to parse definitions from
+ * @param session - The parsing session to store definitions in
+ * @internal
+ */
+export function parseSVGDefinitions(svg, session) {
+    // Find all <defs> elements in the SVG
+    const definitions = svg.querySelectorAll('defs');
+    // Process each <defs> element
+    for (let i = 0; i < definitions.length; i++) {
+        const definition = definitions[i];
+        // Process each child element in the <defs>
+        for (let j = 0; j < definition.children.length; j++) {
+            const child = definition.children[j];
+            // Handle different types of gradient definitions
+            switch (child.nodeName.toLowerCase()) {
+                case 'lineargradient':
+                    // Store the parsed linear gradient in the session defs using the gradient's ID
+                    session.defs[child.id] = parseLinearGradient(child);
+                    break;
+                case 'radialgradient':
+                    session.defs[child.id] = parseRadialGradient(child);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Parses an SVG linear gradient element into a FillGradient.
+ * @param child - The SVG linear gradient element to parse
+ * @returns A FillGradient configured based on the SVG element
+ */
+function parseLinearGradient(child) {
+    // Parse the gradient vector coordinates (defaults: horizontal line from 0 to 1)
+    const x0 = parseSVGFloatAttribute(child, 'x1', 0);
+    const y0 = parseSVGFloatAttribute(child, 'y1', 0);
+    const x1 = parseSVGFloatAttribute(child, 'x2', 1);
+    const y1 = parseSVGFloatAttribute(child, 'y2', 0);
+    // Get the gradient coordinate system
+    const gradientUnit = child.getAttribute('gradientUnits') || 'objectBoundingBox';
+    // Create gradient with coordinates and space mapping
+    const gradient = new FillGradient(x0, y0, x1, y1, gradientUnit === 'objectBoundingBox' ? 'local' : 'global');
+    // Process each gradient stop
+    for (let k = 0; k < child.children.length; k++) {
+        const stop = child.children[k];
+        // Get stop position (0-1) and color
+        const offset = parseSVGFloatAttribute(stop, 'offset', 0);
+        const color = Color.shared.setValue(stop.getAttribute('stop-color')).toNumber();
+        gradient.addColorStop(offset, color);
+    }
+    return gradient;
+}
+/**
+ * Placeholder function for parsing SVG radial gradients.
+ * Currently returns a simple horizontal linear gradient and logs a warning.
+ * @param _child - The SVG radial gradient element (currently unused)
+ * @returns A default linear gradient
+ */
+function parseRadialGradient(_child) {
+    // #if _DEBUG
+    warn('[SVG Parser] Radial gradients are not yet supported');
+    // #endif
+    return new FillGradient(0, 0, 1, 0);
+}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGFloatAttribute.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parses a float value from an SVG element's attribute.
+ * This is commonly used for parsing numeric attributes like coordinates, dimensions,
+ * and other measurements from SVG elements.
+ * @param svg - The SVG element to get the attribute from
+ * @param id - The name of the attribute to parse (e.g. 'x', 'y', 'width', etc)
+ * @param defaultValue - The value to return if the attribute doesn't exist or can't be parsed
+ * @returns The parsed float value, or the default value if parsing fails
+ * @example
+ * // For SVG: <rect x="10.5" width="20"/>
+ * parseSVGFloatAttribute(rectElement, 'x', 0) // Returns 10.5
+ * parseSVGFloatAttribute(rectElement, 'y', 0) // Returns 0 since y is not specified
+ * @internal
+ */
+export declare function parseSVGFloatAttribute(svg: SVGElement, id: string, defaultValue: number): number;
+//# sourceMappingURL=parseSVGFloatAttribute.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGFloatAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSVGFloatAttribute.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/svg/parseSVGFloatAttribute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAKhG"}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGFloatAttribute.js

@@ -0,0 +1,18 @@
+/**
+ * Parses a float value from an SVG element's attribute.
+ * This is commonly used for parsing numeric attributes like coordinates, dimensions,
+ * and other measurements from SVG elements.
+ * @param svg - The SVG element to get the attribute from
+ * @param id - The name of the attribute to parse (e.g. 'x', 'y', 'width', etc)
+ * @param defaultValue - The value to return if the attribute doesn't exist or can't be parsed
+ * @returns The parsed float value, or the default value if parsing fails
+ * @example
+ * // For SVG: <rect x="10.5" width="20"/>
+ * parseSVGFloatAttribute(rectElement, 'x', 0) // Returns 10.5
+ * parseSVGFloatAttribute(rectElement, 'y', 0) // Returns 0 since y is not specified
+ * @internal
+ */
+export function parseSVGFloatAttribute(svg, id, defaultValue) {
+    const value = svg.getAttribute(id);
+    return value ? Number(value) : defaultValue;
+}

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGPath.d.ts

@@ -0,0 +1,25 @@
+import type { GraphicsPath } from '../path/GraphicsPath';
+/**
+ * Parses an SVG path data string and builds a GraphicsPath object from the commands.
+ * This function handles all standard SVG path commands including moves, lines, curves and arcs.
+ * It maintains state for the current position and subpaths to properly handle relative commands
+ * and path closures.
+ *
+ * Supported SVG commands:
+ * - M/m: Move to absolute/relative
+ * - L/l: Line to absolute/relative
+ * - H/h: Horizontal line absolute/relative
+ * - V/v: Vertical line absolute/relative
+ * - C/c: Cubic bezier curve absolute/relative
+ * - S/s: Smooth cubic bezier curve absolute/relative
+ * - Q/q: Quadratic bezier curve absolute/relative
+ * - T/t: Smooth quadratic bezier curve absolute/relative
+ * - A/a: Arc absolute/relative
+ * - Z/z: Close path
+ * @param svgPath - The SVG path data string to parse (e.g. "M0,0 L100,100")
+ * @param path - The GraphicsPath object to build the path into
+ * @returns The input path object with the SVG commands applied
+ * @internal
+ */
+export declare function parseSVGPath(svgPath: string, path: GraphicsPath): GraphicsPath;
+//# sourceMappingURL=parseSVGPath.d.ts.map

package/dist/packages/pixijs/src/scene/graphics/shared/svg/parseSVGPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSVGPath.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/scene/graphics/shared/svg/parseSVGPath.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAQzD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CA0M9E"}