matterviz 0.3.7 → 0.4.1

package/dist/fermi-surface/marching-cubes.d.ts

@@ -1,2 +0,0 @@
-export { compute_vertex_normals, marching_cubes } from '../marching-cubes';
-export type { MarchingCubesOptions, MarchingCubesResult } from '../marching-cubes';

package/dist/fermi-surface/marching-cubes.js

@@ -1,2 +0,0 @@
-// Re-export from shared location for backward compatibility
-export { compute_vertex_normals, marching_cubes } from '../marching-cubes';

package/dist/plot/PlotControls.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { PlotControlsProps } from './index';
-declare const PlotControls: import("svelte").Component<PlotControlsProps, {}, "display" | "show_controls" | "x_axis" | "y_axis" | "controls_open" | "x2_axis" | "y2_axis">;
-type PlotControls = ReturnType<typeof PlotControls>;
-export default PlotControls;

package/dist/plot/axis-utils.d.ts

@@ -1,19 +0,0 @@
-import type { AxisConfig, AxisLoadError, BarSeries, DataLoaderFn, DataSeries } from './types';
-type AxisType = `x` | `x2` | `y` | `y2`;
-export declare function merge_series_state<T extends DataSeries | BarSeries>(old_series: T[], new_series: T[]): T[];
-export interface AxisChangeState<T extends DataSeries | BarSeries> {
-    get_axis: (axis: AxisType) => AxisConfig;
-    set_axis: (axis: AxisType, config: AxisConfig) => void;
-    get_series: () => T[];
-    set_series: (series: T[]) => void;
-    get_loading: () => AxisType | null;
-    set_loading: (axis: AxisType | null) => void;
-}
-export declare function create_axis_change_handler<T extends DataSeries | BarSeries>(state: AxisChangeState<T>, data_loader: DataLoaderFn<Record<string, unknown>, T> | undefined, on_axis_change?: (axis: AxisType, key: string, new_series: T[]) => void, on_error?: (error: AxisLoadError) => void): (axis: AxisType, key: string) => Promise<void>;
-export declare const AXIS_LABEL_CONTAINER: {
-    readonly width: 200;
-    readonly height: 24;
-    readonly x_offset: 100;
-    readonly y_offset: 12;
-};
-export {};

package/dist/plot/axis-utils.js

@@ -1,78 +0,0 @@
-// Shared utilities for interactive axis functionality
-// Merge new series with preserved UI state from old series.
-// Matches by stable id first, then by index only for ordered id-less series.
-export function merge_series_state(old_series, new_series) {
-    // Build id lookup map for O(1) matching (string or number ids)
-    const by_id = new Map();
-    for (const srs of old_series) {
-        if (srs.id !== undefined && srs.id !== ``)
-            by_id.set(srs.id, srs);
-    }
-    return new_series.map((new_srs, idx) => {
-        const old_srs = new_srs.id !== undefined && new_srs.id !== `` ? by_id.get(new_srs.id) : old_series[idx];
-        if (!old_srs) {
-            return new_srs;
-        }
-        // Preserve UI state: visibility and styling from old series if not in new
-        const result = { ...new_srs };
-        result.visible ??= old_srs.visible;
-        // Preserve style properties only when key exists in BOTH series (guards against
-        // cross-type injection when T is a union like DataSeries | BarSeries)
-        for (const key of [`point_style`, `line_style`, `color`]) {
-            if (key in old_srs && key in new_srs && result[key] === undefined) {
-                result[key] = old_srs[key];
-            }
-        }
-        return result;
-    });
-}
-// Handle axis property change - loads new data via data_loader
-// Returns a function bound to the component's state accessors
-export function create_axis_change_handler(state, data_loader, on_axis_change, on_error) {
-    return async (axis, key) => {
-        if (!data_loader || state.get_loading())
-            return;
-        const axis_config = state.get_axis(axis);
-        const prev_key = axis_config.selected_key;
-        // Skip if key unchanged AND series already loaded (allows initial load when series empty)
-        if (prev_key === key && state.get_series().length > 0)
-            return;
-        // Update selected_key immediately for UI feedback
-        state.set_axis(axis, { ...axis_config, selected_key: key });
-        state.set_loading(axis);
-        try {
-            const result = await data_loader(axis, key, state.get_series());
-            // Merge new series with preserved state from old series
-            const merged = merge_series_state(state.get_series(), result.series);
-            state.set_series(merged);
-            // Update axis label/unit if provided
-            if (result.axis_label || result.axis_unit) {
-                const current = state.get_axis(axis);
-                state.set_axis(axis, {
-                    ...current,
-                    label: result.axis_label ?? current.label,
-                    unit: result.axis_unit ?? current.unit,
-                });
-            }
-            on_axis_change?.(axis, key, merged);
-        }
-        catch (err) {
-            console.error(`Failed to load data for ${axis}=${key}:`, err);
-            // Revert selection
-            state.set_axis(axis, { ...state.get_axis(axis), selected_key: prev_key });
-            const message = err instanceof Error ? err.message : String(err);
-            on_error?.({ axis, key, message });
-        }
-        finally {
-            state.set_loading(null);
-        }
-    };
-}
-// Constants for axis label foreignObject positioning (all values in px)
-// Use minimal dimensions - overflow: visible handles any dropdown expansion
-export const AXIS_LABEL_CONTAINER = {
-    width: 200, // container width for centering; dropdown can overflow
-    height: 24, // single line height; dropdown options overflow downward
-    x_offset: 100, // half of width for horizontal centering
-    y_offset: 12, // half of height for vertical centering
-};

package/dist/plot/defaults.d.ts

@@ -1,19 +0,0 @@
-export declare const AXIS_DEFAULTS: {
-    format: string;
-    scale_type: "linear";
-    ticks: number;
-    label_shift: {
-        x: number;
-        y: number;
-    };
-    tick: {
-        label: {
-            shift: {
-                x: number;
-                y: number;
-            };
-            inside: boolean;
-        };
-    };
-    range: [number | null, number | null];
-};

package/dist/plot/defaults.js

@@ -1,9 +0,0 @@
-// Shared axis defaults across plot components (single source of truth)
-export const AXIS_DEFAULTS = {
-    format: ``,
-    scale_type: `linear`,
-    ticks: 5,
-    label_shift: { x: 0, y: 0 },
-    tick: { label: { shift: { x: 0, y: 0 }, inside: false } },
-    range: [null, null],
-};

package/dist/plot/fill-utils.d.ts

@@ -1,46 +0,0 @@
-import type { DataSeries, ErrorBand, FillBoundary, FillCurveType, FillGradient, FillRegion, ScaleType } from './types';
-export declare const LOG_EPSILON = 1e-10;
-export interface FillPathPoint {
-    x: number;
-    y1: number;
-    y2: number;
-}
-type FillPathArrays = Record<keyof FillPathPoint, number[]>;
-export interface InterpolatedSeries {
-    x: number[];
-    y_a: number[];
-    y_b: number[];
-}
-export interface FilteredFillData extends FillPathArrays {
-    original_indices: number[];
-}
-export interface ConditionedFillData {
-    segments: FillPathPoint[][];
-}
-export interface ClampedFillData extends FillPathArrays {
-    clamped_indices: number[];
-}
-export declare function resolve_series_ref(ref: {
-    type: `series`;
-    series_idx?: number;
-    series_id?: string | number;
-}, series: readonly DataSeries[]): DataSeries | null;
-export declare function interpolate_series(series_a: {
-    x: readonly number[];
-    y: readonly number[];
-}, series_b: {
-    x: readonly number[];
-    y: readonly number[];
-}, method?: `linear` | `step`): InterpolatedSeries;
-interface DomainContext {
-    y_domain: [number, number];
-    y2_domain?: [number, number];
-}
-export declare function resolve_boundary(boundary: FillBoundary, series: readonly DataSeries[], x_values: readonly number[], domains: DomainContext): number[] | null;
-export declare function apply_range_constraints(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], region: Pick<FillRegion, `x_range` | `y_range`>): FilteredFillData;
-export declare function apply_where_condition(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], region: Pick<FillRegion, `where`>): ConditionedFillData;
-export declare function clamp_for_log_scale(x_values: readonly number[], y1_values: readonly number[], y2_values: readonly number[], y_scale_type: ScaleType, x_scale_type?: ScaleType): ClampedFillData;
-export declare function generate_fill_path(data: readonly FillPathPoint[], curve_type?: FillCurveType): string;
-export declare function convert_error_band_to_fill_region(error_band: ErrorBand, series: readonly DataSeries[], default_color?: string): FillRegion | null;
-export declare const is_fill_gradient: (fill: string | FillGradient | undefined) => fill is FillGradient;
-export {};

package/dist/plot/fill-utils.js

@@ -1,322 +0,0 @@
-// Fill-between utility functions for ScatterPlot fill regions
-// Handles interpolation, boundary resolution, and path generation
-import { area, curveBasis, curveCardinal, curveCatmullRom, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, } from 'd3-shape';
-// Epsilon value for log scale clamping (to avoid log(0) = -Infinity)
-export const LOG_EPSILON = 1e-10;
-// Resolves a series reference (by index or id) to the actual DataSeries
-// Returns null if the reference cannot be resolved
-export function resolve_series_ref(ref, series) {
-    if (`series_idx` in ref && typeof ref.series_idx === `number`) {
-        const idx = ref.series_idx;
-        if (idx >= 0 && idx < series.length) {
-            return series[idx];
-        }
-        return null;
-    }
-    if (`series_id` in ref && ref.series_id !== undefined) {
-        const found = series.find((data_series) => data_series.id === ref.series_id);
-        return found ?? null;
-    }
-    return null;
-}
-// Helper: linear interpolation at a specific x value
-function interpolate_at(x_values, y_values, target_x) {
-    // Find bracketing indices
-    let [left_idx, right_idx] = [-1, -1];
-    for (let idx = 0; idx < x_values.length; idx++) {
-        if (x_values[idx] <= target_x)
-            left_idx = idx;
-        if (x_values[idx] >= target_x && right_idx === -1)
-            right_idx = idx;
-    }
-    // Handle edge cases: exact match, before all, after all
-    if (left_idx >= 0 && x_values[left_idx] === target_x)
-        return y_values[left_idx];
-    if (left_idx === -1)
-        return y_values[0];
-    if (right_idx === -1)
-        return y_values[y_values.length - 1];
-    // Linear interpolation
-    const x_left = x_values[left_idx];
-    const x_right = x_values[right_idx];
-    const y_left = y_values[left_idx];
-    const y_right = y_values[right_idx];
-    return x_right === x_left
-        ? y_left
-        : y_left + ((target_x - x_left) / (x_right - x_left)) * (y_right - y_left);
-}
-// Helper: step interpolation at a specific x value
-function step_interpolate_at(x_values, y_values, target_x) {
-    // Find the last x value <= target_x
-    let last_idx = -1;
-    for (let idx = 0; idx < x_values.length; idx++) {
-        if (x_values[idx] <= target_x)
-            last_idx = idx;
-        else
-            break;
-    }
-    // Before all x values, use first y value
-    if (last_idx === -1)
-        return y_values[0];
-    return y_values[last_idx];
-}
-// Interpolates two series to have matching x-values
-// Returns arrays with the union of all x-values, sorted
-export function interpolate_series(series_a, series_b, method = `linear`) {
-    // Create union of x-values
-    const x_set = new Set();
-    for (const curr_x of series_a.x)
-        x_set.add(curr_x);
-    for (const curr_x of series_b.x)
-        x_set.add(curr_x);
-    // Sort x-values
-    const all_x = Array.from(x_set).sort((val_a, val_b) => val_a - val_b);
-    const interpolate_fn = method === `step` ? step_interpolate_at : interpolate_at;
-    // Interpolate y values for each x
-    const y_a = all_x.map((target_x) => interpolate_fn(series_a.x, series_a.y, target_x));
-    const y_b = all_x.map((target_x) => interpolate_fn(series_b.x, series_b.y, target_x));
-    return { x: all_x, y_a, y_b };
-}
-// Resolves a FillBoundary definition to an array of y-values at given x positions
-// Returns null if the boundary cannot be resolved
-export function resolve_boundary(boundary, series, x_values, domains) {
-    // Handle shorthand number (constant value)
-    if (typeof boundary === `number`) {
-        return x_values.map(() => boundary);
-    }
-    if (boundary.type === `series`) {
-        const resolved = resolve_series_ref(boundary, series);
-        if (!resolved)
-            return null;
-        // Interpolate to match x_values
-        const interpolated = interpolate_series({ x: x_values, y: x_values.map(() => 0) }, { x: resolved.x, y: resolved.y }, `linear`);
-        return interpolated.y_b;
-    }
-    if (boundary.type === `constant`)
-        return x_values.map(() => boundary.value);
-    if (boundary.type === `axis`) {
-        // For axis boundaries, return the edge value of the appropriate axis domain
-        const value = boundary.value ??
-            (boundary.axis === `y2` ? domains.y2_domain?.[0] : undefined) ??
-            domains.y_domain[0];
-        return x_values.map(() => value);
-    }
-    if (boundary.type === `function`)
-        return x_values.map((curr_x) => boundary.fn(curr_x));
-    if (boundary.type === `data`) {
-        if (boundary.values.length === 0)
-            return Array(x_values.length).fill(NaN);
-        // If lengths match, use directly; otherwise interpolate
-        if (boundary.values.length === x_values.length)
-            return [...boundary.values];
-        // Lengths don't match: truncate if values is longer, or extend last value if shorter
-        return x_values.map((_, idx) => boundary.values[idx] ?? boundary.values[boundary.values.length - 1]);
-    }
-    return null;
-}
-export function apply_range_constraints(x_values, y1_values, y2_values, region) {
-    const [x_min, x_max] = region.x_range ?? [null, null];
-    const [y_min, y_max] = region.y_range ?? [null, null];
-    // Helper to clamp value within optional bounds
-    const clamp = (val) => Math.min(y_max ?? Infinity, Math.max(y_min ?? -Infinity, val));
-    const result = {
-        x: [],
-        y1: [],
-        y2: [],
-        original_indices: [],
-    };
-    for (let idx = 0; idx < x_values.length; idx++) {
-        const [curr_x, curr_y1, curr_y2] = [x_values[idx], y1_values[idx], y2_values[idx]];
-        // Skip if outside x range
-        if ((x_min !== null && curr_x < x_min) || (x_max !== null && curr_x > x_max))
-            continue;
-        // Skip if fill region doesn't overlap y range
-        const [fill_min, fill_max] = [Math.min(curr_y1, curr_y2), Math.max(curr_y1, curr_y2)];
-        if ((y_min !== null && fill_max < y_min) || (y_max !== null && fill_min > y_max)) {
-            continue;
-        }
-        result.x.push(curr_x);
-        result.y1.push(clamp(curr_y1));
-        result.y2.push(clamp(curr_y2));
-        result.original_indices.push(idx);
-    }
-    return result;
-}
-// Helper: find x-coordinate where condition changes (linear interpolation)
-function find_crossing(x1, y1_upper, y1_lower, x2, y2_upper, y2_lower, condition) {
-    const cond1 = condition(x1, y1_upper, y1_lower);
-    const cond2 = condition(x2, y2_upper, y2_lower);
-    if (cond1 === cond2)
-        return null;
-    // Binary search for crossing point
-    let left = x1;
-    let right = x2;
-    const tolerance = (x2 - x1) * 0.001;
-    for (let iter = 0; iter < 20; iter++) {
-        const mid = (left + right) / 2;
-        const weight = (mid - x1) / (x2 - x1);
-        const mid_upper = y1_upper + weight * (y2_upper - y1_upper);
-        const mid_lower = y1_lower + weight * (y2_lower - y1_lower);
-        const mid_cond = condition(mid, mid_upper, mid_lower);
-        if (mid_cond === cond1) {
-            left = mid;
-        }
-        else {
-            right = mid;
-        }
-        if (right - left < tolerance)
-            break;
-    }
-    return (left + right) / 2;
-}
-export function apply_where_condition(x_values, y1_values, y2_values, region) {
-    if (!region.where) {
-        // No condition - return single segment with all points
-        const points = x_values.map((curr_x, idx) => ({
-            x: curr_x,
-            y1: y1_values[idx],
-            y2: y2_values[idx],
-        }));
-        return { segments: [points] };
-    }
-    const segments = [];
-    let current_segment = [];
-    for (let idx = 0; idx < x_values.length; idx++) {
-        const curr_x = x_values[idx];
-        const curr_y1 = y1_values[idx];
-        const curr_y2 = y2_values[idx];
-        const passes = region.where(curr_x, curr_y1, curr_y2);
-        if (idx > 0) {
-            const prev_x = x_values[idx - 1];
-            const prev_y1 = y1_values[idx - 1];
-            const prev_y2 = y2_values[idx - 1];
-            const prev_passes = region.where(prev_x, prev_y1, prev_y2);
-            // Check for condition crossing between prev and current
-            if (passes !== prev_passes) {
-                const crossing_x = find_crossing(prev_x, prev_y1, prev_y2, curr_x, curr_y1, curr_y2, region.where);
-                if (crossing_x !== null) {
-                    // Interpolate y values at crossing point
-                    const weight = (crossing_x - prev_x) / (curr_x - prev_x);
-                    const crossing_y1 = prev_y1 + weight * (curr_y1 - prev_y1);
-                    const crossing_y2 = prev_y2 + weight * (curr_y2 - prev_y2);
-                    if (prev_passes) {
-                        // End current segment at crossing
-                        current_segment.push({ x: crossing_x, y1: crossing_y1, y2: crossing_y2 });
-                        segments.push(current_segment);
-                        current_segment = [];
-                    }
-                    else {
-                        // Start new segment at crossing
-                        current_segment.push({ x: crossing_x, y1: crossing_y1, y2: crossing_y2 });
-                    }
-                }
-            }
-        }
-        if (passes) {
-            current_segment.push({ x: curr_x, y1: curr_y1, y2: curr_y2 });
-        }
-        else if (current_segment.length > 0) {
-            segments.push(current_segment);
-            current_segment = [];
-        }
-    }
-    // Don't forget the last segment
-    if (current_segment.length > 0) {
-        segments.push(current_segment);
-    }
-    return { segments };
-}
-export function clamp_for_log_scale(x_values, y1_values, y2_values, y_scale_type, x_scale_type = `linear`) {
-    const result_x = [];
-    const result_y1 = [];
-    const result_y2 = [];
-    const clamped_indices = [];
-    for (let idx = 0; idx < x_values.length; idx++) {
-        let curr_x = x_values[idx];
-        let curr_y1 = y1_values[idx];
-        let curr_y2 = y2_values[idx];
-        let was_clamped = false;
-        // Clamp x if x-axis is log scale
-        if (x_scale_type === `log` && curr_x <= 0) {
-            curr_x = LOG_EPSILON;
-            was_clamped = true;
-        }
-        // Clamp y values if y-axis is log scale
-        if (y_scale_type === `log`) {
-            if (curr_y1 <= 0) {
-                curr_y1 = LOG_EPSILON;
-                was_clamped = true;
-            }
-            if (curr_y2 <= 0) {
-                curr_y2 = LOG_EPSILON;
-                was_clamped = true;
-            }
-        }
-        result_x.push(curr_x);
-        result_y1.push(curr_y1);
-        result_y2.push(curr_y2);
-        if (was_clamped) {
-            clamped_indices.push(idx);
-        }
-    }
-    return {
-        x: result_x,
-        y1: result_y1,
-        y2: result_y2,
-        clamped_indices,
-    };
-}
-// Map FillCurveType to d3 curve factory
-const CURVE_MAP = {
-    linear: curveLinear,
-    monotoneX: curveMonotoneX,
-    monotoneY: curveMonotoneY,
-    step: curveStep,
-    stepBefore: curveStepBefore,
-    stepAfter: curveStepAfter,
-    basis: curveBasis,
-    cardinal: curveCardinal,
-    catmullRom: curveCatmullRom,
-    natural: curveNatural,
-};
-const get_curve = (curve_type) => CURVE_MAP[curve_type] ?? curveMonotoneX;
-// Generate SVG path string for a fill region
-// data should already be in pixel coordinates
-export function generate_fill_path(data, curve_type = `monotoneX`) {
-    if (data.length === 0)
-        return ``;
-    const curve = get_curve(curve_type);
-    const area_generator = area()
-        .x((point) => point.x)
-        .y0((point) => point.y1)
-        .y1((point) => point.y2)
-        .curve(curve);
-    return area_generator(data) ?? ``;
-}
-// Helper to expand error definition to array
-const expand_error = (err, length) => typeof err === `number` ? Array(length).fill(err) : err;
-// Convert an ErrorBand convenience type to a full FillRegion
-export function convert_error_band_to_fill_region(error_band, series, default_color) {
-    const resolved = resolve_series_ref(error_band.series, series);
-    if (!resolved)
-        return null;
-    const { y } = resolved;
-    const { error } = error_band;
-    // Determine upper/lower error arrays
-    const [upper_err, lower_err] = typeof error === `object` && `upper` in error
-        ? [expand_error(error.upper, y.length), expand_error(error.lower, y.length)]
-        : [expand_error(error, y.length), expand_error(error, y.length)];
-    return {
-        id: error_band.id,
-        label: error_band.label,
-        upper: { type: `data`, values: y.map((val, idx) => val + upper_err[idx]) },
-        lower: { type: `data`, values: y.map((val, idx) => val - lower_err[idx]) },
-        fill: error_band.fill ?? default_color ?? `#4e79a7`,
-        fill_opacity: error_band.fill_opacity ?? 0.3,
-        edge_upper: error_band.edge_style,
-        edge_lower: error_band.edge_style,
-        show_in_legend: error_band.show_in_legend ?? true,
-    };
-}
-// Type guard to check if fill is a gradient
-export const is_fill_gradient = (fill) => typeof fill === `object` && fill !== null && `type` in fill && `stops` in fill;

package/dist/plot/hover-lock.svelte.d.ts

@@ -1,14 +0,0 @@
-export declare const HOVER_DEBOUNCE_MS = 300;
-interface ReactiveBoolean {
-    readonly current: boolean;
-}
-export declare function create_hover_lock(): {
-    is_locked: ReactiveBoolean;
-    set_locked: (locked: boolean) => void;
-    cleanup: () => void;
-};
-export declare function create_dimension_tracker(): {
-    has_changed: (width: number, height: number) => boolean;
-    update: (width: number, height: number) => void;
-};
-export {};

package/dist/plot/hover-lock.svelte.js

@@ -1,46 +0,0 @@
-// Shared utility for hover lock behavior on plot elements (legend, colorbar)
-// Prevents element repositioning while user is hovering, with debounced release
-export const HOVER_DEBOUNCE_MS = 300;
-// Creates hover lock state and handlers for a plot element
-export function create_hover_lock() {
-    let is_locked = $state(false);
-    let timeout = null;
-    // Stable object reference with getter - Svelte tracks the getter read
-    const locked_ref = {
-        get current() {
-            return is_locked;
-        },
-    };
-    return {
-        is_locked: locked_ref,
-        set_locked(locked) {
-            if (locked) {
-                if (timeout)
-                    clearTimeout(timeout);
-                is_locked = true;
-            }
-            else {
-                timeout = setTimeout(() => (is_locked = false), HOVER_DEBOUNCE_MS);
-            }
-        },
-        // Clear pending timeout to prevent state updates after unmount
-        cleanup() {
-            if (timeout)
-                clearTimeout(timeout);
-        },
-    };
-}
-// Tracks previous dimensions for resize detection
-export function create_dimension_tracker() {
-    let prev = $state(null);
-    return {
-        has_changed(width, height) {
-            if (!prev)
-                return true;
-            return prev.width !== width || prev.height !== height;
-        },
-        update(width, height) {
-            prev = { width, height };
-        },
-    };
-}

package/dist/plot/interactions.d.ts

@@ -1,12 +0,0 @@
-import type { Point2D, Vec2 } from '../math';
-import type { Y2SyncConfig, Y2SyncMode } from './types';
-export declare function get_relative_coords(evt: MouseEvent): Point2D | null;
-export declare function normalize_y2_sync(sync: Y2SyncConfig | Y2SyncMode | undefined): Y2SyncConfig;
-export declare function sync_y2_range(y1_range: Vec2, y2_base_range: Vec2, sync: Y2SyncConfig): Vec2;
-export declare const pan_range: (current: Vec2, delta: number) => Vec2;
-export declare function pixels_to_data_delta(pixel_delta: number, data_range: Vec2, pixel_range: number): number;
-export declare const PINCH_ZOOM_THRESHOLD = 0.1;
-export declare function expand_range_if_needed(current: Vec2, new_range: Vec2): {
-    range: Vec2;
-    changed: boolean;
-};