@remotion/paths 4.0.166 → 4.0.168

package/dist/cut-instruction.d.ts

@@ -0,0 +1,11 @@
+import type { CInstruction, Point, ReducedInstruction } from './helpers/types';
+export declare function cutCInstruction({ progress, lastPoint, instruction, }: {
+    progress: number;
+    lastPoint: Point;
+    instruction: CInstruction;
+}): CInstruction;
+export declare const cutInstruction: ({ instruction, lastPoint, progress, }: {
+    instruction: ReducedInstruction;
+    lastPoint: Point;
+    progress: number;
+}) => ReducedInstruction;

package/dist/cut-instruction.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cutInstruction = exports.cutCInstruction = void 0;
+const cutLInstruction = ({ instruction, lastPoint, progress, }) => {
+    const x = lastPoint.x + (instruction.x - lastPoint.x) * progress;
+    const y = lastPoint.y + (instruction.y - lastPoint.y) * progress;
+    return {
+        type: 'L',
+        x,
+        y,
+    };
+};
+function interpolatePoint(pA, pB, factor) {
+    return {
+        x: pA.x + (pB.x - pA.x) * factor,
+        y: pA.y + (pB.y - pA.y) * factor,
+    };
+}
+function cutCInstruction({ progress, lastPoint, instruction, }) {
+    // De Casteljau's algorithm for Bezier splitting
+    const u = progress;
+    // Points of original curve
+    const p0 = { x: lastPoint.x, y: lastPoint.y };
+    const p1 = { x: instruction.cp1x, y: instruction.cp1y };
+    const p2 = { x: instruction.cp2x, y: instruction.cp2y };
+    const p3 = { x: instruction.x, y: instruction.y };
+    // First level of interpolation
+    const p01 = interpolatePoint(p0, p1, u);
+    const p12 = interpolatePoint(p1, p2, u);
+    const p23 = interpolatePoint(p2, p3, u);
+    // Second level of interpolation
+    const p012 = interpolatePoint(p01, p12, u);
+    const p123 = interpolatePoint(p12, p23, u);
+    // Third level of interpolation (this is the mid-point of the curve at u)
+    const p0123 = interpolatePoint(p012, p123, u);
+    return {
+        type: 'C',
+        cp1x: p01.x,
+        cp1y: p01.y,
+        cp2x: p012.x,
+        cp2y: p012.y,
+        x: p0123.x,
+        y: p0123.y,
+    };
+}
+exports.cutCInstruction = cutCInstruction;
+const cutInstruction = ({ instruction, lastPoint, progress, }) => {
+    if (instruction.type === 'M') {
+        return instruction;
+    }
+    if (instruction.type === 'L') {
+        return cutLInstruction({ instruction, lastPoint, progress });
+    }
+    if (instruction.type === 'C') {
+        return cutCInstruction({ instruction, lastPoint, progress });
+    }
+    // TODO: Could we cut it as well?
+    if (instruction.type === 'Z') {
+        return instruction;
+    }
+    // @ts-expect-error
+    throw new TypeError(`${instruction.type} is not supported.`);
+};
+exports.cutInstruction = cutInstruction;

package/dist/cut-path.d.ts

@@ -0,0 +1 @@
+export declare const cutPath: (d: string, length: number) => string;

package/dist/cut-path.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cutPath = void 0;
+const cut_instruction_1 = require("./cut-instruction");
+const reduced_analysis_1 = require("./helpers/reduced-analysis");
+const parse_path_1 = require("./parse-path");
+const reduce_instructions_1 = require("./reduce-instructions");
+const serialize_instructions_1 = require("./serialize-instructions");
+const cutPath = (d, length) => {
+    const parsed = (0, parse_path_1.parsePath)(d);
+    const reduced = (0, reduce_instructions_1.reduceInstructions)(parsed);
+    const constructed = (0, reduced_analysis_1.conductAnalysis)(reduced);
+    const newInstructions = [];
+    let summedUpLength = 0;
+    for (const segment of constructed) {
+        for (const instructionAndInfo of segment.instructionsAndInfo) {
+            if (summedUpLength + instructionAndInfo.length > length) {
+                const remainingLength = length - summedUpLength;
+                const progress = remainingLength / instructionAndInfo.length;
+                // cut
+                const cut = (0, cut_instruction_1.cutInstruction)({
+                    instruction: instructionAndInfo.instruction,
+                    lastPoint: instructionAndInfo.startPoint,
+                    progress,
+                });
+                newInstructions.push(cut);
+                return (0, serialize_instructions_1.serializeInstructions)(newInstructions);
+            }
+            summedUpLength += instructionAndInfo.length;
+            newInstructions.push(instructionAndInfo.instruction);
+            if (summedUpLength === length) {
+                return (0, serialize_instructions_1.serializeInstructions)(newInstructions);
+            }
+        }
+    }
+    return (0, serialize_instructions_1.serializeInstructions)(newInstructions);
+};
+exports.cutPath = cutPath;

package/dist/evolve-path.js

@@ -10,6 +10,17 @@ const get_length_1 = require("./get-length");
  */
 const evolvePath = (progress, path) => {
     const length = (0, get_length_1.getLength)(path);
+    if (progress === 0) {
+        // Because Remotion has not the same rounding as the browser, the length may be a bit too short.
+        // This causes a browser artifact https://github.com/remotion-dev/remotion/issues/3960
+        // But any line inbetween length and length * 2 will be invisible.
+        // So we just select the middle I guess!
+        const extendedLength = length * 1.5;
+        return {
+            strokeDasharray: `${extendedLength} ${extendedLength}`,
+            strokeDashoffset: extendedLength,
+        };
+    }
     const strokeDasharray = `${length} ${length}`;
     const strokeDashoffset = length - progress * length;
     return { strokeDasharray, strokeDashoffset };

package/dist/get-bounding-box.js

@@ -133,25 +133,6 @@ const getBoundingBoxFromInstructions = (instructions) => {
                 y = seg.y;
                 break;
             }
-            case 'Q': {
-                const qxMinMax = minmaxQ([x, seg.cpx, seg.x]);
-                if (minX > qxMinMax[0]) {
-                    minX = qxMinMax[0];
-                }
-                if (maxX < qxMinMax[1]) {
-                    maxX = qxMinMax[1];
-                }
-                const qyMinMax = minmaxQ([y, seg.cpy, seg.y]);
-                if (minY > qyMinMax[0]) {
-                    minY = qyMinMax[0];
-                }
-                if (maxY < qyMinMax[1]) {
-                    maxY = qyMinMax[1];
-                }
-                x = seg.x;
-                y = seg.y;
-                break;
-            }
             case 'Z':
                 x = lastMoveX;
                 y = lastMoveY;
@@ -179,7 +160,7 @@ exports.getBoundingBoxFromInstructions = getBoundingBoxFromInstructions;
  */
 const getBoundingBox = (d) => {
     const parsed = (0, parse_path_1.parsePath)(d);
-    const unarced = (0, remove_a_s_t_curves_1.removeATSHVInstructions)((0, normalize_path_1.normalizeInstructions)(parsed));
+    const unarced = (0, remove_a_s_t_curves_1.removeATSHVQInstructions)((0, normalize_path_1.normalizeInstructions)(parsed));
     return (0, exports.getBoundingBoxFromInstructions)(unarced);
 };
 exports.getBoundingBox = getBoundingBox;

package/dist/helpers/convert-q-to-c-instruction.d.ts

@@ -0,0 +1,2 @@
+import type { CInstruction, Point, QInstruction } from './types';
+export declare const convertQToCInstruction: (instruction: QInstruction, startPoint: Point) => CInstruction;

package/dist/helpers/convert-q-to-c-instruction.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertQToCInstruction = void 0;
+const convertQToCInstruction = (instruction, startPoint) => {
+    const cp1x = startPoint.x + (2 / 3) * (instruction.cpx - startPoint.x);
+    const cp1y = startPoint.y + (2 / 3) * (instruction.cpy - startPoint.y);
+    const cp2x = instruction.x + (2 / 3) * (instruction.cpx - instruction.x);
+    const cp2y = instruction.y + (2 / 3) * (instruction.cpy - instruction.y);
+    return {
+        type: 'C',
+        cp1x,
+        cp1y,
+        cp2x,
+        cp2y,
+        x: instruction.x,
+        y: instruction.y,
+    };
+};
+exports.convertQToCInstruction = convertQToCInstruction;

package/dist/helpers/iterate.d.ts

@@ -1,9 +1,9 @@
-import type { AbsoluteInstruction, ReducedInstruction } from './types';
-export declare const iterateOverSegments: <T extends ReducedInstruction>({ segments, iterate, }: {
-    segments: AbsoluteInstruction[];
+import type { AbsoluteInstruction, QInstruction, ReducedInstruction } from './types';
+export declare const iterateOverSegments: <T extends QInstruction | ReducedInstruction>({ segments, iterate, }: {
+    segments: (AbsoluteInstruction | QInstruction)[];
     iterate: (options: {
-        segment: AbsoluteInstruction;
-        prevSegment: AbsoluteInstruction | null;
+        segment: AbsoluteInstruction | QInstruction;
+        prevSegment: (AbsoluteInstruction | QInstruction) | null;
         x: number;
         y: number;
         initialX: number;

package/dist/helpers/reduced-analysis.d.ts

@@ -0,0 +1,13 @@
+import type { Point, Properties, ReducedInstruction } from './types';
+type SegmentInstruction = {
+    function: Properties | null;
+    length: number;
+    instruction: ReducedInstruction;
+    startPoint: Point;
+};
+type Segment = {
+    startPoint: Point;
+    instructionsAndInfo: SegmentInstruction[];
+};
+export declare const conductAnalysis: (instructions: ReducedInstruction[]) => Segment[];
+export {};

package/dist/helpers/reduced-analysis.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conductAnalysis = void 0;
+const bezier_1 = require("./bezier");
+const linear_1 = require("./linear");
+const conductAnalysis = (instructions) => {
+    let currentPoint = { x: 0, y: 0 };
+    let moveStart = { x: 0, y: 0 };
+    const segments = [];
+    for (let i = 0; i < instructions.length; i++) {
+        const instruction = instructions[i];
+        // moveTo
+        if (instruction.type === 'M') {
+            currentPoint = { x: instruction.x, y: instruction.y };
+            moveStart = { x: currentPoint.x, y: currentPoint.y };
+            segments.push({
+                startPoint: { x: instruction.x, y: instruction.y },
+                instructionsAndInfo: [
+                    {
+                        instruction,
+                        function: null,
+                        length: 0,
+                        startPoint: currentPoint,
+                    },
+                ],
+            });
+        }
+        if (instruction.type === 'L') {
+            if (segments.length > 0) {
+                const length = Math.sqrt((currentPoint.x - instruction.x) ** 2 +
+                    (currentPoint.y - instruction.y) ** 2);
+                segments[segments.length - 1].instructionsAndInfo.push({
+                    instruction,
+                    length,
+                    function: (0, linear_1.makeLinearPosition)({
+                        x0: currentPoint.x,
+                        x1: instruction.x,
+                        y0: currentPoint.y,
+                        y1: instruction.y,
+                    }),
+                    startPoint: currentPoint,
+                });
+            }
+            currentPoint = { x: instruction.x, y: instruction.y };
+        }
+        if (instruction.type === 'Z') {
+            if (segments.length > 0) {
+                const length = Math.sqrt((segments[segments.length - 1].startPoint.x - currentPoint.x) ** 2 +
+                    (segments[segments.length - 1].startPoint.y - currentPoint.y) ** 2);
+                segments[segments.length - 1].instructionsAndInfo.push({
+                    instruction,
+                    function: (0, linear_1.makeLinearPosition)({
+                        x0: currentPoint.x,
+                        x1: moveStart.x,
+                        y0: currentPoint.y,
+                        y1: moveStart.y,
+                    }),
+                    length,
+                    startPoint: { ...currentPoint },
+                });
+            }
+            currentPoint = { x: moveStart.x, y: moveStart.y };
+        }
+        if (instruction.type === 'C') {
+            const curve = (0, bezier_1.makeCubic)({
+                startX: currentPoint.x,
+                startY: currentPoint.y,
+                cp1x: instruction.cp1x,
+                cp1y: instruction.cp1y,
+                cp2x: instruction.cp2x,
+                cp2y: instruction.cp2y,
+                x: instruction.x,
+                y: instruction.y,
+            });
+            const length = curve.getTotalLength();
+            if (segments.length > 0) {
+                segments[segments.length - 1].instructionsAndInfo.push({
+                    instruction,
+                    length,
+                    function: curve,
+                    startPoint: { ...currentPoint },
+                });
+            }
+            currentPoint = { x: instruction.x, y: instruction.y };
+        }
+    }
+    return segments;
+};
+exports.conductAnalysis = conductAnalysis;

package/dist/helpers/remove-a-s-t-curves.d.ts

@@ -1,2 +1,2 @@
 import type { AbsoluteInstruction, ReducedInstruction } from './types';
-export declare const removeATSHVInstructions: (segments: AbsoluteInstruction[]) => ReducedInstruction[];
+export declare const removeATSHVQInstructions: (segments: AbsoluteInstruction[]) => ReducedInstruction[];

package/dist/helpers/remove-a-s-t-curves.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeATSHVInstructions = void 0;
+exports.removeATSHVQInstructions = void 0;
+const convert_q_to_c_instruction_1 = require("./convert-q-to-c-instruction");
 const iterate_1 = require("./iterate");
 const TAU = Math.PI * 2;
 function approximate_unit_arc(theta1, delta_theta) {
@@ -157,7 +158,7 @@ function arcToCircle({ x1, y1, x2, y2, largeArcFlag, sweepFlag, rx, ry, phi, })
     });
 }
 // Requires path to be normalized
-const removeATSHVInstructions = (segments) => {
+const removeATSHVQInstructions = (segments) => {
     return (0, iterate_1.iterateOverSegments)({
         segments,
         iterate: ({ segment, prevSegment, x, y, cpX, cpY }) => {
@@ -223,13 +224,13 @@ const removeATSHVInstructions = (segments) => {
                 const newControlX = x - vectorX;
                 const newControlY = y - vectorY;
                 return [
-                    {
+                    (0, convert_q_to_c_instruction_1.convertQToCInstruction)({
                         type: 'Q',
                         cpx: newControlX,
                         cpy: newControlY,
                         x: segment.x,
                         y: segment.y,
-                    },
+                    }, { x, y }),
                 ];
             }
             if (segment.type === 'S') {
@@ -264,8 +265,11 @@ const removeATSHVInstructions = (segments) => {
                     },
                 ];
             }
+            if (segment.type === 'Q') {
+                return [(0, convert_q_to_c_instruction_1.convertQToCInstruction)(segment, { x, y })];
+            }
             return [segment];
         },
     });
 };
-exports.removeATSHVInstructions = removeATSHVInstructions;
+exports.removeATSHVQInstructions = removeATSHVQInstructions;

package/dist/helpers/types.d.ts

@@ -54,8 +54,8 @@ export type QInstruction = {
 export type ZInstruction = {
     type: 'Z';
 };
-export type ReducedInstruction = MInstruction | LInstruction | CInstruction | QInstruction | ZInstruction;
-export type AbsoluteInstruction = ReducedInstruction | {
+export type ReducedInstruction = MInstruction | LInstruction | CInstruction | ZInstruction;
+export type AbsoluteInstruction = ReducedInstruction | QInstruction | {
     type: 'A';
     rx: number;
     ry: number;

package/dist/index.d.ts

@@ -23,4 +23,5 @@ export declare const PathInternals: {
         d: string;
         color: string;
     }[];
+    cutPath: (d: string, length: number) => string;
 };

package/dist/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathInternals = exports.warpPath = exports.translatePath = exports.serializeInstructions = exports.scalePath = exports.reversePath = exports.resetPath = exports.reduceInstructions = exports.parsePath = exports.normalizePath = exports.interpolatePath = exports.getTangentAtLength = exports.getSubpaths = exports.getPointAtLength = exports.getLength = exports.getInstructionIndexAtLength = exports.getBoundingBox = exports.extendViewBox = exports.evolvePath = void 0;
-const get_bounding_box_1 = require("./get-bounding-box");
+const cut_path_1 = require("./cut-path");
 const debug_path_1 = require("./debug-path");
+const get_bounding_box_1 = require("./get-bounding-box");
 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");
@@ -42,4 +43,5 @@ Object.defineProperty(exports, "warpPath", { enumerable: true, get: function ()
 exports.PathInternals = {
     getBoundingBoxFromInstructions: get_bounding_box_1.getBoundingBoxFromInstructions,
     debugPath: debug_path_1.debugPath,
+    cutPath: cut_path_1.cutPath,
 };

package/dist/interpolate-path/convert-to-same-instruction-type.js

@@ -26,43 +26,8 @@ const convertToCCommand = (command, currentPoint) => {
             y: command.y,
         };
     }
-    if (command.type === 'Q') {
-        return {
-            type: 'C',
-            cp1x: command.cpx,
-            cp1y: command.cpy,
-            cp2x: command.cpx,
-            cp2y: command.cpy,
-            x: command.x,
-            y: command.y,
-        };
-    }
     throw new Error('all types should be handled');
 };
-const convertToQCommand = (command) => {
-    if (command.type === 'M' || command.type === 'Q' || command.type === 'Z') {
-        throw new Error('unexpected');
-    }
-    if (command.type === 'C') {
-        return {
-            type: 'Q',
-            cpx: command.cp1x,
-            cpy: command.cp1y,
-            x: command.x,
-            y: command.y,
-        };
-    }
-    if (command.type === 'L') {
-        return {
-            type: 'Q',
-            cpx: command.x,
-            cpy: command.y,
-            x: command.x,
-            y: command.y,
-        };
-    }
-    throw new Error('unhandled');
-};
 /**
  * Converts command A to have the same type as command B.
  *
@@ -96,9 +61,6 @@ function convertToSameInstructionType(aCommand, bCommand, currentPoint) {
     if (bCommand.type === 'L') {
         return convertToLCommand(aCommand);
     }
-    if (bCommand.type === 'Q') {
-        return convertToQCommand(aCommand);
-    }
     if (bCommand.type === 'Z') {
         return {
             type: 'Z',

package/dist/interpolate-path/interpolate-instruction-of-same-kind.d.ts

@@ -1,2 +1,2 @@
-import type { CInstruction, LInstruction, MInstruction, QInstruction, ReducedInstruction, ZInstruction } from '../helpers/types';
-export declare const interpolateInstructionOfSameKind: (t: number, first: ReducedInstruction, second: ReducedInstruction) => LInstruction | CInstruction | MInstruction | QInstruction | ZInstruction;
+import type { CInstruction, LInstruction, MInstruction, ReducedInstruction, ZInstruction } from '../helpers/types';
+export declare const interpolateInstructionOfSameKind: (t: number, first: ReducedInstruction, second: ReducedInstruction) => LInstruction | CInstruction | MInstruction | ZInstruction;

package/dist/interpolate-path/interpolate-instruction-of-same-kind.js

@@ -19,15 +19,6 @@ const interpolateCInstructions = (t, first, second) => {
         y: (1 - t) * first.y + t * second.y,
     };
 };
-const interpolateQInstructions = (t, first, second) => {
-    return {
-        type: 'Q',
-        cpx: (1 - t) * first.cpx + t * second.cpx,
-        cpy: (1 - t) * first.cpy + t * second.cpy,
-        x: (1 - t) * first.x + t * second.x,
-        y: (1 - t) * first.y + t * second.y,
-    };
-};
 const interpolateMInstructions = (t, first, second) => {
     return {
         type: 'M',
@@ -48,12 +39,6 @@ const interpolateInstructionOfSameKind = (t, first, second) => {
         }
         return interpolateCInstructions(t, first, second);
     }
-    if (first.type === 'Q') {
-        if (second.type !== 'Q') {
-            throw new Error('mismatch');
-        }
-        return interpolateQInstructions(t, first, second);
-    }
     if (first.type === 'M') {
         if (second.type !== 'M') {
             throw new Error('mismatch');

package/dist/interpolate-path/points-to-command.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pointsToInstruction = void 0;
+const convert_q_to_c_instruction_1 = require("../helpers/convert-q-to-c-instruction");
 /**
  * Convert segments represented as points back into a command object
  *
@@ -29,13 +30,16 @@ function pointsToInstruction(points) {
     if (points.length === 3) {
         const x1 = points[1][0];
         const y1 = points[1][1];
-        return {
+        return (0, convert_q_to_c_instruction_1.convertQToCInstruction)({
             type: 'Q',
             cpx: x1,
             cpy: y1,
             x,
             y,
-        };
+        }, {
+            x: points[0][0],
+            y: points[0][1],
+        });
     }
     return {
         type: 'L',

package/dist/interpolate-path/split-segment.js

@@ -17,9 +17,7 @@ const split_curve_1 = require("./split-curve");
 function splitSegmentInstructions(commandStart, commandEnd, segmentCount) {
     let segments = [];
     // line, quadratic bezier, or cubic bezier
-    if (commandEnd.type === 'L' ||
-        commandEnd.type === 'Q' ||
-        commandEnd.type === 'C') {
+    if (commandEnd.type === 'L' || commandEnd.type === 'C') {
         if (commandStart.type !== 'Z') {
             segments = segments.concat((0, split_curve_1.splitCurveInstructions)(commandStart.x, commandStart.y, commandEnd, segmentCount));
         }

package/dist/reduce-instructions.js

@@ -10,6 +10,6 @@ const normalize_path_1 = require("./normalize-path");
  */
 const reduceInstructions = (instruction) => {
     const simplified = (0, normalize_path_1.normalizeInstructions)(instruction);
-    return (0, remove_a_s_t_curves_1.removeATSHVInstructions)(simplified);
+    return (0, remove_a_s_t_curves_1.removeATSHVQInstructions)(simplified);
 };
 exports.reduceInstructions = reduceInstructions;

package/dist/warp-path/warp-helpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixZInstruction = exports.warpTransform = exports.svgPathInterpolate = void 0;
+const convert_q_to_c_instruction_1 = require("../helpers/convert-q-to-c-instruction");
 const euclideanDistance = (points) => {
     const startPoint = points[0];
     const endPoint = points[points.length - 1];
@@ -65,13 +66,16 @@ function createLineSegment(points) {
                 y: points[1][1],
             };
         case 3:
-            return {
+            return (0, convert_q_to_c_instruction_1.convertQToCInstruction)({
                 type: 'Q',
                 cpx: points[1][0],
                 cpy: points[1][1],
                 x: points[2][0],
                 y: points[2][1],
-            };
+            }, {
+                x: points[0][0],
+                y: points[0][1],
+            });
         case 4:
             return {
                 type: 'C',
@@ -104,13 +108,7 @@ function warpInterpolate(path, threshold, deltaFunction) {
         if (segment.type === 'L') {
             points.push([segment.x, segment.y]);
         }
-        if (segment.type === 'Q') {
-            points.push([segment.cpx, segment.cpy]);
-            points.push([segment.x, segment.y]);
-        }
-        if (segment.type === 'C' ||
-            segment.type === 'Q' ||
-            segment.type === 'L') {
+        if (segment.type === 'C' || segment.type === 'L') {
             return interpolateUntil(points, threshold, deltaFunction).map((rawSegment) => createLineSegment(rawSegment));
         }
         return [segment];
@@ -144,22 +142,6 @@ const warpTransform = (path, transformer) => {
                 },
             ];
         }
-        if (segment.type === 'Q') {
-            const { x, y } = transformer({ x: segment.x, y: segment.y });
-            const { x: cpx, y: cpy } = transformer({
-                x: segment.cpx,
-                y: segment.cpy,
-            });
-            return [
-                {
-                    type: 'Q',
-                    x,
-                    y,
-                    cpx,
-                    cpy,
-                },
-            ];
-        }
         if (segment.type === 'C') {
             const { x, y } = transformer({ x: segment.x, y: segment.y });
             const { x: cp1x, y: cp1y } = transformer({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/paths",
-  "version": "4.0.166",
+  "version": "4.0.168",
   "description": "Utility functions for SVG paths",
   "main": "dist/index.js",
   "sideEffects": false,

package/dist/helpers/split-curve.d.ts

@@ -1,47 +0,0 @@
-/**
- * List of params for each command type in a path `d` attribute
- */
-export declare const typeMap: {
-    M: string[];
-    L: string[];
-    H: string[];
-    V: string[];
-    C: string[];
-    S: string[];
-    Q: string[];
-    T: string[];
-    A: string[];
-    Z: never[];
-    m: string[];
-    l: string[];
-    h: string[];
-    v: string[];
-    c: string[];
-    s: string[];
-    q: string[];
-    t: string[];
-    a: string[];
-    z: never[];
-};
-export type Command = {
-    x2?: number | undefined;
-    y2?: number | undefined;
-    x1?: number | undefined;
-    y1?: number | undefined;
-    x?: number;
-    y?: number;
-    xAxisRotate?: number;
-    largeArcFlag?: boolean;
-    sweepFlag?: boolean;
-    type: keyof typeof typeMap;
-};
-/**
- * Convert command objects to arrays of points, run de Casteljau's algorithm on it
- * to split into to the desired number of segments.
- *
- * @param {Object} commandStart The start command object
- * @param {Object} commandEnd The end command object
- * @param {Number} segmentCount The number of segments to create
- * @return {Object[]} An array of commands representing the segments in sequence
- */
-export declare const splitCurve: (commandStart: Command, commandEnd: Command, segmentCount: number) => Command[];