@remotion/studio 4.0.476 → 4.0.477

package/dist/components/selected-outline-drag.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uvsEqual = exports.compensateTranslateForTransformOrigin = exports.parseCssRotationToRadians = exports.clearSelectedOutlineRotationDragOverrides = exports.clearSelectedOutlineScaleDragOverrides = exports.getSelectedOutlineKeyboardNudgeDirection = exports.clearSelectedOutlineDragOverrides = exports.getSelectedOutlineRotationDragChanges = exports.getSelectedOutlineRotationDragValues = exports.getSelectedOutlineRotationDragStates = exports.getSelectedOutlineScaleDragChanges = exports.getSelectedOutlineScaleDragValues = exports.getSelectedOutlineScaleDragStates = exports.getSelectedOutlineScaleEdgeInfo = exports.getSelectedOutlineKeyboardNudgeDeltas = exports.getSelectedOutlineKeyboardNudgeDelta = exports.getSelectedOutlineDragChanges = exports.isSelectedOutlineDragPastThreshold = exports.applySelectedOutlineDragAxisLock = exports.getSelectedOutlineDragValues = exports.getSelectedOutlineDragStates = void 0;
+const remotion_1 = require("remotion");
+const no_react_1 = require("remotion/no-react");
+const selected_outline_geometry_1 = require("./selected-outline-geometry");
+const selected_outline_measurement_1 = require("./selected-outline-measurement");
+const selected_outline_types_1 = require("./selected-outline-types");
+const timeline_field_utils_1 = require("./Timeline/timeline-field-utils");
+const timeline_rotation_utils_1 = require("./Timeline/timeline-rotation-utils");
+const timeline_translate_utils_1 = require("./Timeline/timeline-translate-utils");
+const TimelineScaleField_1 = require("./Timeline/TimelineScaleField");
+const getSelectedOutlineDragStates = ({ dragTargets, getDragOverrides, timelinePosition, }) => {
+    return dragTargets.map((target) => {
+        var _a;
+        const dragOverrideValue = ((_a = getDragOverrides(target.nodePath)) !== null && _a !== void 0 ? _a : {})[selected_outline_types_1.translateFieldKey];
+        const sourceFrame = timelinePosition - target.keyframeDisplayOffset;
+        const effectiveValue = remotion_1.Internals.getEffectiveVisualModeValue({
+            propStatus: target.propStatus,
+            dragOverrideValue,
+            defaultValue: target.fieldDefault,
+            frame: sourceFrame,
+            shouldResortToDefaultValueIfUndefined: true,
+        });
+        const [startX, startY] = (0, timeline_translate_utils_1.parseTranslate)(String(effectiveValue !== null && effectiveValue !== void 0 ? effectiveValue : '0px 0px'));
+        return {
+            defaultValue: target.fieldDefault !== undefined
+                ? JSON.stringify(target.fieldDefault)
+                : null,
+            key: remotion_1.Internals.makeSequencePropsSubscriptionKey(target.nodePath),
+            sourceFrame,
+            startX,
+            startY,
+            target,
+        };
+    });
+};
+exports.getSelectedOutlineDragStates = getSelectedOutlineDragStates;
+const getSelectedOutlineDragValues = ({ dragStates, deltaX, deltaY, }) => {
+    return new Map(dragStates.map((dragState) => [
+        dragState.key,
+        (0, timeline_translate_utils_1.serializeTranslate)(dragState.startX + deltaX, dragState.startY + deltaY),
+    ]));
+};
+exports.getSelectedOutlineDragValues = getSelectedOutlineDragValues;
+const applySelectedOutlineDragAxisLock = ({ deltaX, deltaY, axisLocked, }) => {
+    if (!axisLocked) {
+        return { deltaX, deltaY };
+    }
+    if (Math.abs(deltaX) >= Math.abs(deltaY)) {
+        return { deltaX, deltaY: 0 };
+    }
+    return { deltaX: 0, deltaY };
+};
+exports.applySelectedOutlineDragAxisLock = applySelectedOutlineDragAxisLock;
+const isSelectedOutlineDragPastThreshold = ({ deltaX, deltaY, }) => {
+    return Math.hypot(deltaX, deltaY) >= selected_outline_types_1.selectedOutlineDragThresholdPx;
+};
+exports.isSelectedOutlineDragPastThreshold = isSelectedOutlineDragPastThreshold;
+const getSelectedOutlineDragChanges = ({ dragStates, lastValues, }) => {
+    const changes = [];
+    for (const dragState of dragStates) {
+        const value = lastValues.get(dragState.key);
+        if (value === undefined) {
+            continue;
+        }
+        if (dragState.target.propStatus.status === 'keyframed') {
+            const startValue = (0, timeline_translate_utils_1.serializeTranslate)(dragState.startX, dragState.startY);
+            if (value === startValue) {
+                continue;
+            }
+            changes.push({
+                type: 'keyframed',
+                fileName: dragState.target.nodePath.absolutePath,
+                nodePath: dragState.target.nodePath,
+                fieldKey: selected_outline_types_1.translateFieldKey,
+                sourceFrame: dragState.sourceFrame,
+                value,
+                schema: dragState.target.schema,
+                clientId: dragState.target.clientId,
+            });
+            continue;
+        }
+        const stringifiedValue = JSON.stringify(value);
+        const shouldSave = value !== dragState.target.propStatus.codeValue &&
+            !(dragState.defaultValue === stringifiedValue &&
+                dragState.target.propStatus.codeValue === undefined);
+        if (!shouldSave) {
+            continue;
+        }
+        changes.push({
+            type: 'static',
+            fileName: dragState.target.nodePath.absolutePath,
+            nodePath: dragState.target.nodePath,
+            fieldKey: selected_outline_types_1.translateFieldKey,
+            value,
+            defaultValue: dragState.defaultValue,
+            schema: dragState.target.schema,
+        });
+    }
+    return changes;
+};
+exports.getSelectedOutlineDragChanges = getSelectedOutlineDragChanges;
+const getSelectedOutlineKeyboardNudgeDelta = ({ direction, shiftKey, }) => {
+    const increment = shiftKey ? 10 : 1;
+    return direction === 'left' || direction === 'up' ? -increment : increment;
+};
+exports.getSelectedOutlineKeyboardNudgeDelta = getSelectedOutlineKeyboardNudgeDelta;
+const getSelectedOutlineKeyboardNudgeDeltas = ({ deltaX, deltaY, direction, shiftKey, }) => {
+    const delta = (0, exports.getSelectedOutlineKeyboardNudgeDelta)({
+        direction,
+        shiftKey,
+    });
+    if (direction === 'left' || direction === 'right') {
+        return { deltaX: deltaX + delta, deltaY };
+    }
+    return { deltaX, deltaY: deltaY + delta };
+};
+exports.getSelectedOutlineKeyboardNudgeDeltas = getSelectedOutlineKeyboardNudgeDeltas;
+const getScaleCursor = (normal) => {
+    const degrees = Math.atan2(normal.y, normal.x) * (180 / Math.PI);
+    const normalizedDegrees = ((degrees % 180) + 180) % 180;
+    const snappedDegrees = Math.round(normalizedDegrees / 45) * 45;
+    if (snappedDegrees === 0 || snappedDegrees === 180) {
+        return 'ew-resize';
+    }
+    if (snappedDegrees === 45) {
+        return 'nwse-resize';
+    }
+    if (snappedDegrees === 90) {
+        return 'ns-resize';
+    }
+    return 'nesw-resize';
+};
+const getSelectedOutlineScaleEdgeInfo = (points, edge) => {
+    const [tl, tr, br, bl] = points;
+    const edgePoints = {
+        top: { start: tl, end: tr, oppositeStart: bl, oppositeEnd: br },
+        right: { start: tr, end: br, oppositeStart: tl, oppositeEnd: bl },
+        bottom: { start: bl, end: br, oppositeStart: tl, oppositeEnd: tr },
+        left: { start: tl, end: bl, oppositeStart: tr, oppositeEnd: br },
+    }[edge];
+    const edgeMidpoint = (0, selected_outline_measurement_1.midpoint)(edgePoints.start, edgePoints.end);
+    const oppositeMidpoint = (0, selected_outline_measurement_1.midpoint)(edgePoints.oppositeStart, edgePoints.oppositeEnd);
+    const outward = (0, selected_outline_measurement_1.vectorBetween)(oppositeMidpoint, edgeMidpoint);
+    const length = (0, selected_outline_measurement_1.vectorLength)(outward);
+    if (length < 0.001) {
+        return null;
+    }
+    return {
+        axis: edge === 'left' || edge === 'right' ? 'x' : 'y',
+        cursor: getScaleCursor(outward),
+        end: edgePoints.end,
+        extent: length,
+        normal: { x: outward.x / length, y: outward.y / length },
+        start: edgePoints.start,
+    };
+};
+exports.getSelectedOutlineScaleEdgeInfo = getSelectedOutlineScaleEdgeInfo;
+const getSelectedOutlineScaleDragStates = ({ dragTargets, getDragOverrides, timelinePosition, }) => {
+    return dragTargets.map((target) => {
+        var _a;
+        const dragOverrideValue = ((_a = getDragOverrides(target.nodePath)) !== null && _a !== void 0 ? _a : {})[selected_outline_types_1.scaleFieldKey];
+        const sourceFrame = timelinePosition - target.keyframeDisplayOffset;
+        const effectiveValue = remotion_1.Internals.getEffectiveVisualModeValue({
+            propStatus: target.propStatus,
+            dragOverrideValue,
+            defaultValue: target.fieldDefault,
+            frame: sourceFrame,
+            shouldResortToDefaultValueIfUndefined: true,
+        });
+        const [startX, startY, startZ] = no_react_1.NoReactInternals.parseScaleValue(effectiveValue);
+        return {
+            defaultValue: target.fieldDefault !== undefined
+                ? JSON.stringify(target.fieldDefault)
+                : null,
+            key: remotion_1.Internals.makeSequencePropsSubscriptionKey(target.nodePath),
+            sourceFrame,
+            startX,
+            startY,
+            startZ,
+            target,
+        };
+    });
+};
+exports.getSelectedOutlineScaleDragStates = getSelectedOutlineScaleDragStates;
+const getSelectedOutlineScaleDragValues = ({ axis, dragStates, scaleFactor, }) => {
+    return new Map(dragStates.map((dragState) => {
+        var _a, _b;
+        const min = (_a = dragState.target.fieldSchema.min) !== null && _a !== void 0 ? _a : -Infinity;
+        const max = (_b = dragState.target.fieldSchema.max) !== null && _b !== void 0 ? _b : Infinity;
+        const decimalPlaces = (0, timeline_field_utils_1.getTimelineDisplayDecimalPlaces)({
+            defaultDecimalPlaces: 3,
+            step: dragState.target.fieldSchema.step,
+        });
+        const baseX = dragState.startX;
+        const baseY = dragState.startY;
+        const newValue = (axis === 'x' ? baseX : baseY) * scaleFactor;
+        const [rawX, rawY] = dragState.target.linked
+            ? (0, TimelineScaleField_1.getLinkedScale)({
+                axis,
+                newValue,
+                baseX,
+                baseY,
+                min,
+                max,
+            })
+            : axis === 'x'
+                ? [(0, selected_outline_geometry_1.clamp)(newValue, min, max), baseY]
+                : [baseX, (0, selected_outline_geometry_1.clamp)(newValue, min, max)];
+        const x = (0, timeline_field_utils_1.roundToDecimalPlaces)(rawX, decimalPlaces);
+        const y = (0, timeline_field_utils_1.roundToDecimalPlaces)(rawY, decimalPlaces);
+        return [
+            dragState.key,
+            no_react_1.NoReactInternals.serializeScaleValue([x, y, dragState.startZ]),
+        ];
+    }));
+};
+exports.getSelectedOutlineScaleDragValues = getSelectedOutlineScaleDragValues;
+const getSelectedOutlineScaleDragChanges = ({ dragStates, lastValues, }) => {
+    const changes = [];
+    for (const dragState of dragStates) {
+        const value = lastValues.get(dragState.key);
+        if (value === undefined) {
+            continue;
+        }
+        if (dragState.target.propStatus.status === 'keyframed') {
+            const startValue = no_react_1.NoReactInternals.serializeScaleValue([
+                dragState.startX,
+                dragState.startY,
+                dragState.startZ,
+            ]);
+            if (value === startValue) {
+                continue;
+            }
+            changes.push({
+                type: 'keyframed',
+                fileName: dragState.target.nodePath.absolutePath,
+                nodePath: dragState.target.nodePath,
+                fieldKey: selected_outline_types_1.scaleFieldKey,
+                sourceFrame: dragState.sourceFrame,
+                value,
+                schema: dragState.target.schema,
+                clientId: dragState.target.clientId,
+            });
+            continue;
+        }
+        const stringifiedValue = JSON.stringify(value);
+        const shouldSave = stringifiedValue !==
+            JSON.stringify(dragState.target.propStatus.codeValue) &&
+            !(dragState.defaultValue === stringifiedValue &&
+                dragState.target.propStatus.codeValue === undefined);
+        if (!shouldSave) {
+            continue;
+        }
+        changes.push({
+            type: 'static',
+            fileName: dragState.target.nodePath.absolutePath,
+            nodePath: dragState.target.nodePath,
+            fieldKey: selected_outline_types_1.scaleFieldKey,
+            value,
+            defaultValue: dragState.defaultValue,
+            schema: dragState.target.schema,
+        });
+    }
+    return changes;
+};
+exports.getSelectedOutlineScaleDragChanges = getSelectedOutlineScaleDragChanges;
+const getSelectedOutlineRotationDragStates = ({ dragTargets, getDragOverrides, timelinePosition, }) => {
+    return dragTargets.map((target) => {
+        var _a;
+        const dragOverrideValue = ((_a = getDragOverrides(target.nodePath)) !== null && _a !== void 0 ? _a : {})[selected_outline_types_1.rotateFieldKey];
+        const sourceFrame = timelinePosition - target.keyframeDisplayOffset;
+        const effectiveValue = remotion_1.Internals.getEffectiveVisualModeValue({
+            propStatus: target.propStatus,
+            dragOverrideValue,
+            defaultValue: target.fieldDefault,
+            frame: sourceFrame,
+            shouldResortToDefaultValueIfUndefined: true,
+        });
+        return {
+            defaultValue: target.fieldDefault !== undefined
+                ? JSON.stringify(target.fieldDefault)
+                : null,
+            key: remotion_1.Internals.makeSequencePropsSubscriptionKey(target.nodePath),
+            sourceFrame,
+            startDegrees: (0, timeline_rotation_utils_1.parseCssRotationToDegrees)(String(effectiveValue !== null && effectiveValue !== void 0 ? effectiveValue : '0deg')),
+            target,
+        };
+    });
+};
+exports.getSelectedOutlineRotationDragStates = getSelectedOutlineRotationDragStates;
+const getSelectedOutlineRotationDragValues = ({ dragStates, rotationDeltaDegrees, }) => {
+    return new Map(dragStates.map((dragState) => {
+        const decimalPlaces = (0, timeline_field_utils_1.getTimelineDisplayDecimalPlaces)({
+            defaultDecimalPlaces: 1,
+            step: dragState.target.fieldSchema.step,
+        });
+        return [
+            dragState.key,
+            (0, timeline_rotation_utils_1.serializeCssRotation)(dragState.startDegrees + rotationDeltaDegrees, decimalPlaces),
+        ];
+    }));
+};
+exports.getSelectedOutlineRotationDragValues = getSelectedOutlineRotationDragValues;
+const getSelectedOutlineRotationDragChanges = ({ dragStates, lastValues, }) => {
+    const changes = [];
+    for (const dragState of dragStates) {
+        const value = lastValues.get(dragState.key);
+        if (value === undefined) {
+            continue;
+        }
+        if (dragState.target.propStatus.status === 'keyframed') {
+            const decimalPlaces = (0, timeline_field_utils_1.getTimelineDisplayDecimalPlaces)({
+                defaultDecimalPlaces: 1,
+                step: dragState.target.fieldSchema.step,
+            });
+            const startValue = (0, timeline_rotation_utils_1.serializeCssRotation)(dragState.startDegrees, decimalPlaces);
+            if (value === startValue) {
+                continue;
+            }
+            changes.push({
+                type: 'keyframed',
+                fileName: dragState.target.nodePath.absolutePath,
+                nodePath: dragState.target.nodePath,
+                fieldKey: selected_outline_types_1.rotateFieldKey,
+                sourceFrame: dragState.sourceFrame,
+                value,
+                schema: dragState.target.schema,
+                clientId: dragState.target.clientId,
+            });
+            continue;
+        }
+        const stringifiedValue = JSON.stringify(value);
+        const shouldSave = value !== dragState.target.propStatus.codeValue &&
+            !(dragState.defaultValue === stringifiedValue &&
+                dragState.target.propStatus.codeValue === undefined);
+        if (!shouldSave) {
+            continue;
+        }
+        changes.push({
+            type: 'static',
+            fileName: dragState.target.nodePath.absolutePath,
+            nodePath: dragState.target.nodePath,
+            fieldKey: selected_outline_types_1.rotateFieldKey,
+            value,
+            defaultValue: dragState.defaultValue,
+            schema: dragState.target.schema,
+        });
+    }
+    return changes;
+};
+exports.getSelectedOutlineRotationDragChanges = getSelectedOutlineRotationDragChanges;
+const clearSelectedOutlineDragOverrides = ({ clearDragOverrides, dragStates, }) => {
+    for (const dragState of dragStates) {
+        clearDragOverrides(dragState.target.nodePath);
+    }
+};
+exports.clearSelectedOutlineDragOverrides = clearSelectedOutlineDragOverrides;
+const getSelectedOutlineKeyboardNudgeDirection = (key) => {
+    if (key === 'ArrowLeft') {
+        return 'left';
+    }
+    if (key === 'ArrowRight') {
+        return 'right';
+    }
+    if (key === 'ArrowUp') {
+        return 'up';
+    }
+    if (key === 'ArrowDown') {
+        return 'down';
+    }
+    return null;
+};
+exports.getSelectedOutlineKeyboardNudgeDirection = getSelectedOutlineKeyboardNudgeDirection;
+const clearSelectedOutlineScaleDragOverrides = ({ clearDragOverrides, dragStates, }) => {
+    for (const dragState of dragStates) {
+        clearDragOverrides(dragState.target.nodePath);
+    }
+};
+exports.clearSelectedOutlineScaleDragOverrides = clearSelectedOutlineScaleDragOverrides;
+const clearSelectedOutlineRotationDragOverrides = ({ clearDragOverrides, dragStates, }) => {
+    for (const dragState of dragStates) {
+        clearDragOverrides(dragState.target.nodePath);
+    }
+};
+exports.clearSelectedOutlineRotationDragOverrides = clearSelectedOutlineRotationDragOverrides;
+const parseCssRotationToRadians = (value) => {
+    const match = value
+        .trim()
+        .match(/^([+-]?(?:\d+\.?\d*|\.\d+))(deg|rad|turn|grad)$/);
+    if (!match) {
+        return null;
+    }
+    const number = Number(match[1]);
+    if (!Number.isFinite(number)) {
+        return null;
+    }
+    if (match[2] === 'rad') {
+        return number;
+    }
+    if (match[2] === 'turn') {
+        return number * Math.PI * 2;
+    }
+    if (match[2] === 'grad') {
+        return (number / 400) * Math.PI * 2;
+    }
+    return (number / 180) * Math.PI;
+};
+exports.parseCssRotationToRadians = parseCssRotationToRadians;
+const compensateTranslateForTransformOrigin = ({ startTranslate, deltaOrigin, rotate, scale, }) => {
+    const cos = Math.cos(rotate);
+    const sin = Math.sin(rotate);
+    const matrixA = cos * scale[0];
+    const matrixB = sin * scale[0];
+    const matrixC = -sin * scale[1];
+    const matrixD = cos * scale[1];
+    const transformedDeltaX = matrixA * deltaOrigin[0] + matrixC * deltaOrigin[1];
+    const transformedDeltaY = matrixB * deltaOrigin[0] + matrixD * deltaOrigin[1];
+    const compensationX = deltaOrigin[0] - transformedDeltaX;
+    const compensationY = deltaOrigin[1] - transformedDeltaY;
+    return [startTranslate[0] - compensationX, startTranslate[1] - compensationY];
+};
+exports.compensateTranslateForTransformOrigin = compensateTranslateForTransformOrigin;
+const uvsEqual = (left, right) => Math.abs(left[0] - right[0]) < 0.000001 &&
+    Math.abs(left[1] - right[1]) < 0.000001;
+exports.uvsEqual = uvsEqual;

package/dist/components/selected-outline-measurement.d.ts

@@ -0,0 +1,67 @@
+import type { OverrideIdToNodePaths, TSequence } from 'remotion';
+import type { OutlinePoint, SelectedOutline } from './selected-outline-geometry';
+import type { SelectedOutlineTarget, SequenceWithSelectedOutline } from './selected-outline-types';
+import { type TimelineSelection, type TimelineSelectionInteraction } from './Timeline/TimelineSelection';
+export declare const pointToString: (point: OutlinePoint) => string;
+export declare const midpoint: (from: OutlinePoint, to: OutlinePoint) => OutlinePoint;
+export declare const getOutlineCenter: (points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint]) => OutlinePoint;
+export declare const dot: (left: OutlinePoint, right: OutlinePoint) => number;
+export declare const vectorLength: (vector: OutlinePoint) => number;
+export declare const vectorBetween: (from: OutlinePoint, to: OutlinePoint) => OutlinePoint;
+export declare const getAngleDegrees: (from: OutlinePoint, to: OutlinePoint) => number;
+export declare const getSelectedOutlineRotationDeltaDegrees: ({ from, to, }: {
+    readonly from: number;
+    readonly to: number;
+}) => number;
+export type SelectedOutlineRotationCorner = 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left';
+export declare const getRotationCursor: (rotation: number) => string;
+export declare const getSelectedOutlineRotationCornerInfo: (points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint], corner: SelectedOutlineRotationCorner) => {
+    center: OutlinePoint;
+    cursor: string;
+    cursorDegrees: number;
+    point: OutlinePoint;
+};
+export declare const getSelectedOutlineRotationPivot: ({ dimensions, points, transformOriginValue, }: {
+    readonly dimensions: {
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    readonly points: readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint];
+    readonly transformOriginValue: string;
+}) => OutlinePoint;
+type SvgViewport = {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+type SvgScreenCtm = Pick<DOMMatrixReadOnly, 'a' | 'b' | 'c' | 'd' | 'e' | 'f'>;
+export declare const getTransformedSvgViewportPoints: ({ viewport, ctm, containerRect, }: {
+    readonly viewport: SvgViewport;
+    readonly ctm: SvgScreenCtm;
+    readonly containerRect: Pick<DOMRect, "left" | "top">;
+}) => readonly [OutlinePoint, OutlinePoint, OutlinePoint, OutlinePoint];
+export declare const getSelectedSequenceKeys: (selectedItems: readonly TimelineSelection[]) => Set<string>;
+export declare const getSequenceKeysContainingSelection: (selectedItems: readonly TimelineSelection[]) => Set<string>;
+export declare const getOutlineSelectionInteraction: ({ shiftKey, metaKey, ctrlKey, }: {
+    readonly shiftKey: boolean;
+    readonly metaKey: boolean;
+    readonly ctrlKey: boolean;
+}) => TimelineSelectionInteraction;
+type SelectedEffectFields = {
+    allFields: boolean;
+    fieldKeys: Set<string>;
+};
+export declare const getSelectedEffectFieldsBySequenceKey: (selectedItems: readonly TimelineSelection[]) => Map<string, Map<number, SelectedEffectFields>>;
+type SelectedTransformOriginInfo = {
+    readonly sequenceKey: string;
+    readonly displayFrame: number | null;
+};
+export declare const getSelectedTransformOriginInfo: (selectedItems: readonly TimelineSelection[]) => SelectedTransformOriginInfo | null;
+export declare const getSequencesWithSelectableOutlines: ({ sequences, overrideIdsToNodePaths, }: {
+    readonly sequences: readonly TSequence[];
+    readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
+}) => SequenceWithSelectedOutline[];
+export declare const measureOutlines: (container: SVGSVGElement, targets: readonly SelectedOutlineTarget[]) => SelectedOutline[];
+export declare const outlinesAreEqual: (a: readonly SelectedOutline[], b: readonly SelectedOutline[]) => boolean;
+export {};