@remotion/paths 4.0.0-webhook.27 → 4.1.0-alpha2

package/dist/helpers/construct.js

@@ -1,114 +1,159 @@
 "use strict";
 // Copied from: https://github.com/rveciana/svg-path-properties
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.construct = void 0;
+exports.construct = exports.constructFromInstructions = void 0;
+const parse_path_1 = require("../parse-path");
 const arc_1 = require("./arc");
 const bezier_1 = require("./bezier");
 const linear_1 = require("./linear");
-const parse_1 = __importDefault(require("./parse"));
-const construct = (string) => {
+const constructFromInstructions = (instructions) => {
     let length = 0;
     const partial_lengths = [];
     const functions = [];
     let initial_point = null;
-    const parsed = (0, parse_1.default)(string);
     let cur = [0, 0];
     let prev_point = [0, 0];
     let curve;
     let ringStart = [0, 0];
-    for (let i = 0; i < parsed.length; i++) {
+    const segments = [];
+    for (let i = 0; i < instructions.length; i++) {
+        const instruction = instructions[i];
+        if (instruction.type !== 'm' &&
+            instruction.type !== 'M' &&
+            segments.length > 0) {
+            segments[segments.length - 1].push(instruction);
+        }
         // moveTo
-        if (parsed[i][0] === 'M') {
-            cur = [parsed[i][1], parsed[i][2]];
+        if (instruction.type === 'M') {
+            cur = [instruction.x, instruction.y];
             ringStart = [cur[0], cur[1]];
+            segments.push([instruction]);
             functions.push(null);
             if (i === 0) {
-                initial_point = { x: parsed[i][1], y: parsed[i][2] };
+                initial_point = { x: instruction.x, y: instruction.y };
             }
         }
-        else if (parsed[i][0] === 'm') {
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+        else if (instruction.type === 'm') {
+            cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
             ringStart = [cur[0], cur[1]];
+            segments.push([{ type: 'M', x: cur[0], y: cur[1] }]);
             functions.push(null);
             // lineTo
         }
-        else if (parsed[i][0] === 'L') {
-            length += Math.sqrt((cur[0] - parsed[i][1]) ** 2 + (cur[1] - parsed[i][2]) ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]));
-            cur = [parsed[i][1], parsed[i][2]];
+        else if (instruction.type === 'L') {
+            length += Math.sqrt((cur[0] - instruction.x) ** 2 + (cur[1] - instruction.y) ** 2);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: instruction.x,
+                y0: cur[1],
+                y1: instruction.y,
+            }));
+            cur = [instruction.x, instruction.y];
         }
-        else if (parsed[i][0] === 'l') {
-            length += Math.sqrt(parsed[i][1] ** 2 + parsed[i][2] ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1] + cur[0], cur[1], parsed[i][2] + cur[1]));
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+        else if (instruction.type === 'l') {
+            length += Math.sqrt(instruction.dx ** 2 + instruction.dy ** 2);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: instruction.dx + cur[0],
+                y0: cur[1],
+                y1: instruction.dy + cur[1],
+            }));
+            cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (parsed[i][0] === 'H') {
-            length += Math.abs(cur[0] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1];
+        else if (instruction.type === 'H') {
+            length += Math.abs(cur[0] - instruction.x);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: instruction.x,
+                y0: cur[1],
+                y1: cur[1],
+            }));
+            cur[0] = instruction.x;
         }
-        else if (parsed[i][0] === 'h') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1]));
-            cur[0] = parsed[i][1] + cur[0];
+        else if (instruction.type === 'h') {
+            length += Math.abs(instruction.dx);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: cur[0] + instruction.dx,
+                y0: cur[1],
+                y1: cur[1],
+            }));
+            cur[0] = instruction.dx + cur[0];
         }
-        else if (parsed[i][0] === 'V') {
-            length += Math.abs(cur[1] - parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], parsed[i][1]));
-            cur[1] = parsed[i][1];
+        else if (instruction.type === 'V') {
+            length += Math.abs(cur[1] - instruction.y);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: cur[0],
+                y0: cur[1],
+                y1: instruction.y,
+            }));
+            cur[1] = instruction.y;
         }
-        else if (parsed[i][0] === 'v') {
-            length += Math.abs(parsed[i][1]);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1] + parsed[i][1]));
-            cur[1] = parsed[i][1] + cur[1];
+        else if (instruction.type === 'v') {
+            length += Math.abs(instruction.dy);
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: cur[0],
+                y0: cur[1],
+                y1: cur[1] + instruction.dy,
+            }));
+            cur[1] = instruction.dy + cur[1];
             // Close path
         }
-        else if (parsed[i][0] === 'z' || parsed[i][0] === 'Z') {
+        else if (instruction.type === 'Z') {
             length += Math.sqrt((ringStart[0] - cur[0]) ** 2 + (ringStart[1] - cur[1]) ** 2);
-            functions.push((0, linear_1.makeLinearPosition)(cur[0], ringStart[0], cur[1], ringStart[1]));
+            functions.push((0, linear_1.makeLinearPosition)({
+                x0: cur[0],
+                x1: ringStart[0],
+                y0: cur[1],
+                y1: ringStart[1],
+            }));
             cur = [ringStart[0], ringStart[1]];
             // Cubic Bezier curves
         }
-        else if (parsed[i][0] === 'C') {
+        else if (instruction.type === 'C') {
             curve = (0, bezier_1.makeBezier)({
                 ax: cur[0],
                 ay: cur[1],
-                bx: parsed[i][1],
-                by: parsed[i][2],
-                cx: parsed[i][3],
-                cy: parsed[i][4],
-                dx: parsed[i][5],
-                dy: parsed[i][6],
+                bx: instruction.cp1x,
+                by: instruction.cp1y,
+                cx: instruction.cp2x,
+                cy: instruction.cp2y,
+                dx: instruction.x,
+                dy: instruction.y,
             });
             length += curve.getTotalLength();
-            cur = [parsed[i][5], parsed[i][6]];
+            cur = [instruction.x, instruction.y];
             functions.push(curve);
         }
-        else if (parsed[i][0] === 'c') {
+        else if (instruction.type === 'c') {
             curve = (0, bezier_1.makeBezier)({
                 ax: cur[0],
                 ay: cur[1],
-                bx: cur[0] + parsed[i][1],
-                by: cur[1] + parsed[i][2],
-                cx: cur[0] + parsed[i][3],
-                cy: cur[1] + parsed[i][4],
-                dx: cur[0] + parsed[i][5],
-                dy: cur[1] + parsed[i][6],
+                bx: cur[0] + instruction.cp1dx,
+                by: cur[1] + instruction.cp1dy,
+                cx: cur[0] + instruction.cp2dx,
+                cy: cur[1] + instruction.cp2dy,
+                dx: cur[0] + instruction.dx,
+                dy: cur[1] + instruction.dy,
             });
             if (curve.getTotalLength() > 0) {
                 length += curve.getTotalLength();
                 functions.push(curve);
-                cur = [parsed[i][5] + cur[0], parsed[i][6] + cur[1]];
+                cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
             }
             else {
-                functions.push((0, linear_1.makeLinearPosition)(cur[0], cur[0], cur[1], cur[1]));
+                functions.push((0, linear_1.makeLinearPosition)({ x0: cur[0], x1: cur[0], y0: cur[1], y1: cur[1] }));
             }
         }
-        else if (parsed[i][0] === 'S') {
-            if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
+        else if (instruction.type === 'S') {
+            const prev = instructions[i - 1];
+            const prevWasCurve = prev.type === 'C' ||
+                prev.type === 'c' ||
+                prev.type === 'S' ||
+                prev.type === 's';
+            if (i > 0 && prevWasCurve) {
                 if (curve) {
                     const c = curve.getC();
                     curve = (0, bezier_1.makeBezier)({
@@ -116,10 +161,10 @@ const construct = (string) => {
                         ay: cur[1],
                         bx: 2 * cur[0] - c.x,
                         by: 2 * cur[1] - c.y,
-                        cx: parsed[i][1],
-                        cy: parsed[i][2],
-                        dx: parsed[i][3],
-                        dy: parsed[i][4],
+                        cx: instruction.cpx,
+                        cy: instruction.cpy,
+                        dx: instruction.x,
+                        dy: instruction.y,
                     });
                 }
             }
@@ -129,21 +174,25 @@ const construct = (string) => {
                     ay: cur[1],
                     bx: cur[0],
                     by: cur[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
-                    dx: parsed[i][3],
-                    dy: parsed[i][4],
+                    cx: instruction.cpx,
+                    cy: instruction.cpy,
+                    dx: instruction.x,
+                    dy: instruction.y,
                 });
             }
             if (curve) {
                 length += curve.getTotalLength();
-                cur = [parsed[i][3], parsed[i][4]];
+                cur = [instruction.x, instruction.y];
                 functions.push(curve);
             }
         }
-        else if (parsed[i][0] === 's') {
-            // 240 225
-            if (i > 0 && ['C', 'c', 'S', 's'].indexOf(parsed[i - 1][0]) > -1) {
+        else if (instruction.type === 's') {
+            const prev = instructions[i - 1];
+            const prevWasCurve = prev.type === 'C' ||
+                prev.type === 'c' ||
+                prev.type === 'S' ||
+                prev.type === 's';
+            if (i > 0 && prevWasCurve) {
                 if (curve) {
                     const c = curve.getC();
                     const d = curve.getD();
@@ -152,10 +201,10 @@ const construct = (string) => {
                         ay: cur[1],
                         bx: cur[0] + d.x - c.x,
                         by: cur[1] + d.y - c.y,
-                        cx: cur[0] + parsed[i][1],
-                        cy: cur[1] + parsed[i][2],
-                        dx: cur[0] + parsed[i][3],
-                        dy: cur[1] + parsed[i][4],
+                        cx: cur[0] + instruction.cpdx,
+                        cy: cur[1] + instruction.cpdy,
+                        dx: cur[0] + instruction.dx,
+                        dy: cur[1] + instruction.dy,
                     });
                 }
             }
@@ -165,22 +214,27 @@ const construct = (string) => {
                     ay: cur[1],
                     bx: cur[0],
                     by: cur[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
-                    dx: cur[0] + parsed[i][3],
-                    dy: cur[1] + parsed[i][4],
+                    cx: cur[0] + instruction.cpdx,
+                    cy: cur[1] + instruction.cpdy,
+                    dx: cur[0] + instruction.dx,
+                    dy: cur[1] + instruction.dy,
                 });
             }
             if (curve) {
                 length += curve.getTotalLength();
-                cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
+                cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
                 functions.push(curve);
             }
         }
         // Quadratic Bezier curves
-        else if (parsed[i][0] === 'Q') {
-            if (cur[0] === parsed[i][1] && cur[1] === parsed[i][2]) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(parsed[i][1], parsed[i][3], parsed[i][2], parsed[i][4]);
+        else if (instruction.type === 'Q') {
+            if (cur[0] === instruction.cpx && cur[1] === instruction.cpy) {
+                const linearCurve = (0, linear_1.makeLinearPosition)({
+                    x0: instruction.cpx,
+                    x1: instruction.x,
+                    y0: instruction.cpy,
+                    y1: instruction.y,
+                });
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
@@ -188,22 +242,27 @@ const construct = (string) => {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
-                    bx: parsed[i][1],
-                    by: parsed[i][2],
-                    cx: parsed[i][3],
-                    cy: parsed[i][4],
+                    bx: instruction.cpx,
+                    by: instruction.cpy,
+                    cx: instruction.x,
+                    cy: instruction.y,
                     dx: null,
                     dy: null,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
             }
-            cur = [parsed[i][3], parsed[i][4]];
-            prev_point = [parsed[i][1], parsed[i][2]];
+            cur = [instruction.x, instruction.y];
+            prev_point = [instruction.cpx, instruction.cpy];
         }
-        else if (parsed[i][0] === 'q') {
-            if (parsed[i][1] === 0 && parsed[i][2] === 0) {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0] + parsed[i][1], cur[0] + parsed[i][3], cur[1] + parsed[i][2], cur[1] + parsed[i][4]);
+        else if (instruction.type === 'q') {
+            if (instruction.cpdx === 0 && instruction.cpdy === 0) {
+                const linearCurve = (0, linear_1.makeLinearPosition)({
+                    x0: cur[0] + instruction.cpdx,
+                    x1: cur[0] + instruction.cpdy,
+                    y0: cur[1] + instruction.dx,
+                    y1: cur[1] + instruction.dy,
+                });
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
@@ -211,28 +270,33 @@ const construct = (string) => {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
-                    bx: cur[0] + parsed[i][1],
-                    by: cur[1] + parsed[i][2],
-                    cx: cur[0] + parsed[i][3],
-                    cy: cur[1] + parsed[i][4],
+                    bx: cur[0] + instruction.cpdx,
+                    by: cur[1] + instruction.cpdy,
+                    cx: cur[0] + instruction.dx,
+                    cy: cur[1] + instruction.dy,
                     dx: null,
                     dy: null,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
             }
-            prev_point = [cur[0] + parsed[i][1], cur[1] + parsed[i][2]];
-            cur = [parsed[i][3] + cur[0], parsed[i][4] + cur[1]];
+            prev_point = [cur[0] + instruction.cpdx, cur[1] + instruction.cpdy];
+            cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (parsed[i][0] === 'T') {
-            if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
+        else if (instruction.type === 'T') {
+            const prev = instructions[i - 1];
+            const prevWasQ = prev.type === 'Q' ||
+                prev.type === 'q' ||
+                prev.type === 'T' ||
+                prev.type === 't';
+            if (i > 0 && prevWasQ) {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
                     bx: 2 * cur[0] - prev_point[0],
                     by: 2 * cur[1] - prev_point[1],
-                    cx: parsed[i][1],
-                    cy: parsed[i][2],
+                    cx: instruction.x,
+                    cy: instruction.y,
                     dx: null,
                     dy: null,
                 });
@@ -240,22 +304,32 @@ const construct = (string) => {
                 length += curve.getTotalLength();
             }
             else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], parsed[i][1], cur[1], parsed[i][2]);
+                const linearCurve = (0, linear_1.makeLinearPosition)({
+                    x0: cur[0],
+                    x1: instruction.x,
+                    y0: cur[1],
+                    y1: instruction.y,
+                });
                 functions.push(linearCurve);
                 length += linearCurve.getTotalLength();
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1], parsed[i][2]];
+            cur = [instruction.x, instruction.y];
         }
-        else if (parsed[i][0] === 't') {
-            if (i > 0 && ['Q', 'q', 'T', 't'].indexOf(parsed[i - 1][0]) > -1) {
+        else if (instruction.type === 't') {
+            const prev = instructions[i - 1];
+            const prevWasQ = prev.type === 'Q' ||
+                prev.type === 'q' ||
+                prev.type === 'T' ||
+                prev.type === 't';
+            if (i > 0 && prevWasQ) {
                 curve = (0, bezier_1.makeBezier)({
                     ax: cur[0],
                     ay: cur[1],
                     bx: 2 * cur[0] - prev_point[0],
                     by: 2 * cur[1] - prev_point[1],
-                    cx: cur[0] + parsed[i][1],
-                    cy: cur[1] + parsed[i][2],
+                    cx: cur[0] + instruction.dx,
+                    cy: cur[1] + instruction.dy,
                     dx: null,
                     dy: null,
                 });
@@ -263,47 +337,63 @@ const construct = (string) => {
                 functions.push(curve);
             }
             else {
-                const linearCurve = (0, linear_1.makeLinearPosition)(cur[0], cur[0] + parsed[i][1], cur[1], cur[1] + parsed[i][2]);
+                const linearCurve = (0, linear_1.makeLinearPosition)({
+                    x0: cur[0],
+                    x1: cur[0] + instruction.dx,
+                    y0: cur[1],
+                    y1: cur[1] + instruction.dy,
+                });
                 length += linearCurve.getTotalLength();
                 functions.push(linearCurve);
             }
             prev_point = [2 * cur[0] - prev_point[0], 2 * cur[1] - prev_point[1]];
-            cur = [parsed[i][1] + cur[0], parsed[i][2] + cur[1]];
+            cur = [instruction.dx + cur[0], instruction.dy + cur[1]];
         }
-        else if (parsed[i][0] === 'A') {
+        else if (instruction.type === 'A') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: parsed[i][6],
-                y1: parsed[i][7],
+                rx: instruction.rx,
+                ry: instruction.ry,
+                xAxisRotate: instruction.xAxisRotation,
+                LargeArcFlag: instruction.largeArcFlag,
+                SweepFlag: instruction.sweepFlag,
+                x1: instruction.x,
+                y1: instruction.y,
             });
             length += arcCurve.getTotalLength();
-            cur = [parsed[i][6], parsed[i][7]];
+            cur = [instruction.x, instruction.y];
             functions.push(arcCurve);
         }
-        else if (parsed[i][0] === 'a') {
+        else if (instruction.type === 'a') {
             const arcCurve = (0, arc_1.makeArc)({
                 x0: cur[0],
                 y0: cur[1],
-                rx: parsed[i][1],
-                ry: parsed[i][2],
-                xAxisRotate: parsed[i][3],
-                LargeArcFlag: parsed[i][4] === 1,
-                SweepFlag: parsed[i][5] === 1,
-                x1: cur[0] + parsed[i][6],
-                y1: cur[1] + parsed[i][7],
+                rx: instruction.rx,
+                ry: instruction.ry,
+                xAxisRotate: instruction.xAxisRotation,
+                LargeArcFlag: instruction.largeArcFlag,
+                SweepFlag: instruction.sweepFlag,
+                x1: cur[0] + instruction.dx,
+                y1: cur[1] + instruction.dy,
             });
             length += arcCurve.getTotalLength();
-            cur = [cur[0] + parsed[i][6], cur[1] + parsed[i][7]];
+            cur = [cur[0] + instruction.dx, cur[1] + instruction.dy];
             functions.push(arcCurve);
         }
         partial_lengths.push(length);
     }
-    return { initial_point, length, partial_lengths, functions };
+    return {
+        segments,
+        initial_point,
+        length,
+        partial_lengths,
+        functions,
+    };
+};
+exports.constructFromInstructions = constructFromInstructions;
+const construct = (string) => {
+    const parsed = (0, parse_path_1.parsePath)(string);
+    return (0, exports.constructFromInstructions)(parsed);
 };
 exports.construct = construct;

package/dist/helpers/iterate.d.ts

@@ -0,0 +1,14 @@
+import type { AbsoluteInstruction, ReducedInstruction } from './types';
+export declare const iterateOverSegments: <T extends ReducedInstruction>({ segments, iterate, }: {
+    segments: AbsoluteInstruction[];
+    iterate: (options: {
+        segment: AbsoluteInstruction;
+        prevSegment: AbsoluteInstruction | null;
+        x: number;
+        y: number;
+        initialX: number;
+        initialY: number;
+        cpX: number | null;
+        cpY: number | null;
+    }) => T[];
+}) => T[];

package/dist/helpers/iterate.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateOverSegments = void 0;
+const iterateOverSegments = ({ segments, iterate, }) => {
+    let x = 0;
+    let y = 0;
+    let initialX = 0;
+    let initialY = 0;
+    let cpX = null;
+    let cpY = null;
+    const newSegments = segments.map((s, i) => {
+        var _a;
+        const newSeg = iterate({
+            segment: s,
+            x,
+            y,
+            prevSegment: (_a = segments[i - 1]) !== null && _a !== void 0 ? _a : null,
+            initialX,
+            initialY,
+            cpX,
+            cpY,
+        });
+        switch (s.type) {
+            case 'M':
+                initialX = s.x;
+                initialY = s.y;
+                x = s.x;
+                y = s.y;
+                cpX = null;
+                cpY = null;
+                break;
+            case 'Q':
+                x = s.x;
+                y = s.y;
+                cpX = s.cpx;
+                cpY = s.cpy;
+                break;
+            case 'A':
+                x = s.x;
+                y = s.y;
+                cpX = null;
+                cpY = null;
+                break;
+            case 'C':
+                x = s.x;
+                y = s.y;
+                cpX = s.cp2x;
+                cpY = s.cp2y;
+                break;
+            case 'S':
+                x = s.x;
+                y = s.y;
+                cpX = s.cpx;
+                cpY = s.cpy;
+                break;
+            case 'T':
+                // Order of if statement is important here
+                if (cpX !== null && cpY !== null) {
+                    cpX = x - (cpX - x);
+                    cpY = y - (cpY - y);
+                }
+                x = s.x;
+                y = s.y;
+                break;
+            case 'L':
+                x = s.x;
+                y = s.y;
+                cpX = null;
+                cpY = null;
+                break;
+            case 'V':
+                y = s.y;
+                cpX = null;
+                cpY = null;
+                break;
+            case 'H':
+                x = s.x;
+                cpX = null;
+                cpY = null;
+                break;
+            case 'Z':
+                x = initialX;
+                y = initialY;
+                cpX = null;
+                cpY = null;
+                break;
+            default:
+                // @ts-expect-error
+                throw new Error(`Unexpected instruction ${s.type}`);
+        }
+        return newSeg;
+    });
+    return newSegments.flat(1);
+};
+exports.iterateOverSegments = iterateOverSegments;

package/dist/helpers/linear.d.ts

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

package/dist/helpers/linear.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLinearPosition = void 0;
-const makeLinearPosition = (x0, x1, y0, y1) => {
+const makeLinearPosition = ({ x0, x1, y0, y1, }) => {
     const getTotalLength = () => {
         return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
     };

package/dist/helpers/remove-a-s-t-curves.d.ts

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