@remotion/paths 3.3.44 → 3.3.51

package/package.json

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

package/dist/helpers/parse.d.ts

@@ -1,2 +0,0 @@
-export declare type Instruction = [string, ...number[]];
-export declare const parsePath: (path: string) => Instruction[];

package/dist/helpers/parse.js

@@ -1,51 +0,0 @@
-"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,
-    c: 6,
-    h: 1,
-    l: 2,
-    m: 2,
-    q: 4,
-    s: 4,
-    t: 2,
-    v: 1,
-    z: 0,
-};
-const segmentRegExp = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
-const numberRegExp = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
-const parsePath = (path) => {
-    const segments = (path && path.length > 0 ? path : 'M0,0').match(segmentRegExp);
-    if (!segments) {
-        throw new Error(`No path elements found in string ${path}`);
-    }
-    return segments.reduce((segmentsArray, segmentString) => {
-        let command = segmentString.charAt(0);
-        let type = command.toLowerCase();
-        const args = parseValues(segmentString.substr(1));
-        // overloaded moveTo
-        if (type === 'm' && args.length > 2) {
-            segmentsArray.push([command, ...args.splice(0, 2)]);
-            type = 'l';
-            command = command === 'm' ? 'l' : 'L';
-        }
-        while (args.length >= 0) {
-            if (args.length === length[type]) {
-                segmentsArray.push([command, ...args.splice(0, length[type])]);
-                break;
-            }
-            if (args.length < length[type]) {
-                throw new Error(`Malformed path data: "${command}" must have ${length[type]} elements and has ${args.length}: ${segmentString}`);
-            }
-            segmentsArray.push([command, ...args.splice(0, length[type])]);
-        }
-        return segmentsArray;
-    }, []);
-};
-exports.parsePath = parsePath;
-const parseValues = (args) => {
-    const numbers = args.match(numberRegExp);
-    return numbers ? numbers.map(Number) : [];
-};

package/dist/helpers/serialize.d.ts

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

package/dist/helpers/serialize.js

@@ -1,75 +0,0 @@
-"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

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

package/dist/helpers/unarc.js

@@ -1,254 +0,0 @@
-"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

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

package/dist/helpers/unshort.js

@@ -1,65 +0,0 @@
-"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

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

package/dist/parse.js

@@ -1,266 +0,0 @@
-"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

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

package/dist/serialize.js

@@ -1,75 +0,0 @@
-"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

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

package/dist/simplify-instructions.js

@@ -1,10 +0,0 @@
-"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.d.ts

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

package/dist/unarc.js

@@ -1,180 +0,0 @@
-"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) {
-    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 a2c({ x1, y1, x2, y2, fa, fs, 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, fa, fs, 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 unarc = (d) => {
-    const segments = (0, parse_1.parsePath)(d);
-    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;
-    });
-};
-exports.unarc = unarc;
-function get_arc_center({ x1, y1, x2, y2, fa, fs, 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) * (fa === fs ? -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 (fs === 0 && delta_theta > 0) {
-        delta_theta -= TAU;
-    }
-    if (fs === 1 && 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/unshort.d.ts

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

package/dist/unshort.js

@@ -1,118 +0,0 @@
-"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;
-    let x = 0;
-    let y = 0;
-    const newSegments = segments.slice(0);
-    for (let i = 0; i < newSegments.length; i++) {
-        const s = newSegments[i];
-        const name = s[0];
-        switch (s[0]) {
-            case 'M':
-            case 'L': {
-                x = s[1];
-                y = s[2];
-                break;
-            }
-            case 'V': {
-                y = s[1];
-                break;
-            }
-            case 'H': {
-                x = s[1];
-                break;
-            }
-            case 'C': {
-                x = s[5];
-                y = s[6];
-                break;
-            }
-            case 'Q': {
-                x = s[3];
-                y = s[4];
-                break;
-            }
-            case 'Z':
-                break;
-            default:
-                throw new Error('Unexpected command: ' + s[0]);
-        }
-        const nameUC = name.toUpperCase();
-        let isRelative;
-        // First command MUST be M|m, it's safe to skip.
-        // Protect from access to [-1] for sure.
-        if (!i) {
-            continue;
-        }
-        if (nameUC === 'T') {
-            // quadratic curve
-            isRelative = name === 't';
-            const prevSegment = newSegments[i - 1];
-            if (prevSegment[0] === 'Q') {
-                prevControlX = prevSegment[1] - x;
-                prevControlY = prevSegment[2] - y;
-            }
-            else if (prevSegment[0] === 'q') {
-                prevControlX = prevSegment[1] - prevSegment[3];
-                prevControlY = prevSegment[2] - prevSegment[4];
-            }
-            else {
-                prevControlX = 0;
-                prevControlY = 0;
-            }
-            curControlX = -prevControlX;
-            curControlY = -prevControlY;
-            if (!isRelative) {
-                curControlX += x;
-                curControlY += y;
-            }
-            newSegments[i] = [
-                isRelative ? 'q' : 'Q',
-                curControlX,
-                curControlY,
-                s[1],
-                s[2],
-            ];
-        }
-        else if (nameUC === 'S') {
-            // cubic curve
-            isRelative = name === 's';
-            const prevSegment = newSegments[i - 1];
-            if (prevSegment[0] === 'C') {
-                prevControlX = prevSegment[3] - x;
-                prevControlY = prevSegment[4] - y;
-            }
-            else if (prevSegment[0] === 'c') {
-                prevControlX = prevSegment[3] - prevSegment[5];
-                prevControlY = prevSegment[4] - prevSegment[6];
-            }
-            else {
-                prevControlX = 0;
-                prevControlY = 0;
-            }
-            curControlX = -prevControlX;
-            curControlY = -prevControlY;
-            if (!isRelative) {
-                curControlX += x;
-                curControlY += y;
-            }
-            newSegments[i] = [
-                isRelative ? 'c' : 'C',
-                curControlX,
-                curControlY,
-                s[1],
-                s[2],
-                s[3],
-                s[4],
-            ];
-        }
-    }
-    return newSegments;
-};
-exports.unshort = unshort;