@remotion/paths 3.3.5 → 3.3.7

package/dist/get-parts.d.ts

@@ -3,5 +3,6 @@ import type { Part } from './helpers/types';
  * Splits a valid SVG path into it's parts.
  * @param {string} path A valid SVG path
  * @link https://remotion.dev/docs/paths/get-parts
+ * @deprecated In favor of getSubpaths()
  */
 export declare const getParts: (path: string) => Part[];

package/dist/get-parts.js

@@ -6,6 +6,7 @@ const construct_1 = require("./helpers/construct");
  * Splits a valid SVG path into it's parts.
  * @param {string} path A valid SVG path
  * @link https://remotion.dev/docs/paths/get-parts
+ * @deprecated In favor of getSubpaths()
  */
 const getParts = (path) => {
     const parts = [];

package/dist/get-subpaths.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Splits a valid SVG path into it's parts.
+ * @param {string} path A valid SVG path
+ * @link https://remotion.dev/docs/paths/get-subpaths
+ */
+export declare const getSubpaths: (path: string) => string[];

package/dist/get-subpaths.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubpaths = void 0;
+const construct_1 = require("./helpers/construct");
+/**
+ * Splits a valid SVG path into it's parts.
+ * @param {string} path A valid SVG path
+ * @link https://remotion.dev/docs/paths/get-subpaths
+ */
+const getSubpaths = (path) => {
+    const { segments } = (0, construct_1.construct)(path);
+    return segments
+        .map((seg) => {
+        return seg.map((s) => s.join(' '));
+    })
+        .map((_s) => _s.join(' '));
+};
+exports.getSubpaths = getSubpaths;

package/dist/helpers/construct.d.ts

@@ -1,5 +1,7 @@
+import type { Instruction } from './parse';
 import type { Point, Properties } from './types';
 export declare const construct: (string: string) => {
+    segments: Instruction[][];
     initial_point: Point | null;
     length: number;
     partial_lengths: number[];

package/dist/helpers/construct.js

@@ -1,113 +1,117 @@
 "use strict";
 // Copied from: https://github.com/rveciana/svg-path-properties
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.construct = void 0;
 const arc_1 = require("./arc");
 const bezier_1 = require("./bezier");
 const linear_1 = require("./linear");
-const parse_1 = __importDefault(require("./parse"));
+const parse_1 = require("./parse");
 const construct = (string) => {
     let length = 0;
     const partial_lengths = [];
     const functions = [];
     let initial_point = null;
-    const parsed = (0, parse_1.default)(string);
+    const parsed = (0, parse_1.parsePath)(string);
     let cur = [0, 0];
     let prev_point = [0, 0];
     let curve;
     let ringStart = [0, 0];
+    const segments = [];
     for (let i = 0; i < parsed.length; i++) {
+        const instruction = parsed[i];
+        if (instruction[0].toLowerCase() !== 'm' && segments.length > 0) {
+            segments[segments.length - 1].push(instruction);
+        }
         // moveTo
-        if (parsed[i][0] === 'M') {
-            cur = [parsed[i][1], parsed[i][2]];
+        if (instruction[0] === 'M') {
+            cur = [instruction[1], instruction[2]];
             ringStart = [cur[0], cur[1]];
+            segments.push([instruction]);
             functions.push(null);
             if (i === 0) {
-                initial_point = { x: parsed[i][1], y: parsed[i][2] };
+                initial_point = { x: instruction[1], y: instruction[2] };
             }
         }
-        else if (parsed[i][0] === 'm') {
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+        else if (instruction[0] === 'm') {
+            cur = [instruction[1] + cur[0], instruction[2] + cur[1]];
             ringStart = [cur[0], cur[1]];
+            segments.push([['M', cur[0], cur[1]]]);
             functions.push(null);
             // lineTo
         }
-        else if (parsed[i][0] === 'L') {
-            length += Math.sqrt((cur[0] - parsed[i][1]) ** 2 + (cur[1] - parsed[i][2]) ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]));
-            cur = [parsed[i][1], parsed[i][2]];
+        else if (instruction[0] === 'L') {
+            length += Math.sqrt((cur[0] - instruction[1]) ** 2 + (cur[1] - instruction[2]) ** 2);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], instruction[1], cur[1], instruction[2]));
+            cur = [instruction[1], instruction[2]];
         }
-        else if (parsed[i][0] === 'l') {
-            length += Math.sqrt(parsed[i][1] ** 2 + parsed[i][2] ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1] + cur[0], cur[1], parsed[i][2] + cur[1]));
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+        else if (instruction[0] === 'l') {
+            length += Math.sqrt(instruction[1] ** 2 + instruction[2] ** 2);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], instruction[1] + cur[0], cur[1], instruction[2] + cur[1]));
+            cur = [instruction[1] + cur[0], instruction[2] + cur[1]];
         }
-        else if (parsed[i][0] === 'H') {
-            length += Math.abs(cur[0] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1];
+        else if (instruction[0] === 'H') {
+            length += Math.abs(cur[0] - instruction[1]);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], instruction[1], cur[1], cur[1]));
+            cur[0] = instruction[1];
         }
-        else if (parsed[i][0] === 'h') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1] + cur[0];
+        else if (instruction[0] === 'h') {
+            length += Math.abs(instruction[1]);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0] + instruction[1], cur[1], cur[1]));
+            cur[0] = instruction[1] + cur[0];
         }
-        else if (parsed[i][0] === 'V') {
-            length += Math.abs(cur[1] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], parsed[i][1]));
-            cur[1] = parsed[i][1];
+        else if (instruction[0] === 'V') {
+            length += Math.abs(cur[1] - instruction[1]);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], instruction[1]));
+            cur[1] = instruction[1];
         }
-        else if (parsed[i][0] === 'v') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1] + parsed[i][1]));
-            cur[1] = parsed[i][1] + cur[1];
+        else if (instruction[0] === 'v') {
+            length += Math.abs(instruction[1]);
+            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1] + instruction[1]));
+            cur[1] = instruction[1] + cur[1];
             // Close path
         }
-        else if (parsed[i][0] === 'z' || parsed[i][0] === 'Z') {
+        else if (instruction[0] === 'z' || instruction[0] === 'Z') {
             length += Math.sqrt((ringStart[0] - cur[0]) ** 2 + (ringStart[1] - cur[1]) ** 2);
             functions.push((0, linear_1.makeLinearPosition)(cur[0], ringStart[0], cur[1], ringStart[1]));
             cur = [ringStart[0], ringStart[1]];
             // Cubic Bezier curves
         }
-        else if (parsed[i][0] === 'C') {
+        else if (instruction[0] === 'C') {
             curve = (0, bezier_1.makeBezier)({
                 ax: cur[0],
                 ay: cur[1],
-                bx: parsed[i][1],
-                by: parsed[i][2],
-                cx: parsed[i][3],
-                cy: parsed[i][4],
-                dx: parsed[i][5],
-                dy: parsed[i][6],
+                bx: instruction[1],
+                by: instruction[2],
+                cx: instruction[3],
+                cy: instruction[4],
+                dx: instruction[5],
+                dy: instruction[6],
             });
             length += curve.getTotalLength();
-            cur = [parsed[i][5], parsed[i][6]];
+            cur = [instruction[5], instruction[6]];
             functions.push(curve);
         }
-        else if (parsed[i][0] === 'c') {
+        else if (instruction[0] === 'c') {
             curve = (0, bezier_1.makeBezier)({
                 ax: cur[0],
                 ay: cur[1],
-                bx: cur[0] + parsed[i][1],
-                by: cur[1] + parsed[i][2],
-                cx: cur[0] + parsed[i][3],
-                cy: cur[1] + parsed[i][4],
-                dx: cur[0] + parsed[i][5],
-                dy: cur[1] + parsed[i][6],
+                bx: cur[0] + instruction[1],
+                by: cur[1] + instruction[2],
+                cx: cur[0] + instruction[3],
+                cy: cur[1] + instruction[4],
+                dx: cur[0] + instruction[5],
+                dy: cur[1] + instruction[6],
             });
             if (curve.getTotalLength() > 0) {
                 length += curve.getTotalLength();
                 functions.push(curve);
-                cur = [parsed[i][5] + cur[0], parsed[i][6] + cur[1]];
+                cur = [instruction[5] + cur[0], instruction[6] + cur[1]];
             }
             else {
                 functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1]));
             }
         }
-        else if (parsed[i][0] === 'S') {
+        else if (instruction[0] === 'S') {
             if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
                 if (curve) {
                     const c = curve.getC();
@@ -116,10 +120,10 @@ const construct = (string) => {
                         ay: cur[1],
                         bx: 2 * cur[0] - c.x,
                         by: 2 * cur[1] - c.y,
-                        cx: parsed[i][1],
-                        cy: parsed[i][2],
-                        dx: parsed[i][3],
-                        dy: parsed[i][4],
+                        cx: instruction[1],
+                        cy: instruction[2],
+                        dx: instruction[3],
+                        dy: instruction[4],
                     });
                 }
             }
@@ -129,19 +133,19 @@ const construct = (string) => {
                     ay: cur[1],
                     bx: cur[0],
                     by: cur[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
-                    dx: parsed[i][3],
-                    dy: parsed[i][4],
+                    cx: instruction[1],
+                    cy: instruction[2],
+                    dx: instruction[3],
+                    dy: instruction[4],
                 });
             }
             if (curve) {
                 length += curve.getTotalLength();
-                cur = [parsed[i][3], parsed[i][4]];
+                cur = [instruction[3], instruction[4]];
                 functions.push(curve);
             }
         }
-        else if (parsed[i][0] === 's') {
+        else if (instruction[0] === 's') {
             // 240 225
             if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
                 if (curve) {
@@ -152,10 +156,10 @@ const construct = (string) => {
                         ay: cur[1],
                         bx: cur[0] + d.x - c.x,
                         by: cur[1] + d.y - c.y,
-                        cx: cur[0] + parsed[i][1],
-                        cy: cur[1] + parsed[i][2],
-                        dx: cur[0] + parsed[i][3],
-                        dy: cur[1] + parsed[i][4],
+                        cx: cur[0] + instruction[1],
+                        cy: cur[1] + instruction[2],
+                        dx: cur[0] + instruction[3],
+                        dy: cur[1] + instruction[4],
                     });
                 }
             }
@@ -165,22 +169,22 @@ const construct = (string) => {
                     ay: cur[1],
                     bx: cur[0],
                     by: cur[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
-                    dx: cur[0] + parsed[i][3],
-                    dy: cur[1] + parsed[i][4],
+                    cx: cur[0] + instruction[1],
+                    cy: cur[1] + instruction[2],
+                    dx: cur[0] + instruction[3],
+                    dy: cur[1] + instruction[4],
                 });
             }
             if (curve) {
                 length += curve.getTotalLength();
-                cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
+                cur = [instruction[3] + cur[0], instruction[4] + cur[1]];
                 functions.push(curve);
             }
         }
         // Quadratic Bezier curves
-        else if (parsed[i][0] === 'Q') {
-            if (cur[0] === parsed[i][1] && cur[1] === parsed[i][2]) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(parsed[i][1], parsed[i][3], parsed[i][2], parsed[i][4]);
+        else if (instruction[0] === 'Q') {
+            if (cur[0] === instruction[1] && cur[1] === instruction[2]) {
+                const linearCurve = (0, linear_1.makeLinearPosition)(instruction[1], instruction[3], instruction[2], instruction[4]);
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
@@ -188,22 +192,22 @@ const construct = (string) => {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
-                    bx: parsed[i][1],
-                    by: parsed[i][2],
-                    cx: parsed[i][3],
-                    cy: parsed[i][4],
+                    bx: instruction[1],
+                    by: instruction[2],
+                    cx: instruction[3],
+                    cy: instruction[4],
                     dx: null,
                     dy: null,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
             }
-            cur = [parsed[i][3], parsed[i][4]];
-            prev_point = [parsed[i][1], parsed[i][2]];
+            cur = [instruction[3], instruction[4]];
+            prev_point = [instruction[1], instruction[2]];
         }
-        else if (parsed[i][0] === 'q') {
-            if (parsed[i][1] === 0 && parsed[i][2] === 0) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0] + parsed[i][1], cur[0] + parsed[i][3], cur[1] + parsed[i][2], cur[1] + parsed[i][4]);
+        else if (instruction[0] === 'q') {
+            if (instruction[1] === 0 && instruction[2] === 0) {
+                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0] + instruction[1], cur[0] + instruction[3], cur[1] + instruction[2], cur[1] + instruction[4]);
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
@@ -211,28 +215,28 @@ const construct = (string) => {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
-                    bx: cur[0] + parsed[i][1],
-                    by: cur[1] + parsed[i][2],
-                    cx: cur[0] + parsed[i][3],
-                    cy: cur[1] + parsed[i][4],
+                    bx: cur[0] + instruction[1],
+                    by: cur[1] + instruction[2],
+                    cx: cur[0] + instruction[3],
+                    cy: cur[1] + instruction[4],
                     dx: null,
                     dy: null,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
             }
-            prev_point = [cur[0] + parsed[i][1], cur[1] + parsed[i][2]];
-            cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
+            prev_point = [cur[0] + instruction[1], cur[1] + instruction[2]];
+            cur = [instruction[3] + cur[0], instruction[4] + cur[1]];
         }
-        else if (parsed[i][0] === 'T') {
+        else if (instruction[0] === 'T') {
             if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
                     bx: 2 * cur[0] - prev_point[0],
                     by: 2 * cur[1] - prev_point[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
+                    cx: instruction[1],
+                    cy: instruction[2],
                     dx: null,
                     dy: null,
                 });
@@ -240,22 +244,22 @@ const construct = (string) => {
                 length += curve.getTotalLength();
             }
             else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]);
+                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], instruction[1], cur[1], instruction[2]);
                 functions.push(linearCurve);
                 length += linearCurve.getTotalLength();
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1], parsed[i][2]];
+            cur = [instruction[1], instruction[2]];
         }
-        else if (parsed[i][0] === 't') {
+        else if (instruction[0] === 't') {
             if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
                     bx: 2 * cur[0] - prev_point[0],
                     by: 2 * cur[1] - prev_point[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
+                    cx: cur[0] + instruction[1],
+                    cy: cur[1] + instruction[2],
                     dx: null,
                     dy: null,
                 });
@@ -263,47 +267,53 @@ const construct = (string) => {
                 functions.push(curve);
             }
             else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1] + parsed[i][2]);
+                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], cur[0] + instruction[1], cur[1], cur[1] + instruction[2]);
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+            cur = [instruction[1] + cur[0], instruction[2] + cur[1]];
         }
-        else if (parsed[i][0] === 'A') {
+        else if (instruction[0] === 'A') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: parsed[i][6],
-                y1: parsed[i][7],
+                rx: instruction[1],
+                ry: instruction[2],
+                xAxisRotate: instruction[3],
+                LargeArcFlag: instruction[4] === 1,
+                SweepFlag: instruction[5] === 1,
+                x1: instruction[6],
+                y1: instruction[7],
             });
             length += arcCurve.getTotalLength();
-            cur = [parsed[i][6], parsed[i][7]];
+            cur = [instruction[6], instruction[7]];
             functions.push(arcCurve);
         }
-        else if (parsed[i][0] === 'a') {
+        else if (instruction[0] === 'a') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: cur[0] + parsed[i][6],
-                y1: cur[1] + parsed[i][7],
+                rx: instruction[1],
+                ry: instruction[2],
+                xAxisRotate: instruction[3],
+                LargeArcFlag: instruction[4] === 1,
+                SweepFlag: instruction[5] === 1,
+                x1: cur[0] + instruction[6],
+                y1: cur[1] + instruction[7],
             });
             length += arcCurve.getTotalLength();
-            cur = [cur[0] + parsed[i][6], cur[1] + parsed[i][7]];
+            cur = [cur[0] + instruction[6], cur[1] + instruction[7]];
             functions.push(arcCurve);
         }
         partial_lengths.push(length);
     }
-    return { initial_point, length, partial_lengths, functions };
+    return {
+        segments,
+        initial_point,
+        length,
+        partial_lengths,
+        functions,
+    };
 };
 exports.construct = construct;

package/dist/helpers/parse.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (path: string) => [string, ...number[]][];
-export default _default;
+export declare type Instruction = [string, ...number[]];
+export declare const parsePath: (path: string) => Instruction[];

package/dist/helpers/parse.js

@@ -1,6 +1,7 @@
 "use strict";
 // Copied from: https://github.com/rveciana/svg-path-properties
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePath = void 0;
 const length = {
     a: 7,
     c: 6,
@@ -15,7 +16,7 @@ const length = {
 };
 const segmentRegExp = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
 const numberRegExp = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
-exports.default = (path) => {
+const parsePath = (path) => {
     const segments = (path && path.length > 0 ? path : 'M0,0').match(segmentRegExp);
     if (!segments) {
         throw new Error(`No path elements found in string ${path}`);
@@ -43,6 +44,7 @@ exports.default = (path) => {
         return segmentsArray;
     }, []);
 };
+exports.parsePath = parsePath;
 const parseValues = (args) => {
     const numbers = args.match(numberRegExp);
     return numbers ? numbers.map(Number) : [];

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { extendViewBox } from './extend-viewbox';
 export { getLength } from './get-length';
 export { getParts } from './get-parts';
 export { getPointAtLength } from './get-point-at-length';
+export { getSubpaths } from './get-subpaths';
 export { getTangentAtLength } from './get-tangent-at-length';
 export { Part } from './helpers/types';
 export { interpolatePath } from './interpolate-path';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reversePath = exports.normalizePath = exports.interpolatePath = exports.getTangentAtLength = exports.getPointAtLength = exports.getParts = exports.getLength = exports.extendViewBox = exports.evolvePath = void 0;
+exports.reversePath = exports.normalizePath = exports.interpolatePath = exports.getTangentAtLength = exports.getSubpaths = exports.getPointAtLength = exports.getParts = exports.getLength = exports.extendViewBox = exports.evolvePath = void 0;
 var evolve_path_1 = require("./evolve-path");
 Object.defineProperty(exports, "evolvePath", { enumerable: true, get: function () { return evolve_path_1.evolvePath; } });
 var extend_viewbox_1 = require("./extend-viewbox");
@@ -11,6 +11,8 @@ var get_parts_1 = require("./get-parts");
 Object.defineProperty(exports, "getParts", { enumerable: true, get: function () { return get_parts_1.getParts; } });
 var get_point_at_length_1 = require("./get-point-at-length");
 Object.defineProperty(exports, "getPointAtLength", { enumerable: true, get: function () { return get_point_at_length_1.getPointAtLength; } });
+var get_subpaths_1 = require("./get-subpaths");
+Object.defineProperty(exports, "getSubpaths", { enumerable: true, get: function () { return get_subpaths_1.getSubpaths; } });
 var get_tangent_at_length_1 = require("./get-tangent-at-length");
 Object.defineProperty(exports, "getTangentAtLength", { enumerable: true, get: function () { return get_tangent_at_length_1.getTangentAtLength; } });
 var interpolate_path_1 = require("./interpolate-path");

package/dist/split-parts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Splits a valid SVG path into it's parts.
+ * @param {string} path A valid SVG path
+ * @link https://remotion.dev/docs/paths/split-parts
+ */
+export declare const splitParts: (path: string) => string[];

package/dist/split-parts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitParts = void 0;
+const construct_1 = require("./helpers/construct");
+/**
+ * Splits a valid SVG path into it's parts.
+ * @param {string} path A valid SVG path
+ * @link https://remotion.dev/docs/paths/split-parts
+ */
+const splitParts = (path) => {
+    const { segments } = (0, construct_1.construct)(path);
+    return segments
+        .map((seg) => {
+        return seg.map((s) => s.join(' '));
+    })
+        .map((_s) => _s.join(' '));
+};
+exports.splitParts = splitParts;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/paths",
-	"version": "3.3.5",
+	"version": "3.3.7",
 	"description": "Utility functions for SVG paths",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -35,5 +35,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "0a2d5f0ff4f2abf11b9a5a6d41c1ce8df67df63f"
+	"gitHead": "5a9310dd3db431e7a3e2eb2e2b3c508bbc7b258a"
 }