samcan 0.0.2 → 0.1.0

package/dist/editor/index.cjs

@@ -0,0 +1,5007 @@
+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
+    });
+};
+
+// editor/index.ts
+var exports_editor = {};
+__export(exports_editor, {
+  uninstall_editor_plugin_editor: () => uninstall_editor_plugin_editor,
+  ungroup_selection_editor: () => ungroup_selection_editor,
+  undo_action_editor: () => undo_action_editor,
+  snap_point_editor: () => snap_point_editor,
+  set_tool_editor: () => set_tool_editor,
+  selection_handles_for_elements_editor: () => selection_handles_for_elements_editor,
+  selection_handles_editor: () => selection_handles_editor,
+  render_editor: () => render_editor,
+  register_editor_tool_editor: () => register_editor_tool_editor,
+  redo_action_editor: () => redo_action_editor,
+  pointer_up_editor: () => pointer_up_editor,
+  pointer_move_editor: () => pointer_move_editor,
+  pointer_down_editor: () => pointer_down_editor,
+  paste_clipboard_editor: () => paste_clipboard_editor,
+  key_up_editor: () => key_up_editor,
+  key_down_editor: () => key_down_editor,
+  is_text_editing_editor: () => is_text_editing_editor,
+  install_editor_plugin_editor: () => install_editor_plugin_editor,
+  hover_editor: () => hover_editor,
+  hit_selection_handles_editor: () => hit_selection_handles_editor,
+  hit_selection_handle_editor: () => hit_selection_handle_editor,
+  group_selection_editor: () => group_selection_editor,
+  element_hit_at_point_editor: () => element_hit_at_point_editor,
+  editor_tool_text: () => editor_tool_text,
+  editor_tool_select: () => editor_tool_select,
+  editor_tool_rectangle: () => editor_tool_rectangle,
+  editor_tool_line: () => editor_tool_line,
+  editor_tool_image_place: () => editor_tool_image_place,
+  editor_tool_hand: () => editor_tool_hand,
+  editor_tool_frame: () => editor_tool_frame,
+  editor_tool_ellipse: () => editor_tool_ellipse,
+  editor_tool_draw: () => editor_tool_draw,
+  editor_tool_arrow: () => editor_tool_arrow,
+  double_click_editor: () => double_click_editor,
+  delete_selection_editor: () => delete_selection_editor,
+  cut_selection_editor: () => cut_selection_editor,
+  cursor_editor: () => cursor_editor,
+  create_grid_snapper_editor: () => create_grid_snapper_editor,
+  create_element_smart_snapper_editor: () => create_element_smart_snapper_editor,
+  create_editor: () => create_editor,
+  copy_selection_editor: () => copy_selection_editor,
+  contains_point_editor: () => contains_point_editor,
+  commit_text_edit_editor: () => commit_text_edit_editor,
+  cancel_editor: () => cancel_editor,
+  begin_text_edit_editor: () => begin_text_edit_editor
+});
+module.exports = __toCommonJS(exports_editor);
+
+// editor/types.ts
+var editor_tool_select = 0;
+var editor_tool_hand = 1;
+var editor_tool_draw = 2;
+var editor_tool_rectangle = 3;
+var editor_tool_ellipse = 4;
+var editor_tool_line = 5;
+var editor_tool_arrow = 6;
+var editor_tool_text = 7;
+var editor_tool_image_place = 8;
+var editor_tool_frame = 9;
+// document/element.ts
+var element_type_stroke = 0;
+var element_type_shape = 1;
+var element_type_image = 2;
+var element_type_text = 3;
+var shape_type_rectangle = 0;
+var shape_type_ellipse = 1;
+var shape_type_line = 2;
+var shape_type_arrow = 3;
+var shape_type_frame = 4;
+var text_align_left = 0;
+var text_align_center = 1;
+var text_align_right = 2;
+function create_stroke_element(id, bounds, z_index, layer_id, points, pressure, color, width, group_id = null) {
+  return {
+    type: element_type_stroke,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    points: points.map((p) => [p[0], p[1]]),
+    pressure: pressure === null ? null : [...pressure],
+    color: [color[0], color[1], color[2], color[3]],
+    width,
+    simplified_points: null,
+    spline: null
+  };
+}
+function create_shape_element(id, bounds, z_index, layer_id, shape_type, fill_color, stroke_color, stroke_width, start_point, end_point, group_id = null) {
+  return {
+    type: element_type_shape,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    shape_type,
+    fill_color: fill_color === null ? null : [fill_color[0], fill_color[1], fill_color[2], fill_color[3]],
+    stroke_color: stroke_color === null ? null : [stroke_color[0], stroke_color[1], stroke_color[2], stroke_color[3]],
+    stroke_width,
+    start_point: start_point === null ? null : [start_point[0], start_point[1]],
+    end_point: end_point === null ? null : [end_point[0], end_point[1]]
+  };
+}
+function create_image_element(id, bounds, z_index, layer_id, src, original_width, original_height, opacity, group_id = null, asset_id = null) {
+  return {
+    type: element_type_image,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    asset_id,
+    src,
+    original_width,
+    original_height,
+    opacity,
+    loaded: false,
+    load_error: false,
+    bitmap: null
+  };
+}
+function create_text_element(id, bounds, z_index, layer_id, content, font_family, font_size, color, align, group_id = null) {
+  return {
+    type: element_type_text,
+    id,
+    bounds: [bounds[0], bounds[1], bounds[2], bounds[3]],
+    z_index,
+    layer_id,
+    group_id,
+    content,
+    font_family,
+    font_size,
+    color: [color[0], color[1], color[2], color[3]],
+    align
+  };
+}
+function clone_element(el) {
+  if (el.type === element_type_stroke) {
+    const stroke = el;
+    return create_stroke_element(stroke.id, stroke.bounds, stroke.z_index, stroke.layer_id, stroke.points, stroke.pressure, stroke.color, stroke.width, stroke.group_id);
+  } else if (el.type === element_type_shape) {
+    const shape = el;
+    return create_shape_element(shape.id, shape.bounds, shape.z_index, shape.layer_id, shape.shape_type, shape.fill_color, shape.stroke_color, shape.stroke_width, shape.start_point, shape.end_point, shape.group_id);
+  } else if (el.type === element_type_image) {
+    const image = el;
+    const cloned = create_image_element(image.id, image.bounds, image.z_index, image.layer_id, image.src, image.original_width, image.original_height, image.opacity, image.group_id, image.asset_id);
+    cloned.loaded = image.loaded;
+    cloned.load_error = image.load_error;
+    cloned.bitmap = image.bitmap;
+    return cloned;
+  } else {
+    const text = el;
+    return create_text_element(text.id, text.bounds, text.z_index, text.layer_id, text.content, text.font_family, text.font_size, text.color, text.align, text.group_id);
+  }
+}
+function id_of_element(el) {
+  return el.id;
+}
+function bounds_of_element(el) {
+  return [el.bounds[0], el.bounds[1], el.bounds[2], el.bounds[3]];
+}
+function z_index_of_element(el) {
+  return el.z_index;
+}
+function layer_id_of_element(el) {
+  return el.layer_id;
+}
+function type_of_element(el) {
+  return el.type;
+}
+function update_element_bounds(el, bounds) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.bounds = [bounds[0], bounds[1], bounds[2], bounds[3]];
+  return cloned;
+}
+function update_element_z_index(el, z_index) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.z_index = z_index;
+  return cloned;
+}
+function update_element_layer_id(el, layer_id) {
+  const cloned = clone_element(el);
+  const mutable = cloned;
+  mutable.layer_id = layer_id;
+  return cloned;
+}
+function update_stroke_points(el, points) {
+  return {
+    ...el,
+    points: points.map((p) => [p[0], p[1]]),
+    simplified_points: null,
+    spline: null
+  };
+}
+function update_stroke_simplified_points(el, simplified) {
+  return {
+    ...el,
+    simplified_points: simplified === null ? null : simplified.map((p) => [p[0], p[1]])
+  };
+}
+function update_stroke_spline(el, spline_data) {
+  return {
+    ...el,
+    spline: spline_data
+  };
+}
+function update_image_loaded(el, loaded, bitmap, load_error = false) {
+  return {
+    ...el,
+    loaded,
+    load_error,
+    bitmap
+  };
+}
+function update_image_asset_id(el, asset_id) {
+  return {
+    ...el,
+    asset_id
+  };
+}
+function update_text_content(el, content) {
+  return {
+    ...el,
+    content
+  };
+}
+function equals_element_identity(a, b) {
+  if (a.type !== b.type || a.id !== b.id) {
+    return false;
+  }
+  if (a.z_index !== b.z_index || a.layer_id !== b.layer_id) {
+    return false;
+  }
+  if (a.group_id !== b.group_id) {
+    return false;
+  }
+  if (a.bounds[0] !== b.bounds[0] || a.bounds[1] !== b.bounds[1] || a.bounds[2] !== b.bounds[2] || a.bounds[3] !== b.bounds[3]) {
+    return false;
+  }
+  return true;
+}
+
+// math/rectangle.ts
+function create_rectangle(x = 0, y = 0, width = 0, height = 0) {
+  return [x, y, width, height];
+}
+function clone_rectangle(r) {
+  return [r[0], r[1], r[2], r[3]];
+}
+function from_center_rectangle(center, width, height, out) {
+  out[0] = center[0] - width / 2;
+  out[1] = center[1] - height / 2;
+  out[2] = width;
+  out[3] = height;
+  return out;
+}
+function top_of_rectangle(r) {
+  return r[1] + r[3];
+}
+function left_of_rectangle(r) {
+  return r[0];
+}
+function right_of_rectangle(r) {
+  return r[0] + r[2];
+}
+function bottom_of_rectangle(r) {
+  return r[1];
+}
+function center_of_rectangle(r, out) {
+  out[0] = r[0] + r[2] / 2;
+  out[1] = r[1] + r[3] / 2;
+  return out;
+}
+function width_of_rectangle(r) {
+  return r[2];
+}
+function height_of_rectangle(r) {
+  return r[3];
+}
+function area_of_rectangle(r) {
+  return r[2] * r[3];
+}
+function set_rectangle(x, y, width, height, out) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = width;
+  out[3] = height;
+  return out;
+}
+function translate_rectangle(r, dx, dy, out) {
+  out[0] = r[0] + dx;
+  out[1] = r[1] + dy;
+  out[2] = r[2];
+  out[3] = r[3];
+  return out;
+}
+function scale_rectangle(r, scale, out) {
+  out[0] = r[0] * scale;
+  out[1] = r[1] * scale;
+  out[2] = r[2] * scale;
+  out[3] = r[3] * scale;
+  return out;
+}
+function contains_point_rectangle(r, x, y) {
+  return x >= r[0] && x <= r[0] + r[2] && y >= r[1] && y <= r[1] + r[3];
+}
+function contains_rectangle(r1, r2) {
+  return r2[0] >= r1[0] && r2[1] >= r1[1] && r2[0] + r2[2] <= r1[0] + r1[2] && r2[1] + r2[3] <= r1[1] + r1[3];
+}
+function intersects_rectangle(r1, r2) {
+  return r1[0] < r2[0] + r2[2] && r1[0] + r1[2] > r2[0] && r1[1] < r2[1] + r2[3] && r1[1] + r1[3] > r2[1];
+}
+function intersection_rectangle(r1, r2, out) {
+  const x1 = Math.max(r1[0], r2[0]);
+  const y1 = Math.max(r1[1], r2[1]);
+  const x2 = Math.min(r1[0] + r1[2], r2[0] + r2[2]);
+  const y2 = Math.min(r1[1] + r1[3], r2[1] + r2[3]);
+  if (x2 <= x1 || y2 <= y1) {
+    return null;
+  }
+  out[0] = x1;
+  out[1] = y1;
+  out[2] = x2 - x1;
+  out[3] = y2 - y1;
+  return out;
+}
+function union_rectangle(r1, r2, out) {
+  const x1 = Math.min(r1[0], r2[0]);
+  const y1 = Math.min(r1[1], r2[1]);
+  const x2 = Math.max(r1[0] + r1[2], r2[0] + r2[2]);
+  const y2 = Math.max(r1[1] + r1[3], r2[1] + r2[3]);
+  out[0] = x1;
+  out[1] = y1;
+  out[2] = x2 - x1;
+  out[3] = y2 - y1;
+  return out;
+}
+function expand_rectangle(r, amount, out) {
+  out[0] = r[0] - amount;
+  out[1] = r[1] - amount;
+  out[2] = r[2] + amount * 2;
+  out[3] = r[3] + amount * 2;
+  return out;
+}
+function is_empty_rectangle(r) {
+  return r[2] <= 0 || r[3] <= 0;
+}
+function equals_rectangle(r1, r2) {
+  return r1[0] === r2[0] && r1[1] === r2[1] && r1[2] === r2[2] && r1[3] === r2[3];
+}
+
+// math/quadtree.ts
+function create_quadtree_point(x, y, data = null) {
+  return [x, y, data];
+}
+function x_of_quadtree_point(point) {
+  return point[0];
+}
+function y_of_quadtree_point(point) {
+  return point[1];
+}
+function data_of_quadtree_point(point) {
+  return point[2];
+}
+function create_quadtree_node(boundary, capacity = 4, depth = 0) {
+  return {
+    boundary: [boundary[0], boundary[1], boundary[2], boundary[3]],
+    points: [],
+    children: null,
+    capacity: Math.max(1, capacity),
+    depth: Math.max(0, depth)
+  };
+}
+function create_quadtree(boundary, capacity = 4, max_depth = 8) {
+  const normalized_capacity = Math.max(1, capacity);
+  const normalized_max_depth = Math.max(1, max_depth);
+  return {
+    root: create_quadtree_node(boundary, normalized_capacity, 0),
+    capacity: normalized_capacity,
+    max_depth: normalized_max_depth
+  };
+}
+function is_leaf_quadtree_node(node) {
+  return node.children === null;
+}
+function point_count_quadtree_node(node) {
+  if (is_leaf_quadtree_node(node)) {
+    return node.points.length;
+  }
+  let total = 0;
+  if (node.children !== null) {
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        total = total + point_count_quadtree_node(child);
+      }
+    }
+  }
+  return total;
+}
+function subdivide_quadtree_node(node, max_depth) {
+  if (node.children !== null) {
+    return node;
+  }
+  const boundary = node.boundary;
+  const half_width = boundary[2] / 2;
+  const half_height = boundary[3] / 2;
+  const x = boundary[0];
+  const y = boundary[1];
+  const next_depth = node.depth + 1;
+  const new_children = [
+    create_quadtree_node(create_rectangle(x, y, half_width, half_height), node.capacity, next_depth),
+    create_quadtree_node(create_rectangle(x + half_width, y, half_width, half_height), node.capacity, next_depth),
+    create_quadtree_node(create_rectangle(x, y + half_height, half_width, half_height), node.capacity, next_depth),
+    create_quadtree_node(create_rectangle(x + half_width, y + half_height, half_width, half_height), node.capacity, next_depth)
+  ];
+  let updated_children = [...new_children];
+  for (let i = 0;i < node.points.length; i = i + 1) {
+    const point = node.points[i];
+    if (point) {
+      for (let j = 0;j < 4; j = j + 1) {
+        const child = updated_children[j];
+        if (child) {
+          const child_result = insert_quadtree_node(child, point, max_depth);
+          if (child_result !== null) {
+            updated_children[j] = child_result;
+            break;
+          }
+        }
+      }
+    }
+  }
+  return {
+    boundary: node.boundary,
+    points: [],
+    children: updated_children,
+    capacity: node.capacity,
+    depth: node.depth
+  };
+}
+function insert_quadtree_node(node, point, max_depth) {
+  if (!contains_point_rectangle(node.boundary, point[0], point[1])) {
+    return null;
+  }
+  if (is_leaf_quadtree_node(node)) {
+    if (node.points.length < node.capacity || node.depth >= max_depth) {
+      const new_points = [...node.points, [point[0], point[1], point[2]]];
+      return {
+        boundary: node.boundary,
+        points: new_points,
+        children: null,
+        capacity: node.capacity,
+        depth: node.depth
+      };
+    }
+    const subdivided = subdivide_quadtree_node(node, max_depth);
+    return insert_quadtree_node(subdivided, point, max_depth);
+  }
+  if (node.children !== null && node.children.length === 4) {
+    const new_children = [...node.children];
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        const child_result = insert_quadtree_node(child, point, max_depth);
+        if (child_result !== null) {
+          new_children[i] = child_result;
+          return {
+            boundary: node.boundary,
+            points: node.points,
+            children: new_children,
+            capacity: node.capacity,
+            depth: node.depth
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+function insert_quadtree(tree, point) {
+  const new_root = insert_quadtree_node(tree.root, point, tree.max_depth);
+  if (new_root !== null) {
+    return {
+      root: new_root,
+      capacity: tree.capacity,
+      max_depth: tree.max_depth
+    };
+  }
+  return tree;
+}
+function query_range_quadtree_node(node, range, out_results) {
+  if (!intersects_rectangle(node.boundary, range)) {
+    return out_results;
+  }
+  if (is_leaf_quadtree_node(node)) {
+    for (let i = 0;i < node.points.length; i = i + 1) {
+      const point = node.points[i];
+      if (point && contains_point_rectangle(range, point[0], point[1])) {
+        out_results.push([point[0], point[1], point[2]]);
+      }
+    }
+    return out_results;
+  }
+  if (node.children !== null && node.children.length === 4) {
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        query_range_quadtree_node(child, range, out_results);
+      }
+    }
+  }
+  return out_results;
+}
+function query_range_quadtree(tree, range, out_results) {
+  return query_range_quadtree_node(tree.root, range, out_results);
+}
+function query_radius_quadtree_node(node, center_x, center_y, radius, out_results) {
+  const radius_squared = radius * radius;
+  const query_bounds = create_rectangle(center_x - radius, center_y - radius, radius * 2, radius * 2);
+  const candidates = [];
+  query_range_quadtree_node(node, query_bounds, candidates);
+  for (let i = 0;i < candidates.length; i = i + 1) {
+    const point = candidates[i];
+    if (point) {
+      const dx = point[0] - center_x;
+      const dy = point[1] - center_y;
+      const distance_squared = dx * dx + dy * dy;
+      if (distance_squared <= radius_squared) {
+        out_results.push([point[0], point[1], point[2]]);
+      }
+    }
+  }
+  return out_results;
+}
+function query_radius_quadtree(tree, center_x, center_y, radius, out_results) {
+  return query_radius_quadtree_node(tree.root, center_x, center_y, radius, out_results);
+}
+function find_nearest_quadtree(tree, x, y, max_distance = Number.POSITIVE_INFINITY) {
+  return find_nearest_quadtree_node(tree.root, x, y, max_distance);
+}
+function find_nearest_quadtree_node(node, x, y, max_distance = Number.POSITIVE_INFINITY) {
+  let best_point = null;
+  let best_distance_squared = max_distance * max_distance;
+  function search_node_recursive(search_node) {
+    if (is_leaf_quadtree_node(search_node)) {
+      for (let i = 0;i < search_node.points.length; i = i + 1) {
+        const point = search_node.points[i];
+        if (point) {
+          const dx = point[0] - x;
+          const dy = point[1] - y;
+          const distance_squared = dx * dx + dy * dy;
+          if (distance_squared < best_distance_squared) {
+            best_distance_squared = distance_squared;
+            best_point = [point[0], point[1], point[2]];
+          }
+        }
+      }
+    } else if (search_node.children !== null && search_node.children.length === 4) {
+      const child_distances = [];
+      for (let i = 0;i < 4; i = i + 1) {
+        const child = search_node.children[i];
+        if (child) {
+          const boundary = child.boundary;
+          const closest_x = Math.max(boundary[0], Math.min(x, boundary[0] + boundary[2]));
+          const closest_y = Math.max(boundary[1], Math.min(y, boundary[1] + boundary[3]));
+          const dx = x - closest_x;
+          const dy = y - closest_y;
+          const distance = dx * dx + dy * dy;
+          if (distance < best_distance_squared) {
+            child_distances.push({ node: child, distance });
+          }
+        }
+      }
+      child_distances.sort((a, b) => a.distance - b.distance);
+      for (let i = 0;i < child_distances.length; i = i + 1) {
+        const child_info = child_distances[i];
+        if (child_info && child_info.distance < best_distance_squared) {
+          search_node_recursive(child_info.node);
+        }
+      }
+    }
+  }
+  search_node_recursive(node);
+  return best_point;
+}
+function remove_quadtree_node(node, point) {
+  if (!contains_point_rectangle(node.boundary, point[0], point[1])) {
+    return node;
+  }
+  if (is_leaf_quadtree_node(node)) {
+    const new_points = [];
+    let removed = false;
+    for (let i = 0;i < node.points.length; i = i + 1) {
+      const existing = node.points[i];
+      if (existing && existing[0] === point[0] && existing[1] === point[1] && !removed) {
+        removed = true;
+      } else if (existing) {
+        new_points.push([existing[0], existing[1], existing[2]]);
+      }
+    }
+    return {
+      boundary: node.boundary,
+      points: new_points,
+      children: null,
+      capacity: node.capacity,
+      depth: node.depth
+    };
+  }
+  if (node.children !== null && node.children.length === 4) {
+    const new_children = [...node.children];
+    let changed = false;
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        const new_child = remove_quadtree_node(child, point);
+        if (new_child !== child) {
+          new_children[i] = new_child;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      let total_points = 0;
+      for (let i = 0;i < 4; i = i + 1) {
+        const child = new_children[i];
+        if (child) {
+          total_points = total_points + point_count_quadtree_node(child);
+        }
+      }
+      if (total_points <= node.capacity) {
+        const all_points = [];
+        collect_all_points_quadtree_node({ ...node, children: new_children }, all_points);
+        return {
+          boundary: node.boundary,
+          points: all_points,
+          children: null,
+          capacity: node.capacity,
+          depth: node.depth
+        };
+      }
+      return {
+        boundary: node.boundary,
+        points: node.points,
+        children: new_children,
+        capacity: node.capacity,
+        depth: node.depth
+      };
+    }
+  }
+  return node;
+}
+function remove_quadtree(tree, point) {
+  const new_root = remove_quadtree_node(tree.root, point);
+  return {
+    root: new_root,
+    capacity: tree.capacity,
+    max_depth: tree.max_depth
+  };
+}
+function collect_all_points_quadtree_node(node, out_points) {
+  if (is_leaf_quadtree_node(node)) {
+    for (let i = 0;i < node.points.length; i = i + 1) {
+      const point = node.points[i];
+      if (point) {
+        out_points.push([point[0], point[1], point[2]]);
+      }
+    }
+  } else if (node.children !== null && node.children.length === 4) {
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        collect_all_points_quadtree_node(child, out_points);
+      }
+    }
+  }
+  return out_points;
+}
+function clear_quadtree(tree) {
+  return {
+    root: create_quadtree_node(tree.root.boundary, tree.capacity, 0),
+    capacity: tree.capacity,
+    max_depth: tree.max_depth
+  };
+}
+function point_count_quadtree(tree) {
+  return point_count_quadtree_node(tree.root);
+}
+function depth_of_quadtree_node(node) {
+  if (is_leaf_quadtree_node(node)) {
+    return node.depth;
+  }
+  let max_depth = node.depth;
+  if (node.children !== null && node.children.length === 4) {
+    for (let i = 0;i < 4; i = i + 1) {
+      const child = node.children[i];
+      if (child) {
+        const child_depth = depth_of_quadtree_node(child);
+        if (child_depth > max_depth) {
+          max_depth = child_depth;
+        }
+      }
+    }
+  }
+  return max_depth;
+}
+function depth_of_quadtree(tree) {
+  return depth_of_quadtree_node(tree.root);
+}
+function is_empty_quadtree(tree) {
+  return point_count_quadtree(tree) === 0;
+}
+function bounds_of_quadtree(tree, out_bounds) {
+  out_bounds[0] = tree.root.boundary[0];
+  out_bounds[1] = tree.root.boundary[1];
+  out_bounds[2] = tree.root.boundary[2];
+  out_bounds[3] = tree.root.boundary[3];
+  return out_bounds;
+}
+function find_k_nearest_quadtree(tree, x, y, k, max_distance, out_results) {
+  if (point_count_quadtree(tree) <= k * 2) {
+    const all_points = [];
+    collect_all_points_quadtree_node(tree.root, all_points);
+    const distances2 = [];
+    for (let i = 0;i < all_points.length; i = i + 1) {
+      const point = all_points[i];
+      if (point) {
+        const dx = point[0] - x;
+        const dy = point[1] - y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        if (distance <= max_distance) {
+          distances2.push({ point, distance });
+        }
+      }
+    }
+    distances2.sort((a, b) => a.distance - b.distance);
+    const limit2 = Math.min(k, distances2.length);
+    for (let i = 0;i < limit2; i = i + 1) {
+      const item = distances2[i];
+      if (item && item.point) {
+        out_results.push([item.point[0], item.point[1], item.point[2]]);
+      }
+    }
+    return out_results;
+  }
+  let current_radius = 100;
+  const bounds = [0, 0, 0, 0];
+  bounds_of_quadtree(tree, bounds);
+  const max_possible_radius = Math.sqrt(bounds[2] * bounds[2] + bounds[3] * bounds[3]);
+  while (current_radius <= max_possible_radius) {
+    const candidates = [];
+    query_radius_quadtree(tree, x, y, Math.min(current_radius, max_distance), candidates);
+    if (candidates.length >= k) {
+      const distances2 = [];
+      for (let i = 0;i < candidates.length; i = i + 1) {
+        const point = candidates[i];
+        if (point) {
+          const dx = point[0] - x;
+          const dy = point[1] - y;
+          const distance = Math.sqrt(dx * dx + dy * dy);
+          if (distance <= max_distance) {
+            distances2.push({ point, distance });
+          }
+        }
+      }
+      distances2.sort((a, b) => a.distance - b.distance);
+      const limit2 = Math.min(k, distances2.length);
+      for (let i = 0;i < limit2; i = i + 1) {
+        const item = distances2[i];
+        if (item && item.point) {
+          out_results.push([item.point[0], item.point[1], item.point[2]]);
+        }
+      }
+      return out_results;
+    }
+    current_radius = current_radius * 2;
+  }
+  const final_candidates = [];
+  query_radius_quadtree(tree, x, y, max_distance, final_candidates);
+  const distances = [];
+  for (let i = 0;i < final_candidates.length; i = i + 1) {
+    const point = final_candidates[i];
+    if (point) {
+      const dx = point[0] - x;
+      const dy = point[1] - y;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      distances.push({ point, distance });
+    }
+  }
+  distances.sort((a, b) => a.distance - b.distance);
+  const limit = Math.min(k, distances.length);
+  for (let i = 0;i < limit; i = i + 1) {
+    const item = distances[i];
+    if (item && item.point) {
+      out_results.push([item.point[0], item.point[1], item.point[2]]);
+    }
+  }
+  return out_results;
+}
+function detect_collisions_quadtree(tree, point, radius, out_collisions) {
+  return query_radius_quadtree(tree, point[0], point[1], radius, out_collisions);
+}
+function detect_collisions_rectangle_quadtree(tree, rect, out_collisions) {
+  return query_range_quadtree(tree, rect, out_collisions);
+}
+
+// document/query.ts
+function elements_in_bounds_document(doc, bounds) {
+  const results = [];
+  for (const el of doc.elements.values()) {
+    const el_bounds = el.bounds;
+    if (el_bounds[0] < bounds[0] + bounds[2] && el_bounds[0] + el_bounds[2] > bounds[0] && el_bounds[1] < bounds[1] + bounds[3] && el_bounds[1] + el_bounds[3] > bounds[1]) {
+      results.push(el);
+    }
+  }
+  return results;
+}
+
+// engine/shared.ts
+var default_background = [1, 1, 1, 1];
+var default_element_fill = [0.95, 0.97, 1, 1];
+var default_element_stroke = [0.18, 0.22, 0.31, 1];
+var min_zoom_engine = 0.0001;
+var max_zoom_engine = 1e6;
+var scratch_camera = [0, 0, 1, 0];
+var scratch_frustum = [0, 0, 0, 0, 0, 0];
+var scratch_transform = [1, 0, 0, 1, 0, 0];
+var scratch_world = [0, 0];
+var scratch_screen = [0, 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);
+}
+
+// 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;
+}
+
+// engine/camera.ts
+function set_camera_engine(state, x, y, zoom, rotation = 0) {
+  set_camera(sanitize_number_engine(x, state.camera[0]), sanitize_number_engine(y, state.camera[1]), sanitize_zoom_engine(zoom, state.camera[2]), sanitize_number_engine(rotation, state.camera[3]), state.camera);
+  return state;
+}
+function pan_engine(state, dx, dy) {
+  pan_camera(state.camera, dx, dy, scratch_camera);
+  copy_camera_into_engine(state, scratch_camera);
+  return state;
+}
+function zoom_engine(state, factor) {
+  zoom_camera(state.camera, factor, scratch_camera);
+  copy_camera_into_engine(state, scratch_camera);
+  return state;
+}
+function zoom_at_engine(state, factor, screen_x, screen_y) {
+  scratch_screen[0] = screen_x;
+  scratch_screen[1] = screen_y;
+  screen_to_world_camera(state.camera, state.viewport, scratch_screen, scratch_world);
+  zoom_at_camera(state.camera, factor, {
+    screen_x,
+    screen_y,
+    world_x: scratch_world[0],
+    world_y: scratch_world[1]
+  }, scratch_camera);
+  copy_camera_into_engine(state, scratch_camera);
+  return state;
+}
+function resize_engine(state, width, height, pixel_ratio = Math.max(1, globalThis.devicePixelRatio || 1)) {
+  const safe_width = Math.max(1, width);
+  const safe_height = Math.max(1, height);
+  const safe_pixel_ratio = Math.max(1, pixel_ratio);
+  state.viewport[0] = safe_width;
+  state.viewport[1] = safe_height;
+  state.viewport[2] = safe_pixel_ratio;
+  state.renderer.resize(safe_width, safe_height, safe_pixel_ratio);
+  return state;
+}
+function world_to_screen_engine(state, world, out) {
+  return world_to_screen_camera(state.camera, state.viewport, world, out);
+}
+function screen_to_world_engine(state, screen, out) {
+  return screen_to_world_camera(state.camera, state.viewport, screen, out);
+}
+function visible_bounds_world_engine(state) {
+  camera_frustum(state.camera, state.viewport, scratch_frustum);
+  return [
+    scratch_frustum[0],
+    scratch_frustum[3],
+    scratch_frustum[1] - scratch_frustum[0],
+    scratch_frustum[2] - scratch_frustum[3]
+  ];
+}
+function camera_to_screen_transform_engine(c, v, out) {
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  const zoom = c[2];
+  out[0] = cos_r * zoom;
+  out[1] = sin_r * zoom;
+  out[2] = -sin_r * zoom;
+  out[3] = cos_r * zoom;
+  out[4] = v[0] / 2 - c[0] * cos_r * zoom + c[1] * sin_r * zoom;
+  out[5] = v[1] / 2 - c[0] * sin_r * zoom - c[1] * cos_r * zoom;
+  return out;
+}
+function sanitize_number_engine(value, fallback) {
+  if (Number.isFinite(value)) {
+    return value;
+  }
+  return Number.isFinite(fallback) ? fallback : 0;
+}
+function sanitize_zoom_engine(value, fallback) {
+  const safe_value = Number.isFinite(value) ? value : fallback;
+  if (!Number.isFinite(safe_value) || safe_value <= 0) {
+    return 1;
+  }
+  return Math.min(max_zoom_engine, Math.max(min_zoom_engine, safe_value));
+}
+function copy_camera_into_engine(state, value) {
+  state.camera[0] = sanitize_number_engine(value[0], state.camera[0]);
+  state.camera[1] = sanitize_number_engine(value[1], state.camera[1]);
+  state.camera[2] = sanitize_zoom_engine(value[2], state.camera[2]);
+  state.camera[3] = sanitize_number_engine(value[3], state.camera[3]);
+}
+
+// math/color.ts
+function create_color(r = 0, g = 0, b = 0, a = 1) {
+  return [
+    Math.max(0, Math.min(1, r)),
+    Math.max(0, Math.min(1, g)),
+    Math.max(0, Math.min(1, b)),
+    Math.max(0, Math.min(1, a))
+  ];
+}
+function clone_color(c) {
+  return [c[0], c[1], c[2], c[3]];
+}
+function set_color(r, g, b, a = 1, out) {
+  out[0] = Math.max(0, Math.min(1, r));
+  out[1] = Math.max(0, Math.min(1, g));
+  out[2] = Math.max(0, Math.min(1, b));
+  out[3] = Math.max(0, Math.min(1, a));
+  return out;
+}
+function copy_color(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function from_rgb_color(r, g, b, a = 255) {
+  return create_color(r / 255, g / 255, b / 255, a / 255);
+}
+function from_hex_color(hex) {
+  const cleaned = hex.replace("#", "");
+  const r = parseInt(cleaned.substring(0, 2), 16) / 255;
+  const g = parseInt(cleaned.substring(2, 4), 16) / 255;
+  const b = parseInt(cleaned.substring(4, 6), 16) / 255;
+  const a = cleaned.length === 8 ? parseInt(cleaned.substring(6, 8), 16) / 255 : 1;
+  return create_color(r, g, b, a);
+}
+function to_rgba_string_color(c) {
+  return `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${c[3]})`;
+}
+function to_hex_string_color(c) {
+  const r = Math.round(c[0] * 255).toString(16).padStart(2, "0");
+  const g = Math.round(c[1] * 255).toString(16).padStart(2, "0");
+  const b = Math.round(c[2] * 255).toString(16).padStart(2, "0");
+  const a = Math.round(c[3] * 255).toString(16).padStart(2, "0");
+  return c[3] === 1 ? `#${r}${g}${b}` : `#${r}${g}${b}${a}`;
+}
+function lerp_color(c1, c2, t, out) {
+  out[0] = c1[0] + (c2[0] - c1[0]) * t;
+  out[1] = c1[1] + (c2[1] - c1[1]) * t;
+  out[2] = c1[2] + (c2[2] - c1[2]) * t;
+  out[3] = c1[3] + (c2[3] - c1[3]) * t;
+  return out;
+}
+function equals_color(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 white_color() {
+  return [1, 1, 1, 1];
+}
+function black_color() {
+  return [0, 0, 0, 1];
+}
+function transparent_color() {
+  return [0, 0, 0, 0];
+}
+
+// engine/elements.ts
+var loaded_images_engine = new Map;
+var text_bitmap_cache_engine = new Map;
+var text_bitmap_cache_limit_engine = 128;
+function render_element_engine(drawer, el, asset_src = null) {
+  if (el.type === element_type_stroke) {
+    render_stroke_element_engine(drawer, el);
+    return;
+  }
+  if (el.type === element_type_shape) {
+    render_shape_element_engine(drawer, el);
+    return;
+  }
+  if (el.type === element_type_image) {
+    render_image_element_engine(drawer, el, asset_src);
+    return;
+  }
+  if (el.type === element_type_text) {
+    render_text_element_engine(drawer, el);
+  }
+}
+function render_stroke_element_engine(drawer, el) {
+  const style = {
+    fill: null,
+    stroke: el.color,
+    stroke_width: el.width,
+    line_cap: 1,
+    line_join: 1,
+    miter_limit: 10,
+    alpha: el.color[3]
+  };
+  const points = el.simplified_points && el.simplified_points.length > 1 ? el.simplified_points : el.points;
+  if (points.length === 1) {
+    const p = points[0];
+    if (p !== undefined) {
+      drawer.draw_circle([p[0], p[1], Math.max(0.5, el.width * 0.5)], style);
+    }
+    return;
+  }
+  if (points.length > 1) {
+    drawer.draw_polyline(points, style);
+  }
+}
+function render_shape_element_engine(drawer, el) {
+  const style = {
+    fill: el.fill_color,
+    stroke: el.stroke_color,
+    stroke_width: el.stroke_width,
+    line_cap: 1,
+    line_join: 1,
+    miter_limit: 10,
+    alpha: 1
+  };
+  if (el.shape_type === shape_type_rectangle) {
+    drawer.draw_rectangle(el.bounds, style);
+    return;
+  }
+  if (el.shape_type === shape_type_frame) {
+    const header_height = Math.max(20, Math.min(36, el.bounds[3] * 0.18));
+    const header_style = {
+      fill: style.stroke,
+      stroke: style.stroke,
+      stroke_width: Math.max(1, style.stroke_width),
+      line_cap: style.line_cap,
+      line_join: style.line_join,
+      miter_limit: style.miter_limit,
+      alpha: 0.12
+    };
+    const outline_style = {
+      ...style,
+      fill: null,
+      alpha: 1
+    };
+    drawer.draw_rectangle(el.bounds, outline_style);
+    drawer.draw_rectangle([el.bounds[0], el.bounds[1], el.bounds[2], header_height], header_style);
+    return;
+  }
+  if (el.shape_type === shape_type_ellipse) {
+    const cx = el.bounds[0] + el.bounds[2] / 2;
+    const cy = el.bounds[1] + el.bounds[3] / 2;
+    const rx = Math.max(0.5, Math.abs(el.bounds[2]) / 2);
+    const ry = Math.max(0.5, Math.abs(el.bounds[3]) / 2);
+    const segments = 40;
+    const points = [];
+    for (let i = 0;i <= segments; i = i + 1) {
+      const t = i / segments * Math.PI * 2;
+      points.push([cx + Math.cos(t) * rx, cy + Math.sin(t) * ry]);
+    }
+    drawer.draw_polyline(points, style);
+    return;
+  }
+  if (el.shape_type === shape_type_line || el.shape_type === shape_type_arrow) {
+    const from = el.start_point ?? [el.bounds[0], el.bounds[1]];
+    const to = el.end_point ?? [el.bounds[0] + el.bounds[2], el.bounds[1] + el.bounds[3]];
+    drawer.draw_line(from, to, style);
+    if (el.shape_type === shape_type_arrow) {
+      draw_arrowhead_engine(drawer, from, to, style);
+    }
+  }
+}
+function render_image_element_engine(drawer, el, asset_src) {
+  const image = resolve_image_source_engine(el, asset_src);
+  const opacity = Math.max(0, Math.min(1, el.opacity));
+  if (image.status === "loaded" && image.source !== null) {
+    drawer.draw_image(image.source, fit_image_bounds_engine(el.bounds, image.source), opacity);
+    return;
+  }
+  const style = {
+    fill: default_element_fill,
+    stroke: default_element_stroke,
+    stroke_width: 1,
+    line_cap: 1,
+    line_join: 1,
+    miter_limit: 10,
+    alpha: opacity
+  };
+  drawer.draw_rectangle(el.bounds, style);
+  if (image.status === "error") {
+    const mark_style = {
+      fill: null,
+      stroke: default_element_stroke,
+      stroke_width: 1.5,
+      line_cap: 1,
+      line_join: 1,
+      miter_limit: 10,
+      alpha: opacity
+    };
+    const inset = Math.max(8, Math.min(el.bounds[2], el.bounds[3]) * 0.12);
+    const x0 = el.bounds[0] + inset;
+    const y0 = el.bounds[1] + inset;
+    const x1 = el.bounds[0] + el.bounds[2] - inset;
+    const y1 = el.bounds[1] + el.bounds[3] - inset;
+    drawer.draw_line([x0, y0], [x1, y1], mark_style);
+    drawer.draw_line([x1, y0], [x0, y1], mark_style);
+  }
+}
+function render_text_element_engine(drawer, el) {
+  const key = [
+    el.content,
+    el.font_family,
+    el.font_size,
+    el.color.join(","),
+    el.align,
+    Math.max(1, Math.round(el.bounds[2])),
+    Math.max(1, Math.round(el.bounds[3])),
+    Math.max(1, Math.round(drawer.pixel_ratio))
+  ].join("|");
+  let bitmap = text_bitmap_cache_engine.get(key);
+  if (bitmap === undefined) {
+    bitmap = rasterize_text_engine(el, Math.max(1, Math.round(drawer.pixel_ratio)));
+    text_bitmap_cache_engine.set(key, bitmap);
+    trim_text_bitmap_cache_engine();
+  }
+  drawer.draw_image(bitmap, el.bounds, 1);
+}
+function resolve_image_source_engine(el, asset_src) {
+  if (el.bitmap !== null) {
+    return { status: "loaded", source: el.bitmap };
+  }
+  const src = (asset_src ?? el.src).trim();
+  if (src.length === 0 || typeof Image === "undefined") {
+    return { status: "empty", source: null };
+  }
+  let cached = loaded_images_engine.get(src);
+  if (cached === undefined) {
+    const image = new Image;
+    cached = { image, status: "loading" };
+    loaded_images_engine.set(src, cached);
+    image.onload = () => {
+      const current = loaded_images_engine.get(src);
+      if (current !== undefined)
+        current.status = "loaded";
+    };
+    image.onerror = () => {
+      const current = loaded_images_engine.get(src);
+      if (current !== undefined)
+        current.status = "error";
+    };
+    image.src = src;
+    return { status: "loading", source: null };
+  }
+  if (cached.status === "loaded") {
+    return { status: "loaded", source: cached.image };
+  }
+  return { status: cached.status, source: null };
+}
+function fit_image_bounds_engine(bounds, source) {
+  const source_w = source instanceof HTMLImageElement ? source.naturalWidth : source.width;
+  const source_h = source instanceof HTMLImageElement ? source.naturalHeight : source.height;
+  const x = bounds[0];
+  const y = bounds[1];
+  const w = Math.max(1, bounds[2]);
+  const h = Math.max(1, bounds[3]);
+  if (source_w <= 0 || source_h <= 0) {
+    return [x, y, w, h];
+  }
+  const scale = Math.min(w / source_w, h / source_h);
+  const draw_w = source_w * scale;
+  const draw_h = source_h * scale;
+  const draw_x = x + (w - draw_w) * 0.5;
+  const draw_y = y + (h - draw_h) * 0.5;
+  return [draw_x, draw_y, draw_w, draw_h];
+}
+function draw_arrowhead_engine(drawer, from, to, style) {
+  const dx = to[0] - from[0];
+  const dy = to[1] - from[1];
+  const len = Math.hypot(dx, dy);
+  if (len < 0.0001)
+    return;
+  const ux = dx / len;
+  const uy = dy / len;
+  const size = Math.max(8, style.stroke_width * 5);
+  const wing_angle = Math.PI / 7;
+  const cos = Math.cos(wing_angle);
+  const sin = Math.sin(wing_angle);
+  const lx = to[0] - (ux * cos - uy * sin) * size;
+  const ly = to[1] - (uy * cos + ux * sin) * size;
+  const rx = to[0] - (ux * cos + uy * sin) * size;
+  const ry = to[1] - (uy * cos - ux * sin) * size;
+  drawer.draw_line(to, [lx, ly], style);
+  drawer.draw_line(to, [rx, ry], style);
+}
+function rasterize_text_engine(el, scale) {
+  const canvas = document.createElement("canvas");
+  const width = Math.max(1, Math.ceil(el.bounds[2] * scale));
+  const height = Math.max(1, Math.ceil(el.bounds[3] * scale));
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext("2d");
+  if (ctx === null)
+    return canvas;
+  const font_size = Math.max(1, el.font_size);
+  const line_height = font_size * 1.3;
+  const padding = Math.max(4, Math.round(font_size * 0.35));
+  const max_text_width = Math.max(1, el.bounds[2] - padding * 2);
+  ctx.scale(scale, scale);
+  ctx.font = `${font_size}px ${el.font_family}`;
+  ctx.textBaseline = "top";
+  ctx.fillStyle = to_rgba_string_color(el.color);
+  const lines = wrap_text_lines_engine(ctx, el.content, max_text_width);
+  const base_x = el.bounds[0];
+  const base_y = el.bounds[1];
+  const text_top = base_y + padding;
+  const text_bottom = base_y + el.bounds[3] - padding;
+  let y = text_top;
+  for (let i = 0;i < lines.length; i = i + 1) {
+    const line = lines[i];
+    if (line === undefined)
+      continue;
+    if (y + line_height > text_bottom + 0.5)
+      break;
+    const line_width = ctx.measureText(line).width;
+    let x = base_x + padding;
+    if (el.align === text_align_center) {
+      x = base_x + el.bounds[2] * 0.5 - line_width * 0.5;
+    } else if (el.align === text_align_right) {
+      x = base_x + el.bounds[2] - padding - line_width;
+    }
+    ctx.fillText(line, x - base_x, y - base_y);
+    y = y + line_height;
+  }
+  return canvas;
+}
+function wrap_text_lines_engine(ctx, content, max_width) {
+  const normalized = content.length > 0 ? content : "";
+  const paragraphs = normalized.split(/\r?\n/);
+  const lines = [];
+  for (let i = 0;i < paragraphs.length; i = i + 1) {
+    const paragraph = paragraphs[i];
+    if (paragraph === undefined)
+      continue;
+    if (paragraph.length === 0) {
+      lines.push("");
+      continue;
+    }
+    const words = paragraph.split(/(\s+)/).filter((word) => word.length > 0);
+    let current = "";
+    for (let j = 0;j < words.length; j = j + 1) {
+      const word = words[j];
+      if (word === undefined)
+        continue;
+      const candidate = current.length === 0 ? word : `${current}${word}`;
+      if (ctx.measureText(candidate).width <= max_width || current.length === 0) {
+        current = candidate;
+      } else {
+        lines.push(current.trimEnd());
+        current = word.trimStart();
+      }
+    }
+    lines.push(current.length > 0 ? current : "");
+  }
+  return lines;
+}
+function trim_text_bitmap_cache_engine() {
+  if (text_bitmap_cache_engine.size <= text_bitmap_cache_limit_engine) {
+    return;
+  }
+  const remove_count = Math.ceil(text_bitmap_cache_engine.size / 3);
+  let removed = 0;
+  for (const key of text_bitmap_cache_engine.keys()) {
+    text_bitmap_cache_engine.delete(key);
+    removed = removed + 1;
+    if (removed >= remove_count)
+      return;
+  }
+}
+
+// engine/render.ts
+function render_engine(state) {
+  render_engine_with_overlay(state, null);
+}
+function render_engine_with_overlay(state, overlay) {
+  const view_bounds = visible_bounds_world_engine(state);
+  const visible_elements = elements_in_bounds_document(state.document, view_bounds);
+  const layer_info = build_layer_render_info_map_engine(state.document);
+  const renderable_elements = [];
+  for (let i = 0;i < visible_elements.length; i = i + 1) {
+    const el = visible_elements[i];
+    if (el === undefined) {
+      continue;
+    }
+    const info = layer_info.get(el.layer_id);
+    if (info === undefined || info.visible) {
+      renderable_elements.push(el);
+    }
+  }
+  renderable_elements.sort((a, b) => {
+    const a_order = layer_info.get(a.layer_id)?.order ?? Number.MAX_SAFE_INTEGER;
+    const b_order = layer_info.get(b.layer_id)?.order ?? Number.MAX_SAFE_INTEGER;
+    if (a_order !== b_order) {
+      return a_order - b_order;
+    }
+    return a.z_index - b.z_index;
+  });
+  state.renderer.begin_frame();
+  state.renderer.clear(state.background);
+  camera_to_screen_transform_engine(state.camera, state.viewport, scratch_transform);
+  state.renderer.set_transform(scratch_transform);
+  if (state.background_image !== null) {
+    state.renderer.draw_image(state.background_image, [0, 0, state.background_image.width, state.background_image.height], 1);
+  }
+  for (let i = 0;i < renderable_elements.length; i = i + 1) {
+    const el = renderable_elements[i];
+    if (el !== undefined) {
+      const asset_src = el.type === element_type_image && el.asset_id !== null ? state.document.assets.get(el.asset_id)?.src ?? null : null;
+      render_element_engine(state.renderer, el, asset_src);
+    }
+  }
+  if (overlay !== null) {
+    overlay(state.renderer);
+  }
+  state.renderer.end_frame();
+}
+function build_layer_render_info_map_engine(doc) {
+  const map = new Map;
+  for (let i = 0;i < doc.layers.length; i = i + 1) {
+    const layer = doc.layers[i];
+    if (layer !== undefined) {
+      map.set(layer.id, { order: i, visible: layer.visible });
+    }
+  }
+  return map;
+}
+
+// document/layer.ts
+function create_layer(id, name, visible = true, locked = false, opacity = 1) {
+  return {
+    id,
+    name,
+    visible,
+    locked,
+    opacity: Math.max(0, Math.min(1, opacity)),
+    element_ids: []
+  };
+}
+function clone_layer(l) {
+  return {
+    id: l.id,
+    name: l.name,
+    visible: l.visible,
+    locked: l.locked,
+    opacity: l.opacity,
+    element_ids: [...l.element_ids]
+  };
+}
+function id_of_layer(l) {
+  return l.id;
+}
+function name_of_layer(l) {
+  return l.name;
+}
+function is_visible_layer(l) {
+  return l.visible;
+}
+function is_locked_layer(l) {
+  return l.locked;
+}
+function opacity_of_layer(l) {
+  return l.opacity;
+}
+function element_ids_of_layer(l) {
+  return l.element_ids;
+}
+function element_count_of_layer(l) {
+  return l.element_ids.length;
+}
+function update_layer_name(l, name) {
+  return {
+    ...l,
+    name
+  };
+}
+function update_layer_visibility(l, visible) {
+  return {
+    ...l,
+    visible
+  };
+}
+function update_layer_locked(l, locked) {
+  return {
+    ...l,
+    locked
+  };
+}
+function update_layer_opacity(l, opacity) {
+  return {
+    ...l,
+    opacity: Math.max(0, Math.min(1, opacity))
+  };
+}
+function add_element_id_to_layer(l, element_id) {
+  if (l.element_ids.includes(element_id)) {
+    return l;
+  }
+  return {
+    ...l,
+    element_ids: [...l.element_ids, element_id]
+  };
+}
+function remove_element_id_from_layer(l, element_id) {
+  const index = l.element_ids.indexOf(element_id);
+  if (index === -1) {
+    return l;
+  }
+  const new_ids = [...l.element_ids];
+  new_ids.splice(index, 1);
+  return {
+    ...l,
+    element_ids: new_ids
+  };
+}
+function has_element_id_in_layer(l, element_id) {
+  return l.element_ids.includes(element_id);
+}
+function reorder_element_ids_in_layer(l, element_ids) {
+  const existing_set = new Set(l.element_ids);
+  const filtered_ids = element_ids.filter((id) => existing_set.has(id));
+  const new_ids_set = new Set(filtered_ids);
+  const remaining_ids = l.element_ids.filter((id) => !new_ids_set.has(id));
+  return {
+    ...l,
+    element_ids: [...remaining_ids, ...filtered_ids]
+  };
+}
+function equals_layer(a, b) {
+  if (a.id !== b.id || a.name !== b.name) {
+    return false;
+  }
+  if (a.visible !== b.visible || a.locked !== b.locked) {
+    return false;
+  }
+  if (a.opacity !== b.opacity) {
+    return false;
+  }
+  if (a.element_ids.length !== b.element_ids.length) {
+    return false;
+  }
+  for (let i = 0;i < a.element_ids.length; i = i + 1) {
+    if (a.element_ids[i] !== b.element_ids[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// document/document.ts
+function create_document(id, active_layer_id) {
+  return {
+    id,
+    elements: new Map,
+    layers: [],
+    active_layer_id,
+    assets: new Map,
+    bounds: [0, 0, 0, 0],
+    element_count: 0
+  };
+}
+function clone_document(doc) {
+  const new_elements = new Map;
+  for (const [id, el] of doc.elements) {
+    new_elements.set(id, el);
+  }
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: doc.layers.map((l) => ({ ...l, element_ids: [...l.element_ids] })),
+    active_layer_id: doc.active_layer_id,
+    assets: new Map(doc.assets),
+    bounds: [doc.bounds[0], doc.bounds[1], doc.bounds[2], doc.bounds[3]],
+    element_count: doc.element_count
+  };
+}
+function id_of_document(doc) {
+  return doc.id;
+}
+function elements_map_of_document(doc) {
+  return doc.elements;
+}
+function layers_of_document(doc) {
+  return doc.layers;
+}
+function active_layer_id_of_document(doc) {
+  return doc.active_layer_id;
+}
+function assets_of_document(doc) {
+  return doc.assets;
+}
+function bounds_of_document(doc) {
+  return [doc.bounds[0], doc.bounds[1], doc.bounds[2], doc.bounds[3]];
+}
+function element_count_of_document(doc) {
+  return doc.element_count;
+}
+function get_element_by_id_document(doc, element_id) {
+  return doc.elements.get(element_id) || null;
+}
+function get_layer_by_id_document(doc, layer_id) {
+  for (let i = 0;i < doc.layers.length; i = i + 1) {
+    const layer = doc.layers[i];
+    if (layer && layer.id === layer_id) {
+      return layer;
+    }
+  }
+  return null;
+}
+function add_element_document(doc, el) {
+  const layer = get_layer_by_id_document(doc, el.layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.set(el.id, el);
+  const new_layers = doc.layers.map((l) => {
+    if (l.id === el.layer_id) {
+      return add_element_id_to_layer(l, el.id);
+    }
+    return l;
+  });
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function remove_element_document(doc, element_id) {
+  const el = doc.elements.get(element_id);
+  if (el === undefined) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.delete(element_id);
+  const new_layers = doc.layers.map((l) => {
+    if (l.id === el.layer_id) {
+      return remove_element_id_from_layer(l, element_id);
+    }
+    return l;
+  });
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function update_element_document(doc, element_id, new_element) {
+  if (!doc.elements.has(element_id)) {
+    return doc;
+  }
+  const old_element = doc.elements.get(element_id);
+  if (old_element === undefined) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  new_elements.set(element_id, new_element);
+  let new_layers = doc.layers;
+  if (old_element.layer_id !== new_element.layer_id) {
+    new_layers = doc.layers.map((l) => {
+      if (l.id === old_element.layer_id) {
+        return remove_element_id_from_layer(l, element_id);
+      }
+      if (l.id === new_element.layer_id) {
+        return add_element_id_to_layer(l, element_id);
+      }
+      return l;
+    });
+  }
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function add_layer_document(doc, layer) {
+  const existing = get_layer_by_id_document(doc, layer.id);
+  if (existing !== null) {
+    return doc;
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: [...doc.layers, layer],
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function remove_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  const new_elements = new Map(doc.elements);
+  for (const element_id of layer.element_ids) {
+    new_elements.delete(element_id);
+  }
+  const new_layers = doc.layers.filter((l) => l.id !== layer_id);
+  let new_active_layer_id = doc.active_layer_id;
+  if (doc.active_layer_id === layer_id) {
+    if (new_layers.length > 0) {
+      const first_layer = new_layers[0];
+      if (first_layer !== undefined) {
+        new_active_layer_id = first_layer.id;
+      } else {
+        new_active_layer_id = "";
+      }
+    } else {
+      new_active_layer_id = "";
+    }
+  }
+  const new_bounds = calculate_bounds_document_internal(new_elements);
+  return {
+    id: doc.id,
+    elements: new_elements,
+    layers: new_layers,
+    active_layer_id: new_active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: new_elements.size
+  };
+}
+function reorder_layers_document(doc, layer_ids) {
+  const id_set = new Set(layer_ids);
+  const existing_ids = doc.layers.map((l) => l.id);
+  const missing_ids = existing_ids.filter((id) => !id_set.has(id));
+  const ordered_layers = [];
+  const layer_map = new Map(doc.layers.map((l) => [l.id, l]));
+  for (const id of layer_ids) {
+    const layer = layer_map.get(id);
+    if (layer) {
+      ordered_layers.push(layer);
+    }
+  }
+  for (const id of missing_ids) {
+    const layer = layer_map.get(id);
+    if (layer) {
+      ordered_layers.push(layer);
+    }
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: ordered_layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function set_active_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return doc;
+  }
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: doc.layers,
+    active_layer_id: layer_id,
+    assets: doc.assets,
+    bounds: doc.bounds,
+    element_count: doc.element_count
+  };
+}
+function get_elements_in_layer_document(doc, layer_id) {
+  const layer = get_layer_by_id_document(doc, layer_id);
+  if (layer === null) {
+    return [];
+  }
+  const elements = [];
+  for (const element_id of layer.element_ids) {
+    const el = doc.elements.get(element_id);
+    if (el !== undefined) {
+      elements.push(el);
+    }
+  }
+  return elements;
+}
+function get_all_elements_document(doc) {
+  return Array.from(doc.elements.values());
+}
+function calculate_bounds_document_internal(elements) {
+  if (elements.size === 0) {
+    return [0, 0, 0, 0];
+  }
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  for (const el of elements.values()) {
+    const bounds = el.bounds;
+    min_x = Math.min(min_x, bounds[0]);
+    min_y = Math.min(min_y, bounds[1]);
+    max_x = Math.max(max_x, bounds[0] + bounds[2]);
+    max_y = Math.max(max_y, bounds[1] + bounds[3]);
+  }
+  if (min_x === Infinity) {
+    return [0, 0, 0, 0];
+  }
+  return [min_x, min_y, max_x - min_x, max_y - min_y];
+}
+function recalculate_bounds_document(doc) {
+  const new_bounds = calculate_bounds_document_internal(doc.elements);
+  return {
+    id: doc.id,
+    elements: doc.elements,
+    layers: doc.layers,
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: new_bounds,
+    element_count: doc.element_count
+  };
+}
+function clear_document(doc) {
+  return {
+    id: doc.id,
+    elements: new Map,
+    layers: doc.layers.map((l) => ({ ...l, element_ids: [] })),
+    active_layer_id: doc.active_layer_id,
+    assets: doc.assets,
+    bounds: [0, 0, 0, 0],
+    element_count: 0
+  };
+}
+function add_image_asset_document(doc, asset) {
+  const assets = new Map(doc.assets);
+  assets.set(asset.id, { ...asset });
+  return {
+    ...doc,
+    assets
+  };
+}
+function get_image_asset_document(doc, asset_id) {
+  return doc.assets.get(asset_id) ?? null;
+}
+function remove_image_asset_document(doc, asset_id) {
+  if (!doc.assets.has(asset_id))
+    return doc;
+  const assets = new Map(doc.assets);
+  assets.delete(asset_id);
+  return {
+    ...doc,
+    assets
+  };
+}
+
+// editor/history.ts
+function begin_transaction_editor(state, label) {
+  if (state.active_transaction !== null) {
+    return;
+  }
+  state.active_transaction = {
+    label,
+    before: clone_document(state.engine.document)
+  };
+}
+function commit_transaction_editor(state) {
+  if (state.active_transaction === null) {
+    return;
+  }
+  const before = state.active_transaction.before;
+  const after = state.engine.document;
+  if (before !== after) {
+    state.undo_stack.push(before);
+    state.redo_stack = [];
+  }
+  state.active_transaction = null;
+}
+function cancel_transaction_editor(state) {
+  if (state.active_transaction === null) {
+    return;
+  }
+  state.engine.document = state.active_transaction.before;
+  state.active_transaction = null;
+}
+function undo_editor(state) {
+  if (state.active_transaction !== null) {
+    return false;
+  }
+  const previous = state.undo_stack.pop();
+  if (previous === undefined) {
+    return false;
+  }
+  state.redo_stack.push(clone_document(state.engine.document));
+  state.engine.document = previous;
+  return true;
+}
+function redo_editor(state) {
+  if (state.active_transaction !== null) {
+    return false;
+  }
+  const next = state.redo_stack.pop();
+  if (next === undefined) {
+    return false;
+  }
+  state.undo_stack.push(clone_document(state.engine.document));
+  state.engine.document = next;
+  return true;
+}
+
+// editor/clone.ts
+function clone_element_editor(el) {
+  if (el.type === element_type_stroke) {
+    const stroke = el;
+    return {
+      ...stroke,
+      bounds: [stroke.bounds[0], stroke.bounds[1], stroke.bounds[2], stroke.bounds[3]],
+      points: stroke.points.map((point) => [point[0], point[1]]),
+      pressure: stroke.pressure === null ? null : [...stroke.pressure],
+      color: [stroke.color[0], stroke.color[1], stroke.color[2], stroke.color[3]],
+      simplified_points: stroke.simplified_points === null ? null : stroke.simplified_points.map((point) => [point[0], point[1]]),
+      spline: stroke.spline
+    };
+  }
+  if (el.type === element_type_shape) {
+    const shape = el;
+    return {
+      ...shape,
+      bounds: [shape.bounds[0], shape.bounds[1], shape.bounds[2], shape.bounds[3]],
+      fill_color: shape.fill_color === null ? null : [shape.fill_color[0], shape.fill_color[1], shape.fill_color[2], shape.fill_color[3]],
+      stroke_color: shape.stroke_color === null ? null : [
+        shape.stroke_color[0],
+        shape.stroke_color[1],
+        shape.stroke_color[2],
+        shape.stroke_color[3]
+      ],
+      start_point: shape.start_point === null ? null : [shape.start_point[0], shape.start_point[1]],
+      end_point: shape.end_point === null ? null : [shape.end_point[0], shape.end_point[1]]
+    };
+  }
+  if (el.type === element_type_image) {
+    const image = el;
+    return {
+      ...image,
+      bounds: [image.bounds[0], image.bounds[1], image.bounds[2], image.bounds[3]]
+    };
+  }
+  const text = el;
+  return {
+    ...text,
+    bounds: [text.bounds[0], text.bounds[1], text.bounds[2], text.bounds[3]],
+    color: [text.color[0], text.color[1], text.color[2], text.color[3]]
+  };
+}
+
+// math/simplify.ts
+function create_simplify_result() {
+  return {
+    points: [],
+    original_count: 0,
+    simplified_count: 0,
+    reduction_ratio: 0
+  };
+}
+function clone_simplify_result(result) {
+  return {
+    points: result.points.map((point) => [point[0], point[1]]),
+    original_count: result.original_count,
+    simplified_count: result.simplified_count,
+    reduction_ratio: result.reduction_ratio
+  };
+}
+function copy_simplify_result(result, out) {
+  out.points = result.points.map((point) => [point[0], point[1]]);
+  out.original_count = result.original_count;
+  out.simplified_count = result.simplified_count;
+  out.reduction_ratio = result.reduction_ratio;
+  return out;
+}
+function perpendicular_distance_to_line(point, line_start, line_end) {
+  const dx = line_end[0] - line_start[0];
+  const dy = line_end[1] - line_start[1];
+  if (dx === 0 && dy === 0) {
+    const px = point[0] - line_start[0];
+    const py = point[1] - line_start[1];
+    return Math.sqrt(px * px + py * py);
+  }
+  const numerator = Math.abs(dy * point[0] - dx * point[1] + line_end[0] * line_start[1] - line_end[1] * line_start[0]);
+  const denominator = Math.sqrt(dx * dx + dy * dy);
+  return numerator / denominator;
+}
+function find_farthest_point(points, start_index, end_index, out_result) {
+  let max_distance = 0;
+  let farthest_index = -1;
+  const line_start = points[start_index];
+  const line_end = points[end_index];
+  for (let i = start_index + 1;i < end_index; i++) {
+    const distance = perpendicular_distance_to_line(points[i], line_start, line_end);
+    if (distance > max_distance) {
+      max_distance = distance;
+      farthest_index = i;
+    }
+  }
+  out_result.index = farthest_index;
+  out_result.distance = max_distance;
+  return out_result;
+}
+function douglas_peucker_recursive(points, start_index, end_index, epsilon, keep_flags) {
+  if (end_index <= start_index + 1) {
+    return;
+  }
+  const farthest_result = { index: -1, distance: 0 };
+  find_farthest_point(points, start_index, end_index, farthest_result);
+  if (farthest_result.index === -1 || farthest_result.distance <= epsilon) {
+    return;
+  }
+  keep_flags[farthest_result.index] = true;
+  douglas_peucker_recursive(points, start_index, farthest_result.index, epsilon, keep_flags);
+  douglas_peucker_recursive(points, farthest_result.index, end_index, epsilon, keep_flags);
+}
+function simplify_douglas_peucker(points, epsilon, out_points) {
+  if (points.length <= 2) {
+    for (let i = 0;i < points.length; i++) {
+      const p = points[i];
+      const out = out_points[i];
+      if (out) {
+        out[0] = p[0];
+        out[1] = p[1];
+      } else {
+        out_points[i] = [p[0], p[1]];
+      }
+    }
+    return points.length;
+  }
+  const keep_flags = Array.from({ length: points.length }, () => false);
+  keep_flags[0] = true;
+  keep_flags[points.length - 1] = true;
+  douglas_peucker_recursive(points, 0, points.length - 1, epsilon, keep_flags);
+  let result_count = 0;
+  for (let i = 0;i < points.length; i++) {
+    if (keep_flags[i]) {
+      const p = points[i];
+      const out = out_points[result_count];
+      if (out) {
+        out[0] = p[0];
+        out[1] = p[1];
+      } else {
+        out_points[result_count] = [p[0], p[1]];
+      }
+      result_count = result_count + 1;
+    }
+  }
+  return result_count;
+}
+function simplify_douglas_peucker_detailed(points, epsilon, out_result) {
+  const temp_points = Array.from({ length: points.length }, () => [0, 0]);
+  const simplified_count = simplify_douglas_peucker(points, epsilon, temp_points);
+  out_result.points = temp_points.slice(0, simplified_count);
+  out_result.original_count = points.length;
+  out_result.simplified_count = simplified_count;
+  out_result.reduction_ratio = points.length > 0 ? (points.length - simplified_count) / points.length : 0;
+  return out_result;
+}
+function estimate_epsilon_from_points(points, tolerance_factor = 0.1) {
+  if (points.length < 2) {
+    return 1;
+  }
+  let total_distance = 0;
+  let segment_count = 0;
+  for (let i = 1;i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance > 0) {
+      total_distance = total_distance + distance;
+      segment_count = segment_count + 1;
+    }
+  }
+  if (segment_count === 0) {
+    return 1;
+  }
+  const average_distance = total_distance / segment_count;
+  return average_distance * tolerance_factor;
+}
+function polyline_length(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let total_length = 0;
+  for (let i = 1;i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    total_length = total_length + Math.sqrt(dx * dx + dy * dy);
+  }
+  return total_length;
+}
+function polyline_area_under_curve(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let area = 0;
+  for (let i = 1;i < points.length; i++) {
+    const x1 = points[i - 1][0];
+    const y1 = points[i - 1][1];
+    const x2 = points[i][0];
+    const y2 = points[i][1];
+    area = area + (x2 - x1) * (y1 + y2) * 0.5;
+  }
+  return Math.abs(area);
+}
+function validate_simplified_polyline(points) {
+  if (points.length < 4) {
+    return true;
+  }
+  for (let i = 0;i < points.length - 3; i++) {
+    for (let j = i + 2;j < points.length - 1; j++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const p3 = points[j];
+      const p4 = points[j + 1];
+      if (line_segments_intersect(p1, p2, p3, p4)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function line_segments_intersect(p1, p2, p3, p4) {
+  const d1 = direction(p3, p4, p1);
+  const d2 = direction(p3, p4, p2);
+  const d3 = direction(p1, p2, p3);
+  const d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return true;
+  }
+  if (d1 === 0 && on_segment(p3, p1, p4))
+    return true;
+  if (d2 === 0 && on_segment(p3, p2, p4))
+    return true;
+  if (d3 === 0 && on_segment(p1, p3, p2))
+    return true;
+  if (d4 === 0 && on_segment(p1, p4, p2))
+    return true;
+  return false;
+}
+function direction(pi, pj, pk) {
+  return (pk[0] - pi[0]) * (pj[1] - pi[1]) - (pj[0] - pi[0]) * (pk[1] - pi[1]);
+}
+function on_segment(pi, pj, pk) {
+  return Math.min(pi[0], pk[0]) <= pj[0] && pj[0] <= Math.max(pi[0], pk[0]) && Math.min(pi[1], pk[1]) <= pj[1] && pj[1] <= Math.max(pi[1], pk[1]);
+}
+
+// math/spline.ts
+function create_spline() {
+  return {
+    segments_x: [],
+    segments_y: [],
+    point_count: 0
+  };
+}
+function clone_spline(s) {
+  return {
+    segments_x: s.segments_x.map((seg) => ({ ...seg })),
+    segments_y: s.segments_y.map((seg) => ({ ...seg })),
+    point_count: s.point_count
+  };
+}
+function build_natural_spline_1d(points, t_values) {
+  const n = points.length;
+  if (n < 2)
+    return [];
+  if (n === 2) {
+    const slope = (points[1] - points[0]) / (t_values[1] - t_values[0]);
+    return [
+      {
+        a: points[0],
+        b: slope,
+        c: 0,
+        d: 0,
+        x_start: t_values[0],
+        x_end: t_values[1]
+      }
+    ];
+  }
+  const h = Array.from({ length: n - 1 }, () => 0);
+  for (let i = 0;i < n - 1; i++) {
+    h[i] = t_values[i + 1] - t_values[i];
+  }
+  const alpha = Array.from({ length: n - 1 }, () => 0);
+  for (let i = 1;i < n - 1; i++) {
+    alpha[i] = 3 / h[i] * (points[i + 1] - points[i]) - 3 / h[i - 1] * (points[i] - points[i - 1]);
+  }
+  const l = Array.from({ length: n }, () => 0);
+  const mu = Array.from({ length: n }, () => 0);
+  const z = Array.from({ length: n }, () => 0);
+  l[0] = 1;
+  mu[0] = 0;
+  z[0] = 0;
+  for (let i = 1;i < n - 1; i++) {
+    l[i] = 2 * (t_values[i + 1] - t_values[i - 1]) - h[i - 1] * mu[i - 1];
+    mu[i] = h[i] / l[i];
+    z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
+  }
+  l[n - 1] = 1;
+  z[n - 1] = 0;
+  const c = Array.from({ length: n }, () => 0);
+  c[n - 1] = 0;
+  for (let j = n - 2;j >= 0; j--) {
+    c[j] = z[j] - mu[j] * c[j + 1];
+  }
+  const segments = [];
+  for (let i = 0;i < n - 1; i++) {
+    const a = points[i];
+    const b = (points[i + 1] - points[i]) / h[i] - h[i] * (c[i + 1] + 2 * c[i]) / 3;
+    const d = (c[i + 1] - c[i]) / (3 * h[i]);
+    segments.push({
+      a,
+      b,
+      c: c[i],
+      d,
+      x_start: t_values[i],
+      x_end: t_values[i + 1]
+    });
+  }
+  return segments;
+}
+function build_natural_spline_from_points(points, spline) {
+  const n = points.length;
+  if (n < 2) {
+    spline.segments_x = [];
+    spline.segments_y = [];
+    spline.point_count = 0;
+    return spline;
+  }
+  const t_values = Array.from({ length: n }, () => 0);
+  t_values[0] = 0;
+  for (let i = 1;i < n; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    t_values[i] = t_values[i - 1] + distance;
+  }
+  const x_coords = points.map((p) => p[0]);
+  const y_coords = points.map((p) => p[1]);
+  spline.segments_x = build_natural_spline_1d(x_coords, t_values);
+  spline.segments_y = build_natural_spline_1d(y_coords, t_values);
+  spline.point_count = n;
+  return spline;
+}
+function evaluate_spline_segment(segment, t) {
+  const dt = t - segment.x_start;
+  return segment.a + segment.b * dt + segment.c * dt * dt + segment.d * dt * dt * dt;
+}
+function evaluate_spline_at_t(spline, t, out) {
+  if (spline.segments_x.length === 0 || spline.segments_y.length === 0) {
+    return null;
+  }
+  let segment_x = null;
+  let segment_y = null;
+  for (let i = 0;i < spline.segments_x.length; i++) {
+    const seg_x = spline.segments_x[i];
+    const seg_y = spline.segments_y[i];
+    if (t >= seg_x.x_start && t <= seg_x.x_end) {
+      segment_x = seg_x;
+      segment_y = seg_y;
+      break;
+    }
+  }
+  if (!segment_x || !segment_y) {
+    const last_idx = spline.segments_x.length - 1;
+    if (t > spline.segments_x[last_idx].x_end) {
+      segment_x = spline.segments_x[last_idx];
+      segment_y = spline.segments_y[last_idx];
+      t = segment_x.x_end;
+    } else {
+      segment_x = spline.segments_x[0];
+      segment_y = spline.segments_y[0];
+      t = segment_x.x_start;
+    }
+  }
+  out[0] = evaluate_spline_segment(segment_x, t);
+  out[1] = evaluate_spline_segment(segment_y, t);
+  return out;
+}
+function evaluate_spline_at_points(spline, t_values, out_points) {
+  let valid_count = 0;
+  const temp_point = [0, 0];
+  for (let i = 0;i < t_values.length; i++) {
+    const t_val = t_values[i];
+    if (evaluate_spline_at_t(spline, t_val, temp_point)) {
+      out_points[valid_count][0] = temp_point[0];
+      out_points[valid_count][1] = temp_point[1];
+      valid_count = valid_count + 1;
+    }
+  }
+  return valid_count;
+}
+function get_spline_length(spline, steps = 100) {
+  if (spline.segments_x.length === 0)
+    return 0;
+  const first_segment = spline.segments_x[0];
+  const last_segment = spline.segments_x[spline.segments_x.length - 1];
+  const t_start = first_segment.x_start;
+  const t_end = last_segment.x_end;
+  const dt = (t_end - t_start) / steps;
+  let length = 0;
+  const prev = [0, 0];
+  const curr = [0, 0];
+  evaluate_spline_at_t(spline, t_start, prev);
+  for (let i = 1;i <= steps; i++) {
+    const t = t_start + i * dt;
+    if (evaluate_spline_at_t(spline, t, curr)) {
+      const dx = curr[0] - prev[0];
+      const dy = curr[1] - prev[1];
+      length = length + Math.sqrt(dx * dx + dy * dy);
+      prev[0] = curr[0];
+      prev[1] = curr[1];
+    }
+  }
+  return length;
+}
+function simplify_points_for_spline(points, tolerance = 1) {
+  if (points.length <= 2)
+    return [...points];
+  const simplified = [points[0]];
+  for (let i = 1;i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const dx1 = curr[0] - prev[0];
+    const dy1 = curr[1] - prev[1];
+    const dx2 = next[0] - curr[0];
+    const dy2 = next[1] - curr[1];
+    const dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+    if (dist1 < tolerance && dist2 < tolerance) {
+      if (dist1 > 0 && dist2 > 0) {
+        const dot = (dx1 * dx2 + dy1 * dy2) / (dist1 * dist2);
+        if (dot > 0.99) {
+          continue;
+        }
+      } else {
+        continue;
+      }
+    }
+    simplified.push(curr);
+  }
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}
+
+// stroke/process.ts
+var default_simplify_epsilon = 1;
+var default_lod_simplify_factor = 3;
+function simplify_stroke_points(points, epsilon = default_simplify_epsilon, out) {
+  return simplify_douglas_peucker(points, epsilon, out);
+}
+function simplify_stroke_points_auto(points, out) {
+  const epsilon = estimate_epsilon_from_points(points, 0.1);
+  return simplify_douglas_peucker(points, epsilon, out);
+}
+function fit_spline_to_stroke(points, out_spline) {
+  if (points.length < 2) {
+    out_spline.segments_x = [];
+    out_spline.segments_y = [];
+    out_spline.point_count = 0;
+    return out_spline;
+  }
+  const simplified_for_spline = simplify_points_for_spline(points, 2);
+  return build_natural_spline_from_points(simplified_for_spline, out_spline);
+}
+function compute_stroke_bounds(points, width, out) {
+  if (points.length === 0) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    return out;
+  }
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  for (let i = 0;i < points.length; i++) {
+    const point = points[i];
+    if (point === undefined)
+      continue;
+    min_x = Math.min(min_x, point[0]);
+    min_y = Math.min(min_y, point[1]);
+    max_x = Math.max(max_x, point[0]);
+    max_y = Math.max(max_y, point[1]);
+  }
+  const half_width = width / 2;
+  out[0] = min_x - half_width;
+  out[1] = min_y - half_width;
+  out[2] = max_x - min_x + width;
+  out[3] = max_y - min_y + width;
+  return out;
+}
+function process_stroke(points, pressure, style, out_simplified, out_spline) {
+  let epsilon = default_simplify_epsilon;
+  if (pressure && pressure.length > 1 && style.pressure_sensitivity > 0) {
+    const variance = calculate_pressure_variance(pressure);
+    epsilon = epsilon / (1 + variance * style.pressure_sensitivity * 2);
+  }
+  const simplified_count = simplify_stroke_points(points, epsilon, out_simplified);
+  const simplified = out_simplified.slice(0, simplified_count);
+  fit_spline_to_stroke(simplified, out_spline);
+  return {
+    simplified,
+    spline: out_spline
+  };
+}
+function calculate_pressure_variance(pressure) {
+  if (pressure.length < 2)
+    return 0;
+  let sum = 0;
+  let sum_sq = 0;
+  for (let i = 0;i < pressure.length; i++) {
+    const p = pressure[i];
+    sum += p;
+    sum_sq += p * p;
+  }
+  const mean = sum / pressure.length;
+  return Math.sqrt(Math.max(0, sum_sq / pressure.length - mean * mean));
+}
+function get_simplified_for_lod(points, lod_level, out) {
+  const lod_epsilon = default_simplify_epsilon * (lod_level * default_lod_simplify_factor);
+  const simplified_count = simplify_douglas_peucker(points, lod_epsilon, out);
+  return out.slice(0, simplified_count);
+}
+
+// editor/transform.ts
+function move_element_editor(el, dx, dy) {
+  return apply_transform_element_editor(el, (point) => [point[0] + dx, point[1] + dy]);
+}
+function transform_elements_editor(base_document, ids, transform_point) {
+  let doc = base_document;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id === undefined)
+      continue;
+    const base_element = get_element_by_id_document(base_document, id);
+    if (base_element === null)
+      continue;
+    doc = update_element_document(doc, id, apply_transform_element_editor(base_element, transform_point));
+  }
+  return doc;
+}
+function angle_to_center_editor(center, point) {
+  return Math.atan2(point[1] - center[1], point[0] - center[0]);
+}
+function apply_transform_element_editor(el, map_point) {
+  if (el.type === element_type_stroke)
+    return transform_stroke_editor(el, map_point);
+  if (el.type === element_type_shape)
+    return transform_shape_editor(el, map_point);
+  if (el.type === element_type_image)
+    return transform_image_editor(el, map_point);
+  if (el.type === element_type_text)
+    return transform_text_editor(el, map_point);
+  return clone_element_editor(el);
+}
+function transform_stroke_editor(stroke, map_point) {
+  const out = clone_element_editor(stroke);
+  out.points = out.points.map((point) => map_point(point));
+  out.simplified_points = out.simplified_points === null ? null : out.simplified_points.map((point) => map_point(point));
+  const bounds = [0, 0, 0, 0];
+  compute_stroke_bounds(out.points, out.width, bounds);
+  out.bounds = bounds;
+  out.spline = null;
+  return out;
+}
+function transform_shape_editor(shape, map_point) {
+  const out = clone_element_editor(shape);
+  if ((out.shape_type === shape_type_line || out.shape_type === shape_type_arrow) && out.start_point !== null && out.end_point !== null) {
+    out.start_point = map_point(out.start_point);
+    out.end_point = map_point(out.end_point);
+    out.bounds = bounds_from_points_editor([out.start_point, out.end_point]);
+    return out;
+  }
+  out.bounds = transform_bounds_editor(out.bounds, map_point);
+  return out;
+}
+function transform_image_editor(image, map_point) {
+  const out = clone_element_editor(image);
+  out.bounds = transform_bounds_editor(out.bounds, map_point);
+  return out;
+}
+function transform_text_editor(text, map_point) {
+  const out = clone_element_editor(text);
+  out.bounds = transform_bounds_editor(out.bounds, map_point);
+  return out;
+}
+function transform_bounds_editor(bounds, map_point) {
+  const p1 = map_point([bounds[0], bounds[1]]);
+  const p2 = map_point([bounds[0] + bounds[2], bounds[1]]);
+  const p3 = map_point([bounds[0], bounds[1] + bounds[3]]);
+  const p4 = map_point([bounds[0] + bounds[2], bounds[1] + bounds[3]]);
+  return bounds_from_points_editor([p1, p2, p3, p4]);
+}
+function bounds_from_points_editor(points) {
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  for (let i = 0;i < points.length; i = i + 1) {
+    const point = points[i];
+    if (point === undefined)
+      continue;
+    min_x = Math.min(min_x, point[0]);
+    min_y = Math.min(min_y, point[1]);
+    max_x = Math.max(max_x, point[0]);
+    max_y = Math.max(max_y, point[1]);
+  }
+  if (min_x === Infinity)
+    return [0, 0, 1, 1];
+  return [min_x, min_y, Math.max(1, max_x - min_x), Math.max(1, max_y - min_y)];
+}
+
+// renderer/style.ts
+var line_cap_butt = 0;
+var line_cap_round = 1;
+var line_cap_square = 2;
+var line_join_miter = 0;
+var line_join_round = 1;
+var line_join_bevel = 2;
+function create_draw_style() {
+  return {
+    fill: null,
+    stroke: null,
+    stroke_width: 1,
+    line_cap: line_cap_round,
+    line_join: line_join_round,
+    miter_limit: 10,
+    alpha: 1
+  };
+}
+function clone_draw_style(s) {
+  return {
+    fill: s.fill,
+    stroke: s.stroke,
+    stroke_width: s.stroke_width,
+    line_cap: s.line_cap,
+    line_join: s.line_join,
+    miter_limit: s.miter_limit,
+    alpha: s.alpha
+  };
+}
+function copy_draw_style(s, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function set_draw_style(fill, stroke, stroke_width, line_cap, line_join, miter_limit, alpha, out) {
+  const mutable_out = out;
+  mutable_out.fill = fill;
+  mutable_out.stroke = stroke;
+  mutable_out.stroke_width = stroke_width;
+  mutable_out.line_cap = line_cap;
+  mutable_out.line_join = line_join;
+  mutable_out.miter_limit = miter_limit;
+  mutable_out.alpha = alpha;
+  return out;
+}
+function with_fill_draw_style(s, fill, out) {
+  const mutable_out = out;
+  mutable_out.fill = fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_stroke_draw_style(s, stroke, stroke_width, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = stroke;
+  mutable_out.stroke_width = stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_alpha_draw_style(s, alpha, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = alpha;
+  return out;
+}
+function with_line_cap_draw_style(s, line_cap, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_line_join_draw_style(s, line_join, miter_limit, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = line_join;
+  mutable_out.miter_limit = miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function equals_draw_style(a, b) {
+  const fill_equal = a.fill === null && b.fill === null || a.fill !== null && b.fill !== null && equals_color(a.fill, b.fill);
+  const stroke_equal = a.stroke === null && b.stroke === null || a.stroke !== null && b.stroke !== null && equals_color(a.stroke, b.stroke);
+  return fill_equal && stroke_equal && a.stroke_width === b.stroke_width && a.line_cap === b.line_cap && a.line_join === b.line_join && a.miter_limit === b.miter_limit && a.alpha === b.alpha;
+}
+
+// editor/styles.ts
+var overlay_selection_style = {
+  fill: [0.2, 0.5, 1, 0.15],
+  stroke: [0.2, 0.5, 1, 0.95],
+  stroke_width: 1,
+  line_cap: line_cap_round,
+  line_join: line_join_round,
+  miter_limit: 10,
+  alpha: 1
+};
+var overlay_marquee_style = {
+  fill: [0.2, 0.5, 1, 0.07],
+  stroke: [0.2, 0.5, 1, 0.7],
+  stroke_width: 1,
+  line_cap: line_cap_round,
+  line_join: line_join_round,
+  miter_limit: 10,
+  alpha: 1
+};
+var overlay_hover_style = {
+  fill: null,
+  stroke: [0.2, 0.5, 1, 0.65],
+  stroke_width: 1,
+  line_cap: line_cap_round,
+  line_join: line_join_round,
+  miter_limit: 10,
+  alpha: 1
+};
+var overlay_handle_style = {
+  fill: [1, 1, 1, 1],
+  stroke: [0.2, 0.5, 1, 0.95],
+  stroke_width: 1,
+  line_cap: line_cap_round,
+  line_join: line_join_round,
+  miter_limit: 10,
+  alpha: 1
+};
+var default_shape_fill = [0.95, 0.95, 0.95, 1];
+var default_shape_stroke = [0.15, 0.15, 0.15, 1];
+var default_text_color = [0.1, 0.1, 0.1, 1];
+var default_stroke_color = [0.1, 0.1, 0.1, 1];
+
+// editor/hitmath.ts
+function contains_with_padding_editor(bounds, x, y, padding) {
+  return x >= bounds[0] - padding && x <= bounds[0] + bounds[2] + padding && y >= bounds[1] - padding && y <= bounds[1] + bounds[3] + padding;
+}
+function distance_point_to_segment_editor(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  if (dx === 0 && dy === 0) {
+    return Math.hypot(px - ax, py - ay);
+  }
+  const length_sq = dx * dx + dy * dy;
+  const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / length_sq));
+  const cx = ax + t * dx;
+  const cy = ay + t * dy;
+  return Math.hypot(px - cx, py - cy);
+}
+function contains_ellipse_editor(bounds, x, y, padding) {
+  const cx = bounds[0] + bounds[2] / 2;
+  const cy = bounds[1] + bounds[3] / 2;
+  const rx = Math.max(0.001, bounds[2] / 2 + padding);
+  const ry = Math.max(0.001, bounds[3] / 2 + padding);
+  const nx = (x - cx) / rx;
+  const ny = (y - cy) / ry;
+  return nx * nx + ny * ny <= 1;
+}
+function contains_polyline_editor(points, x, y, radius) {
+  if (points.length === 0) {
+    return false;
+  }
+  if (points.length === 1) {
+    const p = points[0];
+    return p !== undefined && Math.hypot(x - p[0], y - p[1]) <= radius;
+  }
+  for (let i = 1;i < points.length; i = i + 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    if (a === undefined || b === undefined) {
+      continue;
+    }
+    if (distance_point_to_segment_editor(x, y, a[0], a[1], b[0], b[1]) <= radius) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// editor/textlayout.ts
+var measure_canvas_editor = typeof document !== "undefined" ? document.createElement("canvas") : null;
+var measure_context_editor = measure_canvas_editor?.getContext("2d") ?? null;
+function build_text_layout_editor(el, content) {
+  const font_size = Math.max(1, el.font_size);
+  const line_height = font_size * 1.3;
+  const padding = Math.max(4, Math.round(font_size * 0.35));
+  const max_text_width = Math.max(1, el.bounds[2] - padding * 2);
+  const lines = [];
+  const ctx = measure_context_editor;
+  if (ctx === null) {
+    lines.push({
+      text: content,
+      start: 0,
+      end: content.length,
+      width: content.length * font_size * 0.6
+    });
+    return { lines, line_height, padding, max_text_width };
+  }
+  ctx.font = `${font_size}px ${el.font_family}`;
+  const paragraphs = content.split(`
+`);
+  let cursor = 0;
+  for (let p = 0;p < paragraphs.length; p = p + 1) {
+    const paragraph = paragraphs[p] ?? "";
+    if (paragraph.length === 0) {
+      lines.push({ text: "", start: cursor, end: cursor, width: 0 });
+      cursor = cursor + 1;
+      continue;
+    }
+    let local = 0;
+    while (local < paragraph.length) {
+      const remaining = paragraph.length - local;
+      let take = remaining;
+      while (take > 1) {
+        const slice = paragraph.slice(local, local + take);
+        if (ctx.measureText(slice).width <= max_text_width)
+          break;
+        take = take - 1;
+      }
+      if (take <= 0)
+        take = 1;
+      if (take < remaining) {
+        const space = paragraph.lastIndexOf(" ", local + take - 1);
+        if (space >= local) {
+          take = Math.max(1, space - local + 1);
+        }
+      }
+      const text = paragraph.slice(local, local + take).replace(/\s+$/g, "");
+      const width = ctx.measureText(text).width;
+      const start = cursor + local;
+      const end = start + take;
+      lines.push({ text, start, end, width });
+      local = local + take;
+    }
+    cursor = cursor + paragraph.length + 1;
+  }
+  if (lines.length === 0) {
+    lines.push({ text: "", start: 0, end: 0, width: 0 });
+  }
+  return { lines, line_height, padding, max_text_width };
+}
+function line_index_for_caret_editor(layout, index) {
+  if (layout.lines.length === 0)
+    return 0;
+  for (let i = 0;i < layout.lines.length; i = i + 1) {
+    const line = layout.lines[i];
+    if (line === undefined)
+      continue;
+    if (index >= line.start && index <= line.end)
+      return i;
+  }
+  return Math.max(0, layout.lines.length - 1);
+}
+function line_caret_x_editor(el, layout, line_index, caret_index) {
+  const line = layout.lines[line_index];
+  if (line === undefined)
+    return 0;
+  const local = Math.max(0, Math.min(line.text.length, caret_index - line.start));
+  return measure_text_width_editor(el, line.text.slice(0, local));
+}
+function nearest_caret_for_x_editor(el, layout, line_index, x) {
+  const line = layout.lines[line_index];
+  if (line === undefined)
+    return 0;
+  let best_index = line.start;
+  let best_distance = Infinity;
+  for (let i = 0;i <= line.text.length; i = i + 1) {
+    const width = measure_text_width_editor(el, line.text.slice(0, i));
+    const distance = Math.abs(width - x);
+    if (distance < best_distance) {
+      best_distance = distance;
+      best_index = line.start + i;
+    }
+  }
+  return Math.max(line.start, Math.min(line.end, best_index));
+}
+function caret_index_from_point_editor(el, content, world_x, world_y) {
+  const layout = build_text_layout_editor(el, content);
+  const local_x = world_x - el.bounds[0] - layout.padding;
+  const local_y = world_y - el.bounds[1] - layout.padding;
+  const line_index = Math.max(0, Math.min(layout.lines.length - 1, Math.floor(local_y / Math.max(1, layout.line_height))));
+  return nearest_caret_for_x_editor(el, layout, line_index, local_x);
+}
+function measure_text_width_editor(el, text) {
+  const ctx = measure_context_editor;
+  if (ctx === null)
+    return text.length * Math.max(1, el.font_size) * 0.6;
+  ctx.font = `${Math.max(1, el.font_size)}px ${el.font_family}`;
+  return ctx.measureText(text).width;
+}
+
+// editor/hittest.ts
+function element_hit_at_point_editor(doc, x, y, padding = 4) {
+  let topmost = null;
+  let top_z = -Infinity;
+  for (const el of doc.elements.values()) {
+    if (!element_contains_point_editor(el, x, y, padding)) {
+      continue;
+    }
+    if (el.z_index >= top_z) {
+      top_z = el.z_index;
+      topmost = el;
+    }
+  }
+  return topmost;
+}
+function element_contains_point_editor(el, x, y, padding) {
+  if (el.type === element_type_stroke) {
+    return stroke_contains_point_editor(el, x, y, padding);
+  }
+  if (el.type === element_type_shape) {
+    return shape_contains_point_editor(el, x, y, padding);
+  }
+  if (el.type === element_type_text) {
+    return text_contains_point_editor(el, x, y, padding);
+  }
+  return contains_with_padding_editor(el.bounds, x, y, padding);
+}
+function stroke_contains_point_editor(stroke, x, y, padding) {
+  const radius = Math.max(1, stroke.width / 2 + padding);
+  const points = stroke.simplified_points !== null && stroke.simplified_points.length > 0 ? stroke.simplified_points : stroke.points;
+  return contains_polyline_editor(points, x, y, radius);
+}
+function shape_contains_point_editor(shape, x, y, padding) {
+  if (shape.shape_type === shape_type_ellipse) {
+    return contains_ellipse_editor(shape.bounds, x, y, padding);
+  }
+  if (shape.shape_type === shape_type_line || shape.shape_type === shape_type_arrow) {
+    const a = shape.start_point ?? [shape.bounds[0], shape.bounds[1]];
+    const b = shape.end_point ?? [
+      shape.bounds[0] + shape.bounds[2],
+      shape.bounds[1] + shape.bounds[3]
+    ];
+    const radius = Math.max(1, shape.stroke_width / 2 + padding);
+    if (distance_point_to_segment_editor(x, y, a[0], a[1], b[0], b[1]) <= radius) {
+      return true;
+    }
+    if (shape.shape_type === shape_type_arrow) {
+      const hit_head = arrowhead_contains_point_editor(a, b, x, y, radius);
+      if (hit_head)
+        return true;
+    }
+    return false;
+  }
+  if (shape.shape_type === shape_type_frame) {
+    return frame_contains_point_editor(shape, x, y, padding);
+  }
+  return contains_with_padding_editor(shape.bounds, x, y, padding);
+}
+function arrowhead_contains_point_editor(from, to, x, y, radius) {
+  const dx = to[0] - from[0];
+  const dy = to[1] - from[1];
+  const len = Math.hypot(dx, dy);
+  if (len < 0.0001)
+    return false;
+  const ux = dx / len;
+  const uy = dy / len;
+  const size = Math.max(8, radius * 4);
+  const wing_angle = Math.PI / 7;
+  const cos = Math.cos(wing_angle);
+  const sin = Math.sin(wing_angle);
+  const lx = to[0] - (ux * cos - uy * sin) * size;
+  const ly = to[1] - (uy * cos + ux * sin) * size;
+  const rx = to[0] - (ux * cos + uy * sin) * size;
+  const ry = to[1] - (uy * cos - ux * sin) * size;
+  return distance_point_to_segment_editor(x, y, to[0], to[1], lx, ly) <= radius || distance_point_to_segment_editor(x, y, to[0], to[1], rx, ry) <= radius;
+}
+function frame_contains_point_editor(shape, x, y, padding) {
+  const bx = shape.bounds[0];
+  const by = shape.bounds[1];
+  const bw = Math.max(1, shape.bounds[2]);
+  const bh = Math.max(1, shape.bounds[3]);
+  const stroke = Math.max(1, shape.stroke_width + padding);
+  const header_height = Math.max(20, Math.min(36, bh * 0.18));
+  const in_outer = contains_with_padding_editor([bx, by, bw, bh], x, y, padding);
+  if (!in_outer)
+    return false;
+  const in_inner = x >= bx + stroke && x <= bx + bw - stroke && y >= by + stroke && y <= by + bh - stroke;
+  const in_header_band = x >= bx - padding && x <= bx + bw + padding && y >= by - padding && y <= by + header_height + padding;
+  return !in_inner || in_header_band;
+}
+function text_contains_point_editor(text, x, y, padding) {
+  if (!contains_with_padding_editor(text.bounds, x, y, padding))
+    return false;
+  if (text.content.length === 0)
+    return true;
+  const layout = build_text_layout_editor(text, text.content);
+  const local_x = x - text.bounds[0];
+  const local_y = y - text.bounds[1];
+  const top = layout.padding;
+  const bottom = text.bounds[3] - layout.padding;
+  if (local_y < top - padding || local_y > bottom + padding)
+    return false;
+  for (let i = 0;i < layout.lines.length; i = i + 1) {
+    const line = layout.lines[i];
+    if (line === undefined)
+      continue;
+    const y0 = layout.padding + i * layout.line_height;
+    const y1 = y0 + layout.line_height;
+    if (local_y < y0 - padding || local_y > y1 + padding)
+      continue;
+    let x0 = layout.padding;
+    if (text.align === text_align_center) {
+      x0 = text.bounds[2] * 0.5 - line.width * 0.5;
+    } else if (text.align === text_align_right) {
+      x0 = text.bounds[2] - layout.padding - line.width;
+    }
+    const x1 = x0 + line.width;
+    if (local_x >= x0 - padding && local_x <= x1 + padding)
+      return true;
+  }
+  return false;
+}
+
+// editor/selection.ts
+function selection_bounds_editor(doc, ids) {
+  if (ids.length === 0) {
+    return null;
+  }
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  let found = false;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id === undefined) {
+      continue;
+    }
+    const element = get_element_by_id_document(doc, id);
+    if (element === null) {
+      continue;
+    }
+    min_x = Math.min(min_x, element.bounds[0]);
+    min_y = Math.min(min_y, element.bounds[1]);
+    max_x = Math.max(max_x, element.bounds[0] + element.bounds[2]);
+    max_y = Math.max(max_y, element.bounds[1] + element.bounds[3]);
+    found = true;
+  }
+  if (!found) {
+    return null;
+  }
+  return [min_x, min_y, max_x - min_x, max_y - min_y];
+}
+function marquee_rectangle_editor(origin_x, origin_y, current_x, current_y) {
+  const x = Math.min(origin_x, current_x);
+  const y = Math.min(origin_y, current_y);
+  const width = Math.abs(current_x - origin_x);
+  const height = Math.abs(current_y - origin_y);
+  return [x, y, width, height];
+}
+
+// editor/hit.ts
+var handle_size = 10;
+var rotate_offset = 28;
+function selection_handles_editor(bounds) {
+  return box_handles_editor(bounds, true);
+}
+function selection_handles_for_elements_editor(doc, selected_ids) {
+  const bounds = selection_bounds_editor(doc, selected_ids);
+  if (bounds === null) {
+    return [];
+  }
+  if (selected_ids.length !== 1) {
+    return box_handles_editor(bounds, true);
+  }
+  const id = selected_ids[0];
+  if (id === undefined) {
+    return box_handles_editor(bounds, true);
+  }
+  const element = get_element_by_id_document(doc, id);
+  if (element === null) {
+    return box_handles_editor(bounds, true);
+  }
+  return element_specific_handles_editor(element, bounds);
+}
+function element_specific_handles_editor(element, bounds) {
+  if (element.type === element_type_shape) {
+    const shape = element;
+    if (shape.shape_type === shape_type_line || shape.shape_type === shape_type_arrow) {
+      const start = shape.start_point ?? [bounds[0], bounds[1]];
+      const end = shape.end_point ?? [bounds[0] + bounds[2], bounds[1] + bounds[3]];
+      return [
+        point_handle_editor("start", start[0], start[1]),
+        point_handle_editor("end", end[0], end[1])
+      ];
+    }
+    return box_handles_editor(bounds, true);
+  }
+  if (element.type === element_type_image) {
+    return box_handles_editor(bounds, false, ["nw", "ne", "se", "sw"]);
+  }
+  if (element.type === element_type_text) {
+    return box_handles_editor(bounds, false, ["w", "e"]);
+  }
+  return box_handles_editor(bounds, true);
+}
+function box_handles_editor(bounds, include_rotate, ids) {
+  const x = bounds[0];
+  const y = bounds[1];
+  const w = bounds[2];
+  const h = bounds[3];
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const hs = handle_size / 2;
+  const all = [
+    { id: "nw", bounds: [x - hs, y - hs, handle_size, handle_size] },
+    { id: "n", bounds: [cx - hs, y - hs, handle_size, handle_size] },
+    { id: "ne", bounds: [x + w - hs, y - hs, handle_size, handle_size] },
+    { id: "e", bounds: [x + w - hs, cy - hs, handle_size, handle_size] },
+    { id: "se", bounds: [x + w - hs, y + h - hs, handle_size, handle_size] },
+    { id: "s", bounds: [cx - hs, y + h - hs, handle_size, handle_size] },
+    { id: "sw", bounds: [x - hs, y + h - hs, handle_size, handle_size] },
+    { id: "w", bounds: [x - hs, cy - hs, handle_size, handle_size] }
+  ];
+  if (include_rotate) {
+    all.push({ id: "rotate", bounds: [cx - hs, y - rotate_offset - hs, handle_size, handle_size] });
+  }
+  if (ids === undefined) {
+    return all;
+  }
+  return all.filter((handle) => ids.includes(handle.id));
+}
+function hit_selection_handle_editor(bounds, point) {
+  const handles = selection_handles_editor(bounds);
+  for (let i = 0;i < handles.length; i = i + 1) {
+    const handle = handles[i];
+    if (handle === undefined) {
+      continue;
+    }
+    if (contains_point_editor(handle.bounds, point)) {
+      return handle;
+    }
+  }
+  return null;
+}
+function hit_selection_handles_editor(handles, point) {
+  for (let i = 0;i < handles.length; i = i + 1) {
+    const handle = handles[i];
+    if (handle !== undefined && contains_point_editor(handle.bounds, point)) {
+      return handle;
+    }
+  }
+  return null;
+}
+function point_handle_editor(id, x, y) {
+  const hs = handle_size / 2;
+  return { id, bounds: [x - hs, y - hs, handle_size, handle_size] };
+}
+function contains_point_editor(bounds, point) {
+  return point[0] >= bounds[0] && point[0] <= bounds[0] + bounds[2] && point[1] >= bounds[1] && point[1] <= bounds[1] + bounds[3];
+}
+
+// editor/shared.ts
+function current_tool_impl_editor(state) {
+  return state.tools.get(state.current_tool) ?? state.tools.get(editor_tool_select);
+}
+function next_id_editor(state, prefix) {
+  state.id_counter = state.id_counter + 1;
+  return `${prefix}_${Date.now()}_${state.id_counter}`;
+}
+function next_z_index_editor(doc) {
+  let max = -1;
+  for (const item of doc.elements.values()) {
+    if (item.z_index > max) {
+      max = item.z_index;
+    }
+  }
+  return max + 1;
+}
+function cleanup_selection_editor(state) {
+  const ids = Array.from(state.selected_element_ids.values());
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id !== undefined && get_element_by_id_document(state.engine.document, id) === null) {
+      state.selected_element_ids.delete(id);
+    }
+  }
+}
+function update_pointer_editor(state, input) {
+  state.pointer_screen[0] = input.screen[0];
+  state.pointer_screen[1] = input.screen[1];
+  state.has_pointer_input = true;
+  screen_to_world_engine(state.engine, input.screen, state.pointer_world);
+}
+function update_hover_editor(state) {
+  const hit = element_hit_at_point_editor(state.engine.document, state.pointer_world[0], state.pointer_world[1]);
+  state.hovered_element_id = hit?.id ?? null;
+}
+function update_select_hover_editor(state) {
+  state.transient_guides = [];
+  const selected_ids = Array.from(state.selected_element_ids.values());
+  const handles = selection_handles_for_elements_editor(state.engine.document, selected_ids);
+  state.active_handle = hit_selection_handles_editor(handles, state.pointer_world)?.id ?? null;
+  update_hover_editor(state);
+}
+function rectangle_from_points_editor(a, b, keep_square) {
+  const x1 = a[0];
+  const y1 = a[1];
+  let x2 = b[0];
+  let y2 = b[1];
+  if (keep_square) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const size = Math.max(Math.abs(dx), Math.abs(dy));
+    x2 = x1 + Math.sign(dx || 1) * size;
+    y2 = y1 + Math.sign(dy || 1) * size;
+  }
+  return [
+    Math.min(x1, x2),
+    Math.min(y1, y2),
+    Math.max(1, Math.abs(x2 - x1)),
+    Math.max(1, Math.abs(y2 - y1))
+  ];
+}
+function shape_name_for_tool_editor(tool) {
+  if (tool === editor_tool_rectangle)
+    return "rectangle";
+  if (tool === editor_tool_ellipse)
+    return "ellipse";
+  if (tool === editor_tool_line)
+    return "line";
+  if (tool === editor_tool_arrow)
+    return "arrow";
+  if (tool === editor_tool_frame)
+    return "frame";
+  return "shape";
+}
+function shape_type_for_tool_editor(tool) {
+  if (tool === editor_tool_rectangle)
+    return shape_type_rectangle;
+  if (tool === editor_tool_ellipse)
+    return shape_type_ellipse;
+  if (tool === editor_tool_line)
+    return shape_type_line;
+  if (tool === editor_tool_arrow)
+    return shape_type_arrow;
+  return shape_type_frame;
+}
+function grouped_ids_for_element_editor(doc, element_id) {
+  const element = get_element_by_id_document(doc, element_id);
+  if (element === null || element.group_id === null) {
+    return element === null ? [] : [element_id];
+  }
+  const ids = [];
+  for (const item of doc.elements.values()) {
+    if (item.group_id === element.group_id)
+      ids.push(item.id);
+  }
+  return ids;
+}
+function expand_ids_with_groups_editor(doc, ids) {
+  const out = new Set;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id === undefined)
+      continue;
+    const group_ids = grouped_ids_for_element_editor(doc, id);
+    if (group_ids.length === 0)
+      continue;
+    for (let j = 0;j < group_ids.length; j = j + 1) {
+      const group_id = group_ids[j];
+      if (group_id !== undefined)
+        out.add(group_id);
+    }
+  }
+  return Array.from(out);
+}
+
+// editor/ops.ts
+function update_shape_preview_editor(state, drag_state, keep_square) {
+  const el = get_element_by_id_document(state.engine.document, drag_state.element_id);
+  if (el === null || el.type !== element_type_shape)
+    return;
+  const rect = rectangle_from_points_editor(drag_state.origin_world, drag_state.current_world, keep_square);
+  const shape = clone_element_editor(el);
+  shape.bounds = rect;
+  if (shape.shape_type === shape_type_line || shape.shape_type === shape_type_arrow) {
+    const constrained = keep_square ? constrain_line_angle_editor(drag_state.origin_world, drag_state.current_world) : [drag_state.current_world[0], drag_state.current_world[1]];
+    const end_x = constrained[0];
+    const end_y = constrained[1];
+    if (end_x === undefined || end_y === undefined) {
+      return;
+    }
+    shape.start_point = [drag_state.origin_world[0], drag_state.origin_world[1]];
+    shape.end_point = [end_x, end_y];
+    const end_point = shape.end_point;
+    shape.bounds = [
+      Math.min(shape.start_point[0], end_point[0]),
+      Math.min(shape.start_point[1], end_point[1]),
+      Math.max(1, Math.abs(end_point[0] - shape.start_point[0])),
+      Math.max(1, Math.abs(end_point[1] - shape.start_point[1]))
+    ];
+  }
+  state.engine.document = update_element_document(state.engine.document, el.id, shape);
+}
+function constrain_line_angle_editor(origin, target) {
+  const dx = target[0] - origin[0];
+  const dy = target[1] - origin[1];
+  const length = Math.hypot(dx, dy);
+  if (length === 0) {
+    return [target[0], target[1]];
+  }
+  const angle = Math.atan2(dy, dx);
+  const snap = Math.PI / 4;
+  const snapped = Math.round(angle / snap) * snap;
+  return [origin[0] + Math.cos(snapped) * length, origin[1] + Math.sin(snapped) * length];
+}
+function update_box_resize_editor(state, element_id, origin_world, current_world) {
+  const el = get_element_by_id_document(state.engine.document, element_id);
+  if (el === null)
+    return;
+  const rect = rectangle_from_points_editor(origin_world, current_world, false);
+  const updated = clone_element_editor(el);
+  updated.bounds = [rect[0], rect[1], Math.max(rect[2], 2), Math.max(rect[3], 2)];
+  state.engine.document = update_element_document(state.engine.document, element_id, updated);
+}
+function insert_drawn_stroke_editor(state, points, pressure) {
+  if (points.length === 0)
+    return;
+  const simplified_out = Array.from({ length: points.length }, () => [0, 0]);
+  const spline = create_spline();
+  const processed = process_stroke(points, pressure, {
+    color: default_stroke_color,
+    width: 2,
+    opacity: 1,
+    pressure_sensitivity: 0.5
+  }, simplified_out, spline);
+  const stroke_bounds = [0, 0, 0, 0];
+  compute_stroke_bounds(points, 2, stroke_bounds);
+  const element_id = next_id_editor(state, "stroke");
+  const stroke = create_stroke_element(element_id, stroke_bounds, next_z_index_editor(state.engine.document), state.engine.document.active_layer_id, points, pressure, default_stroke_color, 2);
+  stroke.simplified_points = processed.simplified;
+  stroke.spline = processed.spline;
+  state.engine.document = add_element_document(state.engine.document, stroke);
+  state.selected_element_ids.clear();
+  state.selected_element_ids.add(element_id);
+}
+function insert_elements_with_offset_editor(state, elements, dx, dy) {
+  if (elements.length === 0)
+    return false;
+  const id_map = new Map;
+  for (let i = 0;i < elements.length; i = i + 1) {
+    const item = elements[i];
+    if (item !== undefined)
+      id_map.set(item.id, next_id_editor(state, "el"));
+  }
+  let doc = state.engine.document;
+  state.selected_element_ids.clear();
+  for (let i = 0;i < elements.length; i = i + 1) {
+    const item = elements[i];
+    if (item === undefined)
+      continue;
+    const clone = move_element_editor(item, dx, dy);
+    const new_id = id_map.get(item.id);
+    if (new_id === undefined)
+      continue;
+    clone.id = new_id;
+    clone.z_index = next_z_index_editor(doc);
+    doc = add_element_document(doc, clone);
+    state.selected_element_ids.add(new_id);
+  }
+  state.engine.document = doc;
+  return true;
+}
+
+// editor/actions.ts
+function copy_selection_editor(state) {
+  const selected_ids = Array.from(state.selected_element_ids.values());
+  if (selected_ids.length === 0)
+    return false;
+  const payload_elements = [];
+  for (let i = 0;i < selected_ids.length; i = i + 1) {
+    const id = selected_ids[i];
+    if (id === undefined)
+      continue;
+    const el = get_element_by_id_document(state.engine.document, id);
+    if (el !== null)
+      payload_elements.push(clone_element_editor(el));
+  }
+  if (payload_elements.length === 0)
+    return false;
+  const bounds = selection_bounds_editor(state.engine.document, selected_ids);
+  const anchor = bounds === null ? [state.pointer_world[0], state.pointer_world[1]] : [bounds[0] + bounds[2] / 2, bounds[1] + bounds[3] / 2];
+  state.clipboard_payload = { elements: payload_elements, anchor };
+  return true;
+}
+function cut_selection_editor(state) {
+  return copy_selection_editor(state) ? delete_selection_editor(state) : false;
+}
+function paste_clipboard_editor(state, world_anchor) {
+  if (state.clipboard_payload === null || state.clipboard_payload.elements.length === 0)
+    return false;
+  const anchor = world_anchor ?? paste_anchor_editor(state);
+  const dx = anchor[0] - state.clipboard_payload.anchor[0] + 16;
+  const dy = anchor[1] - state.clipboard_payload.anchor[1] + 16;
+  begin_transaction_editor(state, "paste");
+  const ok = insert_elements_with_offset_editor(state, state.clipboard_payload.elements, dx, dy);
+  if (!ok) {
+    cancel_transaction_editor(state);
+    return false;
+  }
+  commit_transaction_editor(state);
+  return true;
+}
+function duplicate_selection_editor(state) {
+  return copy_selection_editor(state) ? paste_clipboard_editor(state, state.pointer_world) : false;
+}
+function paste_anchor_editor(state) {
+  if (state.has_pointer_input) {
+    return [state.pointer_world[0], state.pointer_world[1]];
+  }
+  const center_screen = [state.engine.viewport[0] / 2, state.engine.viewport[1] / 2];
+  const center_world = [0, 0];
+  screen_to_world_engine(state.engine, center_screen, center_world);
+  return center_world;
+}
+function delete_selection_editor(state) {
+  if (state.selected_element_ids.size === 0)
+    return false;
+  begin_transaction_editor(state, "delete");
+  const selected_ids = Array.from(state.selected_element_ids.values());
+  let doc = state.engine.document;
+  for (let i = 0;i < selected_ids.length; i = i + 1) {
+    const id = selected_ids[i];
+    if (id !== undefined)
+      doc = remove_element_document(doc, id);
+  }
+  state.engine.document = doc;
+  state.selected_element_ids.clear();
+  commit_transaction_editor(state);
+  return true;
+}
+function undo_action_editor(state) {
+  const ok = undo_editor(state);
+  if (ok)
+    cleanup_selection_editor(state);
+  return ok;
+}
+function redo_action_editor(state) {
+  const ok = redo_editor(state);
+  if (ok)
+    cleanup_selection_editor(state);
+  return ok;
+}
+function group_selection_editor(state) {
+  const raw_ids = Array.from(state.selected_element_ids.values());
+  const ids = expand_ids_with_groups_editor(state.engine.document, raw_ids);
+  if (ids.length < 2) {
+    return false;
+  }
+  begin_transaction_editor(state, "group");
+  const group_id = next_id_editor(state, "group");
+  let doc = state.engine.document;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id === undefined)
+      continue;
+    const element = get_element_by_id_document(doc, id);
+    if (element === null)
+      continue;
+    doc = update_element_document(doc, id, { ...element, group_id });
+  }
+  state.engine.document = doc;
+  state.selected_element_ids.clear();
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id !== undefined)
+      state.selected_element_ids.add(id);
+  }
+  commit_transaction_editor(state);
+  return true;
+}
+function ungroup_selection_editor(state) {
+  const raw_ids = Array.from(state.selected_element_ids.values());
+  const ids = expand_ids_with_groups_editor(state.engine.document, raw_ids);
+  if (ids.length === 0) {
+    return false;
+  }
+  begin_transaction_editor(state, "ungroup");
+  let doc = state.engine.document;
+  let changed = false;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id === undefined)
+      continue;
+    const element = get_element_by_id_document(doc, id);
+    if (element === null || element.group_id === null)
+      continue;
+    changed = true;
+    doc = update_element_document(doc, id, { ...element, group_id: null });
+  }
+  if (!changed) {
+    cancel_transaction_editor(state);
+    return false;
+  }
+  state.engine.document = doc;
+  commit_transaction_editor(state);
+  return true;
+}
+
+// editor/keys.ts
+function handle_global_key_editor(state, input) {
+  const normalized = normalize_key_editor(input.key);
+  const mod = !!input.meta || !!input.ctrl;
+  if (mod && normalized === "z" && !input.shift)
+    return undo_action_editor(state);
+  if (mod && normalized === "y" || mod && normalized === "z" && !!input.shift)
+    return redo_action_editor(state);
+  if (mod && normalized === "c")
+    return copy_selection_editor(state);
+  if (mod && normalized === "x")
+    return cut_selection_editor(state);
+  if (mod && normalized === "v")
+    return paste_clipboard_editor(state);
+  if (mod && normalized === "d")
+    return duplicate_selection_editor(state);
+  if (mod && normalized === "g" && !!input.shift)
+    return ungroup_selection_editor(state);
+  if (mod && normalized === "g")
+    return group_selection_editor(state);
+  if (normalized === "delete" || normalized === "backspace")
+    return delete_selection_editor(state);
+  if (normalized === "escape") {
+    current_tool_impl_editor(state).cancel(state);
+    return true;
+  }
+  if (normalized === " ") {
+    if (state.current_tool !== editor_tool_hand) {
+      state.previous_tool_before_hand = state.current_tool;
+      state.current_tool = editor_tool_hand;
+    }
+    return true;
+  }
+  if (normalized === "v")
+    return set_tool_shortcut_editor(state, editor_tool_select);
+  if (normalized === "h")
+    return set_tool_shortcut_editor(state, editor_tool_hand);
+  if (normalized === "p")
+    return set_tool_shortcut_editor(state, editor_tool_draw);
+  if (normalized === "r")
+    return set_tool_shortcut_editor(state, editor_tool_rectangle);
+  if (normalized === "e")
+    return set_tool_shortcut_editor(state, editor_tool_ellipse);
+  if (normalized === "l")
+    return set_tool_shortcut_editor(state, editor_tool_line);
+  if (normalized === "a")
+    return set_tool_shortcut_editor(state, editor_tool_arrow);
+  if (normalized === "f")
+    return set_tool_shortcut_editor(state, editor_tool_frame);
+  if (normalized === "t")
+    return set_tool_shortcut_editor(state, editor_tool_text);
+  if (normalized === "i")
+    return set_tool_shortcut_editor(state, editor_tool_image_place);
+  return false;
+}
+function normalize_key_editor(key) {
+  return key.toLowerCase();
+}
+function set_tool_shortcut_editor(state, tool) {
+  if (!state.tools.has(tool) || state.current_tool === tool)
+    return true;
+  current_tool_impl_editor(state).cancel(state);
+  state.current_tool = tool;
+  return true;
+}
+
+// editor/overlay.ts
+function draw_editor_overlay(state, drawer) {
+  draw_hover_overlay_editor(state, drawer);
+  draw_selection_overlay_editor(state, drawer);
+  draw_marquee_overlay_editor(state, drawer);
+  draw_guides_overlay_editor(state, drawer);
+  draw_text_edit_overlay_editor(state, drawer);
+}
+function draw_hover_overlay_editor(state, drawer) {
+  if (state.hovered_element_id === null || state.selected_element_ids.has(state.hovered_element_id)) {
+    return;
+  }
+  const hovered = get_element_by_id_document(state.engine.document, state.hovered_element_id);
+  if (hovered !== null) {
+    drawer.draw_rectangle(hovered.bounds, overlay_hover_style);
+  }
+}
+function draw_selection_overlay_editor(state, drawer) {
+  const selected_ids = Array.from(state.selected_element_ids.values());
+  const selection_bounds = selection_bounds_editor(state.engine.document, selected_ids);
+  if (selection_bounds === null) {
+    return;
+  }
+  drawer.draw_rectangle(selection_bounds, overlay_selection_style);
+  const handles = selection_handles_for_elements_editor(state.engine.document, selected_ids);
+  for (let i = 0;i < handles.length; i = i + 1) {
+    const handle = handles[i];
+    if (handle !== undefined) {
+      drawer.draw_rectangle(handle.bounds, overlay_handle_style);
+    }
+  }
+}
+function draw_marquee_overlay_editor(state, drawer) {
+  if (state.marquee_state === null) {
+    return;
+  }
+  const marquee = marquee_rectangle_editor(state.marquee_state.origin_world[0], state.marquee_state.origin_world[1], state.marquee_state.current_world[0], state.marquee_state.current_world[1]);
+  drawer.draw_rectangle(marquee, overlay_marquee_style);
+}
+function draw_guides_overlay_editor(state, drawer) {
+  for (let i = 0;i < state.transient_guides.length; i = i + 1) {
+    const guide = state.transient_guides[i];
+    if (guide !== undefined) {
+      drawer.draw_rectangle(guide, overlay_hover_style);
+    }
+  }
+}
+function draw_text_edit_overlay_editor(state, drawer) {
+  if (state.text_edit === null) {
+    return;
+  }
+  const element = get_element_by_id_document(state.engine.document, state.text_edit.element_id);
+  if (element === null || element.type !== element_type_text)
+    return;
+  const draft = state.text_edit.draft;
+  const layout = build_text_layout_editor(element, draft);
+  const anchor = state.text_edit.anchor;
+  const caret = state.text_edit.caret;
+  if (anchor !== null && anchor !== caret) {
+    const start = Math.min(anchor, caret);
+    const end = Math.max(anchor, caret);
+    draw_text_selection_editor(drawer, element, layout, start, end);
+  }
+  draw_text_caret_editor(drawer, element, layout, caret);
+  drawer.draw_rectangle(element.bounds, overlay_handle_style);
+}
+function draw_text_selection_editor(drawer, element, layout, start, end) {
+  for (let i = 0;i < layout.lines.length; i = i + 1) {
+    const line = layout.lines[i];
+    if (line === undefined)
+      continue;
+    if (end <= line.start || start >= line.end)
+      continue;
+    const local_start = Math.max(0, start - line.start);
+    const local_end = Math.max(local_start, Math.min(line.text.length, end - line.start));
+    const x0 = line_x_offset_editor(element, layout, line.width) + measure_line_prefix_width_editor(line.text, local_start, element);
+    const x1 = line_x_offset_editor(element, layout, line.width) + measure_line_prefix_width_editor(line.text, local_end, element);
+    const y = element.bounds[1] + layout.padding + i * layout.line_height;
+    drawer.draw_rectangle([x0, y, Math.max(1, x1 - x0), layout.line_height], overlay_marquee_style);
+  }
+}
+function draw_text_caret_editor(drawer, element, layout, caret) {
+  const line_index = line_index_for_caret_editor(layout, caret);
+  const line = layout.lines[line_index];
+  if (line === undefined)
+    return;
+  const local = Math.max(0, Math.min(line.text.length, caret - line.start));
+  const x = line_x_offset_editor(element, layout, line.width) + measure_line_prefix_width_editor(line.text, local, element);
+  const y = element.bounds[1] + layout.padding + line_index * layout.line_height;
+  drawer.draw_rectangle([x, y, 1.5, layout.line_height], text_caret_style_editor);
+}
+function line_x_offset_editor(element, layout, line_width) {
+  if (element.align === text_align_center) {
+    return element.bounds[0] + element.bounds[2] * 0.5 - line_width * 0.5;
+  }
+  if (element.align === text_align_right) {
+    return element.bounds[0] + element.bounds[2] - layout.padding - line_width;
+  }
+  return element.bounds[0] + layout.padding;
+}
+function measure_line_prefix_width_editor(text, length, element) {
+  const ctx = selection_measure_context_editor;
+  if (ctx === null)
+    return Math.max(0, length) * 8;
+  const size = Math.max(1, element.font_size);
+  const family = element.font_family;
+  ctx.font = `${size}px ${family}`;
+  return ctx.measureText(text.slice(0, Math.max(0, length))).width;
+}
+var selection_measure_canvas_editor = typeof document !== "undefined" ? document.createElement("canvas") : null;
+var selection_measure_context_editor = selection_measure_canvas_editor?.getContext("2d") ?? null;
+var text_caret_style_editor = {
+  fill: [0.2, 0.5, 1, 0.95],
+  stroke: null,
+  stroke_width: 0,
+  line_cap: 1,
+  line_join: 1,
+  miter_limit: 10,
+  alpha: 1
+};
+
+// editor/tools/draw.ts
+function create_draw_tool_editor() {
+  return {
+    id: editor_tool_draw,
+    name: "draw",
+    pointer_down: (state) => {
+      begin_transaction_editor(state, "draw");
+      state.drag_state = {
+        kind: "draw",
+        points: [[state.pointer_world[0], state.pointer_world[1]]],
+        pressure: [1]
+      };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state) => {
+      if (state.drag_state === null || state.drag_state.kind !== "draw")
+        return;
+      state.drag_state.points.push([state.pointer_world[0], state.pointer_world[1]]);
+      state.drag_state.pressure.push(1);
+    },
+    pointer_up: (state) => {
+      if (state.drag_state !== null && state.drag_state.kind === "draw") {
+        insert_drawn_stroke_editor(state, state.drag_state.points, state.drag_state.pressure);
+        commit_transaction_editor(state);
+      }
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    double_click: () => {},
+    key_down: () => {},
+    cancel: (state) => {
+      cancel_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    hover: () => {},
+    cursor: () => "crosshair",
+    overlay: (state, drawer) => {
+      if (state.drag_state?.kind === "draw" && state.drag_state.points.length > 1) {
+        drawer.draw_polyline(state.drag_state.points, overlay_hover_style);
+      }
+    }
+  };
+}
+
+// editor/tools/hand.ts
+function create_hand_tool_editor() {
+  return {
+    id: editor_tool_hand,
+    name: "hand",
+    pointer_down: (state) => {
+      state.drag_state = {
+        kind: "pan",
+        origin_screen: [state.pointer_screen[0], state.pointer_screen[1]],
+        current_screen: [state.pointer_screen[0], state.pointer_screen[1]]
+      };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state) => {
+      if (state.drag_state === null || state.drag_state.kind !== "pan")
+        return;
+      const dx_screen = state.pointer_screen[0] - state.drag_state.current_screen[0];
+      const dy_screen = state.pointer_screen[1] - state.drag_state.current_screen[1];
+      state.drag_state.current_screen = [state.pointer_screen[0], state.pointer_screen[1]];
+      const zoom = Math.max(0.001, state.engine.camera[2]);
+      pan_engine(state.engine, -dx_screen / zoom, -dy_screen / zoom);
+    },
+    pointer_up: (state) => {
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    double_click: () => {},
+    key_down: () => {},
+    cancel: (state) => {
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    hover: () => {},
+    cursor: () => "grab",
+    overlay: () => {}
+  };
+}
+
+// editor/snap.ts
+function snap_point_editor(state, point, context, meta) {
+  if (state.snappers.length === 0) {
+    state.transient_guides = [];
+    return [point[0], point[1]];
+  }
+  let best_point = [point[0], point[1]];
+  const guides = [];
+  for (let i = 0;i < state.snappers.length; i = i + 1) {
+    const snapper = state.snappers[i];
+    if (snapper === undefined)
+      continue;
+    const result = snapper(state, best_point, context, meta);
+    if (result === null)
+      continue;
+    best_point = [result.point[0], result.point[1]];
+    for (let j = 0;j < result.guides.length; j = j + 1) {
+      const guide = result.guides[j];
+      if (guide !== undefined)
+        guides.push(guide);
+    }
+  }
+  state.transient_guides = guides;
+  return best_point;
+}
+function create_grid_snapper_editor(grid_size = 16, tolerance = 6) {
+  const safe_grid = Math.max(1, grid_size);
+  const safe_tol = Math.max(0.1, tolerance);
+  return (_state, point) => {
+    const gx = Math.round(point[0] / safe_grid) * safe_grid;
+    const gy = Math.round(point[1] / safe_grid) * safe_grid;
+    const dx = Math.abs(gx - point[0]);
+    const dy = Math.abs(gy - point[1]);
+    const snapped_x = dx <= safe_tol ? gx : point[0];
+    const snapped_y = dy <= safe_tol ? gy : point[1];
+    if (snapped_x === point[0] && snapped_y === point[1]) {
+      return null;
+    }
+    const guides = [];
+    if (snapped_x !== point[0])
+      guides.push([snapped_x - 0.25, -1e5, 0.5, 200000]);
+    if (snapped_y !== point[1])
+      guides.push([-1e5, snapped_y - 0.25, 200000, 0.5]);
+    return { point: [snapped_x, snapped_y], guides };
+  };
+}
+function create_element_smart_snapper_editor(tolerance = 6) {
+  const safe_tol = Math.max(0.1, tolerance);
+  return (state, point, context, meta) => {
+    if (context === "rotate") {
+      return null;
+    }
+    const candidates_x = [];
+    const candidates_y = [];
+    for (const element of state.engine.document.elements.values()) {
+      if (state.selected_element_ids.has(element.id)) {
+        continue;
+      }
+      const bounds = element.bounds;
+      candidates_x.push(bounds[0], bounds[0] + bounds[2], bounds[0] + bounds[2] / 2);
+      candidates_y.push(bounds[1], bounds[1] + bounds[3], bounds[1] + bounds[3] / 2);
+    }
+    const subject = meta?.subject_bounds;
+    const snapped_x = subject ? closest_bounds_snap_delta_editor([subject[0], subject[0] + subject[2], subject[0] + subject[2] / 2], candidates_x, safe_tol) : closest_axis_snap_editor(point[0], candidates_x, safe_tol);
+    const snapped_y = subject ? closest_bounds_snap_delta_editor([subject[1], subject[1] + subject[3], subject[1] + subject[3] / 2], candidates_y, safe_tol) : closest_axis_snap_editor(point[1], candidates_y, safe_tol);
+    if (snapped_x === null && snapped_y === null) {
+      return null;
+    }
+    const out_x = subject ? point[0] + (snapped_x?.delta ?? 0) : snapped_x?.value ?? point[0];
+    const out_y = subject ? point[1] + (snapped_y?.delta ?? 0) : snapped_y?.value ?? point[1];
+    const guides = [];
+    if (snapped_x !== null) {
+      guides.push([snapped_x.value - 0.25, -1e5, 0.5, 200000]);
+    }
+    if (snapped_y !== null) {
+      guides.push([-1e5, snapped_y.value - 0.25, 200000, 0.5]);
+    }
+    return { point: [out_x, out_y], guides };
+  };
+}
+function closest_axis_snap_editor(value, candidates, tolerance) {
+  let best = null;
+  let best_delta = Infinity;
+  for (let i = 0;i < candidates.length; i = i + 1) {
+    const candidate = candidates[i];
+    if (candidate === undefined) {
+      continue;
+    }
+    const delta = Math.abs(candidate - value);
+    if (delta <= tolerance && delta < best_delta) {
+      best_delta = delta;
+      best = { value: candidate, delta: candidate - value };
+    }
+  }
+  return best;
+}
+function closest_bounds_snap_delta_editor(subject_values, candidates, tolerance) {
+  let best = null;
+  let best_delta = Infinity;
+  for (let i = 0;i < subject_values.length; i = i + 1) {
+    const subject = subject_values[i];
+    if (subject === undefined)
+      continue;
+    for (let j = 0;j < candidates.length; j = j + 1) {
+      const candidate = candidates[j];
+      if (candidate === undefined)
+        continue;
+      const delta = candidate - subject;
+      const abs = Math.abs(delta);
+      if (abs <= tolerance && abs < best_delta) {
+        best_delta = abs;
+        best = { value: candidate, delta };
+      }
+    }
+  }
+  return best;
+}
+
+// editor/tools/image.ts
+function create_image_tool_editor() {
+  return {
+    id: editor_tool_image_place,
+    name: "image_place",
+    pointer_down: (state) => {
+      begin_transaction_editor(state, "image");
+      const element_id = next_id_editor(state, "image");
+      const x = state.pointer_world[0];
+      const y = state.pointer_world[1];
+      const image = create_image_element(element_id, [x, y, 220, 140], next_z_index_editor(state.engine.document), state.engine.document.active_layer_id, "", 0, 0, 1);
+      state.engine.document = add_element_document(state.engine.document, image);
+      state.selected_element_ids.clear();
+      state.selected_element_ids.add(element_id);
+      state.drag_state = { kind: "image", origin_world: [x, y], current_world: [x, y], element_id };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state) => {
+      if (state.drag_state === null || state.drag_state.kind !== "image")
+        return;
+      state.drag_state.current_world = snap_point_editor(state, [state.pointer_world[0], state.pointer_world[1]], "image");
+      update_box_resize_editor(state, state.drag_state.element_id, state.drag_state.origin_world, state.drag_state.current_world);
+    },
+    pointer_up: (state) => {
+      if (state.drag_state?.kind === "image")
+        commit_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    double_click: () => {},
+    key_down: () => {},
+    cancel: (state) => {
+      cancel_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    hover: () => {},
+    cursor: () => "copy",
+    overlay: () => {}
+  };
+}
+
+// editor/tools/lineresize.ts
+function apply_line_endpoint_resize_editor(state) {
+  if (state.drag_state === null || state.drag_state.kind !== "resize") {
+    return false;
+  }
+  if (state.drag_state.handle !== "start" && state.drag_state.handle !== "end") {
+    return false;
+  }
+  if (state.drag_state.resized_element_ids.length !== 1) {
+    return false;
+  }
+  const element_id = state.drag_state.resized_element_ids[0];
+  if (element_id === undefined) {
+    return false;
+  }
+  const base = get_element_by_id_document(state.drag_state.base_document, element_id);
+  if (base === null || base.type !== element_type_shape) {
+    return false;
+  }
+  if (base.shape_type !== shape_type_line && base.shape_type !== shape_type_arrow) {
+    return false;
+  }
+  const updated = clone_element_editor(base);
+  const shape = updated.type === element_type_shape ? updated : null;
+  if (shape === null) {
+    return false;
+  }
+  if (shape.start_point === null) {
+    shape.start_point = [shape.bounds[0], shape.bounds[1]];
+  }
+  if (shape.end_point === null) {
+    shape.end_point = [shape.bounds[0] + shape.bounds[2], shape.bounds[1] + shape.bounds[3]];
+  }
+  if (state.drag_state.handle === "start") {
+    shape.start_point = [state.drag_state.current_world[0], state.drag_state.current_world[1]];
+  } else {
+    shape.end_point = [state.drag_state.current_world[0], state.drag_state.current_world[1]];
+  }
+  shape.bounds = [
+    Math.min(shape.start_point[0], shape.end_point[0]),
+    Math.min(shape.start_point[1], shape.end_point[1]),
+    Math.max(1, Math.abs(shape.end_point[0] - shape.start_point[0])),
+    Math.max(1, Math.abs(shape.end_point[1] - shape.start_point[1]))
+  ];
+  state.engine.document = update_element_document(state.drag_state.base_document, element_id, shape);
+  return true;
+}
+
+// editor/tools/selectops.ts
+var drag_threshold_screen_editor = 4;
+function start_move_editor(state, ids) {
+  const expanded_ids = expand_move_ids_for_frames_editor(state.engine.document.elements, ids);
+  const selection_bounds = selection_bounds_editor(state.engine.document, expanded_ids) ?? [
+    0,
+    0,
+    1,
+    1
+  ];
+  state.drag_state = {
+    kind: "move",
+    origin_world: [state.pointer_world[0], state.pointer_world[1]],
+    current_world: [state.pointer_world[0], state.pointer_world[1]],
+    base_document: clone_document(state.engine.document),
+    moved_element_ids: expanded_ids,
+    selection_bounds
+  };
+  state.pointer_capture = true;
+}
+function exceeds_drag_threshold_editor(origin, current) {
+  const dx = current[0] - origin[0];
+  const dy = current[1] - origin[1];
+  return dx * dx + dy * dy >= drag_threshold_screen_editor * drag_threshold_screen_editor;
+}
+function apply_move_drag_editor(state) {
+  if (state.drag_state === null || state.drag_state.kind !== "move")
+    return;
+  const dx = state.drag_state.current_world[0] - state.drag_state.origin_world[0];
+  const dy = state.drag_state.current_world[1] - state.drag_state.origin_world[1];
+  state.engine.document = transform_elements_editor(state.drag_state.base_document, state.drag_state.moved_element_ids, (point) => [point[0] + dx, point[1] + dy]);
+}
+function apply_marquee_selection_editor(state, marquee_state) {
+  const rect = marquee_rectangle_editor(marquee_state.origin_world[0], marquee_state.origin_world[1], marquee_state.current_world[0], marquee_state.current_world[1]);
+  if (!marquee_state.add_mode)
+    state.selected_element_ids.clear();
+  const in_bounds = elements_in_bounds_document(state.engine.document, rect);
+  const hit_ids = [];
+  for (let i = 0;i < in_bounds.length; i = i + 1) {
+    const el = in_bounds[i];
+    if (el !== undefined)
+      hit_ids.push(el.id);
+  }
+  const expanded = expand_ids_with_groups_editor(state.engine.document, hit_ids);
+  for (let i = 0;i < expanded.length; i = i + 1) {
+    const id = expanded[i];
+    if (id !== undefined)
+      state.selected_element_ids.add(id);
+  }
+}
+function apply_resize_drag_editor(state) {
+  if (state.drag_state === null || state.drag_state.kind !== "resize")
+    return;
+  if (apply_line_endpoint_resize_editor(state))
+    return;
+  const base = state.drag_state.selection_bounds;
+  const left = base[0];
+  const right = base[0] + base[2];
+  const top = base[1];
+  const bottom = base[1] + base[3];
+  const width = Math.max(0.0001, right - left);
+  const height = Math.max(0.0001, bottom - top);
+  const c = state.drag_state.current_world;
+  const handle = state.drag_state.handle;
+  const centered = state.drag_state.centered;
+  const keep_aspect = state.drag_state.keep_aspect;
+  const anchor_x = centered ? left + width / 2 : handle.includes("w") ? right : handle.includes("e") ? left : left + width / 2;
+  const anchor_y = centered ? top + height / 2 : handle.includes("n") ? bottom : handle.includes("s") ? top : top + height / 2;
+  let sx = 1;
+  let sy = 1;
+  if (handle.includes("w"))
+    sx = centered ? Math.abs(c[0] - anchor_x) * 2 / width : (right - c[0]) / width;
+  if (handle.includes("e"))
+    sx = centered ? Math.abs(c[0] - anchor_x) * 2 / width : (c[0] - left) / width;
+  if (handle.includes("n"))
+    sy = centered ? Math.abs(c[1] - anchor_y) * 2 / height : (bottom - c[1]) / height;
+  if (handle.includes("s"))
+    sy = centered ? Math.abs(c[1] - anchor_y) * 2 / height : (c[1] - top) / height;
+  sx = Math.max(0.0001, sx);
+  sy = Math.max(0.0001, sy);
+  if (keep_aspect) {
+    const has_x = handle.includes("w") || handle.includes("e");
+    const has_y = handle.includes("n") || handle.includes("s");
+    const scale = !has_y ? sx : !has_x ? sy : Math.max(sx, sy);
+    sx = scale;
+    sy = scale;
+  }
+  const nl = anchor_x - (anchor_x - left) * sx;
+  const nt = anchor_y - (anchor_y - top) * sy;
+  state.engine.document = transform_elements_editor(state.drag_state.base_document, state.drag_state.resized_element_ids, (point) => [nl + (point[0] - left) * sx, nt + (point[1] - top) * sy]);
+}
+function apply_rotate_drag_editor(state) {
+  if (state.drag_state === null || state.drag_state.kind !== "rotate")
+    return;
+  const center = state.drag_state.center;
+  const current_angle = angle_to_center_editor(center, state.drag_state.current_world);
+  let delta = current_angle - state.drag_state.start_angle;
+  if (state.drag_state.snap_angle) {
+    const snap = Math.PI / 12;
+    delta = Math.round(delta / snap) * snap;
+  }
+  const sin_angle = Math.sin(delta);
+  const cos_angle = Math.cos(delta);
+  state.engine.document = transform_elements_editor(state.drag_state.base_document, state.drag_state.rotated_element_ids, (point) => {
+    const dx = point[0] - center[0];
+    const dy = point[1] - center[1];
+    return [
+      center[0] + dx * cos_angle - dy * sin_angle,
+      center[1] + dx * sin_angle + dy * cos_angle
+    ];
+  });
+}
+function expand_move_ids_for_frames_editor(elements, selected_ids) {
+  const out = new Set;
+  const selected_frames = [];
+  for (let i = 0;i < selected_ids.length; i = i + 1) {
+    const id = selected_ids[i];
+    if (id === undefined)
+      continue;
+    const element = elements.get(id);
+    if (element === undefined)
+      continue;
+    out.add(id);
+    if (element.type === element_type_shape && element.shape_type === shape_type_frame) {
+      selected_frames.push(element);
+    }
+  }
+  if (selected_frames.length === 0) {
+    return Array.from(out);
+  }
+  for (const element of elements.values()) {
+    if (out.has(element.id))
+      continue;
+    const cx = element.bounds[0] + element.bounds[2] / 2;
+    const cy = element.bounds[1] + element.bounds[3] / 2;
+    for (let i = 0;i < selected_frames.length; i = i + 1) {
+      const frame = selected_frames[i];
+      if (frame === undefined)
+        continue;
+      if (contains_point_in_bounds_editor(frame.bounds, cx, cy)) {
+        out.add(element.id);
+        break;
+      }
+    }
+  }
+  return Array.from(out);
+}
+function contains_point_in_bounds_editor(bounds, x, y) {
+  return x >= bounds[0] && x <= bounds[0] + bounds[2] && y >= bounds[1] && y <= bounds[1] + bounds[3];
+}
+
+// editor/textops.ts
+function move_caret_line_editor(state, direction2, extend) {
+  if (state.text_edit === null)
+    return false;
+  const element = get_element_by_id_document(state.engine.document, state.text_edit.element_id);
+  if (element === null || element.type !== element_type_text)
+    return false;
+  const previous_caret = state.text_edit.caret;
+  const caret = state.text_edit.caret;
+  const layout = build_text_layout_editor(element, state.text_edit.draft);
+  const line_index = line_index_for_caret_editor(layout, caret);
+  const desired_x = state.text_edit.preferred_column ?? line_caret_x_editor(element, layout, line_index, caret);
+  const target_line = Math.max(0, Math.min(layout.lines.length - 1, line_index + (direction2 < 0 ? -1 : 1)));
+  const target = nearest_caret_for_x_editor(element, layout, target_line, desired_x);
+  collapse_selection_if_needed_editor(state, direction2 < 0 ? "start" : "end", extend);
+  state.text_edit.caret = target;
+  update_anchor_editor(state, extend, previous_caret);
+  state.text_edit.preferred_column = desired_x;
+  return true;
+}
+function select_all_text_editor(state) {
+  if (state.text_edit === null)
+    return false;
+  state.text_edit.anchor = 0;
+  state.text_edit.caret = state.text_edit.draft.length;
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function delete_selection_text_editor(state) {
+  if (state.text_edit === null || state.text_edit.anchor === null)
+    return false;
+  const start = Math.min(state.text_edit.anchor, state.text_edit.caret);
+  const end = Math.max(state.text_edit.anchor, state.text_edit.caret);
+  if (start === end)
+    return false;
+  state.text_edit.draft = `${state.text_edit.draft.slice(0, start)}${state.text_edit.draft.slice(end)}`;
+  state.text_edit.caret = start;
+  state.text_edit.anchor = null;
+  return true;
+}
+function collapse_selection_if_needed_editor(state, edge, extend) {
+  if (state.text_edit === null || extend || state.text_edit.anchor === null)
+    return;
+  const start = Math.min(state.text_edit.anchor, state.text_edit.caret);
+  const end = Math.max(state.text_edit.anchor, state.text_edit.caret);
+  if (start === end) {
+    state.text_edit.anchor = null;
+    return;
+  }
+  state.text_edit.caret = edge === "start" ? start : end;
+  state.text_edit.anchor = null;
+}
+function update_anchor_editor(state, extend, previous_caret) {
+  if (state.text_edit === null)
+    return;
+  if (extend) {
+    if (state.text_edit.anchor === null)
+      state.text_edit.anchor = previous_caret;
+    return;
+  }
+  state.text_edit.anchor = null;
+}
+
+// editor/textedit.ts
+function begin_text_edit_editor(state, element_id, caret_from_world) {
+  const element = get_element_by_id_document(state.engine.document, element_id);
+  if (element === null || element.type !== element_type_text) {
+    return false;
+  }
+  const initial_caret = caret_from_world === undefined ? element.content.length : caret_index_from_point_editor(element, element.content, caret_from_world[0], caret_from_world[1]);
+  state.text_edit = {
+    element_id,
+    draft: element.content,
+    original: element.content,
+    caret: initial_caret,
+    anchor: null,
+    preferred_column: null
+  };
+  state.selected_element_ids.clear();
+  state.selected_element_ids.add(element_id);
+  return true;
+}
+function is_text_editing_editor(state) {
+  return state.text_edit !== null;
+}
+function commit_text_edit_editor(state) {
+  if (state.text_edit === null)
+    return false;
+  const editing = state.text_edit;
+  const element = get_element_by_id_document(state.engine.document, editing.element_id);
+  if (element === null || element.type !== element_type_text) {
+    state.text_edit = null;
+    return false;
+  }
+  if (editing.draft !== editing.original) {
+    begin_transaction_editor(state, "text_edit");
+    state.engine.document = update_element_document(state.engine.document, element.id, {
+      ...element,
+      content: editing.draft
+    });
+    commit_transaction_editor(state);
+  }
+  state.text_edit = null;
+  return true;
+}
+function cancel_text_edit_editor(state) {
+  if (state.text_edit === null)
+    return false;
+  state.text_edit = null;
+  return true;
+}
+function handle_text_key_editor(state, input) {
+  if (state.text_edit === null)
+    return false;
+  const key = input.key;
+  if (key === "Escape")
+    return cancel_text_edit_editor(state);
+  if (key === "Enter" && !!input.ctrl)
+    return commit_text_edit_editor(state);
+  if (key === "ArrowLeft")
+    return move_caret_editor(state, -1, !!input.shift);
+  if (key === "ArrowRight")
+    return move_caret_editor(state, 1, !!input.shift);
+  if (key === "ArrowUp")
+    return move_caret_line_editor(state, -1, !!input.shift);
+  if (key === "ArrowDown")
+    return move_caret_line_editor(state, 1, !!input.shift);
+  if (key === "Home")
+    return set_caret_editor(state, 0, !!input.shift);
+  if (key === "End")
+    return set_caret_editor(state, state.text_edit.draft.length, !!input.shift);
+  if ((key === "a" || key === "A") && (input.ctrl || input.meta))
+    return select_all_text_editor(state);
+  if (key === "Backspace")
+    return backspace_editor(state);
+  if (key === "Delete")
+    return delete_editor(state);
+  if (key === "Enter")
+    return insert_text_editor(state, `
+`);
+  if (key === "Tab")
+    return insert_text_editor(state, "\t");
+  if (!input.ctrl && !input.meta && !input.alt && key.length === 1) {
+    return insert_text_editor(state, key);
+  }
+  return true;
+}
+function move_caret_editor(state, delta, extend) {
+  if (state.text_edit === null)
+    return false;
+  const previous_caret = state.text_edit.caret;
+  collapse_selection_if_needed_editor(state, delta < 0 ? "start" : "end", extend);
+  const next = clamp_caret_editor(state.text_edit.caret + delta, state.text_edit.draft.length);
+  state.text_edit.caret = next;
+  update_anchor_editor(state, extend, previous_caret);
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function set_caret_editor(state, value, extend) {
+  if (state.text_edit === null)
+    return false;
+  const previous_caret = state.text_edit.caret;
+  collapse_selection_if_needed_editor(state, value <= state.text_edit.caret ? "start" : "end", extend);
+  state.text_edit.caret = clamp_caret_editor(value, state.text_edit.draft.length);
+  update_anchor_editor(state, extend, previous_caret);
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function backspace_editor(state) {
+  if (state.text_edit === null)
+    return false;
+  if (delete_selection_text_editor(state))
+    return true;
+  const caret = state.text_edit.caret;
+  if (caret <= 0)
+    return true;
+  const before = state.text_edit.draft.slice(0, caret - 1);
+  const after = state.text_edit.draft.slice(caret);
+  state.text_edit.draft = `${before}${after}`;
+  state.text_edit.caret = caret - 1;
+  state.text_edit.anchor = null;
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function delete_editor(state) {
+  if (state.text_edit === null)
+    return false;
+  if (delete_selection_text_editor(state))
+    return true;
+  const caret = state.text_edit.caret;
+  if (caret >= state.text_edit.draft.length)
+    return true;
+  const before = state.text_edit.draft.slice(0, caret);
+  const after = state.text_edit.draft.slice(caret + 1);
+  state.text_edit.draft = `${before}${after}`;
+  state.text_edit.anchor = null;
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function insert_text_editor(state, value) {
+  if (state.text_edit === null)
+    return false;
+  delete_selection_text_editor(state);
+  const caret = state.text_edit.caret;
+  const before = state.text_edit.draft.slice(0, caret);
+  const after = state.text_edit.draft.slice(caret);
+  state.text_edit.draft = `${before}${value}${after}`;
+  state.text_edit.caret = caret + value.length;
+  state.text_edit.anchor = null;
+  state.text_edit.preferred_column = null;
+  return true;
+}
+function clamp_caret_editor(value, length) {
+  return Math.max(0, Math.min(length, value));
+}
+
+// editor/tools/selectview.ts
+function handle_select_double_click_editor(state) {
+  const hit = element_hit_at_point_editor(state.engine.document, state.pointer_world[0], state.pointer_world[1]);
+  if (hit !== null && hit.type === element_type_text) {
+    begin_text_edit_editor(state, hit.id, [state.pointer_world[0], state.pointer_world[1]]);
+  }
+}
+function handle_select_pointer_up_reset_editor(state) {
+  state.drag_state = null;
+  state.marquee_state = null;
+  state.active_handle = null;
+  state.pointer_capture = false;
+}
+function cursor_select_editor(state) {
+  if (state.drag_state?.kind === "move")
+    return "grabbing";
+  if (state.drag_state?.kind === "pending_move")
+    return "grab";
+  if (state.drag_state?.kind === "resize")
+    return "nwse-resize";
+  if (state.drag_state?.kind === "rotate")
+    return "crosshair";
+  if (state.active_handle === "rotate")
+    return "crosshair";
+  if (state.active_handle === "start" || state.active_handle === "end")
+    return "crosshair";
+  if (["nw", "se"].includes(state.active_handle ?? ""))
+    return "nwse-resize";
+  if (["ne", "sw"].includes(state.active_handle ?? ""))
+    return "nesw-resize";
+  if (["n", "s"].includes(state.active_handle ?? ""))
+    return "ns-resize";
+  if (["e", "w"].includes(state.active_handle ?? ""))
+    return "ew-resize";
+  return "default";
+}
+
+// editor/tools/select.ts
+function create_select_tool_editor() {
+  return {
+    id: editor_tool_select,
+    name: "select",
+    pointer_down: (state, input) => {
+      const selected_ids = Array.from(state.selected_element_ids.values());
+      const selected_bounds = selection_bounds_editor(state.engine.document, selected_ids);
+      const handles = selection_handles_for_elements_editor(state.engine.document, selected_ids);
+      const handle_hit = hit_selection_handles_editor(handles, state.pointer_world);
+      if (handle_hit !== null) {
+        state.active_handle = handle_hit.id;
+        begin_transaction_editor(state, handle_hit.id === "rotate" ? "rotate" : "resize");
+        if (handle_hit.id === "rotate") {
+          const center = [
+            selected_bounds[0] + selected_bounds[2] / 2,
+            selected_bounds[1] + selected_bounds[3] / 2
+          ];
+          state.drag_state = {
+            kind: "rotate",
+            origin_world: [state.pointer_world[0], state.pointer_world[1]],
+            current_world: [state.pointer_world[0], state.pointer_world[1]],
+            base_document: clone_document(state.engine.document),
+            rotated_element_ids: selected_ids,
+            selection_bounds: [
+              selected_bounds[0],
+              selected_bounds[1],
+              selected_bounds[2],
+              selected_bounds[3]
+            ],
+            center,
+            start_angle: Math.atan2(state.pointer_world[1] - center[1], state.pointer_world[0] - center[0]),
+            snap_angle: false
+          };
+        } else {
+          state.drag_state = {
+            kind: "resize",
+            origin_world: [state.pointer_world[0], state.pointer_world[1]],
+            current_world: [state.pointer_world[0], state.pointer_world[1]],
+            base_document: clone_document(state.engine.document),
+            resized_element_ids: selected_ids,
+            selection_bounds: [
+              selected_bounds[0],
+              selected_bounds[1],
+              selected_bounds[2],
+              selected_bounds[3]
+            ],
+            handle: handle_hit.id,
+            keep_aspect: false,
+            centered: false
+          };
+        }
+        state.pointer_capture = true;
+        return;
+      }
+      const hit = element_hit_at_point_editor(state.engine.document, state.pointer_world[0], state.pointer_world[1]);
+      const is_shift = !!input.shift;
+      if (hit !== null) {
+        const hit_ids = grouped_ids_for_element_editor(state.engine.document, hit.id);
+        if (is_shift) {
+          const all_selected = hit_ids.every((id) => state.selected_element_ids.has(id));
+          for (let i = 0;i < hit_ids.length; i = i + 1) {
+            const id = hit_ids[i];
+            if (id === undefined)
+              continue;
+            if (all_selected)
+              state.selected_element_ids.delete(id);
+            else
+              state.selected_element_ids.add(id);
+          }
+        } else if (!state.selected_element_ids.has(hit.id) || state.selected_element_ids.size > hit_ids.length) {
+          state.selected_element_ids.clear();
+          for (let i = 0;i < hit_ids.length; i = i + 1) {
+            const id = hit_ids[i];
+            if (id !== undefined)
+              state.selected_element_ids.add(id);
+          }
+        }
+        const selected = expand_ids_with_groups_editor(state.engine.document, Array.from(state.selected_element_ids.values()));
+        if (selected.length > 0) {
+          state.drag_state = {
+            kind: "pending_move",
+            origin_world: [state.pointer_world[0], state.pointer_world[1]],
+            origin_screen: [state.pointer_screen[0], state.pointer_screen[1]],
+            selected_element_ids: selected
+          };
+          state.pointer_capture = true;
+        }
+        return;
+      }
+      if (!is_shift)
+        state.selected_element_ids.clear();
+      state.drag_state = {
+        kind: "pending_marquee",
+        origin_world: [state.pointer_world[0], state.pointer_world[1]],
+        origin_screen: [state.pointer_screen[0], state.pointer_screen[1]],
+        add_mode: is_shift
+      };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state, input) => {
+      if (state.drag_state === null)
+        return update_select_hover_editor(state);
+      if (state.drag_state.kind === "pending_move") {
+        const should_start = exceeds_drag_threshold_editor(state.drag_state.origin_screen, state.pointer_screen);
+        if (!should_start) {
+          return;
+        }
+        begin_transaction_editor(state, "move");
+        start_move_editor(state, state.drag_state.selected_element_ids);
+      }
+      if (state.drag_state.kind === "pending_marquee") {
+        const should_start = exceeds_drag_threshold_editor(state.drag_state.origin_screen, state.pointer_screen);
+        if (!should_start) {
+          return;
+        }
+        const marquee_state = {
+          kind: "marquee",
+          origin_world: [state.drag_state.origin_world[0], state.drag_state.origin_world[1]],
+          current_world: [state.pointer_world[0], state.pointer_world[1]],
+          add_mode: state.drag_state.add_mode
+        };
+        state.drag_state = marquee_state;
+        state.marquee_state = marquee_state;
+      }
+      if (state.drag_state.kind === "move") {
+        const raw = [state.pointer_world[0], state.pointer_world[1]];
+        const dx = raw[0] - state.drag_state.origin_world[0];
+        const dy = raw[1] - state.drag_state.origin_world[1];
+        const b = state.drag_state.selection_bounds;
+        state.drag_state.current_world = snap_point_editor(state, raw, "move", {
+          subject_bounds: [b[0] + dx, b[1] + dy, b[2], b[3]]
+        });
+        return apply_move_drag_editor(state);
+      }
+      if (state.drag_state.kind === "resize") {
+        state.drag_state.current_world = snap_point_editor(state, [state.pointer_world[0], state.pointer_world[1]], "resize");
+        state.drag_state.keep_aspect = !!input.shift;
+        state.drag_state.centered = !!input.alt;
+        return apply_resize_drag_editor(state);
+      }
+      if (state.drag_state.kind === "rotate") {
+        state.drag_state.current_world = [state.pointer_world[0], state.pointer_world[1]];
+        state.drag_state.snap_angle = !!input.shift;
+        return apply_rotate_drag_editor(state);
+      }
+      if (state.drag_state.kind === "marquee") {
+        state.drag_state.current_world = [state.pointer_world[0], state.pointer_world[1]];
+        state.marquee_state = state.drag_state;
+      }
+    },
+    pointer_up: (state) => {
+      if (state.drag_state !== null && (state.drag_state.kind === "pending_move" || state.drag_state.kind === "pending_marquee")) {
+        handle_select_pointer_up_reset_editor(state);
+        return;
+      }
+      if (state.drag_state !== null && state.drag_state.kind !== "marquee")
+        commit_transaction_editor(state);
+      if (state.drag_state !== null && state.drag_state.kind === "marquee") {
+        apply_marquee_selection_editor(state, state.drag_state);
+      }
+      handle_select_pointer_up_reset_editor(state);
+    },
+    double_click: (state) => handle_select_double_click_editor(state),
+    key_down: () => {},
+    cancel: (state) => {
+      if (state.drag_state !== null && (state.drag_state.kind === "move" || state.drag_state.kind === "resize" || state.drag_state.kind === "rotate"))
+        cancel_transaction_editor(state);
+      state.drag_state = null;
+      state.marquee_state = null;
+      state.active_handle = null;
+      state.pointer_capture = false;
+    },
+    hover: (state) => update_select_hover_editor(state),
+    cursor: (state) => cursor_select_editor(state),
+    overlay: () => {}
+  };
+}
+
+// editor/tools/shape.ts
+function create_shape_tool_editor(tool) {
+  return {
+    id: tool,
+    name: shape_name_for_tool_editor(tool),
+    pointer_down: (state) => {
+      begin_transaction_editor(state, shape_name_for_tool_editor(tool));
+      const element_id = next_id_editor(state, "shape");
+      const shape_type = shape_type_for_tool_editor(tool);
+      const start = [state.pointer_world[0], state.pointer_world[1]];
+      const is_box = shape_type === shape_type_rectangle || shape_type === shape_type_ellipse || shape_type === shape_type_frame;
+      const fill = shape_type === shape_type_frame ? null : default_shape_fill;
+      const shape = create_shape_element(element_id, [start[0], start[1], 1, 1], next_z_index_editor(state.engine.document), state.engine.document.active_layer_id, shape_type, fill, default_shape_stroke, 1.5, is_box ? null : start, is_box ? null : start);
+      state.engine.document = add_element_document(state.engine.document, shape);
+      state.selected_element_ids.clear();
+      state.selected_element_ids.add(element_id);
+      state.drag_state = {
+        kind: "shape",
+        origin_world: [start[0], start[1]],
+        current_world: [start[0], start[1]],
+        element_id,
+        shape_tool: tool
+      };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state, input) => {
+      if (state.drag_state === null || state.drag_state.kind !== "shape")
+        return;
+      state.drag_state.current_world = snap_point_editor(state, [state.pointer_world[0], state.pointer_world[1]], "shape");
+      update_shape_preview_editor(state, state.drag_state, !!input.shift);
+    },
+    pointer_up: (state) => {
+      if (state.drag_state?.kind === "shape")
+        commit_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    double_click: () => {},
+    key_down: () => {},
+    cancel: (state) => {
+      cancel_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    hover: () => {},
+    cursor: () => "crosshair",
+    overlay: () => {}
+  };
+}
+
+// editor/tools/text.ts
+function create_text_tool_editor() {
+  return {
+    id: editor_tool_text,
+    name: "text",
+    pointer_down: (state) => {
+      begin_transaction_editor(state, "text");
+      const element_id = next_id_editor(state, "text");
+      const x = state.pointer_world[0];
+      const y = state.pointer_world[1];
+      const text = create_text_element(element_id, [x, y, 220, 40], next_z_index_editor(state.engine.document), state.engine.document.active_layer_id, "Text", "sans-serif", 18, default_text_color, 0);
+      state.engine.document = add_element_document(state.engine.document, text);
+      state.selected_element_ids.clear();
+      state.selected_element_ids.add(element_id);
+      state.drag_state = { kind: "text", origin_world: [x, y], current_world: [x, y], element_id };
+      state.pointer_capture = true;
+    },
+    pointer_move: (state) => {
+      if (state.drag_state === null || state.drag_state.kind !== "text")
+        return;
+      state.drag_state.current_world = snap_point_editor(state, [state.pointer_world[0], state.pointer_world[1]], "text");
+      update_box_resize_editor(state, state.drag_state.element_id, state.drag_state.origin_world, state.drag_state.current_world);
+    },
+    pointer_up: (state) => {
+      if (state.drag_state?.kind === "text") {
+        const element_id = state.drag_state.element_id;
+        commit_transaction_editor(state);
+        begin_text_edit_editor(state, element_id);
+      }
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    double_click: () => {},
+    key_down: () => {},
+    cancel: (state) => {
+      cancel_transaction_editor(state);
+      state.drag_state = null;
+      state.pointer_capture = false;
+    },
+    hover: () => {},
+    cursor: () => "text",
+    overlay: () => {}
+  };
+}
+
+// editor/registry.ts
+function create_tool_registry_editor() {
+  const tools = new Map;
+  register_tool_in_map_editor(tools, create_select_tool_editor());
+  register_tool_in_map_editor(tools, create_hand_tool_editor());
+  register_tool_in_map_editor(tools, create_draw_tool_editor());
+  register_tool_in_map_editor(tools, create_shape_tool_editor(editor_tool_rectangle));
+  register_tool_in_map_editor(tools, create_shape_tool_editor(editor_tool_ellipse));
+  register_tool_in_map_editor(tools, create_shape_tool_editor(editor_tool_line));
+  register_tool_in_map_editor(tools, create_shape_tool_editor(editor_tool_arrow));
+  register_tool_in_map_editor(tools, create_shape_tool_editor(editor_tool_frame));
+  register_tool_in_map_editor(tools, create_text_tool_editor());
+  register_tool_in_map_editor(tools, create_image_tool_editor());
+  return tools;
+}
+function register_tool_editor(state, tool) {
+  register_tool_in_map_editor(state.tools, tool);
+}
+function install_plugin_editor(state, plugin) {
+  const ids = [];
+  for (let i = 0;i < plugin.tools.length; i = i + 1) {
+    const tool = plugin.tools[i];
+    if (tool === undefined)
+      continue;
+    register_tool_in_map_editor(state.tools, tool);
+    ids.push(tool.id);
+  }
+  state.plugin_tools.set(plugin.id, ids);
+}
+function uninstall_plugin_editor(state, plugin_id) {
+  const ids = state.plugin_tools.get(plugin_id);
+  if (ids === undefined)
+    return;
+  for (let i = 0;i < ids.length; i = i + 1) {
+    const id = ids[i];
+    if (id !== undefined)
+      state.tools.delete(id);
+  }
+  state.plugin_tools.delete(plugin_id);
+}
+function register_tool_in_map_editor(tools, tool) {
+  tools.set(tool.id, tool);
+}
+
+// editor/create.ts
+function create_editor(state, options = {}) {
+  const editor_state = {
+    engine: state,
+    current_tool: options.initial_tool ?? editor_tool_select,
+    previous_tool_before_hand: null,
+    selected_element_ids: new Set,
+    hovered_element_id: null,
+    active_handle: null,
+    pointer_capture: false,
+    drag_state: null,
+    marquee_state: null,
+    clipboard_payload: null,
+    active_transaction: null,
+    undo_stack: [],
+    redo_stack: [],
+    transient_guides: [],
+    pointer_world: [0, 0],
+    pointer_screen: [0, 0],
+    has_pointer_input: false,
+    text_edit: null,
+    snappers: options.snappers ?? [create_element_smart_snapper_editor()],
+    tools: create_tool_registry_editor(),
+    plugin_tools: new Map,
+    id_counter: 0
+  };
+  const plugins = options.plugins ?? [];
+  for (let i = 0;i < plugins.length; i = i + 1) {
+    const plugin = plugins[i];
+    if (plugin !== undefined)
+      install_plugin_editor(editor_state, plugin);
+  }
+  return editor_state;
+}
+function render_editor(state) {
+  render_engine_with_overlay(state.engine, (drawer) => {
+    draw_editor_overlay(state, drawer);
+    current_tool_impl_editor(state).overlay(state, drawer);
+  });
+}
+function set_tool_editor(state, tool) {
+  if (!state.tools.has(tool) || state.current_tool === tool)
+    return;
+  cancel_editor(state);
+  state.current_tool = tool;
+}
+function register_editor_tool_editor(state, tool) {
+  register_tool_editor(state, tool);
+}
+function install_editor_plugin_editor(state, plugin) {
+  install_plugin_editor(state, plugin);
+}
+function uninstall_editor_plugin_editor(state, plugin_id) {
+  uninstall_plugin_editor(state, plugin_id);
+}
+function cursor_editor(state) {
+  return current_tool_impl_editor(state).cursor(state);
+}
+function pointer_down_editor(state, input) {
+  update_pointer_editor(state, input);
+  if (is_text_editing_editor(state)) {
+    commit_text_edit_editor(state);
+  }
+  current_tool_impl_editor(state).pointer_down(state, input);
+}
+function pointer_move_editor(state, input) {
+  update_pointer_editor(state, input);
+  current_tool_impl_editor(state).pointer_move(state, input);
+}
+function pointer_up_editor(state, input) {
+  update_pointer_editor(state, input);
+  current_tool_impl_editor(state).pointer_up(state, input);
+  state.transient_guides = [];
+}
+function hover_editor(state, input) {
+  update_pointer_editor(state, input);
+  current_tool_impl_editor(state).hover(state, input);
+}
+function double_click_editor(state, input) {
+  update_pointer_editor(state, input);
+  current_tool_impl_editor(state).double_click(state, input);
+}
+function key_down_editor(state, input) {
+  if (handle_text_key_editor(state, input))
+    return;
+  if (is_text_editing_editor(state))
+    return;
+  if (!handle_global_key_editor(state, input))
+    current_tool_impl_editor(state).key_down(state, input);
+}
+function key_up_editor(state, input) {
+  if (normalize_key_editor(input.key) === " " && state.previous_tool_before_hand !== null) {
+    state.current_tool = state.previous_tool_before_hand;
+    state.previous_tool_before_hand = null;
+  }
+}
+function cancel_editor(state) {
+  if (cancel_text_edit_editor(state))
+    return;
+  current_tool_impl_editor(state).cancel(state);
+}