@remotion/paths 4.0.164 → 4.0.166

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateInstructionOfSameKind = void 0;
+const interpolateLInstruction = (t, first, second) => {
+    return {
+        type: 'L',
+        x: (1 - t) * first.x + t * second.x,
+        y: (1 - t) * first.y + t * second.y,
+    };
+};
+const interpolateCInstructions = (t, first, second) => {
+    return {
+        type: 'C',
+        cp1x: (1 - t) * first.cp1x + t * second.cp1x,
+        cp2x: (1 - t) * first.cp2x + t * second.cp2x,
+        cp1y: (1 - t) * first.cp1y + t * second.cp1y,
+        cp2y: (1 - t) * first.cp2y + t * second.cp2y,
+        x: (1 - t) * first.x + t * second.x,
+        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',
+        x: (1 - t) * first.x + t * second.x,
+        y: (1 - t) * first.y + t * second.y,
+    };
+};
+const interpolateInstructionOfSameKind = (t, first, second) => {
+    if (first.type === 'L') {
+        if (second.type !== 'L') {
+            throw new Error('mismatch');
+        }
+        return interpolateLInstruction(t, first, second);
+    }
+    if (first.type === 'C') {
+        if (second.type !== 'C') {
+            throw new Error('mismatch');
+        }
+        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');
+        }
+        return interpolateMInstructions(t, first, second);
+    }
+    if (first.type === 'Z') {
+        if (second.type !== 'Z') {
+            throw new Error('mismatch');
+        }
+        return {
+            type: 'Z',
+        };
+    }
+    throw new Error('mismatch');
+};
+exports.interpolateInstructionOfSameKind = interpolateInstructionOfSameKind;

package/dist/interpolate-path/interpolate-instructions.d.ts

@@ -0,0 +1,16 @@
+import type { ReducedInstruction } from '../helpers/types';
+/**
+ * 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.
+ */
+export declare function interpolateInstructions(aCommandsInput: ReducedInstruction[], bCommandsInput: ReducedInstruction[]): (t: number) => ReducedInstruction[];

package/dist/interpolate-path/interpolate-instructions.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateInstructions = void 0;
+const get_end_position_1 = require("../get-end-position");
+const convert_to_same_instruction_type_1 = require("./convert-to-same-instruction-type");
+const extend_command_1 = require("./extend-command");
+const interpolate_instruction_of_same_kind_1 = require("./interpolate-instruction-of-same-kind");
+/**
+ * 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 interpolateInstructions(aCommandsInput, bCommandsInput) {
+    // make a copy so we don't mess with the input arrays
+    let aCommands = aCommandsInput.slice();
+    let bCommands = 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 = (0, extend_command_1.extendInstruction)(aCommands, bCommands);
+            // else if A has more points than B, add more points to B
+        }
+        else if (bCommands.length < aCommands.length) {
+            bCommands = (0, extend_command_1.extendInstruction)(bCommands, aCommands);
+        }
+    }
+    // commands have same length now.
+    // convert commands in A to the same type as those in B
+    const aSameType = aCommands.map((aCommand, i) => {
+        const commandsUntilNow = aCommands.slice(0, i);
+        const point = (0, get_end_position_1.getEndPosition)(commandsUntilNow);
+        return (0, convert_to_same_instruction_type_1.convertToSameInstructionType)(aCommand, bCommands[i], point);
+    });
+    const interpolatedCommands = [];
+    if (addZ) {
+        aSameType.push({ type: 'Z' }); // required for when returning at t == 0
+        bCommands.push({ type: 'Z' });
+    }
+    return function (t) {
+        // at 1 return the final value without the extensions used during interpolation
+        if (t === 1) {
+            return bCommandsInput;
+        }
+        // work with aCommands directly since interpolatedCommands are mutated
+        if (t === 0) {
+            return aSameType;
+        }
+        // interpolate the commands using the mutable interpolated command objs
+        for (let i = 0; i < aSameType.length; ++i) {
+            interpolatedCommands.push((0, interpolate_instruction_of_same_kind_1.interpolateInstructionOfSameKind)(t, aSameType[i], bCommands[i]));
+        }
+        return interpolatedCommands;
+    };
+}
+exports.interpolateInstructions = interpolateInstructions;

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

@@ -33,112 +33,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.interpolatePath = void 0;
-const command_1 = require("./command");
-const command_to_string_1 = require("./command-to-string");
-const convert_to_same_type_1 = require("./convert-to-same-type");
-const extend_command_1 = require("./extend-command");
-const path_commands_from_string_1 = require("./path-commands-from-string");
-/**
- * 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 = (0, extend_command_1.extend)(aCommands, bCommands);
-            // else if A has more points than B, add more points to B
-        }
-        else if (bCommands.length < aCommands.length) {
-            bCommands = (0, extend_command_1.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) => (0, convert_to_same_type_1.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 command_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;
-    };
-}
+const parse_path_1 = require("../parse-path");
+const reduce_instructions_1 = require("../reduce-instructions");
+const serialize_instructions_1 = require("../serialize-instructions");
+const interpolate_instructions_1 = require("./interpolate-instructions");
 /**
  * @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
@@ -154,21 +52,15 @@ const interpolatePath = (value, firstPath, secondPath) => {
     if (value === 0) {
         return firstPath;
     }
-    const aCommands = (0, path_commands_from_string_1.pathCommandsFromString)(firstPath);
+    const aCommands = (0, reduce_instructions_1.reduceInstructions)((0, parse_path_1.parsePath)(firstPath));
     if (aCommands.length === 0) {
         throw new TypeError(`SVG Path "${firstPath}" is not valid`);
     }
-    const bCommands = (0, path_commands_from_string_1.pathCommandsFromString)(secondPath);
+    const bCommands = (0, reduce_instructions_1.reduceInstructions)((0, parse_path_1.parsePath)(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 (0, command_to_string_1.commandToString)(c);
-    })
-        .join(' ');
+    const commandInterpolator = (0, interpolate_instructions_1.interpolateInstructions)(aCommands, bCommands);
+    return (0, serialize_instructions_1.serializeInstructions)(commandInterpolator(value));
 };
 exports.interpolatePath = interpolatePath;

package/dist/interpolate-path/points-to-command.d.ts

@@ -0,0 +1,9 @@
+import type { ReducedInstruction } from '../helpers/types';
+/**
+ * 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.
+ */
+export declare function pointsToInstruction(points: number[][]): ReducedInstruction;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointsToInstruction = void 0;
+/**
+ * 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 pointsToInstruction(points) {
+    const x = points[points.length - 1][0];
+    const y = points[points.length - 1][1];
+    if (points.length === 4) {
+        const x1 = points[1][0];
+        const y1 = points[1][1];
+        const x2 = points[2][0];
+        const y2 = points[2][1];
+        return {
+            type: 'C',
+            cp1x: x1,
+            cp1y: y1,
+            cp2x: x2,
+            cp2y: y2,
+            x,
+            y,
+        };
+    }
+    if (points.length === 3) {
+        const x1 = points[1][0];
+        const y1 = points[1][1];
+        return {
+            type: 'Q',
+            cpx: x1,
+            cpy: y1,
+            x,
+            y,
+        };
+    }
+    return {
+        type: 'L',
+        x,
+        y,
+    };
+}
+exports.pointsToInstruction = pointsToInstruction;

package/dist/interpolate-path/split-curve-as-points.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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
+ */
+export declare function splitCurveAsPoints(points: number[][], segmentCount?: number): number[][][];

package/dist/interpolate-path/split-curve-as-points.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCurveAsPoints = void 0;
+const de_casteljau_1 = require("./de-casteljau");
+/**
+ * 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 = 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 = (0, de_casteljau_1.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;
+}
+exports.splitCurveAsPoints = splitCurveAsPoints;

package/dist/interpolate-path/split-curve.d.ts

@@ -1,11 +1,11 @@
-import type { Command } from './command';
+import type { CInstruction, LInstruction, QInstruction, ReducedInstruction } from '../helpers/types';
 /**
  * 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 {Object} instructionEnd 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: (commandStartX: number, commandStartY: number, commandEnd: Command, segmentCount: number) => Command[];
+export declare const splitCurveInstructions: (instructionStartX: number, instructionStartY: number, instructionEnd: LInstruction | QInstruction | CInstruction, segmentCount: number) => ReducedInstruction[];

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

@@ -32,134 +32,30 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitCurve = 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() };
-}
-/**
- * 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;
-}
+exports.splitCurveInstructions = void 0;
+const points_to_command_1 = require("./points-to-command");
+const split_curve_as_points_1 = require("./split-curve-as-points");
 /**
  * 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 {Object} instructionEnd 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 = (commandStartX, commandStartY, commandEnd, segmentCount) => {
-    const points = [[commandStartX, commandStartY]];
-    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);
+const splitCurveInstructions = (instructionStartX, instructionStartY, instructionEnd, segmentCount) => {
+    const points = [[instructionStartX, instructionStartY]];
+    if (instructionEnd.type === 'Q') {
+        points.push([instructionEnd.cpx, instructionEnd.cpy]);
+    }
+    if (instructionEnd.type === 'C') {
+        points.push([instructionEnd.cp1x, instructionEnd.cp1y]);
+        points.push([instructionEnd.cp2x, instructionEnd.cp2y]);
+    }
+    points.push([instructionEnd.x, instructionEnd.y]);
+    return (0, split_curve_as_points_1.splitCurveAsPoints)(points, segmentCount).map((p) => {
+        return (0, points_to_command_1.pointsToInstruction)(p);
+    });
 };
-exports.splitCurve = splitCurve;
+exports.splitCurveInstructions = splitCurveInstructions;

package/dist/interpolate-path/split-segment.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from './command';
+import type { ReducedInstruction } from '../helpers/types';
 /**
  * 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.
@@ -11,4 +11,4 @@ import type { Command } from './command';
  * @return {Object[]} Array of ~segmentCount command objects between commandStart and
  *   commandEnd. (Can be segmentCount+1 objects if commandStart is type M).
  */
-export declare function splitSegment(commandStart: Command, commandEnd: Command, segmentCount: number): Command[];
+export declare function splitSegmentInstructions(commandStart: ReducedInstruction, commandEnd: ReducedInstruction, segmentCount: number): ReducedInstruction[];

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitSegment = void 0;
-const array_of_length_1 = require("./array-of-length");
+exports.splitSegmentInstructions = void 0;
 const split_curve_1 = require("./split-curve");
 /**
  * Interpolate between command objects commandStart and commandEnd segmentCount times.
@@ -15,27 +14,28 @@ const split_curve_1 = require("./split-curve");
  * @return {Object[]} Array of ~segmentCount command objects between commandStart and
  *   commandEnd. (Can be segmentCount+1 objects if commandStart is type M).
  */
-// TODO: Delete and replace
-function splitSegment(commandStart, commandEnd, segmentCount) {
+function splitSegmentInstructions(commandStart, commandEnd, segmentCount) {
     let segments = [];
     // line, quadratic bezier, or cubic bezier
     if (commandEnd.type === 'L' ||
         commandEnd.type === 'Q' ||
         commandEnd.type === 'C') {
         if (commandStart.type !== 'Z') {
-            segments = segments.concat((0, split_curve_1.splitCurve)(commandStart.x, commandStart.y, commandEnd, segmentCount));
+            segments = segments.concat((0, split_curve_1.splitCurveInstructions)(commandStart.x, commandStart.y, 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((0, array_of_length_1.arrayOfLength)(segmentCount - 1, undefined).map(() => copyCommand));
+        const copyCommand = commandStart.type === 'M'
+            ? {
+                type: 'L',
+                x: commandStart.x,
+                y: commandStart.y,
+            }
+            : commandStart;
+        segments = segments.concat(new Array(segmentCount - 1).fill(true).map(() => copyCommand));
         segments.push(commandEnd);
     }
     return segments;
 }
-exports.splitSegment = splitSegment;
+exports.splitSegmentInstructions = splitSegmentInstructions;