samcan 0.0.2 → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,962 @@
+type camera = [number, number, number, number];
+type camera_limits = {
+	readonly min_zoom: number;
+	readonly max_zoom: number;
+	readonly min_x: number;
+	readonly max_x: number;
+	readonly min_y: number;
+	readonly max_y: number;
+};
+type zoom_anchor = {
+	readonly screen_x: number;
+	readonly screen_y: number;
+	readonly world_x: number;
+	readonly world_y: number;
+};
+declare function create_camera(x?: number, y?: number, zoom?: number, rotation?: number): camera;
+declare function clone_camera(c: camera): camera;
+declare function copy_camera(c: camera, out: camera): camera;
+declare function set_camera(x: number, y: number, zoom: number, rotation: number, out: camera): camera;
+declare function x_of_camera(c: camera): number;
+declare function y_of_camera(c: camera): number;
+declare function zoom_of_camera(c: camera): number;
+declare function rotation_of_camera(c: camera): number;
+declare function position_of_camera(c: camera, out: [number, number]): [number, number];
+declare function pan_camera(c: camera, dx: number, dy: number, out: camera): camera;
+declare function zoom_camera(c: camera, factor: number, out: camera): camera;
+declare function zoom_at_camera(c: camera, factor: number, anchor: zoom_anchor, out: camera): camera;
+declare function rotate_camera(c: camera, angle: number, out: camera): camera;
+declare function clamp_camera(c: camera, limits: camera_limits, out: camera): camera;
+declare function lerp_camera(a: camera, b: camera, t: number, out: camera): camera;
+declare function smooth_damp_camera(current: camera, target: camera, velocity: camera, smooth_time: number, delta_time: number, out: camera): camera;
+declare function equals_camera(c1: camera, c2: camera, epsilon?: number): boolean;
+declare function is_identity_camera(c: camera): boolean;
+type vector2 = [number, number];
+declare function create_vector2(x: number, y: number): vector2;
+declare function zero_vector2(): vector2;
+declare function unit_vector2(): vector2;
+declare function clone_vector2(v: vector2): vector2;
+declare function copy_vector2(v: vector2, out: vector2): vector2;
+declare function set_vector2(x: number, y: number, out: vector2): vector2;
+declare function add_vector2(a: vector2, b: vector2, out: vector2): vector2;
+declare function subtract_vector2(a: vector2, b: vector2, out: vector2): vector2;
+declare function multiply_vector2(a: vector2, b: number, out: vector2): vector2;
+declare function divide_vector2(a: vector2, b: number, out: vector2): vector2;
+declare function normalize_vector2(a: vector2, out: vector2): vector2;
+declare function lerp_vector2(a: vector2, b: vector2, t: number, out: vector2): vector2;
+declare function dot_vector2(a: vector2, b: vector2): number;
+declare function cross_vector2(a: vector2, b: vector2): number;
+declare function length_squared_vector2(a: vector2): number;
+declare function length_vector2(a: vector2): number;
+declare function distance_squared_vector2(a: vector2, b: vector2): number;
+declare function distance_vector2(a: vector2, b: vector2): number;
+declare function is_equal_vector2(a: vector2, b: vector2, epsilon?: number): boolean;
+type rectangle = [number, number, number, number];
+declare function create_rectangle(x?: number, y?: number, width?: number, height?: number): rectangle;
+declare function clone_rectangle(r: rectangle): rectangle;
+declare function from_center_rectangle(center: vector2, width: number, height: number, out: rectangle): rectangle;
+declare function top_of_rectangle(r: rectangle): number;
+declare function left_of_rectangle(r: rectangle): number;
+declare function right_of_rectangle(r: rectangle): number;
+declare function bottom_of_rectangle(r: rectangle): number;
+declare function center_of_rectangle(r: rectangle, out: vector2): vector2;
+declare function width_of_rectangle(r: rectangle): number;
+declare function height_of_rectangle(r: rectangle): number;
+declare function area_of_rectangle(r: rectangle): number;
+declare function set_rectangle(x: number, y: number, width: number, height: number, out: rectangle): rectangle;
+declare function translate_rectangle(r: rectangle, dx: number, dy: number, out: rectangle): rectangle;
+declare function scale_rectangle(r: rectangle, scale: number, out: rectangle): rectangle;
+declare function contains_point_rectangle(r: rectangle, x: number, y: number): boolean;
+declare function contains_rectangle(r1: rectangle, r2: rectangle): boolean;
+declare function intersects_rectangle(r1: rectangle, r2: rectangle): boolean;
+declare function intersection_rectangle(r1: rectangle, r2: rectangle, out: rectangle): rectangle | null;
+declare function union_rectangle(r1: rectangle, r2: rectangle, out: rectangle): rectangle;
+declare function expand_rectangle(r: rectangle, amount: number, out: rectangle): rectangle;
+declare function is_empty_rectangle(r: rectangle): boolean;
+declare function equals_rectangle(r1: rectangle, r2: rectangle): boolean;
+type frustum = [number, number, number, number, number, number];
+declare function create_frustum(left: number, right: number, top: number, bottom: number, near: number, far: number): frustum;
+declare function create_frustum_from_bounds(min_x: number, max_x: number, min_y: number, max_y: number, out: frustum): frustum;
+declare function create_frustum_from_rectangle(view_bounds: rectangle, out: frustum): frustum;
+declare function left_of_frustum(f: frustum): number;
+declare function right_of_frustum(f: frustum): number;
+declare function top_of_frustum(f: frustum): number;
+declare function bottom_of_frustum(f: frustum): number;
+declare function near_of_frustum(f: frustum): number;
+declare function far_of_frustum(f: frustum): number;
+declare function width_of_frustum(f: frustum): number;
+declare function height_of_frustum(f: frustum): number;
+declare function set_frustum_bounds(left: number, right: number, top: number, bottom: number, near: number, far: number, out: frustum): frustum;
+declare function clone_frustum(f: frustum): frustum;
+declare function copy_frustum(f: frustum, out: frustum): frustum;
+declare function create_frustum_from_camera(camera_x: number, camera_y: number, viewport_width: number, viewport_height: number, zoom: number, out: frustum): frustum;
+declare function create_frustum_from_view_matrix(camera_position: vector2, viewport_size: vector2, zoom: number, out: frustum): frustum;
+declare function expand_frustum(f: frustum, margin: number, out: frustum): frustum;
+declare function intersects_frustum_rectangle(f: frustum, r: rectangle): boolean;
+declare function contains_rectangle_frustum(f: frustum, r: rectangle): boolean;
+declare function contains_point_frustum(f: frustum, x: number, y: number): boolean;
+declare function cull_rectangle_frustum(f: frustum, r: rectangle): boolean;
+declare function cull_rectangles_frustum(f: frustum, rectangles: rectangle[]): rectangle[];
+declare function filter_visible_rectangles_frustum(f: frustum, rectangles: rectangle[], out_visible: rectangle[]): rectangle[];
+declare function count_visible_rectangles_frustum(f: frustum, rectangles: rectangle[]): number;
+declare function is_empty_frustum(f: frustum): boolean;
+declare function equals_frustum(f1: frustum, f2: frustum): boolean;
+declare function area_of_frustum(f: frustum): number;
+declare function center_of_frustum(f: frustum, out: vector2): vector2;
+declare function translate_frustum(f: frustum, dx: number, dy: number, out: frustum): frustum;
+declare function intersection_frustum_rectangle(f: frustum, r: rectangle, out: rectangle): rectangle | null;
+type transform = [number, number, number, number, number, number];
+declare function create_transform(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): transform;
+declare function clone_transform(t: transform): transform;
+declare function set_transform(a: number, b: number, c: number, d: number, tx: number, ty: number, out: transform): transform;
+declare function copy_transform(t: transform, out: transform): transform;
+declare function identity_transform(): transform;
+declare function set_identity_transform(out: transform): transform;
+declare function translate_transform(x: number, y: number): transform;
+declare function scale_transform(sx: number, sy?: number): transform;
+declare function rotate_transform(angle: number): transform;
+declare function from_trs_transform(translation: vector2, rotation: number, scale: vector2): transform;
+declare function multiply_transform(t1: transform, t2: transform, out: transform): transform;
+declare function determinant_transform(t: transform): number;
+declare function invert_transform(t: transform, out: transform): transform | null;
+declare function transform_point_transform(t: transform, point: vector2, out: vector2): vector2;
+declare function transform_vector_transform(t: transform, vector: vector2, out: vector2): vector2;
+declare function append_translation_transform(t: transform, x: number, y: number, out: transform): transform;
+declare function append_rotation_transform(t: transform, angle: number, out: transform): transform;
+declare function append_scale_transform(t: transform, sx: number, sy: number | undefined, out: transform): transform;
+declare function prepend_translation_transform(x: number, y: number, t: transform, out: transform): transform;
+declare function prepend_rotation_transform(angle: number, t: transform, out: transform): transform;
+declare function prepend_scale_transform(sx: number, sy: number | undefined, t: transform, out: transform): transform;
+declare function equals_transform(t1: transform, t2: transform, epsilon?: number): boolean;
+declare function is_identity_transform(t: transform, epsilon?: number): boolean;
+type viewport = [number, number, number];
+declare function world_to_screen_camera(c: camera, v: viewport, world_pos: vector2, out: vector2): vector2;
+declare function screen_to_world_camera(c: camera, v: viewport, screen_pos: vector2, out: vector2): vector2;
+declare function view_transform_camera(c: camera, out: transform): transform;
+declare function inverse_view_transform_camera(c: camera, out: transform): transform;
+declare function camera_frustum(c: camera, v: viewport, out: frustum): frustum;
+declare function fit_camera_to_bounds(bounds: rectangle, v: viewport, margin: number | undefined, out: camera): camera;
+declare function contains_point_camera_frustum(c: camera, v: viewport, world_x: number, world_y: number): boolean;
+declare function width_of_camera_world(c: camera, v: viewport): number;
+declare function height_of_camera_world(c: camera, v: viewport): number;
+declare function pixel_size_of_camera(c: camera): number;
+declare function pixel_ratio_of_viewport(v: viewport): number;
+declare function device_width_of_viewport(v: viewport): number;
+declare function device_height_of_viewport(v: viewport): number;
+declare function world_to_device_camera(c: camera, v: viewport, world_pos: vector2, out: vector2): vector2;
+declare function device_to_world_camera(c: camera, v: viewport, device_pos: vector2, out: vector2): vector2;
+type image_asset = {
+	id: string;
+	src: string;
+	width: number;
+	height: number;
+};
+declare function create_image_asset(id: string, src: string, width?: number, height?: number): image_asset;
+type color = [number, number, number, number];
+declare function create_color(r?: number, g?: number, b?: number, a?: number): color;
+declare function clone_color(c: color): color;
+declare function set_color(r: number, g: number, b: number, a: number | undefined, out: color): color;
+declare function copy_color(c: color, out: color): color;
+declare function from_rgb_color(r: number, g: number, b: number, a?: number): color;
+declare function from_hex_color(hex: string): color;
+declare function to_rgba_string_color(c: color): string;
+declare function to_hex_string_color(c: color): string;
+declare function lerp_color(c1: color, c2: color, t: number, out: color): color;
+declare function equals_color(c1: color, c2: color, epsilon?: number): boolean;
+declare function white_color(): color;
+declare function black_color(): color;
+declare function transparent_color(): color;
+type spline_segment = {
+	a: number;
+	b: number;
+	c: number;
+	d: number;
+	x_start: number;
+	x_end: number;
+};
+type spline = {
+	segments_x: spline_segment[];
+	segments_y: spline_segment[];
+	point_count: number;
+};
+declare function create_spline(): spline;
+declare function clone_spline(s: spline): spline;
+declare function build_natural_spline_1d(points: number[], t_values: number[]): spline_segment[];
+declare function build_natural_spline_from_points(points: vector2[], spline: spline): spline;
+declare function evaluate_spline_segment(segment: spline_segment, t: number): number;
+declare function evaluate_spline_at_t(spline: spline, t: number, out: vector2): vector2 | null;
+declare function evaluate_spline_at_points(spline: spline, t_values: number[], out_points: vector2[]): number;
+declare function get_spline_length(spline: spline, steps?: number): number;
+declare function simplify_points_for_spline(points: vector2[], tolerance?: number): vector2[];
+declare const element_type_stroke = 0;
+declare const element_type_shape = 1;
+declare const element_type_image = 2;
+declare const element_type_text = 3;
+type stroke_element = {
+	type: typeof element_type_stroke;
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	group_id: string | null;
+	points: vector2[];
+	pressure: number[] | null;
+	color: color;
+	width: number;
+	simplified_points: vector2[] | null;
+	spline: spline | null;
+};
+declare const shape_type_rectangle = 0;
+declare const shape_type_ellipse = 1;
+declare const shape_type_line = 2;
+declare const shape_type_arrow = 3;
+declare const shape_type_frame = 4;
+type shape_element = {
+	type: typeof element_type_shape;
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	group_id: string | null;
+	shape_type: number;
+	fill_color: color | null;
+	stroke_color: color | null;
+	stroke_width: number;
+	start_point: vector2 | null;
+	end_point: vector2 | null;
+};
+type image_element = {
+	type: typeof element_type_image;
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	group_id: string | null;
+	asset_id: string | null;
+	src: string;
+	original_width: number;
+	original_height: number;
+	opacity: number;
+	loaded: boolean;
+	load_error: boolean;
+	bitmap: ImageBitmap | HTMLImageElement | null;
+};
+declare const text_align_left = 0;
+declare const text_align_center = 1;
+declare const text_align_right = 2;
+type text_element = {
+	type: typeof element_type_text;
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	group_id: string | null;
+	content: string;
+	font_family: string;
+	font_size: number;
+	color: color;
+	align: number;
+};
+type element = stroke_element | shape_element | image_element | text_element;
+declare function create_stroke_element(id: string, bounds: rectangle, z_index: number, layer_id: string, points: vector2[], pressure: number[] | null, color: color, width: number, group_id?: string | null): stroke_element;
+declare function create_shape_element(id: string, bounds: rectangle, z_index: number, layer_id: string, shape_type: number, fill_color: color | null, stroke_color: color | null, stroke_width: number, start_point: vector2 | null, end_point: vector2 | null, group_id?: string | null): shape_element;
+declare function create_image_element(id: string, bounds: rectangle, z_index: number, layer_id: string, src: string, original_width: number, original_height: number, opacity: number, group_id?: string | null, asset_id?: string | null): image_element;
+declare function create_text_element(id: string, bounds: rectangle, z_index: number, layer_id: string, content: string, font_family: string, font_size: number, color: color, align: number, group_id?: string | null): text_element;
+declare function clone_element(el: element): element;
+declare function id_of_element(el: element): string;
+declare function bounds_of_element(el: element): rectangle;
+declare function z_index_of_element(el: element): number;
+declare function layer_id_of_element(el: element): string;
+declare function type_of_element(el: element): number;
+declare function update_element_bounds(el: element, bounds: rectangle): element;
+declare function update_element_z_index(el: element, z_index: number): element;
+declare function update_element_layer_id(el: element, layer_id: string): element;
+declare function update_stroke_points(el: stroke_element, points: vector2[]): stroke_element;
+declare function update_stroke_simplified_points(el: stroke_element, simplified: vector2[] | null): stroke_element;
+declare function update_stroke_spline(el: stroke_element, spline_data: spline | null): stroke_element;
+declare function update_image_loaded(el: image_element, loaded: boolean, bitmap: ImageBitmap | HTMLImageElement | null, load_error?: boolean): image_element;
+declare function update_image_asset_id(el: image_element, asset_id: string | null): image_element;
+declare function update_text_content(el: text_element, content: string): text_element;
+declare function equals_element_identity(a: element, b: element): boolean;
+type layer = {
+	id: string;
+	name: string;
+	visible: boolean;
+	locked: boolean;
+	opacity: number;
+	element_ids: string[];
+};
+declare function create_layer(id: string, name: string, visible?: boolean, locked?: boolean, opacity?: number): layer;
+declare function clone_layer(l: layer): layer;
+declare function id_of_layer(l: layer): string;
+declare function name_of_layer(l: layer): string;
+declare function is_visible_layer(l: layer): boolean;
+declare function is_locked_layer(l: layer): boolean;
+declare function opacity_of_layer(l: layer): number;
+declare function element_ids_of_layer(l: layer): readonly string[];
+declare function element_count_of_layer(l: layer): number;
+declare function update_layer_name(l: layer, name: string): layer;
+declare function update_layer_visibility(l: layer, visible: boolean): layer;
+declare function update_layer_locked(l: layer, locked: boolean): layer;
+declare function update_layer_opacity(l: layer, opacity: number): layer;
+declare function add_element_id_to_layer(l: layer, element_id: string): layer;
+declare function remove_element_id_from_layer(l: layer, element_id: string): layer;
+declare function has_element_id_in_layer(l: layer, element_id: string): boolean;
+declare function reorder_element_ids_in_layer(l: layer, element_ids: string[]): layer;
+declare function equals_layer(a: layer, b: layer): boolean;
+type document = {
+	id: string;
+	elements: Map<string, element>;
+	layers: layer[];
+	active_layer_id: string;
+	assets: Map<string, image_asset>;
+	bounds: rectangle;
+	element_count: number;
+};
+declare function create_document(id: string, active_layer_id: string): document;
+declare function clone_document(doc: document): document;
+declare function id_of_document(doc: document): string;
+declare function elements_map_of_document(doc: document): Map<string, element>;
+declare function layers_of_document(doc: document): readonly layer[];
+declare function active_layer_id_of_document(doc: document): string;
+declare function assets_of_document(doc: document): Map<string, image_asset>;
+declare function bounds_of_document(doc: document): rectangle;
+declare function element_count_of_document(doc: document): number;
+declare function get_element_by_id_document(doc: document, element_id: string): element | null;
+declare function get_layer_by_id_document(doc: document, layer_id: string): layer | null;
+declare function add_element_document(doc: document, el: element): document;
+declare function remove_element_document(doc: document, element_id: string): document;
+declare function update_element_document(doc: document, element_id: string, new_element: element): document;
+declare function add_layer_document(doc: document, layer: layer): document;
+declare function remove_layer_document(doc: document, layer_id: string): document;
+declare function reorder_layers_document(doc: document, layer_ids: string[]): document;
+declare function set_active_layer_document(doc: document, layer_id: string): document;
+declare function get_elements_in_layer_document(doc: document, layer_id: string): element[];
+declare function get_all_elements_document(doc: document): element[];
+declare function recalculate_bounds_document(doc: document): document;
+declare function clear_document(doc: document): document;
+declare function add_image_asset_document(doc: document, asset: image_asset): document;
+declare function get_image_asset_document(doc: document, asset_id: string): image_asset | null;
+declare function remove_image_asset_document(doc: document, asset_id: string): document;
+type bezier_cubic = [vector2, vector2, vector2, vector2];
+type bezier_quadratic = [vector2, vector2, vector2];
+declare function create_cubic_bezier(p0: vector2, p1: vector2, p2: vector2, p3: vector2): bezier_cubic;
+declare function create_quadratic_bezier(p0: vector2, p1: vector2, p2: vector2): bezier_quadratic;
+declare function clone_cubic_bezier(b: bezier_cubic): bezier_cubic;
+declare function clone_quadratic_bezier(b: bezier_quadratic): bezier_quadratic;
+declare function evaluate_cubic_bezier(b: bezier_cubic, t: number, out: vector2): vector2;
+declare function evaluate_quadratic_bezier(b: bezier_quadratic, t: number, out: vector2): vector2;
+declare function derivative_cubic_bezier(b: bezier_cubic, t: number, out: vector2): vector2;
+declare function derivative_quadratic_bezier(b: bezier_quadratic, t: number, out: vector2): vector2;
+declare function length_cubic_bezier(b: bezier_cubic, steps?: number): number;
+declare function length_quadratic_bezier(b: bezier_quadratic, steps?: number): number;
+declare function subdivide_cubic_bezier(b: bezier_cubic, t: number, out1: bezier_cubic, out2: bezier_cubic): void;
+declare function closest_point_cubic_bezier(b: bezier_cubic, point: vector2, steps?: number): number;
+declare function from_points_cubic_bezier(points: vector2[], out: bezier_cubic[]): number;
+type circle = [number, number, number];
+declare function create_circle(x?: number, y?: number, radius?: number): circle;
+declare function clone_circle(c: circle): circle;
+declare function set_circle(x: number, y: number, radius: number, out: circle): circle;
+declare function copy_circle(c: circle, out: circle): circle;
+declare function center_of_circle(c: circle, out: vector2): vector2;
+declare function radius_of_circle(c: circle): number;
+declare function diameter_of_circle(c: circle): number;
+declare function area_of_circle(c: circle): number;
+declare function circumference_of_circle(c: circle): number;
+declare function contains_point_circle(c: circle, x: number, y: number): boolean;
+declare function contains_circle(c1: circle, c2: circle): boolean;
+declare function intersects_circle(c1: circle, c2: circle): boolean;
+declare function intersects_rectangle_circle(c: circle, r: rectangle): boolean;
+declare function distance_to_circle(c1: circle, c2: circle): number;
+declare function translate_circle(c: circle, dx: number, dy: number, out: circle): circle;
+declare function scale_circle(c: circle, scale: number, out: circle): circle;
+declare function bounding_rectangle_circle(c: circle, out: rectangle): rectangle;
+declare function equals_circle(c1: circle, c2: circle, epsilon?: number): boolean;
+declare function is_empty_circle(c: circle): boolean;
+type lod_level = {
+	readonly level: number;
+	readonly min_distance: number;
+	readonly max_distance: number;
+	readonly detail_factor: number;
+};
+type lod_config = {
+	readonly levels: readonly lod_level[];
+	readonly max_level: number;
+	readonly min_level: number;
+	readonly base_distance: number;
+	readonly distance_multiplier: number;
+};
+type lod_result = {
+	level: number;
+	blend_factor: number;
+	next_level: number;
+	distance: number;
+	screen_error: number;
+};
+type lod_viewport = {
+	readonly position: vector2;
+	readonly zoom_level: number;
+	readonly screen_width: number;
+	readonly screen_height: number;
+	readonly field_of_view: number;
+};
+declare function create_lod_level(level: number, min_distance: number, max_distance: number, detail_factor: number): lod_level;
+declare function create_lod_config(levels: lod_level[], base_distance?: number, distance_multiplier?: number): lod_config;
+declare function create_lod_result(): lod_result;
+declare function create_lod_viewport(position: vector2, zoom_level: number, screen_width: number, screen_height: number, field_of_view?: number): lod_viewport;
+declare function clone_lod_viewport(viewport: lod_viewport): lod_viewport;
+declare function copy_lod_viewport(viewport: lod_viewport, out_viewport: vector2, out_zoom: {
+	zoom_level: number;
+}, out_screen: {
+	screen_width: number;
+	screen_height: number;
+}, out_fov: {
+	field_of_view: number;
+}): void;
+declare function distance_from_viewport(viewport: lod_viewport, object_position: vector2): number;
+declare function zoom_adjusted_distance(distance: number, zoom_level: number): number;
+declare function screen_space_distance(distance: number, viewport: lod_viewport): number;
+declare function calculate_lod_distance(object_position: vector2, viewport: lod_viewport): number;
+declare function world_to_screen_size(world_size: number, distance: number, viewport: lod_viewport): number;
+declare function screen_to_world_size(screen_size: number, distance: number, viewport: lod_viewport): number;
+declare function select_discrete_lod_level(distance: number, config: lod_config): number;
+declare function select_lod_by_zoom(object_position: vector2, viewport: lod_viewport, config: lod_config): number;
+declare function select_lod_by_screen_size(object_world_size: number, object_position: vector2, viewport: lod_viewport, config: lod_config, pixel_threshold?: number): number;
+declare function find_lod_level_by_index(config: lod_config, level_index: number): lod_level | null;
+declare function get_detail_factor_for_level(config: lod_config, level_index: number): number;
+declare function calculate_continuous_lod(distance: number, config: lod_config, out_result: lod_result): lod_result;
+declare function interpolate_lod_detail_factor(result: lod_result, config: lod_config): number;
+declare function calculate_smooth_lod_transition(object_position: vector2, viewport: lod_viewport, config: lod_config, out_result: lod_result): lod_result;
+declare function lerp_lod_values(value_a: number, value_b: number, blend_factor: number): number;
+declare function smooth_step_transition(t: number): number;
+declare function smoother_step_transition(t: number): number;
+declare function calculate_alpha_blend_factor(result: lod_result, transition_distance?: number): number;
+declare function calculate_hysteresis_lod(current_lod: number, target_lod: number, distance: number, config: lod_config, hysteresis_factor?: number): number;
+declare function calculate_temporal_lod_blend(previous_result: lod_result, current_result: lod_result, delta_time: number, blend_speed?: number): number;
+declare function is_lod_transition_stable(result: lod_result, stability_threshold?: number): boolean;
+declare function calculate_screen_space_error(geometric_error: number, distance: number, viewport: lod_viewport): number;
+declare function calculate_geometric_error_for_lod(config: lod_config, level_index: number, base_error?: number): number;
+declare function select_lod_by_screen_error(object_position: vector2, viewport: lod_viewport, config: lod_config, max_screen_error?: number, base_geometric_error?: number): number;
+declare function calculate_pixel_density_lod(object_bounds: rectangle, object_position: vector2, viewport: lod_viewport, config: lod_config, target_pixels_per_unit?: number): number;
+declare function update_lod_result_screen_error(result: lod_result, viewport: lod_viewport, config: lod_config, base_geometric_error: number | undefined, out_result: lod_result): lod_result;
+declare function create_adaptive_lod_config(max_levels?: number, base_distance?: number, distance_multiplier?: number, detail_falloff?: number): lod_config;
+type quadtree_point = [number, number, unknown];
+type quadtree_node = {
+	readonly boundary: rectangle;
+	readonly points: readonly quadtree_point[];
+	readonly children: readonly quadtree_node[] | null;
+	readonly capacity: number;
+	readonly depth: number;
+};
+type quadtree = {
+	readonly root: quadtree_node;
+	readonly capacity: number;
+	readonly max_depth: number;
+};
+declare function create_quadtree_point(x: number, y: number, data?: unknown): quadtree_point;
+declare function x_of_quadtree_point(point: quadtree_point): number;
+declare function y_of_quadtree_point(point: quadtree_point): number;
+declare function data_of_quadtree_point(point: quadtree_point): unknown;
+declare function create_quadtree_node(boundary: rectangle, capacity?: number, depth?: number): quadtree_node;
+declare function create_quadtree(boundary: rectangle, capacity?: number, max_depth?: number): quadtree;
+declare function is_leaf_quadtree_node(node: quadtree_node): boolean;
+declare function point_count_quadtree_node(node: quadtree_node): number;
+declare function subdivide_quadtree_node(node: quadtree_node, max_depth: number): quadtree_node;
+declare function insert_quadtree_node(node: quadtree_node, point: quadtree_point, max_depth: number): quadtree_node | null;
+declare function insert_quadtree(tree: quadtree, point: quadtree_point): quadtree;
+declare function query_range_quadtree_node(node: quadtree_node, range: rectangle, out_results: quadtree_point[]): quadtree_point[];
+declare function query_range_quadtree(tree: quadtree, range: rectangle, out_results: quadtree_point[]): quadtree_point[];
+declare function query_radius_quadtree_node(node: quadtree_node, center_x: number, center_y: number, radius: number, out_results: quadtree_point[]): quadtree_point[];
+declare function query_radius_quadtree(tree: quadtree, center_x: number, center_y: number, radius: number, out_results: quadtree_point[]): quadtree_point[];
+declare function find_nearest_quadtree(tree: quadtree, x: number, y: number, max_distance?: number): quadtree_point | null;
+declare function find_nearest_quadtree_node(node: quadtree_node, x: number, y: number, max_distance?: number): quadtree_point | null;
+declare function remove_quadtree_node(node: quadtree_node, point: quadtree_point): quadtree_node;
+declare function remove_quadtree(tree: quadtree, point: quadtree_point): quadtree;
+declare function collect_all_points_quadtree_node(node: quadtree_node, out_points: quadtree_point[]): quadtree_point[];
+declare function clear_quadtree(tree: quadtree): quadtree;
+declare function point_count_quadtree(tree: quadtree): number;
+declare function depth_of_quadtree_node(node: quadtree_node): number;
+declare function depth_of_quadtree(tree: quadtree): number;
+declare function is_empty_quadtree(tree: quadtree): boolean;
+declare function bounds_of_quadtree(tree: quadtree, out_bounds: rectangle): rectangle;
+declare function find_k_nearest_quadtree(tree: quadtree, x: number, y: number, k: number, max_distance: number, out_results: quadtree_point[]): quadtree_point[];
+declare function detect_collisions_quadtree(tree: quadtree, point: quadtree_point, radius: number, out_collisions: quadtree_point[]): quadtree_point[];
+declare function detect_collisions_rectangle_quadtree(tree: quadtree, rect: rectangle, out_collisions: quadtree_point[]): quadtree_point[];
+type simplify_result = {
+	points: vector2[];
+	original_count: number;
+	simplified_count: number;
+	reduction_ratio: number;
+};
+declare function create_simplify_result(): simplify_result;
+declare function clone_simplify_result(result: simplify_result): simplify_result;
+declare function copy_simplify_result(result: simplify_result, out: simplify_result): simplify_result;
+declare function perpendicular_distance_to_line(point: vector2, line_start: vector2, line_end: vector2): number;
+declare function find_farthest_point(points: vector2[], start_index: number, end_index: number, out_result: {
+	index: number;
+	distance: number;
+}): {
+	index: number;
+	distance: number;
+};
+declare function simplify_douglas_peucker(points: vector2[], epsilon: number, out_points: vector2[]): number;
+declare function simplify_douglas_peucker_detailed(points: vector2[], epsilon: number, out_result: simplify_result): simplify_result;
+declare function estimate_epsilon_from_points(points: vector2[], tolerance_factor?: number): number;
+declare function polyline_length(points: vector2[]): number;
+declare function polyline_area_under_curve(points: vector2[]): number;
+declare function validate_simplified_polyline(points: vector2[]): boolean;
+declare const path_move = 0;
+declare const path_line = 1;
+declare const path_cubic = 2;
+declare const path_close = 3;
+type path_command_move = [typeof path_move, number, number];
+type path_command_line = [typeof path_line, number, number];
+type path_command_cubic = [typeof path_cubic, number, number, number, number, number, number];
+type path_command_close = [typeof path_close];
+type path_command = path_command_move | path_command_line | path_command_cubic | path_command_close;
+type path = {
+	readonly commands: readonly path_command[];
+	readonly bounds: rectangle;
+};
+declare function create_path(): path;
+declare function clone_path(p: path): path;
+declare function move_to_path(p: path, x: number, y: number): path;
+declare function line_to_path(p: path, x: number, y: number): path;
+declare function cubic_to_path(p: path, c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): path;
+declare function close_path(p: path): path;
+declare function bounds_of_path(p: path): rectangle;
+declare function is_empty_path(p: path): boolean;
+declare function command_count_of_path(p: path): number;
+declare function transform_path(p: path, t: transform, out: path): path;
+declare function hash_of_path(p: path): number;
+declare function from_rectangle_path(r: rectangle): path;
+declare function from_circle_path(c: circle, segments: number): path;
+declare function from_polyline_path(points: readonly vector2[], closed: boolean): path;
+type draw_style = {
+	readonly fill: color | null;
+	readonly stroke: color | null;
+	readonly stroke_width: number;
+	readonly line_cap: number;
+	readonly line_join: number;
+	readonly miter_limit: number;
+	readonly alpha: number;
+};
+declare const line_cap_butt = 0;
+declare const line_cap_round = 1;
+declare const line_cap_square = 2;
+declare const line_join_miter = 0;
+declare const line_join_round = 1;
+declare const line_join_bevel = 2;
+declare function create_draw_style(): draw_style;
+declare function clone_draw_style(s: draw_style): draw_style;
+declare function copy_draw_style(s: draw_style, out: draw_style): draw_style;
+declare function set_draw_style(fill: color | null, stroke: color | null, stroke_width: number, line_cap: number, line_join: number, miter_limit: number, alpha: number, out: draw_style): draw_style;
+declare function with_fill_draw_style(s: draw_style, fill: color | null, out: draw_style): draw_style;
+declare function with_stroke_draw_style(s: draw_style, stroke: color | null, stroke_width: number, out: draw_style): draw_style;
+declare function with_alpha_draw_style(s: draw_style, alpha: number, out: draw_style): draw_style;
+declare function with_line_cap_draw_style(s: draw_style, line_cap: number, out: draw_style): draw_style;
+declare function with_line_join_draw_style(s: draw_style, line_join: number, miter_limit: number, out: draw_style): draw_style;
+declare function equals_draw_style(a: draw_style, b: draw_style): boolean;
+declare const renderer_kind_canvas = 0;
+declare const renderer_kind_webgl = 1;
+type renderer_config = {
+	readonly prefer_webgl: boolean;
+	readonly path_cache_size: number;
+};
+type image_source = HTMLImageElement | HTMLCanvasElement | ImageBitmap;
+type renderer = {
+	readonly kind: number;
+	readonly width: number;
+	readonly height: number;
+	readonly pixel_ratio: number;
+	begin_frame: () => void;
+	end_frame: () => void;
+	set_transform: (t: transform) => void;
+	reset_transform: () => void;
+	save: () => void;
+	restore: () => void;
+	draw_path: (p: path, s: draw_style) => void;
+	draw_rectangle: (r: rectangle, s: draw_style) => void;
+	draw_circle: (c: circle, s: draw_style) => void;
+	draw_line: (a: vector2, b: vector2, s: draw_style) => void;
+	draw_polyline: (points: readonly vector2[], s: draw_style) => void;
+	draw_image: (image: image_source, r: rectangle, opacity: number, version?: number) => void;
+	clip_rectangle: (r: rectangle) => void;
+	clear: (c: color) => void;
+	resize: (width: number, height: number, pixel_ratio: number) => void;
+	dispose: () => void;
+};
+declare function create_renderer_config(): renderer_config;
+declare function create_renderer(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_canvas(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_webgl(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+type spatial_index = {
+	readonly quadtree: quadtree;
+	readonly bounds_map: Map<string, rectangle>;
+	readonly element_positions: Map<string, vector2>;
+	readonly config: spatial_index_config;
+	readonly deletion_count: number;
+};
+type spatial_index_config = {
+	readonly capacity: number;
+	readonly max_depth: number;
+	readonly world_bounds: rectangle;
+	readonly auto_expand: boolean;
+	readonly rebuild_dirty_ratio: number;
+};
+type spatial_query_result = {
+	readonly id: string;
+	readonly bounds: rectangle;
+};
+type spatial_index_stats = {
+	readonly element_count: number;
+	readonly tree_depth: number;
+	readonly node_count: number;
+};
+declare function create_spatial_index_config(world_bounds: rectangle, capacity?: number, max_depth?: number, auto_expand?: boolean, rebuild_dirty_ratio?: number): spatial_index_config;
+declare function create_spatial_index(config: spatial_index_config): spatial_index;
+declare function create_spatial_index_from_document(doc: {
+	elements: Map<string, element>;
+}, config: spatial_index_config): spatial_index;
+declare function insert_spatial_index(index: spatial_index, id: string, bounds: rectangle): spatial_index;
+declare function remove_spatial_index(index: spatial_index, id: string): spatial_index;
+declare function update_spatial_index(index: spatial_index, id: string, new_bounds: rectangle): spatial_index;
+declare function clear_spatial_index(index: spatial_index): spatial_index;
+declare function rebuild_spatial_index(index: spatial_index, elements: Map<string, element>): spatial_index;
+declare function query_range_spatial_index(index: spatial_index, bounds: rectangle, out_results: spatial_query_result[]): spatial_query_result[];
+declare function query_point_spatial_index(index: spatial_index, x: number, y: number, out_results: spatial_query_result[]): spatial_query_result[];
+declare function query_radius_spatial_index(index: spatial_index, x: number, y: number, radius: number, out_results: spatial_query_result[]): spatial_query_result[];
+declare function query_frustum_spatial_index(index: spatial_index, frustum_bounds: frustum, out_results: spatial_query_result[]): spatial_query_result[];
+declare function query_visible_elements_spatial_index(index: spatial_index, viewport_bounds: rectangle, margin: number | undefined, out_results: spatial_query_result[]): spatial_query_result[];
+declare function count_spatial_index(index: spatial_index): number;
+declare function bounds_of_spatial_index(index: spatial_index, out: rectangle): rectangle;
+declare function has_element_spatial_index(index: spatial_index, id: string): boolean;
+declare function get_element_bounds_spatial_index(index: spatial_index, id: string): rectangle | null;
+declare function stats_of_spatial_index(index: spatial_index): spatial_index_stats;
+type stroke_style = {
+	color: color;
+	width: number;
+	opacity: number;
+	pressure_sensitivity: number;
+};
+type stroke_point = {
+	position: vector2;
+	pressure: number;
+	timestamp: number;
+};
+type live_stroke = {
+	id: string;
+	points: stroke_point[];
+	style: stroke_style;
+	stabilizer_state: stabilizer_state;
+};
+type stroke = {
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	simplified_points: vector2[];
+	spline: spline | null;
+	path_cache: path_command[] | null;
+};
+type stabilizer_state = {
+	history: vector2[];
+	smoothing_factor: number;
+};
+declare const default_stroke_style: stroke_style;
+declare function create_stroke_style(color: color, width: number, opacity?: number, pressure_sensitivity?: number): stroke_style;
+declare function clone_stroke_style(s: stroke_style): stroke_style;
+declare const default_smoothing_factor = .3;
+declare const default_stabilizer_history_size = 5;
+declare function create_stabilizer(smoothing_factor?: number): stabilizer_state;
+declare function stabilize_point(state: stabilizer_state, raw: vector2, out: vector2): vector2;
+declare function reset_stabilizer(state: stabilizer_state): void;
+declare function get_stabilized_history(state: stabilizer_state): readonly vector2[];
+declare function generate_stroke_id(): string;
+declare function create_live_stroke(style: stroke_style, id?: string): live_stroke;
+declare function add_point_live_stroke(live: live_stroke, position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function add_raw_point_live_stroke(live: live_stroke, raw_position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function get_points_from_live_stroke(live: live_stroke): vector2[];
+declare function get_pressure_from_live_stroke(live: live_stroke): number[] | null;
+declare function render_live_stroke(live: live_stroke, renderer: renderer): void;
+declare function finalize_live_stroke(live: live_stroke, z_index: number, layer_id: string): {
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	id: string;
+	z_index: number;
+	layer_id: string;
+};
+declare const default_simplify_epsilon = 1;
+declare const default_lod_simplify_factor = 3;
+declare function simplify_stroke_points(points: vector2[], epsilon: number | undefined, out: vector2[]): number;
+declare function simplify_stroke_points_auto(points: vector2[], out: vector2[]): number;
+declare function fit_spline_to_stroke(points: vector2[], out_spline: spline): spline;
+declare function compute_stroke_bounds(points: vector2[], width: number, out: rectangle): rectangle;
+declare function process_stroke(points: vector2[], pressure: number[] | null, style: stroke_style, out_simplified: vector2[], out_spline: spline): {
+	simplified: vector2[];
+	spline: spline;
+};
+declare function get_simplified_for_lod(points: vector2[], lod_level: number, out: vector2[]): vector2[];
+declare const lod_high = 1;
+declare const lod_medium = .5;
+declare const lod_low = .25;
+declare const spline_evaluation_interval_high = 2;
+declare const spline_evaluation_interval_medium = 4;
+declare const spline_evaluation_interval_low = 8;
+declare function select_lod_from_zoom(zoom: number): number;
+declare function get_spline_evaluation_interval(lod: number): number;
+declare function stroke_to_path_commands(stroke: stroke, lod: number, out_commands: number[]): number;
+declare function render_stroke(stroke: stroke, renderer: renderer, zoom?: number): void;
+declare function render_stroke_with_pressure(stroke: stroke, renderer: renderer, _zoom?: number): void;
+type engine_options = {
+	readonly prefer_webgl?: boolean;
+	readonly path_cache_size?: number;
+	readonly document?: document;
+	readonly camera?: camera;
+	readonly background?: color;
+	readonly background_image?: image_source;
+};
+type engine = {
+	renderer: renderer;
+	document: document;
+	camera: camera;
+	viewport: viewport;
+	background: color;
+	background_image: image_source | null;
+};
+type overlay_draw = (drawer: renderer) => void;
+declare function create_engine(canvas: HTMLCanvasElement, options?: engine_options): engine | null;
+declare function dispose_engine(state: engine): void;
+declare function set_document_engine(state: engine, doc: document): engine;
+declare function set_background_engine(state: engine, value: color): engine;
+declare function set_background_image_engine(state: engine, value: image_source | null): engine;
+declare function set_camera_engine(state: engine, x: number, y: number, zoom: number, rotation?: number): engine;
+declare function pan_engine(state: engine, dx: number, dy: number): engine;
+declare function zoom_engine(state: engine, factor: number): engine;
+declare function zoom_at_engine(state: engine, factor: number, screen_x: number, screen_y: number): engine;
+declare function resize_engine(state: engine, width: number, height: number, pixel_ratio?: number): engine;
+declare function world_to_screen_engine(state: engine, world: vector2, out: vector2): vector2;
+declare function screen_to_world_engine(state: engine, screen: vector2, out: vector2): vector2;
+declare function visible_bounds_world_engine(state: engine): rectangle;
+declare function render_engine(state: engine): void;
+declare function render_engine_with_overlay(state: engine, overlay: overlay_draw | null): void;
+type editor_snap_context = "move" | "resize" | "rotate" | "shape" | "text" | "image";
+type editor_snap_result = {
+	point: vector2;
+	guides: rectangle[];
+};
+type editor_snap_meta = {
+	subject_bounds?: rectangle;
+};
+type editor_snapper = (state: editor, point: vector2, context: editor_snap_context, meta?: editor_snap_meta) => editor_snap_result | null;
+declare const editor_tool_select = 0;
+declare const editor_tool_hand = 1;
+declare const editor_tool_draw = 2;
+declare const editor_tool_rectangle = 3;
+declare const editor_tool_ellipse = 4;
+declare const editor_tool_line = 5;
+declare const editor_tool_arrow = 6;
+declare const editor_tool_text = 7;
+declare const editor_tool_image_place = 8;
+declare const editor_tool_frame = 9;
+type editor_tool_id = number | string;
+type editor_pointer_input = {
+	screen: vector2;
+	button?: number;
+	shift?: boolean;
+	alt?: boolean;
+	ctrl?: boolean;
+	meta?: boolean;
+};
+type editor_key_input = {
+	key: string;
+	shift?: boolean;
+	alt?: boolean;
+	ctrl?: boolean;
+	meta?: boolean;
+	repeat?: boolean;
+};
+type editor_clipboard_payload = {
+	elements: element[];
+	anchor: vector2;
+};
+type editor_move_state = {
+	kind: "move";
+	origin_world: vector2;
+	current_world: vector2;
+	base_document: document;
+	moved_element_ids: string[];
+	selection_bounds: rectangle;
+};
+type editor_pending_move_state = {
+	kind: "pending_move";
+	origin_world: vector2;
+	origin_screen: vector2;
+	selected_element_ids: string[];
+};
+type editor_resize_state = {
+	kind: "resize";
+	origin_world: vector2;
+	current_world: vector2;
+	base_document: document;
+	resized_element_ids: string[];
+	selection_bounds: rectangle;
+	handle: string;
+	keep_aspect: boolean;
+	centered: boolean;
+};
+type editor_rotate_state = {
+	kind: "rotate";
+	origin_world: vector2;
+	current_world: vector2;
+	base_document: document;
+	rotated_element_ids: string[];
+	selection_bounds: rectangle;
+	center: vector2;
+	start_angle: number;
+	snap_angle: boolean;
+};
+type editor_marquee_state = {
+	kind: "marquee";
+	origin_world: vector2;
+	current_world: vector2;
+	add_mode: boolean;
+};
+type editor_pending_marquee_state = {
+	kind: "pending_marquee";
+	origin_world: vector2;
+	origin_screen: vector2;
+	add_mode: boolean;
+};
+type editor_pan_state = {
+	kind: "pan";
+	origin_screen: vector2;
+	current_screen: vector2;
+};
+type editor_shape_state = {
+	kind: "shape";
+	origin_world: vector2;
+	current_world: vector2;
+	element_id: string;
+	shape_tool: editor_tool_id;
+};
+type editor_text_state = {
+	kind: "text";
+	origin_world: vector2;
+	current_world: vector2;
+	element_id: string;
+};
+type editor_image_state = {
+	kind: "image";
+	origin_world: vector2;
+	current_world: vector2;
+	element_id: string;
+};
+type editor_draw_state = {
+	kind: "draw";
+	points: vector2[];
+	pressure: number[];
+};
+type editor_text_edit_state = {
+	element_id: string;
+	draft: string;
+	original: string;
+	caret: number;
+	anchor: number | null;
+	preferred_column: number | null;
+};
+type editor_interaction_state = editor_pending_move_state | editor_move_state | editor_resize_state | editor_rotate_state | editor_pending_marquee_state | editor_marquee_state | editor_pan_state | editor_shape_state | editor_text_state | editor_image_state | editor_draw_state;
+type editor_transaction = {
+	label: string;
+	before: document;
+};
+type editor_tool = {
+	id: editor_tool_id;
+	name: string;
+	pointer_down: (state: editor, input: editor_pointer_input) => void;
+	pointer_move: (state: editor, input: editor_pointer_input) => void;
+	pointer_up: (state: editor, input: editor_pointer_input) => void;
+	double_click: (state: editor, input: editor_pointer_input) => void;
+	key_down: (state: editor, input: editor_key_input) => void;
+	cancel: (state: editor) => void;
+	hover: (state: editor, input: editor_pointer_input) => void;
+	cursor: (state: editor) => string;
+	overlay: (state: editor, drawer: renderer) => void;
+};
+type editor_plugin = {
+	id: string;
+	tools: editor_tool[];
+};
+type editor = {
+	engine: engine;
+	current_tool: editor_tool_id;
+	previous_tool_before_hand: editor_tool_id | null;
+	selected_element_ids: Set<string>;
+	hovered_element_id: string | null;
+	active_handle: string | null;
+	pointer_capture: boolean;
+	drag_state: editor_interaction_state | null;
+	marquee_state: editor_marquee_state | null;
+	clipboard_payload: editor_clipboard_payload | null;
+	active_transaction: editor_transaction | null;
+	undo_stack: document[];
+	redo_stack: document[];
+	transient_guides: rectangle[];
+	pointer_world: vector2;
+	pointer_screen: vector2;
+	has_pointer_input: boolean;
+	text_edit: editor_text_edit_state | null;
+	snappers: editor_snapper[];
+	tools: Map<editor_tool_id, editor_tool>;
+	plugin_tools: Map<string, editor_tool_id[]>;
+	id_counter: number;
+};
+declare function copy_selection_editor(state: editor): boolean;
+declare function cut_selection_editor(state: editor): boolean;
+declare function paste_clipboard_editor(state: editor, world_anchor?: vector2): boolean;
+declare function delete_selection_editor(state: editor): boolean;
+declare function undo_action_editor(state: editor): boolean;
+declare function redo_action_editor(state: editor): boolean;
+declare function group_selection_editor(state: editor): boolean;
+declare function ungroup_selection_editor(state: editor): boolean;
+declare function begin_text_edit_editor(state: editor, element_id: string, caret_from_world?: [number, number]): boolean;
+declare function is_text_editing_editor(state: editor): boolean;
+declare function commit_text_edit_editor(state: editor): boolean;
+type editor_options = {
+	initial_tool?: editor_tool_id;
+	plugins?: editor_plugin[];
+	snappers?: editor_snapper[];
+};
+declare function create_editor(state: engine, options?: editor_options): editor;
+declare function render_editor(state: editor): void;
+declare function set_tool_editor(state: editor, tool: editor_tool_id): void;
+declare function register_editor_tool_editor(state: editor, tool: editor_tool): void;
+declare function install_editor_plugin_editor(state: editor, plugin: editor_plugin): void;
+declare function uninstall_editor_plugin_editor(state: editor, plugin_id: string): void;
+declare function cursor_editor(state: editor): string;
+declare function pointer_down_editor(state: editor, input: editor_pointer_input): void;
+declare function pointer_move_editor(state: editor, input: editor_pointer_input): void;
+declare function pointer_up_editor(state: editor, input: editor_pointer_input): void;
+declare function hover_editor(state: editor, input: editor_pointer_input): void;
+declare function double_click_editor(state: editor, input: editor_pointer_input): void;
+declare function key_down_editor(state: editor, input: editor_key_input): void;
+declare function key_up_editor(state: editor, input: editor_key_input): void;
+declare function cancel_editor(state: editor): void;
+type selection_handle = {
+	id: string;
+	bounds: rectangle;
+};
+declare function selection_handles_editor(bounds: rectangle): selection_handle[];
+declare function selection_handles_for_elements_editor(doc: document, selected_ids: readonly string[]): selection_handle[];
+declare function hit_selection_handle_editor(bounds: rectangle, point: vector2): selection_handle | null;
+declare function hit_selection_handles_editor(handles: readonly selection_handle[], point: vector2): selection_handle | null;
+declare function contains_point_editor(bounds: rectangle, point: vector2): boolean;
+declare function element_hit_at_point_editor(doc: document, x: number, y: number, padding?: number): element | null;
+declare function snap_point_editor(state: editor, point: vector2, context: editor_snap_context, meta?: editor_snap_meta): vector2;
+declare function create_grid_snapper_editor(grid_size?: number, tolerance?: number): editor_snapper;
+declare function create_element_smart_snapper_editor(tolerance?: number): editor_snapper;
+export { zoom_of_camera, zoom_engine, zoom_camera, zoom_at_engine, zoom_at_camera, zoom_anchor, zoom_adjusted_distance, zero_vector2, z_index_of_element, y_of_quadtree_point, y_of_camera, x_of_quadtree_point, x_of_camera, world_to_screen_size, world_to_screen_engine, world_to_screen_camera, world_to_device_camera, with_stroke_draw_style, with_line_join_draw_style, with_line_cap_draw_style, with_fill_draw_style, with_alpha_draw_style, width_of_rectangle, width_of_frustum, width_of_camera_world, white_color, visible_bounds_world_engine, viewport, view_transform_camera, vector2, validate_simplified_polyline, update_text_content, update_stroke_spline, update_stroke_simplified_points, update_stroke_points, update_spatial_index, update_lod_result_screen_error, update_layer_visibility, update_layer_opacity, update_layer_name, update_layer_locked, update_image_loaded, update_image_asset_id, update_element_z_index, update_element_layer_id, update_element_document, update_element_bounds, unit_vector2, union_rectangle, uninstall_editor_plugin_editor, ungroup_selection_editor, undo_action_editor, type_of_element, transparent_color, translate_transform, translate_rectangle, translate_frustum, translate_circle, transform_vector_transform, transform_point_transform, transform_path, transform, top_of_rectangle, top_of_frustum, to_rgba_string_color, to_hex_string_color, text_element, text_align_right, text_align_left, text_align_center, subtract_vector2, subdivide_quadtree_node, subdivide_cubic_bezier, stroke_to_path_commands, stroke_style, stroke_point, stroke_element, stroke, stats_of_spatial_index, stabilizer_state, stabilize_point, spline_segment, spline_evaluation_interval_medium, spline_evaluation_interval_low, spline_evaluation_interval_high, spline, spatial_query_result, spatial_index_stats, spatial_index_config, spatial_index, snap_point_editor, smoother_step_transition, smooth_step_transition, smooth_damp_camera, simplify_stroke_points_auto, simplify_stroke_points, simplify_result, simplify_points_for_spline, simplify_douglas_peucker_detailed, simplify_douglas_peucker, shape_type_rectangle, shape_type_line, shape_type_frame, shape_type_ellipse, shape_type_arrow, shape_element, set_vector2, set_transform, set_tool_editor, set_rectangle, set_identity_transform, set_frustum_bounds, set_draw_style, set_document_engine, set_color, set_circle, set_camera_engine, set_camera, set_background_image_engine, set_background_engine, set_active_layer_document, selection_handles_for_elements_editor, selection_handles_editor, select_lod_from_zoom, select_lod_by_zoom, select_lod_by_screen_size, select_lod_by_screen_error, select_discrete_lod_level, screen_to_world_size, screen_to_world_engine, screen_to_world_camera, screen_space_distance, scale_transform, scale_rectangle, scale_circle, rotation_of_camera, rotate_transform, rotate_camera, right_of_rectangle, right_of_frustum, resize_engine, reset_stabilizer, reorder_layers_document, reorder_element_ids_in_layer, renderer_kind_webgl, renderer_kind_canvas, renderer_config, renderer, render_stroke_with_pressure, render_stroke, render_live_stroke, render_engine_with_overlay, render_engine, render_editor, remove_spatial_index, remove_quadtree_node, remove_quadtree, remove_layer_document, remove_image_asset_document, remove_element_id_from_layer, remove_element_document, register_editor_tool_editor, redo_action_editor, rectangle, recalculate_bounds_document, rebuild_spatial_index, radius_of_circle, query_visible_elements_spatial_index, query_range_spatial_index, query_range_quadtree_node, query_range_quadtree, query_radius_spatial_index, query_radius_quadtree_node, query_radius_quadtree, query_point_spatial_index, query_frustum_spatial_index, quadtree_point, quadtree_node, quadtree, process_stroke, prepend_translation_transform, prepend_scale_transform, prepend_rotation_transform, position_of_camera, polyline_length, polyline_area_under_curve, pointer_up_editor, pointer_move_editor, pointer_down_editor, point_count_quadtree_node, point_count_quadtree, pixel_size_of_camera, pixel_ratio_of_viewport, perpendicular_distance_to_line, path_move, path_line, path_cubic, path_command_move, path_command_line, path_command_cubic, path_command_close, path_command, path_close, path, paste_clipboard_editor, pan_engine, pan_camera, overlay_draw, opacity_of_layer, normalize_vector2, near_of_frustum, name_of_layer, multiply_vector2, multiply_transform, move_to_path, lod_viewport, lod_result, lod_medium, lod_low, lod_level, lod_high, lod_config, live_stroke, line_to_path, line_join_round, line_join_miter, line_join_bevel, line_cap_square, line_cap_round, line_cap_butt, lerp_vector2, lerp_lod_values, lerp_color, lerp_camera, length_vector2, length_squared_vector2, length_quadratic_bezier, length_cubic_bezier, left_of_rectangle, left_of_frustum, layers_of_document, layer_id_of_element, layer, key_up_editor, key_down_editor, is_visible_layer, is_text_editing_editor, is_lod_transition_stable, is_locked_layer, is_leaf_quadtree_node, is_identity_transform, is_identity_camera, is_equal_vector2, is_empty_rectangle, is_empty_quadtree, is_empty_path, is_empty_frustum, is_empty_circle, invert_transform, inverse_view_transform_camera, intersects_rectangle_circle, intersects_rectangle, intersects_frustum_rectangle, intersects_circle, intersection_rectangle, intersection_frustum_rectangle, interpolate_lod_detail_factor, install_editor_plugin_editor, insert_spatial_index, insert_quadtree_node, insert_quadtree, image_source, image_element, image_asset, identity_transform, id_of_layer, id_of_element, id_of_document, hover_editor, hit_selection_handles_editor, hit_selection_handle_editor, height_of_rectangle, height_of_frustum, height_of_camera_world, hash_of_path, has_element_spatial_index, has_element_id_in_layer, group_selection_editor, get_stabilized_history, get_spline_length, get_spline_evaluation_interval, get_simplified_for_lod, get_pressure_from_live_stroke, get_points_from_live_stroke, get_layer_by_id_document, get_image_asset_document, get_elements_in_layer_document, get_element_by_id_document, get_element_bounds_spatial_index, get_detail_factor_for_level, get_all_elements_document, generate_stroke_id, frustum, from_trs_transform, from_rgb_color, from_rectangle_path, from_polyline_path, from_points_cubic_bezier, from_hex_color, from_circle_path, from_center_rectangle, fit_spline_to_stroke, fit_camera_to_bounds, find_nearest_quadtree_node, find_nearest_quadtree, find_lod_level_by_index, find_k_nearest_quadtree, find_farthest_point, finalize_live_stroke, filter_visible_rectangles_frustum, far_of_frustum, expand_rectangle, expand_frustum, evaluate_spline_segment, evaluate_spline_at_t, evaluate_spline_at_points, evaluate_quadratic_bezier, evaluate_cubic_bezier, estimate_epsilon_from_points, equals_transform, equals_rectangle, equals_layer, equals_frustum, equals_element_identity, equals_draw_style, equals_color, equals_circle, equals_camera, engine_options, engine, elements_map_of_document, element_type_text, element_type_stroke, element_type_shape, element_type_image, element_ids_of_layer, element_hit_at_point_editor, element_count_of_layer, element_count_of_document, element, editor_transaction, editor_tool_text, editor_tool_select, editor_tool_rectangle, editor_tool_line, editor_tool_image_place, editor_tool_id, editor_tool_hand, editor_tool_frame, editor_tool_ellipse, editor_tool_draw, editor_tool_arrow, editor_tool, editor_text_edit_state, editor_snapper, editor_snap_result, editor_snap_context, editor_pointer_input, editor_plugin, editor_key_input, editor_interaction_state, editor_clipboard_payload, editor, draw_style, double_click_editor, dot_vector2, document, divide_vector2, distance_vector2, distance_to_circle, distance_squared_vector2, distance_from_viewport, dispose_engine, diameter_of_circle, device_width_of_viewport, device_to_world_camera, device_height_of_viewport, determinant_transform, detect_collisions_rectangle_quadtree, detect_collisions_quadtree, derivative_quadratic_bezier, derivative_cubic_bezier, depth_of_quadtree_node, depth_of_quadtree, delete_selection_editor, default_stroke_style, default_stabilizer_history_size, default_smoothing_factor, default_simplify_epsilon, default_lod_simplify_factor, data_of_quadtree_point, cut_selection_editor, cursor_editor, cull_rectangles_frustum, cull_rectangle_frustum, cubic_to_path, cross_vector2, create_vector2, create_transform, create_text_element, create_stroke_style, create_stroke_element, create_stabilizer, create_spline, create_spatial_index_from_document, create_spatial_index_config, create_spatial_index, create_simplify_result, create_shape_element, create_renderer_webgl, create_renderer_config, create_renderer_canvas, create_renderer, create_rectangle, create_quadtree_point, create_quadtree_node, create_quadtree, create_quadratic_bezier, create_path, create_lod_viewport, create_lod_result, create_lod_level, create_lod_config, create_live_stroke, create_layer, create_image_element, create_image_asset, create_grid_snapper_editor, create_frustum_from_view_matrix, create_frustum_from_rectangle, create_frustum_from_camera, create_frustum_from_bounds, create_frustum, create_engine, create_element_smart_snapper_editor, create_editor, create_draw_style, create_document, create_cubic_bezier, create_color, create_circle, create_camera, create_adaptive_lod_config, count_visible_rectangles_frustum, count_spatial_index, copy_vector2, copy_transform, copy_simplify_result, copy_selection_editor, copy_lod_viewport, copy_frustum, copy_draw_style, copy_color, copy_circle, copy_camera, contains_rectangle_frustum, contains_rectangle, contains_point_rectangle, contains_point_frustum, contains_point_editor, contains_point_circle, contains_point_camera_frustum, contains_circle, compute_stroke_bounds, commit_text_edit_editor, command_count_of_path, color, collect_all_points_quadtree_node, closest_point_cubic_bezier, close_path, clone_vector2, clone_transform, clone_stroke_style, clone_spline, clone_simplify_result, clone_rectangle, clone_quadratic_bezier, clone_path, clone_lod_viewport, clone_layer, clone_frustum, clone_element, clone_draw_style, clone_document, clone_cubic_bezier, clone_color, clone_circle, clone_camera, clear_spatial_index, clear_quadtree, clear_document, clamp_camera, circumference_of_circle, circle, center_of_rectangle, center_of_frustum, center_of_circle, cancel_editor, camera_limits, camera_frustum, camera, calculate_temporal_lod_blend, calculate_smooth_lod_transition, calculate_screen_space_error, calculate_pixel_density_lod, calculate_lod_distance, calculate_hysteresis_lod, calculate_geometric_error_for_lod, calculate_continuous_lod, calculate_alpha_blend_factor, build_natural_spline_from_points, build_natural_spline_1d, bounds_of_spatial_index, bounds_of_quadtree, bounds_of_path, bounds_of_element, bounds_of_document, bounding_rectangle_circle, bottom_of_rectangle, bottom_of_frustum, black_color, bezier_quadratic, bezier_cubic, begin_text_edit_editor, assets_of_document, area_of_rectangle, area_of_frustum, area_of_circle, append_translation_transform, append_scale_transform, append_rotation_transform, add_vector2, add_raw_point_live_stroke, add_point_live_stroke, add_layer_document, add_image_asset_document, add_element_id_to_layer, add_element_document, active_layer_id_of_document };