samcan 0.0.2 → 0.1.0

package/{license → LICENSE}

@@ -1,4 +1,6 @@
-Copyright 2025 aquaticcalf
+MIT License
+
+Copyright (c) 2025-present aquaticcalf
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -0,0 +1,3 @@
+# samcan
+
+canvas

package/dist/camera/index.cjs

@@ -0,0 +1,370 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// camera/index.ts
+var exports_camera = {};
+__export(exports_camera, {
+  zoom_of_camera: () => zoom_of_camera,
+  zoom_camera: () => zoom_camera,
+  zoom_at_camera: () => zoom_at_camera,
+  y_of_camera: () => y_of_camera,
+  x_of_camera: () => x_of_camera,
+  world_to_screen_camera: () => world_to_screen_camera,
+  world_to_device_camera: () => world_to_device_camera,
+  width_of_camera_world: () => width_of_camera_world,
+  view_transform_camera: () => view_transform_camera,
+  smooth_damp_camera: () => smooth_damp_camera,
+  set_camera: () => set_camera,
+  screen_to_world_camera: () => screen_to_world_camera,
+  rotation_of_camera: () => rotation_of_camera,
+  rotate_camera: () => rotate_camera,
+  position_of_camera: () => position_of_camera,
+  pixel_size_of_camera: () => pixel_size_of_camera,
+  pixel_ratio_of_viewport: () => pixel_ratio_of_viewport,
+  pan_camera: () => pan_camera,
+  lerp_camera: () => lerp_camera,
+  is_identity_camera: () => is_identity_camera,
+  inverse_view_transform_camera: () => inverse_view_transform_camera,
+  height_of_camera_world: () => height_of_camera_world,
+  fit_camera_to_bounds: () => fit_camera_to_bounds,
+  equals_camera: () => equals_camera,
+  device_width_of_viewport: () => device_width_of_viewport,
+  device_to_world_camera: () => device_to_world_camera,
+  device_height_of_viewport: () => device_height_of_viewport,
+  create_camera: () => create_camera,
+  copy_camera: () => copy_camera,
+  contains_point_camera_frustum: () => contains_point_camera_frustum,
+  clone_camera: () => clone_camera,
+  clamp_camera: () => clamp_camera,
+  camera_frustum: () => camera_frustum
+});
+module.exports = __toCommonJS(exports_camera);
+
+// camera/camera.ts
+function create_camera(x = 0, y = 0, zoom = 1, rotation = 0) {
+  return [x, y, zoom, rotation];
+}
+function clone_camera(c) {
+  return [c[0], c[1], c[2], c[3]];
+}
+function copy_camera(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function set_camera(x, y, zoom, rotation, out) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = zoom;
+  out[3] = rotation;
+  return out;
+}
+function x_of_camera(c) {
+  return c[0];
+}
+function y_of_camera(c) {
+  return c[1];
+}
+function zoom_of_camera(c) {
+  return c[2];
+}
+function rotation_of_camera(c) {
+  return c[3];
+}
+function position_of_camera(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  return out;
+}
+function pan_camera(c, dx, dy, out) {
+  out[0] = c[0] + dx;
+  out[1] = c[1] + dy;
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function zoom_camera(c, factor, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2] * factor;
+  out[3] = c[3];
+  return out;
+}
+function zoom_at_camera(c, factor, anchor, out) {
+  const world_dx = anchor.world_x - c[0];
+  const world_dy = anchor.world_y - c[1];
+  const new_zoom = c[2] * factor;
+  const new_world_x = anchor.world_x - world_dx / factor;
+  const new_world_y = anchor.world_y - world_dy / factor;
+  out[0] = new_world_x;
+  out[1] = new_world_y;
+  out[2] = new_zoom;
+  out[3] = c[3];
+  return out;
+}
+function rotate_camera(c, angle, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3] + angle;
+  return out;
+}
+function clamp_camera(c, limits, out) {
+  const clamped_zoom = Math.max(limits.min_zoom, Math.min(limits.max_zoom, c[2]));
+  const clamped_x = Math.max(limits.min_x, Math.min(limits.max_x, c[0]));
+  const clamped_y = Math.max(limits.min_y, Math.min(limits.max_y, c[1]));
+  out[0] = clamped_x;
+  out[1] = clamped_y;
+  out[2] = clamped_zoom;
+  out[3] = c[3];
+  return out;
+}
+function lerp_camera(a, b, t, out) {
+  const clamped_t = Math.max(0, Math.min(1, t));
+  out[0] = a[0] + clamped_t * (b[0] - a[0]);
+  out[1] = a[1] + clamped_t * (b[1] - a[1]);
+  out[2] = a[2] + clamped_t * (b[2] - a[2]);
+  let rotation_diff = b[3] - a[3];
+  while (rotation_diff > Math.PI) {
+    rotation_diff = rotation_diff - 2 * Math.PI;
+  }
+  while (rotation_diff < -Math.PI) {
+    rotation_diff = rotation_diff + 2 * Math.PI;
+  }
+  out[3] = a[3] + clamped_t * rotation_diff;
+  return out;
+}
+function smooth_damp_camera(current, target, velocity, smooth_time, delta_time, out) {
+  const omega = 2 / Math.max(0.0001, smooth_time);
+  const x = omega * delta_time;
+  const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+  const delta_x = current[0] - target[0];
+  const delta_y = current[1] - target[1];
+  const delta_zoom = current[2] - target[2];
+  let rotation_diff = target[3] - current[3];
+  while (rotation_diff > Math.PI) {
+    rotation_diff = rotation_diff - 2 * Math.PI;
+  }
+  while (rotation_diff < -Math.PI) {
+    rotation_diff = rotation_diff + 2 * Math.PI;
+  }
+  const delta_rotation = -rotation_diff;
+  const temp_x = (velocity[0] + omega * delta_x) * delta_time;
+  const temp_y = (velocity[1] + omega * delta_y) * delta_time;
+  const temp_zoom = (velocity[2] + omega * delta_zoom) * delta_time;
+  const temp_rotation = (velocity[3] + omega * delta_rotation) * delta_time;
+  const new_velocity_x = (velocity[0] - omega * temp_x) * exp;
+  const new_velocity_y = (velocity[1] - omega * temp_y) * exp;
+  const new_velocity_zoom = (velocity[2] - omega * temp_zoom) * exp;
+  const new_velocity_rotation = (velocity[3] - omega * temp_rotation) * exp;
+  velocity[0] = new_velocity_x;
+  velocity[1] = new_velocity_y;
+  velocity[2] = new_velocity_zoom;
+  velocity[3] = new_velocity_rotation;
+  const result_x = target[0] + (delta_x + temp_x) * exp;
+  const result_y = target[1] + (delta_y + temp_y) * exp;
+  const result_zoom = target[2] + (delta_zoom + temp_zoom) * exp;
+  const result_rotation = target[3] + (delta_rotation + temp_rotation) * exp;
+  out[0] = result_x;
+  out[1] = result_y;
+  out[2] = result_zoom;
+  out[3] = result_rotation;
+  return out;
+}
+function equals_camera(c1, c2, epsilon = 0.0001) {
+  return Math.abs(c1[0] - c2[0]) < epsilon && Math.abs(c1[1] - c2[1]) < epsilon && Math.abs(c1[2] - c2[2]) < epsilon && Math.abs(c1[3] - c2[3]) < epsilon;
+}
+function is_identity_camera(c) {
+  return c[0] === 0 && c[1] === 0 && c[2] === 1 && c[3] === 0;
+}
+// camera/projection.ts
+function world_to_screen_camera(c, v, world_pos, out) {
+  const dx = world_pos[0] - c[0];
+  const dy = world_pos[1] - c[1];
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  const rotated_x = dx * cos_r - dy * sin_r;
+  const rotated_y = dx * sin_r + dy * cos_r;
+  const screen_x = rotated_x * c[2] + v[0] / 2;
+  const screen_y = rotated_y * c[2] + v[1] / 2;
+  out[0] = screen_x;
+  out[1] = screen_y;
+  return out;
+}
+function screen_to_world_camera(c, v, screen_pos, out) {
+  if (c[2] <= 0) {
+    out[0] = c[0];
+    out[1] = c[1];
+    return out;
+  }
+  const dx = screen_pos[0] - v[0] / 2;
+  const dy = screen_pos[1] - v[1] / 2;
+  const cos_r = Math.cos(-c[3]);
+  const sin_r = Math.sin(-c[3]);
+  const scaled_x = dx / c[2];
+  const scaled_y = dy / c[2];
+  const rotated_x = scaled_x * cos_r - scaled_y * sin_r;
+  const rotated_y = scaled_x * sin_r + scaled_y * cos_r;
+  out[0] = rotated_x + c[0];
+  out[1] = rotated_y + c[1];
+  return out;
+}
+function view_transform_camera(c, out) {
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  out[0] = cos_r * c[2];
+  out[1] = sin_r * c[2];
+  out[2] = -sin_r * c[2];
+  out[3] = cos_r * c[2];
+  out[4] = -c[0] * cos_r * c[2] + c[1] * sin_r * c[2];
+  out[5] = -c[0] * sin_r * c[2] - c[1] * cos_r * c[2];
+  return out;
+}
+function inverse_view_transform_camera(c, out) {
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  const inverse_zoom = 1 / safe_zoom;
+  out[0] = cos_r * inverse_zoom;
+  out[1] = -sin_r * inverse_zoom;
+  out[2] = sin_r * inverse_zoom;
+  out[3] = cos_r * inverse_zoom;
+  out[4] = c[0];
+  out[5] = c[1];
+  return out;
+}
+function camera_frustum(c, v, out) {
+  if (c[2] <= 0) {
+    out[0] = c[0];
+    out[1] = c[0];
+    out[2] = c[1];
+    out[3] = c[1];
+    out[4] = 0;
+    out[5] = Number.MAX_VALUE;
+    return out;
+  }
+  const half_width = v[0] / (2 * c[2]);
+  const half_height = v[1] / (2 * c[2]);
+  if (c[3] === 0) {
+    out[0] = c[0] - half_width;
+    out[1] = c[0] + half_width;
+    out[2] = c[1] + half_height;
+    out[3] = c[1] - half_height;
+    out[4] = 0;
+    out[5] = Number.MAX_VALUE;
+    return out;
+  }
+  const cos_r = Math.abs(Math.cos(c[3]));
+  const sin_r = Math.abs(Math.sin(c[3]));
+  const x_extent = half_width * cos_r + half_height * sin_r;
+  const y_extent = half_width * sin_r + half_height * cos_r;
+  out[0] = c[0] - x_extent;
+  out[1] = c[0] + x_extent;
+  out[2] = c[1] + y_extent;
+  out[3] = c[1] - y_extent;
+  out[4] = 0;
+  out[5] = Number.MAX_VALUE;
+  return out;
+}
+function fit_camera_to_bounds(bounds, v, margin = 0.1, out) {
+  const bounds_width = bounds[2];
+  const bounds_height = bounds[3];
+  if (bounds_width <= 0 || bounds_height <= 0) {
+    out[0] = bounds[0];
+    out[1] = bounds[1];
+    out[2] = 1;
+    out[3] = 0;
+    return out;
+  }
+  const viewport_width = v[0] * (1 - margin * 2);
+  const viewport_height = v[1] * (1 - margin * 2);
+  if (viewport_width <= 0 || viewport_height <= 0) {
+    out[0] = bounds[0] + bounds_width / 2;
+    out[1] = bounds[1] + bounds_height / 2;
+    out[2] = 1;
+    out[3] = 0;
+    return out;
+  }
+  const zoom_x = viewport_width / bounds_width;
+  const zoom_y = viewport_height / bounds_height;
+  const zoom = Math.min(zoom_x, zoom_y);
+  const center_x = bounds[0] + bounds_width / 2;
+  const center_y = bounds[1] + bounds_height / 2;
+  out[0] = center_x;
+  out[1] = center_y;
+  out[2] = zoom;
+  out[3] = 0;
+  return out;
+}
+function contains_point_camera_frustum(c, v, world_x, world_y) {
+  const dx = world_x - c[0];
+  const dy = world_y - c[1];
+  const cos_r = Math.cos(-c[3]);
+  const sin_r = Math.sin(-c[3]);
+  const rotated_x = dx * cos_r - dy * sin_r;
+  const rotated_y = dx * sin_r + dy * cos_r;
+  const scaled_x = rotated_x * c[2];
+  const scaled_y = rotated_y * c[2];
+  const half_width = v[0] / 2;
+  const half_height = v[1] / 2;
+  return scaled_x >= -half_width && scaled_x <= half_width && scaled_y >= -half_height && scaled_y <= half_height;
+}
+function width_of_camera_world(c, v) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return v[0] / safe_zoom;
+}
+function height_of_camera_world(c, v) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return v[1] / safe_zoom;
+}
+function pixel_size_of_camera(c) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return 1 / safe_zoom;
+}
+function pixel_ratio_of_viewport(v) {
+  return v[2];
+}
+function device_width_of_viewport(v) {
+  return v[0] * v[2];
+}
+function device_height_of_viewport(v) {
+  return v[1] * v[2];
+}
+function world_to_device_camera(c, v, world_pos, out) {
+  world_to_screen_camera(c, v, world_pos, out);
+  out[0] = out[0] * v[2];
+  out[1] = out[1] * v[2];
+  return out;
+}
+function device_to_world_camera(c, v, device_pos, out) {
+  const screen_pos = [device_pos[0] / v[2], device_pos[1] / v[2]];
+  return screen_to_world_camera(c, v, screen_pos, out);
+}

package/dist/camera/index.d.cts

@@ -0,0 +1,54 @@
+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];
+type rectangle = [number, number, number, number];
+type frustum = [number, number, number, number, number, number];
+type transform = [number, number, number, number, number, number];
+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;
+export { zoom_of_camera, zoom_camera, zoom_at_camera, zoom_anchor, y_of_camera, x_of_camera, world_to_screen_camera, world_to_device_camera, width_of_camera_world, viewport, view_transform_camera, smooth_damp_camera, set_camera, screen_to_world_camera, rotation_of_camera, rotate_camera, position_of_camera, pixel_size_of_camera, pixel_ratio_of_viewport, pan_camera, lerp_camera, is_identity_camera, inverse_view_transform_camera, height_of_camera_world, fit_camera_to_bounds, equals_camera, device_width_of_viewport, device_to_world_camera, device_height_of_viewport, create_camera, copy_camera, contains_point_camera_frustum, clone_camera, clamp_camera, camera_limits, camera_frustum, camera };

package/dist/camera/index.d.ts

@@ -0,0 +1,54 @@
+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];
+type rectangle = [number, number, number, number];
+type frustum = [number, number, number, number, number, number];
+type transform = [number, number, number, number, number, number];
+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;
+export { zoom_of_camera, zoom_camera, zoom_at_camera, zoom_anchor, y_of_camera, x_of_camera, world_to_screen_camera, world_to_device_camera, width_of_camera_world, viewport, view_transform_camera, smooth_damp_camera, set_camera, screen_to_world_camera, rotation_of_camera, rotate_camera, position_of_camera, pixel_size_of_camera, pixel_ratio_of_viewport, pan_camera, lerp_camera, is_identity_camera, inverse_view_transform_camera, height_of_camera_world, fit_camera_to_bounds, equals_camera, device_width_of_viewport, device_to_world_camera, device_height_of_viewport, create_camera, copy_camera, contains_point_camera_frustum, clone_camera, clamp_camera, camera_limits, camera_frustum, camera };

package/dist/camera/index.js

@@ -0,0 +1,70 @@
+import {
+  camera_frustum,
+  clamp_camera,
+  clone_camera,
+  contains_point_camera_frustum,
+  copy_camera,
+  create_camera,
+  device_height_of_viewport,
+  device_to_world_camera,
+  device_width_of_viewport,
+  equals_camera,
+  fit_camera_to_bounds,
+  height_of_camera_world,
+  inverse_view_transform_camera,
+  is_identity_camera,
+  lerp_camera,
+  pan_camera,
+  pixel_ratio_of_viewport,
+  pixel_size_of_camera,
+  position_of_camera,
+  rotate_camera,
+  rotation_of_camera,
+  screen_to_world_camera,
+  set_camera,
+  smooth_damp_camera,
+  view_transform_camera,
+  width_of_camera_world,
+  world_to_device_camera,
+  world_to_screen_camera,
+  x_of_camera,
+  y_of_camera,
+  zoom_at_camera,
+  zoom_camera,
+  zoom_of_camera
+} from "../shared/chunk-hewznwbd.js";
+export {
+  zoom_of_camera,
+  zoom_camera,
+  zoom_at_camera,
+  y_of_camera,
+  x_of_camera,
+  world_to_screen_camera,
+  world_to_device_camera,
+  width_of_camera_world,
+  view_transform_camera,
+  smooth_damp_camera,
+  set_camera,
+  screen_to_world_camera,
+  rotation_of_camera,
+  rotate_camera,
+  position_of_camera,
+  pixel_size_of_camera,
+  pixel_ratio_of_viewport,
+  pan_camera,
+  lerp_camera,
+  is_identity_camera,
+  inverse_view_transform_camera,
+  height_of_camera_world,
+  fit_camera_to_bounds,
+  equals_camera,
+  device_width_of_viewport,
+  device_to_world_camera,
+  device_height_of_viewport,
+  create_camera,
+  copy_camera,
+  contains_point_camera_frustum,
+  clone_camera,
+  clamp_camera,
+  camera_frustum
+};