@remotion/paths 3.3.39 → 3.3.41

package/dist/parse-path.js

@@ -0,0 +1,259 @@
+"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 === '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/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/reduce-instructions.d.ts

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

package/dist/reduce-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/reset-path.d.ts

@@ -0,0 +1 @@
+export declare const resetPath: (d: string) => string;

package/dist/reset-path.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetPath = void 0;
+const get_bounding_box_1 = require("./get-bounding-box");
+const translate_path_1 = require("./translate-path");
+const resetPath = (d) => {
+    const box = (0, get_bounding_box_1.getBoundingBox)(d);
+    return (0, translate_path_1.translatePath)(d, -box.x1, -box.y1);
+};
+exports.resetPath = resetPath;

package/dist/serialize-instructions.d.ts

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

package/dist/serialize-instructions.js

@@ -0,0 +1,72 @@
+"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 === '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/serialize.d.ts

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