@remotion/paths 4.0.83 → 4.0.85

package/dist/get-instruction-index-at-length.d.ts

@@ -0,0 +1,8 @@
+import type { Constructed } from './helpers/construct';
+type InstructionAtLength = {
+    index: number;
+    lengthIntoInstruction: number;
+};
+export declare const getInstructionIndexAtLengthFromConstructed: (constructed: Constructed, fractionLength: number) => InstructionAtLength;
+export declare const getInstructionIndexAtLength: (path: string, length: number) => InstructionAtLength;
+export {};

package/dist/get-instruction-index-at-length.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstructionIndexAtLength = exports.getInstructionIndexAtLengthFromConstructed = void 0;
+const construct_1 = require("./helpers/construct");
+const getInstructionIndexAtLengthFromConstructed = (constructed, fractionLength) => {
+    if (fractionLength < 0) {
+        throw new Error('Length less than 0 was passed');
+    }
+    if (fractionLength > constructed.totalLength) {
+        fractionLength = constructed.totalLength;
+    }
+    let index = constructed.partialLengths.length - 1;
+    while (constructed.partialLengths[index] >= fractionLength && index > 0) {
+        index--;
+    }
+    return {
+        lengthIntoInstruction: fractionLength - constructed.partialLengths[index],
+        index,
+    };
+};
+exports.getInstructionIndexAtLengthFromConstructed = getInstructionIndexAtLengthFromConstructed;
+const getInstructionIndexAtLength = (path, length) => {
+    const constructed = (0, construct_1.construct)(path);
+    if (length > constructed.totalLength) {
+        throw new Error(`A length of ${length} was passed to getInstructionIndexAtLength() but the total length of the path is only ${constructed.totalLength}`);
+    }
+    return (0, exports.getInstructionIndexAtLengthFromConstructed)(constructed, length);
+};
+exports.getInstructionIndexAtLength = getInstructionIndexAtLength;

package/dist/get-length.js

@@ -10,6 +10,6 @@ const construct_1 = require("./helpers/construct");
  */
 const getLength = (path) => {
     const constructucted = (0, construct_1.construct)(path);
-    return constructucted.length;
+    return constructucted.totalLength;
 };
 exports.getLength = getLength;

package/dist/get-point-at-length.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPointAtLength = void 0;
+const get_instruction_index_at_length_1 = require("./get-instruction-index-at-length");
 const construct_1 = require("./helpers/construct");
-const get_part_at_length_1 = require("./helpers/get-part-at-length");
 /**
  * @description Gets the coordinates of a point which is on an SVG path.
  * @param {string} path A valid SVG path
@@ -11,13 +11,13 @@ const get_part_at_length_1 = require("./helpers/get-part-at-length");
  */
 const getPointAtLength = (path, length) => {
     const constructed = (0, construct_1.construct)(path);
-    const fractionPart = (0, get_part_at_length_1.getPartAtLength)(path, length);
-    const functionAtPart = constructed.functions[fractionPart.i];
+    const fractionPart = (0, get_instruction_index_at_length_1.getInstructionIndexAtLengthFromConstructed)(constructed, length);
+    const functionAtPart = constructed.functions[fractionPart.index + 1];
     if (functionAtPart) {
-        return functionAtPart.getPointAtLength(fractionPart.fraction);
+        return functionAtPart.getPointAtLength(fractionPart.lengthIntoInstruction);
     }
-    if (constructed.initial_point) {
-        return constructed.initial_point;
+    if (constructed.initialPoint) {
+        return constructed.initialPoint;
     }
     throw new Error('Wrong function at this part.');
 };

package/dist/get-tangent-at-length.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTangentAtLength = void 0;
+const get_instruction_index_at_length_1 = require("./get-instruction-index-at-length");
 const construct_1 = require("./helpers/construct");
-const get_part_at_length_1 = require("./helpers/get-part-at-length");
 /**
  * @description Gets tangent values x and y of a point which is on an SVG path
  * @param {string} path A valid SVG path
@@ -11,12 +11,12 @@ const get_part_at_length_1 = require("./helpers/get-part-at-length");
  */
 const getTangentAtLength = (path, length) => {
     const constructed = (0, construct_1.construct)(path);
-    const fractionPart = (0, get_part_at_length_1.getPartAtLength)(path, length);
-    const functionAtPart = constructed.functions[fractionPart.i];
+    const fractionPart = (0, get_instruction_index_at_length_1.getInstructionIndexAtLengthFromConstructed)(constructed, length);
+    const functionAtPart = constructed.functions[fractionPart.index + 1];
     if (functionAtPart) {
-        return functionAtPart.getTangentAtLength(fractionPart.fraction);
+        return functionAtPart.getTangentAtLength(fractionPart.lengthIntoInstruction);
     }
-    if (constructed.initial_point) {
+    if (constructed.initialPoint) {
         return { x: 0, y: 0 };
     }
     throw new Error('Wrong function at this part.');

package/dist/helpers/arc.js

@@ -165,9 +165,6 @@ const makeArc = ({ x0, y0, rx, ry, xAxisRotate, LargeArcFlag, SweepFlag, x1, y1,
         });
     });
     const length = lengthProperties.arcLength;
-    const getTotalLength = () => {
-        return length;
-    };
     const getPointAtLength = (fractionLength) => {
         if (fractionLength < 0) {
             fractionLength = 0;
@@ -187,40 +184,41 @@ const makeArc = ({ x0, y0, rx, ry, xAxisRotate, LargeArcFlag, SweepFlag, x1, y1,
         });
         return { x: position.x, y: position.y };
     };
-    const getTangentAtLength = (fractionLength) => {
-        if (fractionLength < 0) {
-            fractionLength = 0;
-        }
-        else if (fractionLength > length) {
-            fractionLength = length;
-        }
-        const point_dist = 0.05; // needs testing
-        const p1 = getPointAtLength(fractionLength);
-        let p2;
-        if (fractionLength < 0) {
-            fractionLength = 0;
-        }
-        else if (fractionLength > length) {
-            fractionLength = length;
-        }
-        if (fractionLength < length - point_dist) {
-            p2 = getPointAtLength(fractionLength + point_dist);
-        }
-        else {
-            p2 = getPointAtLength(fractionLength - point_dist);
-        }
-        const xDist = p2.x - p1.x;
-        const yDist = p2.y - p1.y;
-        const dist = Math.sqrt(xDist * xDist + yDist * yDist);
-        if (fractionLength < length - point_dist) {
-            return { x: -xDist / dist, y: -yDist / dist };
-        }
-        return { x: xDist / dist, y: yDist / dist };
-    };
     return {
         getPointAtLength,
-        getTangentAtLength,
-        getTotalLength,
+        getTangentAtLength: (fractionLength) => {
+            if (fractionLength < 0) {
+                fractionLength = 0;
+            }
+            else if (fractionLength > length) {
+                fractionLength = length;
+            }
+            const point_dist = 0.05; // needs testing
+            const p1 = getPointAtLength(fractionLength);
+            let p2;
+            if (fractionLength < 0) {
+                fractionLength = 0;
+            }
+            else if (fractionLength > length) {
+                fractionLength = length;
+            }
+            if (fractionLength < length - point_dist) {
+                p2 = getPointAtLength(fractionLength + point_dist);
+            }
+            else {
+                p2 = getPointAtLength(fractionLength - point_dist);
+            }
+            const xDist = p2.x - p1.x;
+            const yDist = p2.y - p1.y;
+            const dist = Math.sqrt(xDist * xDist + yDist * yDist);
+            if (fractionLength < length - point_dist) {
+                return { x: -xDist / dist, y: -yDist / dist };
+            }
+            return { x: xDist / dist, y: yDist / dist };
+        },
+        getTotalLength: () => {
+            return length;
+        },
         type: 'arc',
     };
 };

package/dist/helpers/construct.d.ts

@@ -1,15 +1,10 @@
 import type { Instruction, Point, Properties } from './types';
-export declare const constructFromInstructions: (instructions: Instruction[]) => {
+export type Constructed = {
     segments: Instruction[][];
-    initial_point: Point | null;
-    length: number;
-    partial_lengths: number[];
-    functions: (Properties | null)[];
-};
-export declare const construct: (string: string) => {
-    segments: Instruction[][];
-    initial_point: Point | null;
-    length: number;
-    partial_lengths: number[];
+    initialPoint: Point | null;
+    totalLength: number;
+    partialLengths: number[];
     functions: (Properties | null)[];
 };
+export declare const constructFromInstructions: (instructions: Instruction[]) => Constructed;
+export declare const construct: (string: string) => Constructed;

package/dist/helpers/construct.js

@@ -7,10 +7,10 @@ const arc_1 = require("./arc");
 const bezier_1 = require("./bezier");
 const linear_1 = require("./linear");
 const constructFromInstructions = (instructions) => {
-    let length = 0;
-    const partial_lengths = [];
+    let totalLength = 0;
+    const partialLengths = [];
     const functions = [];
-    let initial_point = null;
+    let initialPoint = null;
     let cur = [0, 0];
     let prev_point = [0, 0];
     let curve;
@@ -30,18 +30,18 @@ const constructFromInstructions = (instructions) => {
             segments.push([instruction]);
             functions.push(null);
             if (i === 0) {
-                initial_point = { x: instruction.x, y: instruction.y };
+                initialPoint = { x: instruction.x, y: instruction.y };
             }
         }
-        else if (instruction.type === 'm') {
+        if (instruction.type === 'm') {
             cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
             ringStart = [cur[0], cur[1]];
             segments.push([{ type: 'M', x: cur[0], y: cur[1] }]);
             functions.push(null);
             // lineTo
         }
-        else if (instruction.type === 'L') {
-            length += Math.sqrt((cur[0] - instruction.x) ** 2 + (cur[1] - instruction.y) ** 2);
+        if (instruction.type === 'L') {
+            totalLength += Math.sqrt((cur[0] - instruction.x) ** 2 + (cur[1] - instruction.y) ** 2);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: instruction.x,
@@ -50,8 +50,8 @@ const constructFromInstructions = (instructions) => {
             }));
             cur = [instruction.x, instruction.y];
         }
-        else if (instruction.type === 'l') {
-            length += Math.sqrt(instruction.dx ** 2 + instruction.dy ** 2);
+        if (instruction.type === 'l') {
+            totalLength += Math.sqrt(instruction.dx ** 2 + instruction.dy ** 2);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: instruction.dx + cur[0],
@@ -60,8 +60,8 @@ const constructFromInstructions = (instructions) => {
             }));
             cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (instruction.type === 'H') {
-            length += Math.abs(cur[0] - instruction.x);
+        if (instruction.type === 'H') {
+            totalLength += Math.abs(cur[0] - instruction.x);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: instruction.x,
@@ -70,8 +70,8 @@ const constructFromInstructions = (instructions) => {
             }));
             cur[0] = instruction.x;
         }
-        else if (instruction.type === 'h') {
-            length += Math.abs(instruction.dx);
+        if (instruction.type === 'h') {
+            totalLength += Math.abs(instruction.dx);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: cur[0] + instruction.dx,
@@ -81,7 +81,7 @@ const constructFromInstructions = (instructions) => {
             cur[0] = instruction.dx + cur[0];
         }
         else if (instruction.type === 'V') {
-            length += Math.abs(cur[1] - instruction.y);
+            totalLength += Math.abs(cur[1] - instruction.y);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: cur[0],
@@ -90,8 +90,8 @@ const constructFromInstructions = (instructions) => {
             }));
             cur[1] = instruction.y;
         }
-        else if (instruction.type === 'v') {
-            length += Math.abs(instruction.dy);
+        if (instruction.type === 'v') {
+            totalLength += Math.abs(instruction.dy);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: cur[0],
@@ -102,7 +102,7 @@ const constructFromInstructions = (instructions) => {
             // Close path
         }
         else if (instruction.type === 'Z') {
-            length += Math.sqrt((ringStart[0] - cur[0]) ** 2 + (ringStart[1] - cur[1]) ** 2);
+            totalLength += Math.sqrt((ringStart[0] - cur[0]) ** 2 + (ringStart[1] - cur[1]) ** 2);
             functions.push((0, linear_1.makeLinearPosition)({
                 x0: cur[0],
                 x1: ringStart[0],
@@ -112,7 +112,7 @@ const constructFromInstructions = (instructions) => {
             cur = [ringStart[0], ringStart[1]];
             // Cubic Bezier curves
         }
-        else if (instruction.type === 'C') {
+        if (instruction.type === 'C') {
             curve = (0, bezier_1.makeCubic)({
                 startX: cur[0],
                 startY: cur[1],
@@ -123,7 +123,7 @@ const constructFromInstructions = (instructions) => {
                 x: instruction.x,
                 y: instruction.y,
             });
-            length += curve.getTotalLength();
+            totalLength += curve.getTotalLength();
             cur = [instruction.x, instruction.y];
             functions.push(curve);
         }
@@ -139,7 +139,7 @@ const constructFromInstructions = (instructions) => {
                 y: cur[1] + instruction.dy,
             });
             if (curve.getTotalLength() > 0) {
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 functions.push(curve);
                 cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
             }
@@ -147,7 +147,7 @@ const constructFromInstructions = (instructions) => {
                 functions.push((0, linear_1.makeLinearPosition)({ x0: cur[0], x1: cur[0], y0: cur[1], y1: cur[1] }));
             }
         }
-        else if (instruction.type === 'S') {
+        if (instruction.type === 'S') {
             const prev = instructions[i - 1];
             const prevWasCurve = prev.type === 'C' ||
                 prev.type === 'c' ||
@@ -181,12 +181,12 @@ const constructFromInstructions = (instructions) => {
                 });
             }
             if (curve) {
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 cur = [instruction.x, instruction.y];
                 functions.push(curve);
             }
         }
-        else if (instruction.type === 's') {
+        if (instruction.type === 's') {
             const prev = instructions[i - 1];
             const prevWasCurve = prev.type === 'C' ||
                 prev.type === 'c' ||
@@ -221,13 +221,13 @@ const constructFromInstructions = (instructions) => {
                 });
             }
             if (curve) {
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
                 functions.push(curve);
             }
         }
         // Quadratic Bezier curves
-        else if (instruction.type === 'Q') {
+        if (instruction.type === 'Q') {
             if (cur[0] === instruction.cpx && cur[1] === instruction.cpy) {
                 const linearCurve = (0, linear_1.makeLinearPosition)({
                     x0: instruction.cpx,
@@ -235,7 +235,7 @@ const constructFromInstructions = (instructions) => {
                     y0: instruction.cpy,
                     y1: instruction.y,
                 });
-                length += linearCurve.getTotalLength();
+                totalLength += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
             else {
@@ -247,13 +247,13 @@ const constructFromInstructions = (instructions) => {
                     x: instruction.x,
                     y: instruction.y,
                 });
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 functions.push(curve);
             }
             cur = [instruction.x, instruction.y];
             prev_point = [instruction.cpx, instruction.cpy];
         }
-        else if (instruction.type === 'q') {
+        if (instruction.type === 'q') {
             if (instruction.cpdx === 0 && instruction.cpdy === 0) {
                 const linearCurve = (0, linear_1.makeLinearPosition)({
                     x0: cur[0] + instruction.cpdx,
@@ -261,7 +261,7 @@ const constructFromInstructions = (instructions) => {
                     y0: cur[1] + instruction.dx,
                     y1: cur[1] + instruction.dy,
                 });
-                length += linearCurve.getTotalLength();
+                totalLength += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
             else {
@@ -273,13 +273,13 @@ const constructFromInstructions = (instructions) => {
                     x: cur[0] + instruction.dx,
                     y: cur[1] + instruction.dy,
                 });
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 functions.push(curve);
             }
             prev_point = [cur[0] + instruction.cpdx, cur[1] + instruction.cpdy];
             cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (instruction.type === 'T') {
+        if (instruction.type === 'T') {
             const prev = instructions[i - 1];
             const prevWasQ = prev.type === 'Q' ||
                 prev.type === 'q' ||
@@ -295,7 +295,7 @@ const constructFromInstructions = (instructions) => {
                     y: instruction.y,
                 });
                 functions.push(curve);
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
             }
             else {
                 const linearCurve = (0, linear_1.makeLinearPosition)({
@@ -305,12 +305,12 @@ const constructFromInstructions = (instructions) => {
                     y1: instruction.y,
                 });
                 functions.push(linearCurve);
-                length += linearCurve.getTotalLength();
+                totalLength += linearCurve.getTotalLength();
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
             cur = [instruction.x, instruction.y];
         }
-        else if (instruction.type === 't') {
+        if (instruction.type === 't') {
             const prev = instructions[i - 1];
             const prevWasQ = prev.type === 'Q' ||
                 prev.type === 'q' ||
@@ -325,7 +325,7 @@ const constructFromInstructions = (instructions) => {
                     x: cur[0] + instruction.dx,
                     y: cur[1] + instruction.dy,
                 });
-                length += curve.getTotalLength();
+                totalLength += curve.getTotalLength();
                 functions.push(curve);
             }
             else {
@@ -335,13 +335,13 @@ const constructFromInstructions = (instructions) => {
                     y0: cur[1],
                     y1: cur[1] + instruction.dy,
                 });
-                length += linearCurve.getTotalLength();
+                totalLength += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
             cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (instruction.type === 'A') {
+        if (instruction.type === 'A') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
@@ -353,11 +353,11 @@ const constructFromInstructions = (instructions) => {
                 x1: instruction.x,
                 y1: instruction.y,
             });
-            length += arcCurve.getTotalLength();
+            totalLength += arcCurve.getTotalLength();
             cur = [instruction.x, instruction.y];
             functions.push(arcCurve);
         }
-        else if (instruction.type === 'a') {
+        if (instruction.type === 'a') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
@@ -369,17 +369,17 @@ const constructFromInstructions = (instructions) => {
                 x1: cur[0] + instruction.dx,
                 y1: cur[1] + instruction.dy,
             });
-            length += arcCurve.getTotalLength();
+            totalLength += arcCurve.getTotalLength();
             cur = [cur[0] + instruction.dx, cur[1] + instruction.dy];
             functions.push(arcCurve);
         }
-        partial_lengths.push(length);
+        partialLengths.push(totalLength);
     }
     return {
         segments,
-        initial_point,
-        length,
-        partial_lengths,
+        initialPoint,
+        totalLength,
+        partialLengths,
         functions,
     };
 };

package/dist/helpers/linear.js

@@ -2,24 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLinearPosition = void 0;
 const makeLinearPosition = ({ x0, x1, y0, y1, }) => {
-    const getTotalLength = () => {
-        return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
-    };
-    const getPointAtLength = (pos) => {
-        let fraction = pos / Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
-        fraction = Number.isNaN(fraction) ? 1 : fraction;
-        const newDeltaX = (x1 - x0) * fraction;
-        const newDeltaY = (y1 - y0) * fraction;
-        return { x: x0 + newDeltaX, y: y0 + newDeltaY };
-    };
-    const getTangentAtLength = () => {
-        const module = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
-        return { x: (x1 - x0) / module, y: (y1 - y0) / module };
-    };
     return {
-        getTotalLength,
-        getPointAtLength,
-        getTangentAtLength,
+        getTotalLength: () => {
+            return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
+        },
+        getPointAtLength: (pos) => {
+            let fraction = pos / Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
+            fraction = Number.isNaN(fraction) ? 1 : fraction;
+            const newDeltaX = (x1 - x0) * fraction;
+            const newDeltaY = (y1 - y0) * fraction;
+            return { x: x0 + newDeltaX, y: y0 + newDeltaY };
+        },
+        getTangentAtLength: () => {
+            const module = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
+            return { x: (x1 - x0) / module, y: (y1 - y0) / module };
+        },
         type: 'linear',
     };
 };

package/dist/helpers/types.d.ts

@@ -2,7 +2,7 @@ export interface Properties {
     getTotalLength(): number;
     getPointAtLength(pos: number): Point;
     getTangentAtLength(pos: number): Point;
-    type: string;
+    type: 'linear' | 'cubic-bezier' | 'quadratic-bezier' | 'arc';
 }
 export interface Part {
     start: Point;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { evolvePath } from './evolve-path';
 export { extendViewBox } from './extend-viewbox';
 export { getBoundingBox } from './get-bounding-box';
+export { getInstructionIndexAtLength } from './get-instruction-index-at-length';
 export { getLength } from './get-length';
 export { getPointAtLength } from './get-point-at-length';
 export { getSubpaths } from './get-subpaths';

package/dist/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.getBoundingBox = exports.extendViewBox = exports.evolvePath = void 0;
+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;
 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");
 Object.defineProperty(exports, "extendViewBox", { enumerable: true, get: function () { return extend_viewbox_1.extendViewBox; } });
 var get_bounding_box_1 = require("./get-bounding-box");
 Object.defineProperty(exports, "getBoundingBox", { enumerable: true, get: function () { return get_bounding_box_1.getBoundingBox; } });
+var get_instruction_index_at_length_1 = require("./get-instruction-index-at-length");
+Object.defineProperty(exports, "getInstructionIndexAtLength", { enumerable: true, get: function () { return get_instruction_index_at_length_1.getInstructionIndexAtLength; } });
 var get_length_1 = require("./get-length");
 Object.defineProperty(exports, "getLength", { enumerable: true, get: function () { return get_length_1.getLength; } });
 var get_point_at_length_1 = require("./get-point-at-length");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/paths",
-  "version": "4.0.83",
+  "version": "4.0.85",
   "description": "Utility functions for SVG paths",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -16,8 +16,8 @@
     "@jonny/eslint-config": "3.0.276",
     "@types/node": "18.14.6",
     "eslint": "8.42.0",
-    "prettier": "3.0.2",
-    "prettier-plugin-organize-imports": "^3.2.2",
+    "prettier": "3.1.1",
+    "prettier-plugin-organize-imports": "3.2.4",
     "vitest": "0.31.1"
   },
   "keywords": [