@remotion/paths 3.3.43 → 3.3.44

package/dist/helpers/serialize.d.ts

@@ -0,0 +1,2 @@
+import type { Instruction } from './types';
+export declare const serializeInstructions: (path: Instruction[]) => string;

package/dist/helpers/serialize.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeInstructions = void 0;
+const serializeInstruction = (instruction) => {
+    if (instruction.type === 'A') {
+        return `A ${instruction.rx} ${instruction.ry} ${instruction.xAxisRotation} ${Number(instruction.largeArcFlag)} ${Number(instruction.sweepFlag)} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'a') {
+        return `a ${instruction.rx} ${instruction.ry} ${instruction.xAxisRotation} ${Number(instruction.largeArcFlag)} ${Number(instruction.sweepFlag)} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'C') {
+        return `C ${instruction.cp1x} ${instruction.cp1y} ${instruction.cp2x} ${instruction.cp2y} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'c') {
+        return `c ${instruction.cp1dx} ${instruction.cp1dy} ${instruction.cp2dx} ${instruction.cp2dy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'S') {
+        return `S ${instruction.cpx} ${instruction.cpy} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 's') {
+        return `s ${instruction.cpdx} ${instruction.cpdy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'Q') {
+        return `Q ${instruction.cpx} ${instruction.cpy} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'q') {
+        return `q ${instruction.cpdx} ${instruction.cpdy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'z') {
+        return 'z';
+    }
+    if (instruction.type === 'Z') {
+        return 'Z';
+    }
+    if (instruction.type === 'H') {
+        return `H ${instruction.x}`;
+    }
+    if (instruction.type === 'h') {
+        return `h ${instruction.dx}`;
+    }
+    if (instruction.type === 'V') {
+        return `V ${instruction.y}`;
+    }
+    if (instruction.type === 'v') {
+        return `v ${instruction.dy}`;
+    }
+    if (instruction.type === 'L') {
+        return `L ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'l') {
+        return `l ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'M') {
+        return `M ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'm') {
+        return `m ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'T') {
+        return `T ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 't') {
+        return `t ${instruction.dx} ${instruction.dy}`;
+    }
+    // @ts-expect-error
+    throw new Error(`Unknown instruction type: ${instruction.type}`);
+};
+const serializeInstructions = (path) => {
+    return path
+        .map((p) => {
+        return serializeInstruction(p);
+    })
+        .join(' ');
+};
+exports.serializeInstructions = serializeInstructions;

package/dist/helpers/unarc.d.ts

@@ -0,0 +1,2 @@
+import type { AbsoluteInstruction, UnarcedAbsoluteInstruction } from './types';
+export declare const removeArcInstructions: (segments: AbsoluteInstruction[]) => UnarcedAbsoluteInstruction[];

package/dist/helpers/unarc.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeArcInstructions = void 0;
+const iterate_1 = require("./iterate");
+const TAU = Math.PI * 2;
+function approximate_unit_arc(theta1, delta_theta) {
+    const alpha = (4 / 3) * Math.tan(delta_theta / 4);
+    const x1 = Math.cos(theta1);
+    const y1 = Math.sin(theta1);
+    const x2 = Math.cos(theta1 + delta_theta);
+    const y2 = Math.sin(theta1 + delta_theta);
+    return [
+        x1,
+        y1,
+        x1 - y1 * alpha,
+        y1 + x1 * alpha,
+        x2 + y2 * alpha,
+        y2 - x2 * alpha,
+        x2,
+        y2,
+    ];
+}
+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);
+    // Make sure radii are valid
+    //
+    const x1p = (cos_phi * (x1 - x2)) / 2 + (sin_phi * (y1 - y2)) / 2;
+    const y1p = (-sin_phi * (x1 - x2)) / 2 + (cos_phi * (y1 - y2)) / 2;
+    if (x1p === 0 && y1p === 0) {
+        // we're asked to draw line to itself
+        return [];
+    }
+    if (rx === 0 || ry === 0) {
+        // one of the radii is zero
+        return [];
+    }
+    // Compensate out-of-range radii
+    //
+    rx = Math.abs(rx);
+    ry = Math.abs(ry);
+    const lambda = (x1p * x1p) / (rx * rx) + (y1p * y1p) / (ry * ry);
+    if (lambda > 1) {
+        rx *= Math.sqrt(lambda);
+        ry *= Math.sqrt(lambda);
+    }
+    // Get center parameters (cx, cy, theta1, delta_theta)
+    //
+    const cc = get_arc_center({
+        x1,
+        y1,
+        x2,
+        y2,
+        largeArcFlag,
+        sweepFlag,
+        rx,
+        ry,
+        sin_phi,
+        cos_phi,
+    });
+    const result = [];
+    let theta1 = cc[2];
+    let delta_theta = cc[3];
+    // Split an arc to multiple segments, so each segment
+    // will be less than τ/4 (= 90°)
+    //
+    const segments = Math.max(Math.ceil(Math.abs(delta_theta) / (TAU / 4)), 1);
+    delta_theta /= segments;
+    for (let i = 0; i < segments; i++) {
+        result.push(approximate_unit_arc(theta1, delta_theta));
+        theta1 += delta_theta;
+    }
+    // We have a bezier approximation of a unit circle,
+    // now need to transform back to the original ellipse
+    //
+    return result.map((curve) => {
+        for (let i = 0; i < curve.length; i += 2) {
+            let x = curve[i + 0];
+            let y = curve[i + 1];
+            // scale
+            x *= rx;
+            y *= ry;
+            // rotate
+            const xp = cos_phi * x - sin_phi * y;
+            const yp = sin_phi * x + cos_phi * y;
+            // translate
+            curve[i + 0] = xp + cc[0];
+            curve[i + 1] = yp + cc[1];
+        }
+        return curve;
+    });
+}
+// Requires path to be normalized
+const removeArcInstructions = (segments) => {
+    let prevControlX = 0;
+    let prevControlY = 0;
+    let curControlX = 0;
+    let curControlY = 0;
+    return (0, iterate_1.iterateOverSegments)({
+        segments,
+        iterate: ({ segment, prevSegment, x, y }) => {
+            if (segment.type === 'A') {
+                const nextX = segment.x;
+                const nextY = segment.y;
+                const new_segments = arcToCircle({
+                    x1: x,
+                    y1: y,
+                    x2: nextX,
+                    y2: nextY,
+                    largeArcFlag: segment.largeArcFlag,
+                    sweepFlag: segment.sweepFlag,
+                    rx: segment.rx,
+                    ry: segment.ry,
+                    phi: segment.xAxisRotation,
+                });
+                // Degenerated arcs can be ignored by renderer, but should not be dropped
+                // to avoid collisions with `S A S` and so on. Replace with empty line.
+                if (new_segments.length === 0) {
+                    return [
+                        {
+                            type: 'L',
+                            x: segment.x,
+                            y: segment.y,
+                        },
+                    ];
+                }
+                const result = new_segments.map((_s) => {
+                    return {
+                        type: 'C',
+                        cp1x: _s[2],
+                        cp1y: _s[3],
+                        cp2x: _s[4],
+                        cp2y: _s[5],
+                        x: _s[6],
+                        y: _s[7],
+                    };
+                });
+                return result;
+            }
+            if (segment.type === 'T') {
+                if (prevSegment && prevSegment.type === 'Q') {
+                    prevControlX = prevSegment.cpx;
+                    prevControlY = prevSegment.cpy;
+                }
+                else {
+                    prevControlX = 0;
+                    prevControlY = 0;
+                }
+                curControlX = -prevControlX;
+                curControlY = -prevControlY;
+                return [
+                    {
+                        type: 'Q',
+                        cpx: curControlX,
+                        cpy: curControlY,
+                        x: segment.x,
+                        y: segment.y,
+                    },
+                ];
+            }
+            if (segment.type === 'S') {
+                if (prevSegment && prevSegment.type === 'C') {
+                    prevControlX = prevSegment.cp2x;
+                    prevControlY = prevSegment.cp2y;
+                }
+                else {
+                    prevControlX = 0;
+                    prevControlY = 0;
+                }
+                curControlX = -prevControlX;
+                curControlY = -prevControlY;
+                return [
+                    {
+                        type: 'C',
+                        cp1x: curControlX,
+                        cp1y: curControlY,
+                        cp2x: segment.cpx,
+                        cp2y: segment.cpy,
+                        x: segment.x,
+                        y: segment.y,
+                    },
+                ];
+            }
+            return [segment];
+        },
+    });
+};
+exports.removeArcInstructions = removeArcInstructions;
+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/helpers/unshort.d.ts

@@ -0,0 +1,2 @@
+import type { Instruction } from './types';
+export declare const unshort: (segments: Instruction[]) => Instruction[];

package/dist/helpers/unshort.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unshort = void 0;
+// Requires that the path is already normalized
+const unshort = function (segments) {
+    let prevControlX = 0;
+    let prevControlY = 0;
+    let curControlX = 0;
+    let curControlY = 0;
+    const newSegments = segments.slice(0);
+    for (let i = 0; i < newSegments.length; i++) {
+        const s = newSegments[i];
+        // First command MUST be M|m, it's safe to skip.
+        // Protect from access to [-1] for sure.
+        if (!i) {
+            continue;
+        }
+        if (s.type === 'T') {
+            // quadratic curve
+            const prevSegment = newSegments[i - 1];
+            if (prevSegment.type === 'Q') {
+                prevControlX = prevSegment.cpx;
+                prevControlY = prevSegment.cpy;
+            }
+            else {
+                prevControlX = 0;
+                prevControlY = 0;
+            }
+            curControlX = -prevControlX;
+            curControlY = -prevControlY;
+            newSegments[i] = {
+                type: 'Q',
+                cpx: curControlX,
+                cpy: curControlY,
+                x: s.x,
+                y: s.y,
+            };
+        }
+        else if (s.type === 'S') {
+            // cubic curve
+            const prevSegment = newSegments[i - 1];
+            if (prevSegment.type === 'C') {
+                prevControlX = prevSegment.cp2x;
+                prevControlY = prevSegment.cp2y;
+            }
+            else {
+                prevControlX = 0;
+                prevControlY = 0;
+            }
+            curControlX = -prevControlX;
+            curControlY = -prevControlY;
+            newSegments[i] = {
+                type: 'C',
+                cp1x: curControlX,
+                cp1y: curControlY,
+                cp2x: s.cpx,
+                cp2y: s.cpy,
+                x: s.x,
+                y: s.y,
+            };
+        }
+    }
+    return newSegments;
+};
+exports.unshort = unshort;

package/dist/parse.d.ts

@@ -0,0 +1,2 @@
+import type { Instruction } from './types';
+export declare const parsePath: (path: string) => Instruction[];

package/dist/parse.js

@@ -0,0 +1,266 @@
+"use strict";
+// Copied from: https://github.com/rveciana/svg-path-properties
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePath = void 0;
+const length = {
+    a: 7,
+    A: 7,
+    C: 6,
+    c: 6,
+    H: 1,
+    h: 1,
+    L: 2,
+    l: 2,
+    M: 2,
+    m: 2,
+    Q: 4,
+    q: 4,
+    S: 4,
+    s: 4,
+    T: 2,
+    t: 2,
+    V: 1,
+    v: 1,
+    Z: 0,
+    z: 0,
+};
+const chunkExact = (array, instruction) => {
+    const chunks = [];
+    const expectedSize = length[instruction];
+    if (array.length % expectedSize !== 0) {
+        throw new Error(`Expected number of arguments of SVG instruction "${instruction} ${array.join(' ')}" to be a multiple of ${expectedSize}`);
+    }
+    for (let i = 0; i < array.length; i += expectedSize) {
+        chunks.push(array.slice(i, i + expectedSize));
+    }
+    return chunks;
+};
+const makeInstructions = (arr, instruction, cb) => {
+    return chunkExact(arr, instruction).map((args) => {
+        return cb(args);
+    });
+};
+const segmentRegExp = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
+const numberRegExp = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
+const parsePath = (path) => {
+    if (!path) {
+        throw new Error('No path provided');
+    }
+    const segments = path.match(segmentRegExp);
+    if (!segments) {
+        throw new Error(`No path elements found in string ${path}`);
+    }
+    return segments
+        .map((segmentString) => {
+        const command = segmentString.charAt(0);
+        const args = parseValues(segmentString.substring(1), command);
+        // overloaded moveTo
+        if (command === 'M' && args.length > 2) {
+            const segmentsArray = [];
+            segmentsArray.push({
+                type: command,
+                x: args[0],
+                y: args[1],
+            });
+            segmentsArray.push(...makeInstructions(args.slice(2), 'L', (numbers) => ({
+                type: 'L',
+                x: numbers[0],
+                y: numbers[1],
+            })));
+            return segmentsArray;
+        }
+        if (command === 'm' && args.length > 2) {
+            const segmentsArray = [];
+            segmentsArray.push({
+                type: command,
+                dx: args[0],
+                dy: args[1],
+            });
+            segmentsArray.push(...makeInstructions(args.slice(2), 'l', (numbers) => ({
+                type: 'l',
+                dx: numbers[0],
+                dy: numbers[1],
+            })));
+            return segmentsArray;
+        }
+        if (command === 'Z') {
+            return [
+                {
+                    type: 'Z',
+                },
+            ];
+        }
+        if (command === 'z') {
+            return [
+                {
+                    type: 'z',
+                },
+            ];
+        }
+        if (command === 'A') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                rx: numbers[0],
+                ry: numbers[1],
+                xAxisRotation: numbers[2],
+                largeArcFlag: numbers[3] === 1,
+                sweepFlag: numbers[4] === 1,
+                x: numbers[5],
+                y: numbers[6],
+            }));
+        }
+        if (command === 'a') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                rx: numbers[0],
+                ry: numbers[1],
+                xAxisRotation: numbers[2],
+                largeArcFlag: numbers[3] === 1,
+                sweepFlag: numbers[4] === 1,
+                dx: numbers[5],
+                dy: numbers[6],
+            }));
+        }
+        if (command === 'C') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cp1x: numbers[0],
+                cp1y: numbers[1],
+                cp2x: numbers[2],
+                cp2y: numbers[3],
+                x: numbers[4],
+                y: numbers[5],
+            }));
+        }
+        if (command === 'c') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cp1dx: numbers[0],
+                cp1dy: numbers[1],
+                cp2dx: numbers[2],
+                cp2dy: numbers[3],
+                dx: numbers[4],
+                dy: numbers[5],
+            }));
+        }
+        if (command === 'S') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cpx: numbers[0],
+                cpy: numbers[1],
+                x: numbers[2],
+                y: numbers[3],
+            }));
+        }
+        if (command === 's') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cpdx: numbers[0],
+                cpdy: numbers[1],
+                dx: numbers[2],
+                dy: numbers[3],
+            }));
+        }
+        if (command === 'H') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                x: numbers[0],
+            }));
+        }
+        if (command === 'h') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                dx: numbers[0],
+            }));
+        }
+        if (command === 'V') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                y: numbers[0],
+            }));
+        }
+        if (command === 'v') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                dy: numbers[0],
+            }));
+        }
+        if (command === 'L') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                x: numbers[0],
+                y: numbers[1],
+            }));
+        }
+        if (command === 'M') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                x: numbers[0],
+                y: numbers[1],
+            }));
+        }
+        if (command === 'm') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                dx: numbers[0],
+                dy: numbers[1],
+            }));
+        }
+        if (command === 'l') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                dx: numbers[0],
+                dy: numbers[1],
+            }));
+        }
+        if (command === 'Q') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cpx: numbers[0],
+                cpy: numbers[1],
+                x: numbers[2],
+                y: numbers[3],
+            }));
+        }
+        if (command === 'q') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                cpdx: numbers[0],
+                cpdy: numbers[1],
+                dx: numbers[2],
+                dy: numbers[3],
+            }));
+        }
+        if (command === 'T') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                x: numbers[0],
+                y: numbers[1],
+            }));
+        }
+        if (command === 't') {
+            return makeInstructions(args, command, (numbers) => ({
+                type: command,
+                dx: numbers[0],
+                dy: numbers[1],
+            }));
+        }
+        throw new Error(`Invalid path element ${segmentString}`);
+    }, [])
+        .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/serialize.d.ts

@@ -0,0 +1,2 @@
+import type { Instruction } from './types';
+export declare const serializeInstructions: (path: Instruction[]) => string;

package/dist/serialize.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeInstructions = void 0;
+const serializeInstruction = (instruction) => {
+    if (instruction.type === 'A') {
+        return `A ${instruction.rx} ${instruction.ry} ${instruction.xAxisRotation} ${Number(instruction.largeArcFlag)} ${Number(instruction.sweepFlag)} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'a') {
+        return `a ${instruction.rx} ${instruction.ry} ${instruction.xAxisRotation} ${Number(instruction.largeArcFlag)} ${Number(instruction.sweepFlag)} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'C') {
+        return `C ${instruction.cp1x} ${instruction.cp1y} ${instruction.cp2x} ${instruction.cp2y} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'c') {
+        return `c ${instruction.cp1dx} ${instruction.cp1dy} ${instruction.cp2dx} ${instruction.cp2dy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'S') {
+        return `S ${instruction.cpx} ${instruction.cpy} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 's') {
+        return `s ${instruction.cpdx} ${instruction.cpdy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'Q') {
+        return `Q ${instruction.cpx} ${instruction.cpy} ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'q') {
+        return `q ${instruction.cpdx} ${instruction.cpdy} ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'z') {
+        return 'z';
+    }
+    if (instruction.type === 'Z') {
+        return 'Z';
+    }
+    if (instruction.type === 'H') {
+        return `H ${instruction.x}`;
+    }
+    if (instruction.type === 'h') {
+        return `h ${instruction.dx}`;
+    }
+    if (instruction.type === 'V') {
+        return `V ${instruction.y}`;
+    }
+    if (instruction.type === 'v') {
+        return `v ${instruction.dy}`;
+    }
+    if (instruction.type === 'L') {
+        return `L ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'l') {
+        return `l ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'M') {
+        return `M ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 'm') {
+        return `m ${instruction.dx} ${instruction.dy}`;
+    }
+    if (instruction.type === 'T') {
+        return `T ${instruction.x} ${instruction.y}`;
+    }
+    if (instruction.type === 't') {
+        return `t ${instruction.dx} ${instruction.dy}`;
+    }
+    // @ts-expect-error
+    throw new Error(`Unknown instruction type: ${instruction.type}`);
+};
+const serializeInstructions = (path) => {
+    return path
+        .map((p) => {
+        return serializeInstruction(p);
+    })
+        .join(' ');
+};
+exports.serializeInstructions = serializeInstructions;

package/dist/simplify-instructions.d.ts

@@ -0,0 +1,2 @@
+import type { Instruction, ReducedInstruction } from './helpers/types';
+export declare const reduceInstructions: (instruction: Instruction[]) => ReducedInstruction[];

package/dist/simplify-instructions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceInstructions = void 0;
+const remove_a_s_t_curves_1 = require("./helpers/remove-a-s-t-curves");
+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);
+};
+exports.reduceInstructions = reduceInstructions;

package/dist/unarc.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unarc = void 0;
+const iterate_1 = require("./helpers/iterate");
 const parse_1 = require("./helpers/parse");
 const TAU = Math.PI * 2;
 function approximate_unit_arc(theta1, delta_theta) {
@@ -79,70 +80,36 @@ function a2c({ x1, y1, x2, y2, fa, fs, rx, ry, phi, }) {
         return curve;
     });
 }
+// Requires path to be normalized
 const unarc = (d) => {
     const segments = (0, parse_1.parsePath)(d);
-    let x = 0;
-    let y = 0;
-    const newSegments = segments.map((s) => {
-        switch (s[0]) {
-            case 'M':
-            case 'L': {
-                x = s[1];
-                y = s[2];
-                return [s];
-            }
-            case 'A': {
-                const nextX = s[6];
-                const nextY = s[7];
-                const new_segments = a2c({
-                    x1: x,
-                    y1: y,
-                    x2: nextX,
-                    y2: nextY,
-                    fa: s[4],
-                    fs: s[5],
-                    rx: s[1],
-                    ry: s[2],
-                    phi: s[3],
-                });
-                // Degenerated arcs can be ignored by renderer, but should not be dropped
-                // to avoid collisions with `S A S` and so on. Replace with empty line.
-                if (new_segments.length === 0) {
-                    return [['L', s[6], s[7]]];
-                }
-                const result = [];
-                new_segments.forEach((_s) => {
-                    result.push(['C', _s[2], _s[3], _s[4], _s[5], _s[6], _s[7]]);
-                });
-                return result;
-            }
-            case 'V': {
-                y = s[1];
-                return [s];
-            }
-            case 'H': {
-                x = s[1];
-                return [s];
-            }
-            case 'C': {
-                x = s[5];
-                y = s[6];
-                return [s];
-            }
-            case 'Q': {
-                x = s[3];
-                y = s[4];
-                return [s];
-            }
-            case 'Z': {
-                return [s];
-            }
-            default:
-                throw new Error(`Unexpected instruction ${s[0]}`);
+    const x = 0;
+    const y = 0;
+    return (0, iterate_1.iterateOverSegments)(segments, ({ segment }) => {
+        const nextX = segment[6];
+        const nextY = segment[7];
+        const new_segments = a2c({
+            x1: x,
+            y1: y,
+            x2: nextX,
+            y2: nextY,
+            fa: segment[4],
+            fs: segment[5],
+            rx: segment[1],
+            ry: segment[2],
+            phi: segment[3],
+        });
+        // Degenerated arcs can be ignored by renderer, but should not be dropped
+        // to avoid collisions with `S A S` and so on. Replace with empty line.
+        if (new_segments.length === 0) {
+            return [['L', segment[6], segment[7]]];
         }
+        const result = [];
+        new_segments.forEach((_s) => {
+            result.push(['C', _s[2], _s[3], _s[4], _s[5], _s[6], _s[7]]);
+        });
+        return result;
     });
-    const flatted = newSegments.flat(1);
-    return flatted;
 };
 exports.unarc = unarc;
 function get_arc_center({ x1, y1, x2, y2, fa, fs, rx, ry, sin_phi, cos_phi, }) {

package/dist/unshort.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unshort = void 0;
+// Requires that the path is already normalized
 const unshort = function (segments) {
     let prevControlX = 0;
     let prevControlY = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/paths",
-	"version": "3.3.43",
+	"version": "3.3.44",
 	"description": "Utility functions for SVG paths",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -35,5 +35,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "3585e437a30ba001e983539728eb1914172b729c"
+	"gitHead": "7ba7bbdacbda1499ecdb92f1d9581d5db458edf8"
 }