@remotion/paths 4.0.167 → 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.167",
+  "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[];

package/dist/helpers/split-curve.js

@@ -1,190 +0,0 @@
-"use strict";
-/*
-
-Copied and adapted from https://github.com/pbeshai/d3-interpolate-path:
-Copyright 2016, Peter Beshai
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the author nor the names of contributors may be used to
-  endorse or promote products derived from this software without specific prior
-  written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitCurve = exports.typeMap = void 0;
-/**
- * de Casteljau's algorithm for drawing and splitting bezier curves.
- * Inspired by https://pomax.github.io/bezierinfo/
- *
- * @param {Number[][]} points Array of [x,y] points: [start, control1, control2, ..., end]
- *   The original segment to split.
- * @param {Number} t Where to split the curve (value between [0, 1])
- * @return {Object} An object { left, right } where left is the segment from 0..t and
- *   right is the segment from t..1.
- */
-function decasteljau(points, t) {
-    const left = [];
-    const right = [];
-    function decasteljauRecurse(_points, _t) {
-        if (_points.length === 1) {
-            left.push(_points[0]);
-            right.push(_points[0]);
-        }
-        else {
-            const newPoints = Array(_points.length - 1);
-            for (let i = 0; i < newPoints.length; i++) {
-                if (i === 0) {
-                    left.push(_points[0]);
-                }
-                if (i === newPoints.length - 1) {
-                    right.push(_points[i + 1]);
-                }
-                newPoints[i] = [
-                    (1 - _t) * _points[i][0] + _t * _points[i + 1][0],
-                    (1 - _t) * _points[i][1] + _t * _points[i + 1][1],
-                ];
-            }
-            decasteljauRecurse(newPoints, _t);
-        }
-    }
-    if (points.length) {
-        decasteljauRecurse(points, t);
-    }
-    return { left, right: right.reverse() };
-}
-/**
- * List of params for each command type in a path `d` attribute
- */
-exports.typeMap = {
-    M: ['x', 'y'],
-    L: ['x', 'y'],
-    H: ['x'],
-    V: ['y'],
-    C: ['x1', 'y1', 'x2', 'y2', 'x', 'y'],
-    S: ['x2', 'y2', 'x', 'y'],
-    Q: ['x1', 'y1', 'x', 'y'],
-    T: ['x', 'y'],
-    A: ['rx', 'ry', 'xAxisRotation', 'largeArcFlag', 'sweepFlag', 'x', 'y'],
-    Z: [],
-    m: ['x', 'y'],
-    l: ['x', 'y'],
-    h: ['x'],
-    v: ['y'],
-    c: ['x1', 'y1', 'x2', 'y2', 'x', 'y'],
-    s: ['x2', 'y2', 'x', 'y'],
-    q: ['x1', 'y1', 'x', 'y'],
-    t: ['x', 'y'],
-    a: ['rx', 'ry', 'xAxisRotation', 'largeArcFlag', 'sweepFlag', 'x', 'y'],
-    z: [],
-};
-/**
- * Convert segments represented as points back into a command object
- *
- * @param {Number[][]} points Array of [x,y] points: [start, control1, control2, ..., end]
- *   Represents a segment
- * @return {Object} A command object representing the segment.
- */
-function pointsToCommand(points) {
-    let x2;
-    let y2;
-    let x1;
-    let y1;
-    if (points.length === 4) {
-        x2 = points[2][0];
-        y2 = points[2][1];
-    }
-    if (points.length >= 3) {
-        x1 = points[1][0];
-        y1 = points[1][1];
-    }
-    const x = points[points.length - 1][0];
-    const y = points[points.length - 1][1];
-    let type = 'L';
-    if (points.length === 4) {
-        // start, control1, control2, end
-        type = 'C';
-    }
-    else if (points.length === 3) {
-        // start, control, end
-        type = 'Q';
-    }
-    return { x2, y2, x1, y1, x, y, type };
-}
-/**
- * Runs de Casteljau's algorithm enough times to produce the desired number of segments.
- *
- * @param {Number[][]} points Array of [x,y] points for de Casteljau (the initial segment to split)
- * @param {Number} segmentCount Number of segments to split the original into
- * @return {Number[][][]} Array of segments
- */
-function splitCurveAsPoints(points, segmentCount) {
-    segmentCount = segmentCount || 2;
-    const segments = [];
-    let remainingCurve = points;
-    const tIncrement = 1 / segmentCount;
-    // x-----x-----x-----x
-    // t=  0.33   0.66   1
-    // x-----o-----------x
-    // r=  0.33
-    //       x-----o-----x
-    // r=         0.5  (0.33 / (1 - 0.33))  === tIncrement / (1 - (tIncrement * (i - 1))
-    // x-----x-----x-----x----x
-    // t=  0.25   0.5   0.75  1
-    // x-----o----------------x
-    // r=  0.25
-    //       x-----o----------x
-    // r=         0.33  (0.25 / (1 - 0.25))
-    //             x-----o----x
-    // r=         0.5  (0.25 / (1 - 0.5))
-    for (let i = 0; i < segmentCount - 1; i++) {
-        const tRelative = tIncrement / (1 - tIncrement * i);
-        const split = decasteljau(remainingCurve, tRelative);
-        segments.push(split.left);
-        remainingCurve = split.right;
-    }
-    // last segment is just to the end from the last point
-    segments.push(remainingCurve);
-    return segments;
-}
-/**
- * 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
- */
-const splitCurve = (commandStart, commandEnd, segmentCount) => {
-    const points = [[commandStart.x, commandStart.y]];
-    if (commandEnd.x1 !== null && commandEnd.x1 !== undefined) {
-        points.push([commandEnd.x1, commandEnd.y1]);
-    }
-    if (commandEnd.x2 !== null && commandEnd.x2 !== undefined) {
-        points.push([commandEnd.x2, commandEnd.y2]);
-    }
-    points.push([commandEnd.x, commandEnd.y]);
-    return splitCurveAsPoints(points, segmentCount).map(pointsToCommand);
-};
-exports.splitCurve = splitCurve;

package/dist/interpolate-path.d.ts

@@ -1,8 +0,0 @@
-/**
- * @description Interpolates between two SVG paths.
- * @param {number} value A number - 0 means first path, 1 means second path, any other values will be interpolated
- * @param {string} firstPath The first valid SVG path
- * @param {string} secondPath The second valid SVG path
- * @see [Documentation](https://remotion.dev/docs/paths/interpolate-path)
- */
-export declare const interpolatePath: (value: number, firstPath: string, secondPath: string) => string;

package/dist/interpolate-path.js

@@ -1,366 +0,0 @@
-"use strict";
-/*
-
-Copied and adapted from https://github.com/pbeshai/d3-interpolate-path:
-Copyright 2016, Peter Beshai
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the author nor the names of contributors may be used to
-  endorse or promote products derived from this software without specific prior
-  written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolatePath = void 0;
-const split_curve_1 = require("./helpers/split-curve");
-const commandTokenRegex = /[MLCSTQAHVZmlcstqahv]|-?[\d.e+-]+/g;
-function arrayOfLength(length, value) {
-    const array = Array(length);
-    for (let i = 0; i < length; i++) {
-        array[i] = value;
-    }
-    return array;
-}
-/**
- * Converts a command object to a string to be used in a `d` attribute
- * @param {Object} command A command object
- * @return {String} The string for the `d` attribute
- */
-function commandToString(command) {
-    return `${command.type} ${split_curve_1.typeMap[command.type]
-        .map((p) => command[p])
-        .join(' ')}`;
-}
-/**
- * Converts command A to have the same type as command B.
- *
- * e.g., L0,5 -> C0,5,0,5,0,5
- *
- * Uses these rules:
- * x1 <- x
- * x2 <- x
- * y1 <- y
- * y2 <- y
- * rx <- 0
- * ry <- 0
- * xAxisRotation <- read from B
- * largeArcFlag <- read from B
- * sweepflag <- read from B
- *
- * @param {Object} aCommand Command object from path `d` attribute
- * @param {Object} bCommand Command object from path `d` attribute to match against
- * @return {Object} aCommand converted to type of bCommand
- */
-function convertToSameType(aCommand, bCommand) {
-    const conversionMap = {
-        x1: 'x',
-        y1: 'y',
-        x2: 'x',
-        y2: 'y',
-    };
-    const readFromBKeys = ['xAxisRotation', 'largeArcFlag', 'sweepFlag'];
-    // convert (but ignore M types)
-    if (aCommand.type !== bCommand.type && bCommand.type.toUpperCase() !== 'M') {
-        const aConverted = {
-            type: bCommand.type,
-        };
-        Object.keys(bCommand).forEach((bKey) => {
-            const bValue = bCommand[bKey];
-            // first read from the A command
-            let aValue = aCommand[bKey];
-            // if it is one of these values, read from B no matter what
-            if (aValue === undefined) {
-                if (readFromBKeys.includes(bKey)) {
-                    aValue = bValue;
-                }
-                else {
-                    // if it wasn't in the A command, see if an equivalent was
-                    if (aValue === undefined &&
-                        conversionMap[bKey]) {
-                        aValue =
-                            aCommand[conversionMap[bKey]];
-                    }
-                    // if it doesn't have a converted value, use 0
-                    if (aValue === undefined) {
-                        aValue = 0;
-                    }
-                }
-            }
-            // @ts-expect-error
-            aConverted[bKey] = aValue;
-        });
-        // update the type to match B
-        aConverted.type = bCommand.type;
-        aCommand = aConverted;
-    }
-    return aCommand;
-}
-/**
- * Interpolate between command objects commandStart and commandEnd segmentCount times.
- * If the types are L, Q, or C then the curves are split as per de Casteljau's algorithm.
- * Otherwise we just copy commandStart segmentCount - 1 times, finally ending with commandEnd.
- *
- * @param {Object} commandStart Command object at the beginning of the segment
- * @param {Object} commandEnd Command object at the end of the segment
- * @param {Number} segmentCount The number of segments to split this into. If only 1
- *   Then [commandEnd] is returned.
- * @return {Object[]} Array of ~segmentCount command objects between commandStart and
- *   commandEnd. (Can be segmentCount+1 objects if commandStart is type M).
- */
-function splitSegment(commandStart, commandEnd, segmentCount) {
-    let segments = [];
-    // line, quadratic bezier, or cubic bezier
-    if (commandEnd.type === 'L' ||
-        commandEnd.type === 'Q' ||
-        commandEnd.type === 'C') {
-        segments = segments.concat((0, split_curve_1.splitCurve)(commandStart, commandEnd, segmentCount));
-        // general case - just copy the same point
-    }
-    else {
-        const copyCommand = { ...commandStart };
-        // convert M to L
-        if (copyCommand.type === 'M') {
-            copyCommand.type = 'L';
-        }
-        segments = segments.concat(arrayOfLength(segmentCount - 1, undefined).map(() => copyCommand));
-        segments.push(commandEnd);
-    }
-    return segments;
-}
-/**
- * Extends an array of commandsToExtend to the length of the referenceCommands by
- * splitting segments until the number of commands match. Ensures all the actual
- * points of commandsToExtend are in the extended array.
- *
- * @param {Object[]} commandsToExtend The command object array to extend
- * @param {Object[]} referenceCommands The command object array to match in length
- * @return {Object[]} The extended commandsToExtend array
- */
-function extend(commandsToExtend, referenceCommands) {
-    // compute insertion points:
-    // number of segments in the path to extend
-    const numSegmentsToExtend = commandsToExtend.length - 1;
-    // number of segments in the reference path.
-    const numReferenceSegments = referenceCommands.length - 1;
-    // this value is always between [0, 1].
-    const segmentRatio = numSegmentsToExtend / numReferenceSegments;
-    // create a map, mapping segments in referenceCommands to how many points
-    // should be added in that segment (should always be >= 1 since we need each
-    // point itself).
-    // 0 = segment 0-1, 1 = segment 1-2, n-1 = last vertex
-    const countPointsPerSegment = arrayOfLength(numReferenceSegments, undefined).reduce((accum, _d, i) => {
-        const insertIndex = Math.floor(segmentRatio * i);
-        accum[insertIndex] = (accum[insertIndex] || 0) + 1;
-        return accum;
-    }, []);
-    // extend each segment to have the correct number of points for a smooth interpolation
-    const extended = countPointsPerSegment.reduce((_extended, segmentCount, i) => {
-        // if last command, just add `segmentCount` number of times
-        if (i === commandsToExtend.length - 1) {
-            const lastCommandCopies = arrayOfLength(segmentCount, {
-                ...commandsToExtend[commandsToExtend.length - 1],
-            });
-            // convert M to L
-            if (lastCommandCopies[0].type === 'M') {
-                lastCommandCopies.forEach((d) => {
-                    d.type = 'L';
-                });
-            }
-            return _extended.concat(lastCommandCopies);
-        }
-        // otherwise, split the segment segmentCount times.
-        return _extended.concat(splitSegment(commandsToExtend[i], commandsToExtend[i + 1], segmentCount));
-    }, []);
-    // add in the very first point since splitSegment only adds in the ones after it
-    extended.unshift(commandsToExtend[0]);
-    return extended;
-}
-/**
- * Takes a path `d` string and converts it into an array of command
- * objects. Drops the `Z` character.
- *
- * @param {String|null} d A path `d` string
- */
-function pathCommandsFromString(d) {
-    // split into valid tokens
-    const tokens = (d || '').match(commandTokenRegex) || [];
-    const commands = [];
-    let commandArgs;
-    let command;
-    // iterate over each token, checking if we are at a new command
-    // by presence in the typeMap
-    for (let i = 0; i < tokens.length; ++i) {
-        commandArgs = split_curve_1.typeMap[tokens[i]];
-        // new command found:
-        if (commandArgs) {
-            command = {
-                type: tokens[i],
-            };
-            // add each of the expected args for this command:
-            for (let a = 0; a < commandArgs.length; ++a) {
-                // @ts-expect-error
-                command[commandArgs[a]] = Number(tokens[i + a + 1]);
-            }
-            // need to increment our token index appropriately since
-            // we consumed token args
-            i += commandArgs.length;
-            commands.push(command);
-        }
-    }
-    return commands;
-}
-/**
- * Interpolate from A to B by extending A and B during interpolation to have
- * the same number of points. This allows for a smooth transition when they
- * have a different number of points.
- *
- * Ignores the `Z` command in paths unless both A and B end with it.
- *
- * This function works directly with arrays of command objects instead of with
- * path `d` strings (see interpolatePath for working with `d` strings).
- *
- * @param {Object[]} aCommandsInput Array of path commands
- * @param {Object[]} bCommandsInput Array of path commands
- * @returns {Function} Interpolation function that maps t ([0, 1]) to an array of path commands.
- */
-function interpolatePathCommands(aCommandsInput, bCommandsInput) {
-    // make a copy so we don't mess with the input arrays
-    let aCommands = aCommandsInput === null || aCommandsInput === undefined
-        ? []
-        : aCommandsInput.slice();
-    let bCommands = bCommandsInput === null || bCommandsInput === undefined
-        ? []
-        : bCommandsInput.slice();
-    // both input sets are empty, so we don't interpolate
-    if (!aCommands.length && !bCommands.length) {
-        return function () {
-            return [];
-        };
-    }
-    // do we add Z during interpolation? yes if both have it. (we'd expect both to have it or not)
-    const addZ = (aCommands.length === 0 || aCommands[aCommands.length - 1].type === 'Z') &&
-        (bCommands.length === 0 || bCommands[bCommands.length - 1].type === 'Z');
-    // we temporarily remove Z
-    if (aCommands.length > 0 && aCommands[aCommands.length - 1].type === 'Z') {
-        aCommands.pop();
-    }
-    if (bCommands.length > 0 && bCommands[bCommands.length - 1].type === 'Z') {
-        bCommands.pop();
-    }
-    // if A is empty, treat it as if it used to contain just the first point
-    // of B. This makes it so the line extends out of from that first point.
-    if (!aCommands.length) {
-        aCommands.push(bCommands[0]);
-        // otherwise if B is empty, treat it as if it contains the first point
-        // of A. This makes it so the line retracts into the first point.
-    }
-    else if (!bCommands.length) {
-        bCommands.push(aCommands[0]);
-    }
-    // extend to match equal size
-    const numPointsToExtend = Math.abs(bCommands.length - aCommands.length);
-    if (numPointsToExtend !== 0) {
-        // B has more points than A, so add points to A before interpolating
-        if (bCommands.length > aCommands.length) {
-            aCommands = extend(aCommands, bCommands);
-            // else if A has more points than B, add more points to B
-        }
-        else if (bCommands.length < aCommands.length) {
-            bCommands = extend(bCommands, aCommands);
-        }
-    }
-    // commands have same length now.
-    // convert commands in A to the same type as those in B
-    aCommands = aCommands.map((aCommand, i) => convertToSameType(aCommand, bCommands[i]));
-    // create mutable interpolated command objects
-    const interpolatedCommands = aCommands.map((aCommand) => ({ ...aCommand }));
-    if (addZ) {
-        interpolatedCommands.push({ type: 'Z' });
-        aCommands.push({ type: 'Z' }); // required for when returning at t == 0
-    }
-    return function (t) {
-        // at 1 return the final value without the extensions used during interpolation
-        if (t === 1) {
-            return bCommandsInput === null || bCommandsInput === undefined
-                ? []
-                : bCommandsInput;
-        }
-        // work with aCommands directly since interpolatedCommands are mutated
-        if (t === 0) {
-            return aCommands;
-        }
-        // interpolate the commands using the mutable interpolated command objs
-        for (let i = 0; i < interpolatedCommands.length; ++i) {
-            // if (interpolatedCommands[i].type === 'Z') continue;
-            const aCommand = aCommands[i];
-            const bCommand = bCommands[i];
-            const interpolatedCommand = interpolatedCommands[i];
-            for (const arg of split_curve_1.typeMap[interpolatedCommand.type]) {
-                // @ts-expect-error
-                interpolatedCommand[arg] =
-                    (1 - t) * aCommand[arg] +
-                        t * bCommand[arg];
-                // do not use floats for flags (#27), round to integer
-                if (arg === 'largeArcFlag' || arg === 'sweepFlag') {
-                    // @ts-expect-error
-                    interpolatedCommand[arg] = Math.round(interpolatedCommand[arg]);
-                }
-            }
-        }
-        return interpolatedCommands;
-    };
-}
-/**
- * @description Interpolates between two SVG paths.
- * @param {number} value A number - 0 means first path, 1 means second path, any other values will be interpolated
- * @param {string} firstPath The first valid SVG path
- * @param {string} secondPath The second valid SVG path
- * @see [Documentation](https://remotion.dev/docs/paths/interpolate-path)
- */
-const interpolatePath = (value, firstPath, secondPath) => {
-    // at 1 return the final value without the extensions used during interpolation
-    if (value === 1) {
-        return secondPath;
-    }
-    if (value === 0) {
-        return firstPath;
-    }
-    const aCommands = pathCommandsFromString(firstPath);
-    if (aCommands.length === 0) {
-        throw new TypeError(`SVG Path "${firstPath}" is not valid`);
-    }
-    const bCommands = pathCommandsFromString(secondPath);
-    if (bCommands.length === 0) {
-        throw new TypeError(`SVG Path "${secondPath}" is not valid`);
-    }
-    const commandInterpolator = interpolatePathCommands(aCommands, bCommands);
-    const interpolatedCommands = commandInterpolator(value);
-    // convert to a string (fastest concat: https://jsperf.com/join-concat/150)
-    return interpolatedCommands
-        .map((c) => {
-        return commandToString(c);
-    })
-        .join(' ');
-};
-exports.interpolatePath = interpolatePath;