@remotion/paths 3.3.41 → 3.3.43

package/dist/get-bounding-box.d.ts

@@ -1,2 +1,3 @@
-import type { BoundingBox } from './helpers/types';
+import type { BoundingBox, ReducedInstruction } from './helpers/types';
 export declare const getBoundingBox: (d: string) => BoundingBox;
+export declare const getBoundingBoxFromInstructions: (instructions: ReducedInstruction[]) => BoundingBox;

package/dist/get-bounding-box.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBoundingBox = void 0;
+exports.getBoundingBoxFromInstructions = exports.getBoundingBox = void 0;
 const remove_a_s_t_curves_1 = require("./helpers/remove-a-s-t-curves");
 const normalize_path_1 = require("./normalize-path");
 const parse_path_1 = require("./parse-path");
@@ -68,15 +68,19 @@ function minmaxC(A) {
     return [min, max];
 }
 const getBoundingBox = (d) => {
+    const parsed = (0, parse_path_1.parsePath)(d);
+    const unarced = (0, remove_a_s_t_curves_1.removeATSHVInstructions)((0, normalize_path_1.normalizeInstructions)(parsed));
+    return (0, exports.getBoundingBoxFromInstructions)(unarced);
+};
+exports.getBoundingBox = getBoundingBox;
+const getBoundingBoxFromInstructions = (instructions) => {
     let minX = Infinity;
     let minY = Infinity;
     let maxX = -Infinity;
     let maxY = -Infinity;
-    const parsed = (0, parse_path_1.parsePath)((0, normalize_path_1.normalizePath)(d));
-    const unarced = (0, remove_a_s_t_curves_1.removeATSHVInstructions)(parsed);
     let x = 0;
     let y = 0;
-    for (const seg of unarced) {
+    for (const seg of instructions) {
         switch (seg.type) {
             case 'M':
             case 'L': {
@@ -143,4 +147,4 @@ const getBoundingBox = (d) => {
     }
     return { x1: minX, y1: minY, x2: maxX, y2: maxY };
 };
-exports.getBoundingBox = getBoundingBox;
+exports.getBoundingBoxFromInstructions = getBoundingBoxFromInstructions;

package/dist/index.d.ts

@@ -13,5 +13,7 @@ export { parsePath } from './parse-path';
 export { reduceInstructions } from './reduce-instructions';
 export { resetPath } from './reset-path';
 export { reversePath } from './reverse-path';
+export { scalePath } from './scale-path';
 export { serializeInstructions } from './serialize-instructions';
 export { translatePath } from './translate-path';
+export { warpPath, WarpPathFn } from './warp-path';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translatePath = exports.serializeInstructions = exports.reversePath = exports.resetPath = exports.reduceInstructions = exports.parsePath = exports.normalizePath = exports.interpolatePath = exports.getTangentAtLength = exports.getSubpaths = exports.getPointAtLength = exports.getParts = exports.getLength = exports.getBoundingBox = exports.extendViewBox = exports.evolvePath = void 0;
+exports.warpPath = exports.translatePath = exports.serializeInstructions = exports.scalePath = exports.reversePath = exports.resetPath = exports.reduceInstructions = exports.parsePath = exports.normalizePath = exports.interpolatePath = exports.getTangentAtLength = exports.getSubpaths = exports.getPointAtLength = exports.getParts = exports.getLength = exports.getBoundingBox = exports.extendViewBox = exports.evolvePath = void 0;
 var evolve_path_1 = require("./evolve-path");
 Object.defineProperty(exports, "evolvePath", { enumerable: true, get: function () { return evolve_path_1.evolvePath; } });
 var extend_viewbox_1 = require("./extend-viewbox");
@@ -29,7 +29,11 @@ var reset_path_1 = require("./reset-path");
 Object.defineProperty(exports, "resetPath", { enumerable: true, get: function () { return reset_path_1.resetPath; } });
 var reverse_path_1 = require("./reverse-path");
 Object.defineProperty(exports, "reversePath", { enumerable: true, get: function () { return reverse_path_1.reversePath; } });
+var scale_path_1 = require("./scale-path");
+Object.defineProperty(exports, "scalePath", { enumerable: true, get: function () { return scale_path_1.scalePath; } });
 var serialize_instructions_1 = require("./serialize-instructions");
 Object.defineProperty(exports, "serializeInstructions", { enumerable: true, get: function () { return serialize_instructions_1.serializeInstructions; } });
 var translate_path_1 = require("./translate-path");
 Object.defineProperty(exports, "translatePath", { enumerable: true, get: function () { return translate_path_1.translatePath; } });
+var warp_path_1 = require("./warp-path");
+Object.defineProperty(exports, "warpPath", { enumerable: true, get: function () { return warp_path_1.warpPath; } });

package/dist/scale-path.d.ts

@@ -0,0 +1 @@
+export declare const scalePath: (d: string, scaleX: number, scaleY: number) => string;

package/dist/scale-path.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalePath = void 0;
+const get_bounding_box_1 = require("./get-bounding-box");
+const parse_path_1 = require("./parse-path");
+const reduce_instructions_1 = require("./reduce-instructions");
+const serialize_instructions_1 = require("./serialize-instructions");
+const translate_path_1 = require("./translate-path");
+const scalePath = (d, scaleX, scaleY) => {
+    const reduced = (0, reduce_instructions_1.reduceInstructions)((0, parse_path_1.parsePath)(d));
+    const bounded = (0, get_bounding_box_1.getBoundingBoxFromInstructions)(reduced);
+    const zeroed = (0, translate_path_1.translateSegments)(reduced, -bounded.x1, -bounded.y1);
+    const mapped = zeroed.map((instruction) => {
+        if (instruction.type === 'L') {
+            return {
+                type: 'L',
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'C') {
+            return {
+                type: 'C',
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+                cp1x: scaleX * instruction.cp1x,
+                cp1y: scaleY * instruction.cp1y,
+                cp2x: scaleX * instruction.cp2x,
+                cp2y: scaleY * instruction.cp2y,
+            };
+        }
+        if (instruction.type === 'M') {
+            return {
+                type: 'M',
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'Q') {
+            return {
+                type: 'Q',
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+                cpx: scaleX * instruction.cpx,
+                cpy: scaleY * instruction.cpy,
+            };
+        }
+        if (instruction.type === 'Z') {
+            return {
+                type: 'Z',
+            };
+        }
+        if (instruction.type === 'A') {
+            return {
+                type: 'A',
+                largeArcFlag: instruction.largeArcFlag,
+                rx: scaleX * instruction.rx,
+                ry: scaleY * instruction.ry,
+                sweepFlag: instruction.sweepFlag,
+                xAxisRotation: instruction.xAxisRotation,
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'H') {
+            return {
+                type: 'H',
+                x: scaleX * instruction.x,
+            };
+        }
+        if (instruction.type === 'S') {
+            return {
+                type: 'S',
+                cpx: scaleX * instruction.cpx,
+                cpy: scaleY * instruction.cpy,
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'T') {
+            return {
+                type: 'T',
+                x: scaleX * instruction.x,
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'V') {
+            return {
+                type: 'V',
+                y: scaleY * instruction.y,
+            };
+        }
+        if (instruction.type === 'a') {
+            return {
+                type: 'a',
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+                largeArcFlag: instruction.largeArcFlag,
+                rx: scaleX * instruction.rx,
+                ry: scaleY * instruction.ry,
+                sweepFlag: instruction.sweepFlag,
+                xAxisRotation: instruction.xAxisRotation,
+            };
+        }
+        if (instruction.type === 'c') {
+            return {
+                type: 'c',
+                cp1dx: scaleX * instruction.cp1dx,
+                cp1dy: scaleY * instruction.cp1dy,
+                cp2dx: scaleX * instruction.cp2dx,
+                cp2dy: scaleY * instruction.cp2dy,
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 'h') {
+            return {
+                type: 'h',
+                dx: scaleX * instruction.dx,
+            };
+        }
+        if (instruction.type === 'l') {
+            return {
+                type: 'l',
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 'm') {
+            return {
+                type: 'm',
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 'q') {
+            return {
+                type: 'q',
+                cpdx: scaleX * instruction.cpdx,
+                cpdy: scaleY * instruction.cpdy,
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 's') {
+            return {
+                type: 's',
+                cpdx: scaleX * instruction.cpdx,
+                cpdy: scaleY * instruction.cpdy,
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 't') {
+            return {
+                type: 't',
+                dx: scaleX * instruction.dx,
+                dy: scaleY * instruction.dy,
+            };
+        }
+        if (instruction.type === 'v') {
+            return {
+                type: 'v',
+                dy: scaleY * instruction.dy,
+            };
+        }
+        throw new Error('unexpected function');
+    });
+    return (0, serialize_instructions_1.serializeInstructions)((0, translate_path_1.translateSegments)(mapped, bounded.x1, bounded.y1));
+};
+exports.scalePath = scalePath;

package/dist/translate-path.d.ts

@@ -1 +1,3 @@
+import type { Instruction } from './helpers/types';
+export declare const translateSegments: (segments: Instruction[], x: number, y: number) => Instruction[];
 export declare const translatePath: (path: string, x: number, y: number) => string;

package/dist/translate-path.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.translatePath = void 0;
+exports.translatePath = exports.translateSegments = void 0;
 const parse_path_1 = require("./parse-path");
 const serialize_instructions_1 = require("./serialize-instructions");
 const translateSegments = (segments, x, y) => {
@@ -101,7 +101,8 @@ const translateSegments = (segments, x, y) => {
         throw new Error(`Unknown segment type: ${segment.type}`);
     });
 };
+exports.translateSegments = translateSegments;
 const translatePath = (path, x, y) => {
-    return (0, serialize_instructions_1.serializeInstructions)(translateSegments((0, parse_path_1.parsePath)(path), x, y));
+    return (0, serialize_instructions_1.serializeInstructions)((0, exports.translateSegments)((0, parse_path_1.parsePath)(path), x, y));
 };
 exports.translatePath = translatePath;

package/dist/unarc.js

@@ -1,7 +1,6 @@
 "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) {
@@ -80,36 +79,70 @@ 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);
-    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]]];
+    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 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,7 +1,6 @@
 "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/dist/warp-path/index.d.ts

@@ -0,0 +1,5 @@
+import type { WarpPathFn } from './warp-helpers';
+export declare const warpPath: (path: string, transformer: WarpPathFn, options?: {
+    interpolationThreshold?: number;
+}) => string;
+export type { WarpPathFn } from './warp-helpers';

package/dist/warp-path/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warpPath = void 0;
+const get_bounding_box_1 = require("../get-bounding-box");
+const parse_path_1 = require("../parse-path");
+const reduce_instructions_1 = require("../reduce-instructions");
+const serialize_instructions_1 = require("../serialize-instructions");
+const warp_helpers_1 = require("./warp-helpers");
+const getDefaultInterpolationThreshold = (instructions) => {
+    const boundingBox = (0, get_bounding_box_1.getBoundingBoxFromInstructions)(instructions);
+    const longer = Math.max(boundingBox.y2 - boundingBox.y1, boundingBox.x2 - boundingBox.x1);
+    return longer * 0.01;
+};
+const warpPath = (path, transformer, options) => {
+    var _a;
+    const reduced = (0, reduce_instructions_1.reduceInstructions)((0, parse_path_1.parsePath)(path));
+    const withZFix = (0, warp_helpers_1.fixZInstruction)(reduced);
+    const interpolated = (0, warp_helpers_1.svgPathInterpolate)(withZFix, (_a = options === null || options === void 0 ? void 0 : options.interpolationThreshold) !== null && _a !== void 0 ? _a : getDefaultInterpolationThreshold(withZFix));
+    return (0, serialize_instructions_1.serializeInstructions)((0, warp_helpers_1.warpTransform)(interpolated, transformer));
+};
+exports.warpPath = warpPath;

package/dist/warp-path/warp-helpers.d.ts

@@ -0,0 +1,14 @@
+import type { ReducedInstruction } from '../helpers/types';
+export declare type WarpPathFn = (point: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare function svgPathInterpolate(path: ReducedInstruction[], threshold: number): ReducedInstruction[];
+export declare const warpTransform: (path: ReducedInstruction[], transformer: WarpPathFn) => ReducedInstruction[];
+export declare const fixZInstruction: (instructions: ReducedInstruction[]) => ReducedInstruction[];
+export declare function interpolateUntil(points: [number, number][], threshold: number, deltaFunction?: (points: [number, number][]) => number): [number, number][][];
+export declare function split(p: number[][], t?: number): number[][][];
+export declare function createLineSegment(points: number[][]): ReducedInstruction;

package/dist/warp-path/warp-helpers.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLineSegment = exports.split = exports.interpolateUntil = exports.fixZInstruction = exports.warpTransform = exports.svgPathInterpolate = void 0;
+function svgPathInterpolate(path, threshold) {
+    let didWork = false;
+    const deltaFunction = (points) => {
+        const linearPoints = [
+            points[0].slice(0, 2),
+            points[points.length - 1].slice(0, 2),
+        ];
+        const delta = euclideanDistance(linearPoints);
+        didWork = didWork || delta > threshold;
+        return delta;
+    };
+    return warpInterpolate(path, threshold, deltaFunction);
+}
+exports.svgPathInterpolate = svgPathInterpolate;
+function warpInterpolate(path, threshold, deltaFunction) {
+    let prexX = 0;
+    let prexY = 0;
+    return path
+        .map((segment) => {
+        const points = [[prexX, prexY]];
+        if (segment.type !== 'Z') {
+            prexX = segment.x;
+            prexY = segment.y;
+        }
+        if (segment.type === 'C') {
+            points.push([segment.cp1x, segment.cp1y]);
+            points.push([segment.cp2x, segment.cp2y]);
+            points.push([segment.x, segment.y]);
+        }
+        if (segment.type === 'L') {
+            points.push([segment.x, segment.y]);
+        }
+        if (segment.type === 'Q') {
+            points.push([segment.cpx, segment.cpy]);
+            points.push([segment.x, segment.y]);
+        }
+        if (segment.type === 'C' ||
+            segment.type === 'Q' ||
+            segment.type === 'L') {
+            return interpolateUntil(points, threshold, deltaFunction).map((rawSegment) => createLineSegment(rawSegment));
+        }
+        return [segment];
+    })
+        .flat(1);
+}
+const warpTransform = (path, transformer) => {
+    return path
+        .map((segment) => {
+        if (segment.type === 'L') {
+            const { x, y } = transformer({ x: segment.x, y: segment.y });
+            return [
+                {
+                    type: 'L',
+                    x,
+                    y,
+                },
+            ];
+        }
+        if (segment.type === 'Q') {
+            const { x, y } = transformer({ x: segment.x, y: segment.y });
+            const { x: cpx, y: cpy } = transformer({
+                x: segment.cpx,
+                y: segment.cpy,
+            });
+            return [
+                {
+                    type: 'Q',
+                    x,
+                    y,
+                    cpx,
+                    cpy,
+                },
+            ];
+        }
+        if (segment.type === 'C') {
+            const { x, y } = transformer({ x: segment.x, y: segment.y });
+            const { x: cp1x, y: cp1y } = transformer({
+                x: segment.cp1x,
+                y: segment.cp1y,
+            });
+            const { x: cp2x, y: cp2y } = transformer({
+                x: segment.cp2x,
+                y: segment.cp2y,
+            });
+            return [
+                {
+                    type: 'C',
+                    x,
+                    y,
+                    cp1x,
+                    cp1y,
+                    cp2x,
+                    cp2y,
+                },
+            ];
+        }
+        if (segment.type === 'M') {
+            const { x, y } = transformer({ x: segment.x, y: segment.y });
+            return [
+                {
+                    type: 'M',
+                    x,
+                    y,
+                },
+            ];
+        }
+        return [segment];
+    })
+        .flat(1);
+};
+exports.warpTransform = warpTransform;
+// Add a line from second to last point to last point and then keep Z so it can be transformed as well
+const fixZInstruction = (instructions) => {
+    let prevX = 0;
+    let prevY = 0;
+    return instructions
+        .map((instruction) => {
+        if (instruction.type === 'Z') {
+            return [
+                {
+                    type: 'L',
+                    x: prevX,
+                    y: prevY,
+                },
+                {
+                    type: 'Z',
+                },
+            ];
+        }
+        if (instruction.type === 'M') {
+            prevX = instruction.x;
+            prevY = instruction.y;
+        }
+        return [instruction];
+    })
+        .flat(1);
+};
+exports.fixZInstruction = fixZInstruction;
+const euclideanDistance = (points) => {
+    const startPoint = points[0];
+    const endPoint = points[points.length - 1];
+    let d2 = 0;
+    for (let i = 0; i < startPoint.length; i++) {
+        const d = endPoint[i] - startPoint[i];
+        d2 += d ** 2;
+    }
+    return Math.sqrt(d2);
+};
+function interpolateUntil(points, threshold, deltaFunction = euclideanDistance) {
+    const stack = [points];
+    const segments = [];
+    while (stack.length > 0) {
+        const currentPoints = stack.pop();
+        if (deltaFunction(currentPoints) > threshold) {
+            const newPoints = split(currentPoints);
+            // Add new segments backwards so they end up in correct order
+            for (let i = newPoints.length - 1; i >= 0; i--) {
+                stack.push(newPoints[i]);
+            }
+        }
+        else {
+            segments.push(currentPoints);
+        }
+    }
+    return segments;
+}
+exports.interpolateUntil = interpolateUntil;
+function split(p, t = 0.5) {
+    const seg0 = [];
+    const seg1 = [];
+    const orders = [p];
+    while (orders.length < p.length) {
+        const q = orders[orders.length - 1];
+        const r = [];
+        for (let i = 1; i < q.length; i++) {
+            const q0 = q[i - 1];
+            const q1 = q[i];
+            const s = [];
+            const dim = Math.max(q0.length, q1.length);
+            for (let j = 0; j < dim; j++) {
+                const s0 = q0[j] || 0;
+                const s1 = q1[j] || 0;
+                s.push(s0 + (s1 - s0) * t);
+            }
+            r.push(s);
+        }
+        orders.push(r);
+    }
+    for (let i = 0; i < orders.length; i++) {
+        seg0.push(orders[i][0]);
+        seg1.push(orders[orders.length - 1 - i][i]);
+    }
+    return [seg0, seg1];
+}
+exports.split = split;
+function createLineSegment(points) {
+    switch (points.length) {
+        case 2:
+            return {
+                type: 'L',
+                x: points[1][0],
+                y: points[1][1],
+            };
+        case 3:
+            return {
+                type: 'Q',
+                cpx: points[1][0],
+                cpy: points[1][1],
+                x: points[2][0],
+                y: points[2][1],
+            };
+        case 4:
+            return {
+                type: 'C',
+                cp1x: points[1][0],
+                cp1y: points[1][1],
+                cp2x: points[2][0],
+                cp2y: points[2][1],
+                x: points[3][0],
+                y: points[3][1],
+            };
+        default:
+            throw new Error('Expected 2, 3 or 4 points for a line segment, got ' + points.length);
+    }
+}
+exports.createLineSegment = createLineSegment;

package/package.json

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

package/dist/helpers/serialize.d.ts

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