@remotion/paths 3.2.12-crf.6 → 3.2.13

package/dist/bezier.d.ts

@@ -1,26 +0,0 @@
-import type { Point } from './types';
-export declare const makeBezier: ({ ax, ay, bx, by, cx, cy, dx, dy, }: {
-    ax: number;
-    ay: number;
-    bx: number;
-    by: number;
-    cx: number;
-    cy: number;
-    dx: number | null;
-    dy: number | null;
-}) => {
-    getPointAtLength: (len: number) => Point;
-    getPropertiesAtLength: (len: number) => {
-        x: number;
-        y: number;
-        tangentX: number;
-        tangentY: number;
-    };
-    getTangentAtLength: (len: number) => Point;
-    getTotalLength: () => number;
-    getC: () => {
-        x: number;
-        y: number;
-    };
-    getD: () => Point;
-};

package/dist/bezier.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeBezier = void 0;
-const bezier_functions_1 = require("./bezier-functions");
-const makeBezier = ({ ax, ay, bx, by, cx, cy, dx, dy, }) => {
-    let d;
-    let getArcLength;
-    let getPoint;
-    let getDerivative;
-    const a = { x: ax, y: ay };
-    const b = { x: bx, y: by };
-    const c = { x: cx, y: cy };
-    if (dx !== null && dy !== null) {
-        getArcLength = bezier_functions_1.getCubicArcLength;
-        getPoint = bezier_functions_1.cubicPoint;
-        getDerivative = bezier_functions_1.cubicDerivative;
-        d = { x: dx, y: dy };
-    }
-    else {
-        getArcLength = bezier_functions_1.getQuadraticArcLength;
-        getPoint = bezier_functions_1.quadraticPoint;
-        getDerivative = bezier_functions_1.quadraticDerivative;
-        d = { x: 0, y: 0 };
-    }
-    const length = getArcLength([a.x, b.x, c.x, d.x], [a.y, b.y, c.y, d.y], 1);
-    const getTotalLength = () => {
-        return length;
-    };
-    const getPointAtLength = (len) => {
-        const xs = [a.x, b.x, c.x, d.x];
-        const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        return getPoint(xs, xy, t);
-    };
-    const getTangentAtLength = (len) => {
-        const xs = [a.x, b.x, c.x, d.x];
-        const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        const derivative = getDerivative(xs, xy, t);
-        const mdl = Math.sqrt(derivative.x * derivative.x + derivative.y * derivative.y);
-        let tangent;
-        if (mdl > 0) {
-            tangent = { x: derivative.x / mdl, y: derivative.y / mdl };
-        }
-        else {
-            tangent = { x: 0, y: 0 };
-        }
-        return tangent;
-    };
-    const getPropertiesAtLength = (len) => {
-        const xs = [a.x, b.x, c.x, d.x];
-        const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        const derivative = getDerivative(xs, xy, t);
-        const mdl = Math.sqrt(derivative.x * derivative.x + derivative.y * derivative.y);
-        let tangent;
-        if (mdl > 0) {
-            tangent = { x: derivative.x / mdl, y: derivative.y / mdl };
-        }
-        else {
-            tangent = { x: 0, y: 0 };
-        }
-        const point = getPoint(xs, xy, t);
-        return { x: point.x, y: point.y, tangentX: tangent.x, tangentY: tangent.y };
-    };
-    const getC = () => {
-        return c;
-    };
-    const getD = () => {
-        return d;
-    };
-    return {
-        getPointAtLength,
-        getPropertiesAtLength,
-        getTangentAtLength,
-        getTotalLength,
-        getC,
-        getD,
-    };
-};
-exports.makeBezier = makeBezier;

package/dist/construct.d.ts

@@ -1,7 +0,0 @@
-import type { Point, Properties } from './types';
-export declare const construct: (string: string) => {
-    initial_point: Point | null;
-    length: number;
-    partial_lengths: number[];
-    functions: (Properties | null)[];
-};

package/dist/construct.js

@@ -1,308 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.construct = void 0;
-const arc_1 = require("./arc");
-const bezier_1 = require("./bezier");
-const linear_1 = require("./linear");
-const parse_1 = __importDefault(require("./parse"));
-const construct = (string) => {
-    let length = 0;
-    const partial_lengths = [];
-    const functions = [];
-    let initial_point = null;
-    const parsed = (0, parse_1.default)(string);
-    let cur = [0, 0];
-    let prev_point = [0, 0];
-    let curve;
-    let ringStart = [0, 0];
-    for (let i = 0; i < parsed.length; i++) {
-        // moveTo
-        if (parsed[i][0] === 'M') {
-            cur = [parsed[i][1], parsed[i][2]];
-            ringStart = [cur[0], cur[1]];
-            functions.push(null);
-            if (i === 0) {
-                initial_point = { x: parsed[i][1], y: parsed[i][2] };
-            }
-        }
-        else if (parsed[i][0] === 'm') {
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
-            ringStart = [cur[0], cur[1]];
-            functions.push(null);
-            // lineTo
-        }
-        else if (parsed[i][0] === 'L') {
-            length += Math.sqrt((cur[0] - parsed[i][1]) ** 2 + (cur[1] - parsed[i][2]) ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]));
-            cur = [parsed[i][1], parsed[i][2]];
-        }
-        else if (parsed[i][0] === 'l') {
-            length += Math.sqrt(parsed[i][1] ** 2 + parsed[i][2] ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1] + cur[0], cur[1], parsed[i][2] + cur[1]));
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
-        }
-        else if (parsed[i][0] === 'H') {
-            length += Math.abs(cur[0] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1];
-        }
-        else if (parsed[i][0] === 'h') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1] + cur[0];
-        }
-        else if (parsed[i][0] === 'V') {
-            length += Math.abs(cur[1] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], parsed[i][1]));
-            cur[1] = parsed[i][1];
-        }
-        else if (parsed[i][0] === 'v') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1] + parsed[i][1]));
-            cur[1] = parsed[i][1] + cur[1];
-            // Close path
-        }
-        else if (parsed[i][0] === 'z' || parsed[i][0] === 'Z') {
-            length += Math.sqrt((ringStart[0] - cur[0]) ** 2 + (ringStart[1] - cur[1]) ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], ringStart[0], cur[1], ringStart[1]));
-            cur = [ringStart[0], ringStart[1]];
-            // Cubic Bezier curves
-        }
-        else if (parsed[i][0] === 'C') {
-            curve = (0, bezier_1.makeBezier)({
-                ax: cur[0],
-                ay: cur[1],
-                bx: parsed[i][1],
-                by: parsed[i][2],
-                cx: parsed[i][3],
-                cy: parsed[i][4],
-                dx: parsed[i][5],
-                dy: parsed[i][6],
-            });
-            length += curve.getTotalLength();
-            cur = [parsed[i][5], parsed[i][6]];
-            functions.push(curve);
-        }
-        else if (parsed[i][0] === 'c') {
-            curve = (0, bezier_1.makeBezier)({
-                ax: cur[0],
-                ay: cur[1],
-                bx: cur[0] + parsed[i][1],
-                by: cur[1] + parsed[i][2],
-                cx: cur[0] + parsed[i][3],
-                cy: cur[1] + parsed[i][4],
-                dx: cur[0] + parsed[i][5],
-                dy: cur[1] + parsed[i][6],
-            });
-            if (curve.getTotalLength() > 0) {
-                length += curve.getTotalLength();
-                functions.push(curve);
-                cur = [parsed[i][5] + cur[0], parsed[i][6] + cur[1]];
-            }
-            else {
-                functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1]));
-            }
-        }
-        else if (parsed[i][0] === 'S') {
-            if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
-                if (curve) {
-                    const c = curve.getC();
-                    curve = (0, bezier_1.makeBezier)({
-                        ax: cur[0],
-                        ay: cur[1],
-                        bx: 2 * cur[0] - c.x,
-                        by: 2 * cur[1] - c.y,
-                        cx: parsed[i][1],
-                        cy: parsed[i][2],
-                        dx: parsed[i][3],
-                        dy: parsed[i][4],
-                    });
-                }
-            }
-            else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0],
-                    by: cur[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
-                    dx: parsed[i][3],
-                    dy: parsed[i][4],
-                });
-            }
-            if (curve) {
-                length += curve.getTotalLength();
-                cur = [parsed[i][3], parsed[i][4]];
-                functions.push(curve);
-            }
-        }
-        else if (parsed[i][0] === 's') {
-            // 240 225
-            if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
-                if (curve) {
-                    const c = curve.getC();
-                    const d = curve.getD();
-                    curve = (0, bezier_1.makeBezier)({
-                        ax: cur[0],
-                        ay: cur[1],
-                        bx: cur[0] + d.x - c.x,
-                        by: cur[1] + d.y - c.y,
-                        cx: cur[0] + parsed[i][1],
-                        cy: cur[1] + parsed[i][2],
-                        dx: cur[0] + parsed[i][3],
-                        dy: cur[1] + parsed[i][4],
-                    });
-                }
-            }
-            else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0],
-                    by: cur[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
-                    dx: cur[0] + parsed[i][3],
-                    dy: cur[1] + parsed[i][4],
-                });
-            }
-            if (curve) {
-                length += curve.getTotalLength();
-                cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
-                functions.push(curve);
-            }
-        }
-        // Quadratic Bezier curves
-        else if (parsed[i][0] === 'Q') {
-            if (cur[0] === parsed[i][1] && cur[1] === parsed[i][2]) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(parsed[i][1], parsed[i][3], parsed[i][2], parsed[i][4]);
-                length += linearCurve.getTotalLength();
-                functions.push(linearCurve);
-            }
-            else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: parsed[i][1],
-                    by: parsed[i][2],
-                    cx: parsed[i][3],
-                    cy: parsed[i][4],
-                    dx: null,
-                    dy: null,
-                });
-                length += curve.getTotalLength();
-                functions.push(curve);
-            }
-            cur = [parsed[i][3], parsed[i][4]];
-            prev_point = [parsed[i][1], parsed[i][2]];
-        }
-        else if (parsed[i][0] === 'q') {
-            if (parsed[i][1] === 0 && parsed[i][2] === 0) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0] + parsed[i][1], cur[0] + parsed[i][3], cur[1] + parsed[i][2], cur[1] + parsed[i][4]);
-                length += linearCurve.getTotalLength();
-                functions.push(linearCurve);
-            }
-            else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0] + parsed[i][1],
-                    by: cur[1] + parsed[i][2],
-                    cx: cur[0] + parsed[i][3],
-                    cy: cur[1] + parsed[i][4],
-                    dx: null,
-                    dy: null,
-                });
-                length += curve.getTotalLength();
-                functions.push(curve);
-            }
-            prev_point = [cur[0] + parsed[i][1], cur[1] + parsed[i][2]];
-            cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
-        }
-        else if (parsed[i][0] === 'T') {
-            if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: 2 * cur[0] - prev_point[0],
-                    by: 2 * cur[1] - prev_point[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
-                    dx: null,
-                    dy: null,
-                });
-                functions.push(curve);
-                length += curve.getTotalLength();
-            }
-            else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]);
-                functions.push(linearCurve);
-                length += linearCurve.getTotalLength();
-            }
-            prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1], parsed[i][2]];
-        }
-        else if (parsed[i][0] === 't') {
-            if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: 2 * cur[0] - prev_point[0],
-                    by: 2 * cur[1] - prev_point[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
-                    dx: null,
-                    dy: null,
-                });
-                length += curve.getTotalLength();
-                functions.push(curve);
-            }
-            else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1] + parsed[i][2]);
-                length += linearCurve.getTotalLength();
-                functions.push(linearCurve);
-            }
-            prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
-        }
-        else if (parsed[i][0] === 'A') {
-            const arcCurve = (0, arc_1.makeArc)({
-                x0: cur[0],
-                y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: parsed[i][6],
-                y1: parsed[i][7],
-            });
-            length += arcCurve.getTotalLength();
-            cur = [parsed[i][6], parsed[i][7]];
-            functions.push(arcCurve);
-        }
-        else if (parsed[i][0] === 'a') {
-            const arcCurve = (0, arc_1.makeArc)({
-                x0: cur[0],
-                y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: cur[0] + parsed[i][6],
-                y1: cur[1] + parsed[i][7],
-            });
-            length += arcCurve.getTotalLength();
-            cur = [cur[0] + parsed[i][6], cur[1] + parsed[i][7]];
-            functions.push(arcCurve);
-        }
-        partial_lengths.push(length);
-    }
-    return { initial_point, length, partial_lengths, functions };
-};
-exports.construct = construct;

package/dist/get-part-at-length.d.ts

@@ -1,4 +0,0 @@
-export declare const getPartAtLength: (p: string, fractionLength: number) => {
-    fraction: number;
-    i: number;
-};

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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPartAtLength = void 0;
-const construct_1 = require("./helpers/construct");
-const getPartAtLength = (p, fractionLength) => {
-    const constructed = (0, construct_1.construct)(p);
-    if (fractionLength < 0) {
-        fractionLength = 0;
-    }
-    else if (fractionLength > constructed.length) {
-        fractionLength = constructed.length;
-    }
-    let i = constructed.partial_lengths.length - 1;
-    while (constructed.partial_lengths[i] >= fractionLength && i > 0) {
-        i--;
-    }
-    i++;
-    return { fraction: fractionLength - constructed.partial_lengths[i - 1], i };
-};
-exports.getPartAtLength = getPartAtLength;

package/dist/get-properties-at-length.d.ts

@@ -1 +0,0 @@
-export declare const getPropertiesAtLength: (p: string, fractionLength: number) => any;

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

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropertiesAtLength = void 0;
-const construct_1 = require("./helpers/construct");
-const get_part_at_length_1 = require("./helpers/get-part-at-length");
-const getPropertiesAtLength = (p, fractionLength) => {
-    const constructed = (0, construct_1.construct)(p);
-    const fractionPart = (0, get_part_at_length_1.getPartAtLength)(p, fractionLength);
-    const functionAtPart = constructed.functions[fractionPart.i];
-    if (functionAtPart) {
-        return functionAtPart.getPropertiesAtLength(fractionPart.fraction);
-    }
-    if (constructed.initial_point) {
-        return {
-            x: constructed.initial_point.x,
-            y: constructed.initial_point.y,
-            tangentX: 0,
-            tangentY: 0,
-        };
-    }
-    throw new Error('Wrong function at this part.');
-};
-exports.getPropertiesAtLength = getPropertiesAtLength;

package/dist/get-reversed-path.d.ts

@@ -1,12 +0,0 @@
-/**
- * https://github.com/Pomax/svg-path-reverse
- *
- * This code is in the public domain, except in jurisdictions that do
- * not recognise the public domain, where this code is MIT licensed.
- */
-/**
- * This is the function that you'll actually want to
- * make use of, because it lets you reverse individual
- * subpaths in some <path> "d" attribute.
- */
-export declare const reversePath: (_path: string, _subpath?: number) => string;

package/dist/get-reversed-path.js

@@ -1,159 +0,0 @@
-"use strict";
-/**
- * https://github.com/Pomax/svg-path-reverse
- *
- * This code is in the public domain, except in jurisdictions that do
- * not recognise the public domain, where this code is MIT licensed.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reversePath = void 0;
-const normalize_path_1 = require("./normalize-path");
-/**
- * Normalise an SVG path to absolute coordinates
- * and full commands, rather than relative coordinates
- * and/or shortcut commands.
- */
-/**
- * Reverse an SVG path.
- * As long as the input path is normalised, this is actually really
- * simple to do. As all pathing commands are symmetrical, meaning
- * that they render the same when you reverse the coordinate order,
- * the grand trick here is to reverse the path (making sure to keep
- * coordinates ordered pairwise) and shift the operators left by
- * one or two coordinate pairs depending on the operator:
- *
- *   - Z is removed (after noting it existed),
- *   - L moves to 2 spots earlier (skipping one coordinate),
- *   - Q moves to 2 spots earlier (skipping one coordinate),
- *   - C moves to 4 spots earlier (skipping two coordinates)
- *       and its arguments get reversed,
- *   - the path start becomes M.
- *   - the path end becomes Z iff it was there to begin with.
- */
-function reverseNormalizedPath(normalized) {
-    const terms = normalized.trim().split(' ');
-    let term;
-    const tlen = terms.length;
-    const tlen1 = tlen - 1;
-    let t;
-    const reversed = [];
-    let x;
-    let y;
-    let pair;
-    let pairs;
-    let shift;
-    const matcher = /[QAZLCM]/;
-    const closed = terms.slice(-1)[0].toUpperCase() === 'Z';
-    for (t = 0; t < tlen; t++) {
-        term = terms[t];
-        // Is this an operator? If it is, run through its
-        // argument list, which we know is fixed length.
-        if (matcher.test(term)) {
-            // Arc processing relies on not-just-coordinates
-            if (term === 'A') {
-                reversed.push(terms[t + 5] === '0' ? '1' : '0');
-                reversed.push(terms[t + 4]);
-                reversed.push(terms[t + 3]);
-                reversed.push(terms[t + 2]);
-                reversed.push(terms[t + 1]);
-                reversed.push(term);
-                reversed.push(terms[t + 7]);
-                reversed.push(terms[t + 6]);
-                t += 7;
-                continue;
-            }
-            // how many coordinate pairs do we need to read,
-            // and by how many pairs should this operator be
-            // shifted left?
-            else if (term === 'C') {
-                pairs = 3;
-                shift = 2;
-            }
-            else if (term === 'Q') {
-                pairs = 2;
-                shift = 1;
-            }
-            else if (term === 'L') {
-                pairs = 1;
-                shift = 1;
-            }
-            else if (term === 'M') {
-                pairs = 1;
-                shift = 0;
-            }
-            else {
-                continue;
-            }
-            // do the argument reading and operator shifting
-            if (pairs === shift) {
-                reversed.push(term);
-            }
-            for (pair = 0; pair < pairs; pair++) {
-                if (pair === shift) {
-                    reversed.push(term);
-                }
-                x = terms[++t];
-                y = terms[++t];
-                reversed.push(y);
-                reversed.push(x);
-            }
-        }
-        // the code has been set up so that every time we
-        // iterate because of the for() operation, the term
-        // we see is a pathing operator, not a number. As
-        // such, if we get to this "else" the path is malformed.
-        else {
-            const pre = terms.slice(Math.max(t - 3, 0), 3).join(' ');
-            const post = terms.slice(t + 1, Math.min(t + 4, tlen1)).join(' ');
-            const range = pre + ' [' + term + '] ' + post;
-            throw new Error('Error while trying to reverse normalized SVG path, at position ' +
-                t +
-                ' (' +
-                range +
-                ').\n' +
-                "Either the path is not normalised, or it's malformed.");
-        }
-    }
-    reversed.push('M');
-    // generating the reversed path string involves
-    // running through our transformed terms in reverse.
-    let revstring = '';
-    const rlen1 = reversed.length - 1;
-    let r;
-    for (r = rlen1; r > 0; r--) {
-        revstring += reversed[r] + ' ';
-    }
-    if (closed)
-        revstring += 'Z';
-    revstring = revstring.replace(/M M/g, 'Z M');
-    return revstring;
-}
-/**
- * This is the function that you'll actually want to
- * make use of, because it lets you reverse individual
- * subpaths in some <path> "d" attribute.
- */
-const reversePath = (_path, _subpath) => {
-    const subpath = _subpath !== null && _subpath !== void 0 ? _subpath : false;
-    const path = (0, normalize_path_1.normalizePath)(_path);
-    let paths = path.replace(/M/g, '|M').split('|');
-    let revpath;
-    paths.splice(0, 1);
-    if (subpath !== false && subpath >= paths.length) {
-        return path;
-    }
-    if (subpath === false) {
-        paths = paths.map((spath) => {
-            return reverseNormalizedPath(spath.trim());
-        });
-    }
-    else {
-        const spath = paths[subpath];
-        if (spath) {
-            revpath = reverseNormalizedPath(spath.trim());
-            paths[subpath] = revpath;
-        }
-    }
-    return paths.join(' ').replace(/ +/g, ' ').trim();
-};
-exports.reversePath = reversePath;

package/dist/linear.d.ts

@@ -1,7 +0,0 @@
-import type { Point, PointProperties } from './types';
-export declare const makeLinearPosition: (x0: number, x1: number, y0: number, y1: number) => {
-    getTotalLength: () => number;
-    getPointAtLength: (pos: number) => Point;
-    getTangentAtLength: () => Point;
-    getPropertiesAtLength: (pos: number) => PointProperties;
-};