@remotion/paths 4.0.45 → 4.0.47

package/dist/get-bounding-box.d.ts

@@ -1,8 +1,8 @@
 import type { BoundingBox, ReducedInstruction } from './helpers/types';
+export declare const getBoundingBoxFromInstructions: (instructions: ReducedInstruction[]) => BoundingBox;
 /**
  * @description Returns the bounding box of the given path, suitable for calculating the viewBox value that you need to pass to an SVG.
  * @param {string} d
  * @see [Documentation](https://www.remotion.dev/docs/paths/get-bounding-box)
  */
 export declare const getBoundingBox: (d: string) => BoundingBox;
-export declare const getBoundingBoxFromInstructions: (instructions: ReducedInstruction[]) => BoundingBox;

package/dist/get-bounding-box.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBoundingBoxFromInstructions = exports.getBoundingBox = void 0;
+exports.getBoundingBox = exports.getBoundingBoxFromInstructions = void 0;
 const remove_a_s_t_curves_1 = require("./helpers/remove-a-s-t-curves");
 const normalize_path_1 = require("./normalize-path");
 const parse_path_1 = require("./parse-path");
@@ -67,17 +67,6 @@ function minmaxC(A) {
     }
     return [min, max];
 }
-/**
- * @description Returns the bounding box of the given path, suitable for calculating the viewBox value that you need to pass to an SVG.
- * @param {string} d
- * @see [Documentation](https://www.remotion.dev/docs/paths/get-bounding-box)
- */
-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));
-    return (0, exports.getBoundingBoxFromInstructions)(unarced);
-};
-exports.getBoundingBox = getBoundingBox;
 const getBoundingBoxFromInstructions = (instructions) => {
     let minX = Infinity;
     let minY = Infinity;
@@ -183,3 +172,14 @@ const getBoundingBoxFromInstructions = (instructions) => {
     };
 };
 exports.getBoundingBoxFromInstructions = getBoundingBoxFromInstructions;
+/**
+ * @description Returns the bounding box of the given path, suitable for calculating the viewBox value that you need to pass to an SVG.
+ * @param {string} d
+ * @see [Documentation](https://www.remotion.dev/docs/paths/get-bounding-box)
+ */
+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));
+    return (0, exports.getBoundingBoxFromInstructions)(unarced);
+};
+exports.getBoundingBox = getBoundingBox;

package/dist/helpers/arc.js

@@ -2,79 +2,25 @@
 // Copied from: https://github.com/rveciana/svg-path-properties
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeArc = void 0;
-const makeArc = ({ x0, y0, rx, ry, xAxisRotate, LargeArcFlag, SweepFlag, x1, y1, }) => {
-    const lengthProperties = approximateArcLengthOfCurve(300, (t) => {
-        return pointOnEllipticalArc({
-            p0: { x: x0, y: y0 },
-            rx,
-            ry,
-            xAxisRotation: xAxisRotate,
-            largeArcFlag: LargeArcFlag,
-            sweepFlag: SweepFlag,
-            p1: { x: x1, y: y1 },
-            t,
-        });
-    });
-    const length = lengthProperties.arcLength;
-    const getTotalLength = () => {
-        return length;
-    };
-    const getPointAtLength = (fractionLength) => {
-        if (fractionLength < 0) {
-            fractionLength = 0;
-        }
-        else if (fractionLength > length) {
-            fractionLength = length;
-        }
-        const position = pointOnEllipticalArc({
-            p0: { x: x0, y: y0 },
-            rx,
-            ry,
-            xAxisRotation: xAxisRotate,
-            largeArcFlag: LargeArcFlag,
-            sweepFlag: SweepFlag,
-            p1: { x: x1, y: y1 },
-            t: fractionLength / length,
-        });
-        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,
-    };
+const mod = (x, m) => {
+    return ((x % m) + m) % m;
+};
+const toRadians = (angle) => {
+    return angle * (Math.PI / 180);
+};
+const distance = (p0, p1) => {
+    return Math.sqrt((p1.x - p0.x) ** 2 + (p1.y - p0.y) ** 2);
+};
+const clamp = (val, min, max) => {
+    return Math.min(Math.max(val, min), max);
+};
+const angleBetween = (v0, v1) => {
+    const p = v0.x * v1.x + v0.y * v1.y;
+    const n = Math.sqrt((v0.x ** 2 + v0.y ** 2) * (v1.x ** 2 + v1.y ** 2));
+    const sign = v0.x * v1.y - v0.y * v1.x < 0 ? -1 : 1;
+    const angle = sign * Math.acos(p / n);
+    return angle;
 };
-exports.makeArc = makeArc;
 const pointOnEllipticalArc = ({ p0, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, p1, t, }) => {
     // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
     rx = Math.abs(rx);
@@ -205,22 +151,76 @@ const approximateArcLengthOfCurve = (resolution, pointOnCurveFunc) => {
         approximationLines,
     };
 };
-const mod = (x, m) => {
-    return ((x % m) + m) % m;
-};
-const toRadians = (angle) => {
-    return angle * (Math.PI / 180);
-};
-const distance = (p0, p1) => {
-    return Math.sqrt((p1.x - p0.x) ** 2 + (p1.y - p0.y) ** 2);
-};
-const clamp = (val, min, max) => {
-    return Math.min(Math.max(val, min), max);
-};
-const angleBetween = (v0, v1) => {
-    const p = v0.x * v1.x + v0.y * v1.y;
-    const n = Math.sqrt((v0.x ** 2 + v0.y ** 2) * (v1.x ** 2 + v1.y ** 2));
-    const sign = v0.x * v1.y - v0.y * v1.x < 0 ? -1 : 1;
-    const angle = sign * Math.acos(p / n);
-    return angle;
+const makeArc = ({ x0, y0, rx, ry, xAxisRotate, LargeArcFlag, SweepFlag, x1, y1, }) => {
+    const lengthProperties = approximateArcLengthOfCurve(300, (t) => {
+        return pointOnEllipticalArc({
+            p0: { x: x0, y: y0 },
+            rx,
+            ry,
+            xAxisRotation: xAxisRotate,
+            largeArcFlag: LargeArcFlag,
+            sweepFlag: SweepFlag,
+            p1: { x: x1, y: y1 },
+            t,
+        });
+    });
+    const length = lengthProperties.arcLength;
+    const getTotalLength = () => {
+        return length;
+    };
+    const getPointAtLength = (fractionLength) => {
+        if (fractionLength < 0) {
+            fractionLength = 0;
+        }
+        else if (fractionLength > length) {
+            fractionLength = length;
+        }
+        const position = pointOnEllipticalArc({
+            p0: { x: x0, y: y0 },
+            rx,
+            ry,
+            xAxisRotation: xAxisRotate,
+            largeArcFlag: LargeArcFlag,
+            sweepFlag: SweepFlag,
+            p1: { x: x1, y: y1 },
+            t: fractionLength / length,
+        });
+        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,
+    };
 };
+exports.makeArc = makeArc;

package/dist/helpers/bezier-functions.d.ts

@@ -1,8 +1,8 @@
 import type { Point } from './types';
 export declare const cubicPoint: (xs: number[], ys: number[], t: number) => Point;
-export declare const cubicDerivative: (xs: number[], ys: number[], t: number) => Point;
 export declare const getCubicArcLength: (xs: number[], ys: number[], t: number) => number;
 export declare const quadraticPoint: (xs: number[], ys: number[], t: number) => Point;
+export declare const cubicDerivative: (xs: number[], ys: number[], t: number) => Point;
 export declare const getQuadraticArcLength: (xs: number[], ys: number[], t: number) => number;
 export declare const quadraticDerivative: (xs: number[], ys: number[], t: number) => {
     x: number;

package/dist/helpers/bezier-functions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.t2length = exports.quadraticDerivative = exports.getQuadraticArcLength = exports.quadraticPoint = exports.getCubicArcLength = exports.cubicDerivative = exports.cubicPoint = void 0;
+exports.t2length = exports.quadraticDerivative = exports.getQuadraticArcLength = exports.cubicDerivative = exports.quadraticPoint = exports.getCubicArcLength = exports.cubicPoint = void 0;
 const bezier_values_1 = require("./bezier-values");
 const cubicPoint = (xs, ys, t) => {
     const x = (1 - t) * (1 - t) * (1 - t) * xs[0] +
@@ -14,11 +14,38 @@ const cubicPoint = (xs, ys, t) => {
     return { x, y };
 };
 exports.cubicPoint = cubicPoint;
-const cubicDerivative = (xs, ys, t) => {
-    const derivative = (0, exports.quadraticPoint)([3 * (xs[1] - xs[0]), 3 * (xs[2] - xs[1]), 3 * (xs[3] - xs[2])], [3 * (ys[1] - ys[0]), 3 * (ys[2] - ys[1]), 3 * (ys[3] - ys[2])], t);
-    return derivative;
+/**
+ * Compute the curve derivative (hodograph) at t.
+ */
+const getDerivative = (derivative, t, vs) => {
+    // the derivative of any 't'-less function is zero.
+    const n = vs.length - 1;
+    let value;
+    if (n === 0) {
+        return 0;
+    }
+    // direct values? compute!
+    if (derivative === 0) {
+        value = 0;
+        for (let k = 0; k <= n; k++) {
+            value += bezier_values_1.binomialCoefficients[n][k] * (1 - t) ** (n - k) * t ** k * vs[k];
+        }
+        return value;
+    }
+    // Still some derivative? go down one order, then try
+    // for the lower order curve's.
+    const _vs = new Array(n);
+    for (let k = 0; k < n; k++) {
+        _vs[k] = n * (vs[k + 1] - vs[k]);
+    }
+    return getDerivative(derivative - 1, t, _vs);
 };
-exports.cubicDerivative = cubicDerivative;
+function bFunc(xs, ys, t) {
+    const xbase = getDerivative(1, t, xs);
+    const ybase = getDerivative(1, t, ys);
+    const combined = xbase * xbase + ybase * ybase;
+    return Math.sqrt(combined);
+}
 const getCubicArcLength = (xs, ys, t) => {
     let correctedT;
     const n = 20;
@@ -37,6 +64,11 @@ const quadraticPoint = (xs, ys, t) => {
     return { x, y };
 };
 exports.quadraticPoint = quadraticPoint;
+const cubicDerivative = (xs, ys, t) => {
+    const derivative = (0, exports.quadraticPoint)([3 * (xs[1] - xs[0]), 3 * (xs[2] - xs[1]), 3 * (xs[3] - xs[2])], [3 * (ys[1] - ys[0]), 3 * (ys[2] - ys[1]), 3 * (ys[3] - ys[2])], t);
+    return derivative;
+};
+exports.cubicDerivative = cubicDerivative;
 const getQuadraticArcLength = (xs, ys, t) => {
     if (t === undefined) {
         t = 1;
@@ -70,38 +102,6 @@ const quadraticDerivative = (xs, ys, t) => {
     };
 };
 exports.quadraticDerivative = quadraticDerivative;
-function bFunc(xs, ys, t) {
-    const xbase = getDerivative(1, t, xs);
-    const ybase = getDerivative(1, t, ys);
-    const combined = xbase * xbase + ybase * ybase;
-    return Math.sqrt(combined);
-}
-/**
- * Compute the curve derivative (hodograph) at t.
- */
-const getDerivative = (derivative, t, vs) => {
-    // the derivative of any 't'-less function is zero.
-    const n = vs.length - 1;
-    let value;
-    if (n === 0) {
-        return 0;
-    }
-    // direct values? compute!
-    if (derivative === 0) {
-        value = 0;
-        for (let k = 0; k <= n; k++) {
-            value += bezier_values_1.binomialCoefficients[n][k] * (1 - t) ** (n - k) * t ** k * vs[k];
-        }
-        return value;
-    }
-    // Still some derivative? go down one order, then try
-    // for the lower order curve's.
-    const _vs = new Array(n);
-    for (let k = 0; k < n; k++) {
-        _vs[k] = n * (vs[k + 1] - vs[k]);
-    }
-    return getDerivative(derivative - 1, t, _vs);
-};
 const t2length = (length, totalLength, func) => {
     let error = 1;
     let t = length / totalLength;

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

@@ -20,6 +20,72 @@ function approximate_unit_arc(theta1, delta_theta) {
         y2,
     ];
 }
+function unit_vector_angle(ux, uy, vx, vy) {
+    const sign = ux * vy - uy * vx < 0 ? -1 : 1;
+    let dot = ux * vx + uy * vy;
+    // Add this to work with arbitrary vectors:
+    // dot /= Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy);
+    // rounding errors, e.g. -1.0000000000000002 can screw up this
+    if (dot > 1.0) {
+        dot = 1.0;
+    }
+    if (dot < -1.0) {
+        dot = -1.0;
+    }
+    return sign * Math.acos(dot);
+}
+function get_arc_center({ x1, y1, x2, y2, largeArcFlag, sweepFlag, rx, ry, sin_phi, cos_phi, }) {
+    // Step 1.
+    //
+    // Moving an ellipse so origin will be the middlepoint between our two
+    // points. After that, rotate it to line up ellipse axes with coordinate
+    // axes.
+    //
+    const x1p = (cos_phi * (x1 - x2)) / 2 + (sin_phi * (y1 - y2)) / 2;
+    const y1p = (-sin_phi * (x1 - x2)) / 2 + (cos_phi * (y1 - y2)) / 2;
+    const rx_sq = rx * rx;
+    const ry_sq = ry * ry;
+    const x1p_sq = x1p * x1p;
+    const y1p_sq = y1p * y1p;
+    // Step 2.
+    //
+    // Compute coordinates of the centre of this ellipse (cx', cy')
+    // in the new coordinate system.
+    //
+    let radicant = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq;
+    if (radicant < 0) {
+        // due to rounding errors it might be e.g. -1.3877787807814457e-17
+        radicant = 0;
+    }
+    radicant /= rx_sq * y1p_sq + ry_sq * x1p_sq;
+    radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
+    const cxp = ((radicant * rx) / ry) * y1p;
+    const cyp = ((radicant * -ry) / rx) * x1p;
+    // Step 3.
+    //
+    // Transform back to get centre coordinates (cx, cy) in the original
+    // coordinate system.
+    //
+    const cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2;
+    const cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2;
+    // Step 4.
+    //
+    // Compute angles (theta1, delta_theta).
+    //
+    const v1x = (x1p - cxp) / rx;
+    const v1y = (y1p - cyp) / ry;
+    const v2x = (-x1p - cxp) / rx;
+    const v2y = (-y1p - cyp) / ry;
+    const theta1 = unit_vector_angle(1, 0, v1x, v1y);
+    let delta_theta = unit_vector_angle(v1x, v1y, v2x, v2y);
+    if (sweepFlag === false && delta_theta > 0) {
+        delta_theta -= TAU;
+    }
+    if (sweepFlag === true && delta_theta < 0) {
+        delta_theta += TAU;
+    }
+    return [cx, cy, theta1, delta_theta];
+}
 function arcToCircle({ x1, y1, x2, y2, largeArcFlag, sweepFlag, rx, ry, phi, }) {
     const sin_phi = Math.sin((phi * TAU) / 360);
     const cos_phi = Math.cos((phi * TAU) / 360);
@@ -203,69 +269,3 @@ const removeATSHVInstructions = (segments) => {
     });
 };
 exports.removeATSHVInstructions = removeATSHVInstructions;
-function get_arc_center({ x1, y1, x2, y2, largeArcFlag, sweepFlag, rx, ry, sin_phi, cos_phi, }) {
-    // Step 1.
-    //
-    // Moving an ellipse so origin will be the middlepoint between our two
-    // points. After that, rotate it to line up ellipse axes with coordinate
-    // axes.
-    //
-    const x1p = (cos_phi * (x1 - x2)) / 2 + (sin_phi * (y1 - y2)) / 2;
-    const y1p = (-sin_phi * (x1 - x2)) / 2 + (cos_phi * (y1 - y2)) / 2;
-    const rx_sq = rx * rx;
-    const ry_sq = ry * ry;
-    const x1p_sq = x1p * x1p;
-    const y1p_sq = y1p * y1p;
-    // Step 2.
-    //
-    // Compute coordinates of the centre of this ellipse (cx', cy')
-    // in the new coordinate system.
-    //
-    let radicant = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq;
-    if (radicant < 0) {
-        // due to rounding errors it might be e.g. -1.3877787807814457e-17
-        radicant = 0;
-    }
-    radicant /= rx_sq * y1p_sq + ry_sq * x1p_sq;
-    radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
-    const cxp = ((radicant * rx) / ry) * y1p;
-    const cyp = ((radicant * -ry) / rx) * x1p;
-    // Step 3.
-    //
-    // Transform back to get centre coordinates (cx, cy) in the original
-    // coordinate system.
-    //
-    const cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2;
-    const cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2;
-    // Step 4.
-    //
-    // Compute angles (theta1, delta_theta).
-    //
-    const v1x = (x1p - cxp) / rx;
-    const v1y = (y1p - cyp) / ry;
-    const v2x = (-x1p - cxp) / rx;
-    const v2y = (-y1p - cyp) / ry;
-    const theta1 = unit_vector_angle(1, 0, v1x, v1y);
-    let delta_theta = unit_vector_angle(v1x, v1y, v2x, v2y);
-    if (sweepFlag === false && delta_theta > 0) {
-        delta_theta -= TAU;
-    }
-    if (sweepFlag === true && delta_theta < 0) {
-        delta_theta += TAU;
-    }
-    return [cx, cy, theta1, delta_theta];
-}
-function unit_vector_angle(ux, uy, vx, vy) {
-    const sign = ux * vy - uy * vx < 0 ? -1 : 1;
-    let dot = ux * vx + uy * vy;
-    // Add this to work with arbitrary vectors:
-    // dot /= Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy);
-    // rounding errors, e.g. -1.0000000000000002 can screw up this
-    if (dot > 1.0) {
-        dot = 1.0;
-    }
-    if (dot < -1.0) {
-        dot = -1.0;
-    }
-    return sign * Math.acos(dot);
-}

package/dist/normalize-path.d.ts

@@ -1,8 +1,8 @@
 import type { AbsoluteInstruction, Instruction } from './helpers/types';
+export declare const normalizeInstructions: (instructions: Instruction[]) => AbsoluteInstruction[];
 /**
  * @description Removes all relative coordinates from an SVG path and converts them into absolute coordinates.
  * @param {string} path A valid SVG path
  * @see [Documentation](https://remotion.dev/docs/paths/normalize-path)
  */
 export declare const normalizePath: (path: string) => string;
-export declare const normalizeInstructions: (instructions: Instruction[]) => AbsoluteInstruction[];

package/dist/normalize-path.js

@@ -1,19 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeInstructions = exports.normalizePath = void 0;
+exports.normalizePath = exports.normalizeInstructions = void 0;
 const parse_path_1 = require("./parse-path");
 const serialize_instructions_1 = require("./serialize-instructions");
-/**
- * @description Removes all relative coordinates from an SVG path and converts them into absolute coordinates.
- * @param {string} path A valid SVG path
- * @see [Documentation](https://remotion.dev/docs/paths/normalize-path)
- */
-const normalizePath = (path) => {
-    const instructions = (0, parse_path_1.parsePath)(path);
-    const normalized = (0, exports.normalizeInstructions)(instructions);
-    return (0, serialize_instructions_1.serializeInstructions)(normalized);
-};
-exports.normalizePath = normalizePath;
 const normalizeInstructions = (instructions) => {
     // Extended properties must already be normalized
     const normalized = [];
@@ -162,3 +151,14 @@ const normalizeInstructions = (instructions) => {
     return normalized;
 };
 exports.normalizeInstructions = normalizeInstructions;
+/**
+ * @description Removes all relative coordinates from an SVG path and converts them into absolute coordinates.
+ * @param {string} path A valid SVG path
+ * @see [Documentation](https://remotion.dev/docs/paths/normalize-path)
+ */
+const normalizePath = (path) => {
+    const instructions = (0, parse_path_1.parsePath)(path);
+    const normalized = (0, exports.normalizeInstructions)(instructions);
+    return (0, serialize_instructions_1.serializeInstructions)(normalized);
+};
+exports.normalizePath = normalizePath;

package/dist/parse-path.js

@@ -42,6 +42,20 @@ const makeInstructions = (arr, instruction, cb) => {
 };
 const segmentRegExp = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
 const numberRegExp = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
+const parseValues = (args, instructionType) => {
+    const numbers = args.match(numberRegExp);
+    if (!numbers) {
+        if (instructionType === 'Z' || instructionType === 'z') {
+            return [];
+        }
+        throw new Error(`Malformed path data: ${instructionType} was expected to have numbers afterwards`);
+    }
+    const expectedArguments = length[instructionType];
+    if (numbers.length % expectedArguments !== 0) {
+        throw new Error(`Malformed path data: ${instructionType} was expected to have a multiple of ${expectedArguments} numbers, but got "${instructionType} ${numbers.join(' ')} instead"`);
+    }
+    return numbers.map(Number);
+};
 /**
  * @description Parses an SVG string path into an array of Instruction's.
  * @param {string} path
@@ -249,17 +263,3 @@ const parsePath = (path) => {
         .flat(1);
 };
 exports.parsePath = parsePath;
-const parseValues = (args, instructionType) => {
-    const numbers = args.match(numberRegExp);
-    if (!numbers) {
-        if (instructionType === 'Z' || instructionType === 'z') {
-            return [];
-        }
-        throw new Error(`Malformed path data: ${instructionType} was expected to have numbers afterwards`);
-    }
-    const expectedArguments = length[instructionType];
-    if (numbers.length % expectedArguments !== 0) {
-        throw new Error(`Malformed path data: ${instructionType} was expected to have a multiple of ${expectedArguments} numbers, but got "${instructionType} ${numbers.join(' ')} instead"`);
-    }
-    return numbers.map(Number);
-};

package/dist/warp-path/warp-helpers.d.ts

@@ -6,9 +6,9 @@ export type WarpPathFn = (point: {
     x: number;
     y: number;
 };
+export declare function split(p: number[][], t?: number): number[][][];
+export declare function interpolateUntil(points: [number, number][], threshold: number, deltaFunction?: (points: [number, number][]) => number): [number, number][][];
+export declare function createLineSegment(points: number[][]): ReducedInstruction;
 export declare function svgPathInterpolate(path: ReducedInstruction[], threshold: number): ReducedInstruction[];
 export declare const warpTransform: (path: ReducedInstruction[], transformer: WarpPathFn) => ReducedInstruction[];
 export declare const fixZInstruction: (instructions: ReducedInstruction[]) => ReducedInstruction[];
-export declare function interpolateUntil(points: [number, number][], threshold: number, deltaFunction?: (points: [number, number][]) => number): [number, number][][];
-export declare function split(p: number[][], t?: number): number[][][];
-export declare function createLineSegment(points: number[][]): ReducedInstruction;

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

@@ -1,20 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLineSegment = exports.split = exports.interpolateUntil = exports.fixZInstruction = exports.warpTransform = exports.svgPathInterpolate = void 0;
-function svgPathInterpolate(path, threshold) {
-    let didWork = false;
-    const deltaFunction = (points) => {
-        const linearPoints = [
-            points[0].slice(0, 2),
-            points[points.length - 1].slice(0, 2),
-        ];
-        const delta = euclideanDistance(linearPoints);
-        didWork = didWork || delta > threshold;
-        return delta;
-    };
-    return warpInterpolate(path, threshold, deltaFunction);
+exports.fixZInstruction = exports.warpTransform = exports.svgPathInterpolate = exports.createLineSegment = exports.interpolateUntil = exports.split = void 0;
+const euclideanDistance = (points) => {
+    const startPoint = points[0];
+    const endPoint = points[points.length - 1];
+    let d2 = 0;
+    for (let i = 0; i < startPoint.length; i++) {
+        const d = endPoint[i] - startPoint[i];
+        d2 += d ** 2;
+    }
+    return Math.sqrt(d2);
+};
+function split(p, t = 0.5) {
+    const seg0 = [];
+    const seg1 = [];
+    const orders = [p];
+    while (orders.length < p.length) {
+        const q = orders[orders.length - 1];
+        const r = [];
+        for (let i = 1; i < q.length; i++) {
+            const q0 = q[i - 1];
+            const q1 = q[i];
+            const s = [];
+            const dim = Math.max(q0.length, q1.length);
+            for (let j = 0; j < dim; j++) {
+                const s0 = q0[j] || 0;
+                const s1 = q1[j] || 0;
+                s.push(s0 + (s1 - s0) * t);
+            }
+            r.push(s);
+        }
+        orders.push(r);
+    }
+    for (let i = 0; i < orders.length; i++) {
+        seg0.push(orders[i][0]);
+        seg1.push(orders[orders.length - 1 - i][i]);
+    }
+    return [seg0, seg1];
 }
-exports.svgPathInterpolate = svgPathInterpolate;
+exports.split = split;
+function interpolateUntil(points, threshold, deltaFunction = euclideanDistance) {
+    const stack = [points];
+    const segments = [];
+    while (stack.length > 0) {
+        const currentPoints = stack.pop();
+        if (deltaFunction(currentPoints) > threshold) {
+            const newPoints = split(currentPoints);
+            // Add new segments backwards so they end up in correct order
+            for (let i = newPoints.length - 1; i >= 0; i--) {
+                stack.push(newPoints[i]);
+            }
+        }
+        else {
+            segments.push(currentPoints);
+        }
+    }
+    return segments;
+}
+exports.interpolateUntil = interpolateUntil;
+function createLineSegment(points) {
+    switch (points.length) {
+        case 2:
+            return {
+                type: 'L',
+                x: points[1][0],
+                y: points[1][1],
+            };
+        case 3:
+            return {
+                type: 'Q',
+                cpx: points[1][0],
+                cpy: points[1][1],
+                x: points[2][0],
+                y: points[2][1],
+            };
+        case 4:
+            return {
+                type: 'C',
+                cp1x: points[1][0],
+                cp1y: points[1][1],
+                cp2x: points[2][0],
+                cp2y: points[2][1],
+                x: points[3][0],
+                y: points[3][1],
+            };
+        default:
+            throw new Error('Expected 2, 3 or 4 points for a line segment, got ' + points.length);
+    }
+}
+exports.createLineSegment = createLineSegment;
 function warpInterpolate(path, threshold, deltaFunction) {
     let prexX = 0;
     let prexY = 0;
@@ -46,6 +120,20 @@ function warpInterpolate(path, threshold, deltaFunction) {
     })
         .flat(1);
 }
+function svgPathInterpolate(path, threshold) {
+    let didWork = false;
+    const deltaFunction = (points) => {
+        const linearPoints = [
+            points[0].slice(0, 2),
+            points[points.length - 1].slice(0, 2),
+        ];
+        const delta = euclideanDistance(linearPoints);
+        didWork = didWork || delta > threshold;
+        return delta;
+    };
+    return warpInterpolate(path, threshold, deltaFunction);
+}
+exports.svgPathInterpolate = svgPathInterpolate;
 const warpTransform = (path, transformer) => {
     return path
         .map((segment) => {
@@ -139,91 +227,3 @@ const fixZInstruction = (instructions) => {
         .flat(1);
 };
 exports.fixZInstruction = fixZInstruction;
-const euclideanDistance = (points) => {
-    const startPoint = points[0];
-    const endPoint = points[points.length - 1];
-    let d2 = 0;
-    for (let i = 0; i < startPoint.length; i++) {
-        const d = endPoint[i] - startPoint[i];
-        d2 += d ** 2;
-    }
-    return Math.sqrt(d2);
-};
-function interpolateUntil(points, threshold, deltaFunction = euclideanDistance) {
-    const stack = [points];
-    const segments = [];
-    while (stack.length > 0) {
-        const currentPoints = stack.pop();
-        if (deltaFunction(currentPoints) > threshold) {
-            const newPoints = split(currentPoints);
-            // Add new segments backwards so they end up in correct order
-            for (let i = newPoints.length - 1; i >= 0; i--) {
-                stack.push(newPoints[i]);
-            }
-        }
-        else {
-            segments.push(currentPoints);
-        }
-    }
-    return segments;
-}
-exports.interpolateUntil = interpolateUntil;
-function split(p, t = 0.5) {
-    const seg0 = [];
-    const seg1 = [];
-    const orders = [p];
-    while (orders.length < p.length) {
-        const q = orders[orders.length - 1];
-        const r = [];
-        for (let i = 1; i < q.length; i++) {
-            const q0 = q[i - 1];
-            const q1 = q[i];
-            const s = [];
-            const dim = Math.max(q0.length, q1.length);
-            for (let j = 0; j < dim; j++) {
-                const s0 = q0[j] || 0;
-                const s1 = q1[j] || 0;
-                s.push(s0 + (s1 - s0) * t);
-            }
-            r.push(s);
-        }
-        orders.push(r);
-    }
-    for (let i = 0; i < orders.length; i++) {
-        seg0.push(orders[i][0]);
-        seg1.push(orders[orders.length - 1 - i][i]);
-    }
-    return [seg0, seg1];
-}
-exports.split = split;
-function createLineSegment(points) {
-    switch (points.length) {
-        case 2:
-            return {
-                type: 'L',
-                x: points[1][0],
-                y: points[1][1],
-            };
-        case 3:
-            return {
-                type: 'Q',
-                cpx: points[1][0],
-                cpy: points[1][1],
-                x: points[2][0],
-                y: points[2][1],
-            };
-        case 4:
-            return {
-                type: 'C',
-                cp1x: points[1][0],
-                cp1y: points[1][1],
-                cp2x: points[2][0],
-                cp2y: points[2][1],
-                x: points[3][0],
-                y: points[3][1],
-            };
-        default:
-            throw new Error('Expected 2, 3 or 4 points for a line segment, got ' + points.length);
-    }
-}
-exports.createLineSegment = createLineSegment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/paths",
-  "version": "4.0.45",
+  "version": "4.0.47",
   "description": "Utility functions for SVG paths",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -13,7 +13,7 @@
     "url": "https://github.com/remotion-dev/remotion/issues"
   },
   "devDependencies": {
-    "@jonny/eslint-config": "3.0.266",
+    "@jonny/eslint-config": "3.0.276",
     "@types/node": "18.14.6",
     "eslint": "8.42.0",
     "prettier": "3.0.2",