@pixerate/editor 0.19.0 → 0.20.0

package/dist/canvas/index.js

@@ -719,12 +719,1198 @@ var StreamingLayoutManager = class {
     }
   }
 };
+
+// src/canvas/arrange.ts
+var LOCKED_DATA_KEY = "locked";
+var LOCKED_PREVIOUS_FLAGS_KEY = "lockedPrevious";
+function parsePx(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const match = /^\s*(-?\d+(?:\.\d+)?)(px)?\s*$/i.exec(value);
+    if (match) return Number(match[1]);
+  }
+  return void 0;
+}
+function readStyleSize(style) {
+  if (!style) return {};
+  if (typeof style === "object") {
+    return { width: parsePx(style.width), height: parsePx(style.height) };
+  }
+  const read = (prop) => {
+    const match = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i").exec(style);
+    return match ? parsePx(match[1]) : void 0;
+  };
+  return { width: read("width"), height: read("height") };
+}
+function withStyleSize(style, size) {
+  if (!style) return style ?? void 0;
+  if (typeof style === "object") {
+    const next2 = { ...style };
+    if (size.width !== void 0 && "width" in next2) next2.width = size.width;
+    if (size.height !== void 0 && "height" in next2) next2.height = size.height;
+    return next2;
+  }
+  let next = style;
+  for (const prop of ["width", "height"]) {
+    const value = size[prop];
+    if (value === void 0) continue;
+    next = next.replace(
+      new RegExp(`((?:^|;)\\s*${prop}\\s*:\\s*)[^;]+`, "i"),
+      `$1${value}px`
+    );
+  }
+  return next;
+}
+function getNodeSize(node, options = {}) {
+  const styleSize = readStyleSize(node.style);
+  let width = node.measured?.width ?? node.width ?? styleSize.width;
+  let height = node.measured?.height ?? node.height ?? styleSize.height;
+  if (width === void 0 || height === void 0) {
+    const fallback = options.estimate === false ? { width: options.defaultWidth ?? 200, height: options.defaultHeight ?? 60 } : estimateNodeSize(node, options.defaultWidth, options.defaultHeight);
+    width ??= fallback.width;
+    height ??= fallback.height;
+  }
+  return { width, height };
+}
+function getAbsolutePosition(node, lookup) {
+  let x = node.position.x;
+  let y = node.position.y;
+  const seen = /* @__PURE__ */ new Set([node.id]);
+  let parentId = node.parentId;
+  while (parentId && !seen.has(parentId)) {
+    const parent = lookup.get(parentId);
+    if (!parent) break;
+    seen.add(parentId);
+    x += parent.position.x;
+    y += parent.position.y;
+    parentId = parent.parentId;
+  }
+  return { x, y };
+}
+function createNodeLookup(nodes) {
+  return new Map(nodes.map((n) => [n.id, n]));
+}
+function getNodeRect(node, lookup, options) {
+  const { x, y } = node.parentId && lookup ? getAbsolutePosition(node, lookup) : node.position;
+  return { x, y, ...getNodeSize(node, options) };
+}
+function isLocked(node) {
+  return node?.data?.[LOCKED_DATA_KEY] === true;
+}
+function lockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  return nodes.map((node) => {
+    if (!idSet.has(node.id) || isLocked(node)) return node;
+    const previous = {};
+    if (node.draggable !== void 0) previous.draggable = node.draggable;
+    if (node.deletable !== void 0) previous.deletable = node.deletable;
+    return {
+      ...node,
+      draggable: false,
+      deletable: false,
+      data: { ...node.data, [LOCKED_DATA_KEY]: true, [LOCKED_PREVIOUS_FLAGS_KEY]: previous }
+    };
+  });
+}
+function unlockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  return nodes.map((node) => {
+    if (!idSet.has(node.id) || !isLocked(node)) return node;
+    const {
+      [LOCKED_DATA_KEY]: _locked,
+      [LOCKED_PREVIOUS_FLAGS_KEY]: previous = {},
+      ...data
+    } = node.data;
+    const next = { ...node, data };
+    delete next.draggable;
+    delete next.deletable;
+    if (previous.draggable !== void 0) next.draggable = previous.draggable;
+    if (previous.deletable !== void 0) next.deletable = previous.deletable;
+    return next;
+  });
+}
+function toggleLockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  const anyUnlocked = nodes.some((n) => idSet.has(n.id) && !isLocked(n));
+  return anyUnlocked ? lockNodes(nodes, idSet) : unlockNodes(nodes, idSet);
+}
+function collect(nodes, ids, options) {
+  const lookup = createNodeLookup(nodes);
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const node = lookup.get(id);
+    if (!node || seen.has(id)) continue;
+    seen.add(id);
+    items.push({ node, rect: getNodeRect(node, lookup, options), locked: isLocked(node) });
+  }
+  return { lookup, items };
+}
+function toPositionUpdates(lookup, targets) {
+  const updates = [];
+  for (const [id, abs] of targets) {
+    const node = lookup.get(id);
+    let position = abs;
+    if (node.parentId && lookup.has(node.parentId)) {
+      const parent = lookup.get(node.parentId);
+      const parentAbs = targets.get(parent.id) ?? getAbsolutePosition(parent, lookup);
+      position = { x: abs.x - parentAbs.x, y: abs.y - parentAbs.y };
+    }
+    if (position.x !== node.position.x || position.y !== node.position.y) {
+      updates.push({ id, position });
+    }
+  }
+  return updates;
+}
+function alignNodes(nodes, ids, edge, options = {}) {
+  const { lookup, items } = collect(nodes, ids, options);
+  const fixed = typeof options.to === "object" ? options.to : null;
+  if (items.length === 0 || !fixed && items.length < 2) return [];
+  const bounds = fixed ?? boundsOf(items.map((i) => i.rect));
+  const targets = /* @__PURE__ */ new Map();
+  for (const { node, rect, locked } of items) {
+    if (locked) continue;
+    let { x, y } = rect;
+    switch (edge) {
+      case "left":
+        x = bounds.x;
+        break;
+      case "center":
+        x = bounds.x + bounds.width / 2 - rect.width / 2;
+        break;
+      case "right":
+        x = bounds.x + bounds.width - rect.width;
+        break;
+      case "top":
+        y = bounds.y;
+        break;
+      case "middle":
+        y = bounds.y + bounds.height / 2 - rect.height / 2;
+        break;
+      case "bottom":
+        y = bounds.y + bounds.height - rect.height;
+        break;
+    }
+    targets.set(node.id, { x, y });
+  }
+  return toPositionUpdates(lookup, targets);
+}
+function distributeAxis(items, horizontal, mode, gapOverride, targets) {
+  const start = (r) => horizontal ? r.x : r.y;
+  const size = (r) => horizontal ? r.width : r.height;
+  const sorted = [...items].sort(
+    (a, b) => start(a.rect) + size(a.rect) / 2 - (start(b.rect) + size(b.rect) / 2)
+  );
+  const first = sorted[0].rect;
+  const last = sorted[sorted.length - 1].rect;
+  const n = sorted.length;
+  const set = (item, value) => {
+    if (item.locked) return;
+    const current = targets.get(item.node.id) ?? { x: item.rect.x, y: item.rect.y };
+    targets.set(item.node.id, horizontal ? { ...current, x: value } : { ...current, y: value });
+  };
+  if (mode === "centres") {
+    const c0 = start(first) + size(first) / 2;
+    const c1 = start(last) + size(last) / 2;
+    const step = (c1 - c0) / (n - 1);
+    sorted.forEach((item, i) => set(item, c0 + step * i - size(item.rect) / 2));
+    return;
+  }
+  const span = start(last) + size(last) - start(first);
+  const total = sorted.reduce((sum, item) => sum + size(item.rect), 0);
+  const gap = gapOverride ?? (span - total) / (n - 1);
+  let cursor = start(first);
+  for (const item of sorted) {
+    set(item, cursor);
+    cursor += size(item.rect) + gap;
+  }
+}
+function distributeNodes(nodes, ids, axis, mode = "gaps", options = {}) {
+  const { lookup, items } = collect(nodes, ids, options);
+  const minimum = options.gap !== void 0 && mode === "gaps" ? 2 : 3;
+  if (items.length < minimum) return [];
+  const targets = /* @__PURE__ */ new Map();
+  if (axis !== "vertical") distributeAxis(items, true, mode, options.gap, targets);
+  if (axis !== "horizontal") distributeAxis(items, false, mode, options.gap, targets);
+  return toPositionUpdates(lookup, targets);
+}
+function matchSize(nodes, ids, dimension, options = {}) {
+  const { items } = collect(nodes, ids, options);
+  if (items.length < 2) return [];
+  const reference = options.reference ?? "largest";
+  const pick = (dim) => {
+    if (typeof reference === "object") {
+      const item = items.find((i) => i.node.id === reference.id);
+      if (item) return item.rect[dim];
+    }
+    if (reference === "first") return items[0].rect[dim];
+    const values = items.map((i) => i.rect[dim]);
+    return reference === "smallest" ? Math.min(...values) : Math.max(...values);
+  };
+  const width = dimension !== "height" ? pick("width") : void 0;
+  const height = dimension !== "width" ? pick("height") : void 0;
+  const updates = [];
+  for (const { node, rect, locked } of items) {
+    if (locked) continue;
+    const update = { id: node.id };
+    if (width !== void 0 && width !== rect.width) update.width = width;
+    if (height !== void 0 && height !== rect.height) update.height = height;
+    if (update.width === void 0 && update.height === void 0) continue;
+    if (options.keepCentre) {
+      update.position = {
+        x: node.position.x - ((update.width ?? rect.width) - rect.width) / 2,
+        y: node.position.y - ((update.height ?? rect.height) - rect.height) / 2
+      };
+    }
+    updates.push(update);
+  }
+  return updates;
+}
+function reorderNodes(nodes, ids, operation, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const targetIds = new Set(
+    [...ids].filter((id) => lookup.has(id) && !isLocked(lookup.get(id)))
+  );
+  if (targetIds.size === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const key = node.parentId ?? "";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(node);
+  }
+  const updates = [];
+  for (const siblings of groups.values()) {
+    if (!siblings.some((n) => targetIds.has(n.id))) continue;
+    const order = siblings.map((node, index) => ({ node, index, z: typeof node.zIndex === "number" ? node.zIndex : 0 })).sort((a, b) => a.z - b.z || a.index - b.index).map((entry) => entry.node);
+    const isTarget = (n) => targetIds.has(n.id);
+    let next;
+    if (operation === "bringToFront") {
+      next = [...order.filter((n) => !isTarget(n)), ...order.filter(isTarget)];
+    } else if (operation === "sendToBack") {
+      next = [...order.filter(isTarget), ...order.filter((n) => !isTarget(n))];
+    } else {
+      next = [...order];
+      const forward = operation === "bringForward";
+      const rects = new Map(next.map((n) => [n.id, getNodeRect(n, lookup, options)]));
+      const intersects = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+      const indices = next.map((_, i) => i);
+      if (forward) indices.reverse();
+      for (const i of indices) {
+        const node = next[i];
+        if (!isTarget(node)) continue;
+        const step = forward ? 1 : -1;
+        let j = i + step;
+        let swapWith = -1;
+        let firstNonTarget = -1;
+        while (j >= 0 && j < next.length) {
+          if (!isTarget(next[j])) {
+            if (firstNonTarget === -1) firstNonTarget = j;
+            if (intersects(rects.get(node.id), rects.get(next[j].id))) {
+              swapWith = j;
+              break;
+            }
+          }
+          j += step;
+        }
+        if (swapWith === -1) swapWith = firstNonTarget;
+        if (swapWith === -1) continue;
+        next.splice(i, 1);
+        next.splice(swapWith, 0, node);
+      }
+    }
+    if (next.every((node, i) => node === order[i])) continue;
+    next.forEach((node, rank) => {
+      const current = typeof node.zIndex === "number" ? node.zIndex : 0;
+      if (current !== rank) updates.push({ id: node.id, zIndex: rank });
+    });
+  }
+  return updates;
+}
+function applyNodeUpdates(nodes, updates) {
+  if (updates.length === 0) return nodes;
+  const byId = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    byId.set(update.id, { ...byId.get(update.id), ...update });
+  }
+  return nodes.map((node) => {
+    const update = byId.get(node.id);
+    if (!update) return node;
+    const next = { ...node };
+    if (update.position) next.position = { ...update.position };
+    if (update.zIndex !== void 0) next.zIndex = update.zIndex;
+    if (update.width !== void 0 || update.height !== void 0) {
+      if (update.width !== void 0) next.width = update.width;
+      if (update.height !== void 0) next.height = update.height;
+      if (node.style) next.style = withStyleSize(node.style, update);
+      if (node.measured) {
+        next.measured = {
+          ...node.measured,
+          ...update.width !== void 0 ? { width: update.width } : {},
+          ...update.height !== void 0 ? { height: update.height } : {}
+        };
+      }
+    }
+    return next;
+  });
+}
+function invertNodeUpdates(nodes, updates) {
+  const lookup = createNodeLookup(nodes);
+  const inverse = [];
+  for (const update of updates) {
+    const node = lookup.get(update.id);
+    if (!node) continue;
+    const back = { id: node.id };
+    if (update.position) back.position = { ...node.position };
+    if (update.zIndex !== void 0) back.zIndex = typeof node.zIndex === "number" ? node.zIndex : 0;
+    if (update.width !== void 0 || update.height !== void 0) {
+      const size = getNodeSize(node);
+      if (update.width !== void 0) back.width = size.width;
+      if (update.height !== void 0) back.height = size.height;
+    }
+    inverse.push(back);
+  }
+  return inverse;
+}
+
+// src/canvas/guides.ts
+function buildAxis(entries) {
+  entries.sort((a, b) => a.value - b.value);
+  return {
+    values: Float64Array.from(entries.map((e) => e.value)),
+    rects: entries.map((e) => e.rect)
+  };
+}
+function lowerBound(values, v) {
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (values[mid] < v) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function createGuideIndex(rects) {
+  const edgeX = [];
+  const centreX = [];
+  const edgeY = [];
+  const centreY = [];
+  for (const rect of rects) {
+    edgeX.push({ value: rect.x, rect }, { value: rect.x + rect.width, rect });
+    centreX.push({ value: rect.x + rect.width / 2, rect });
+    edgeY.push({ value: rect.y, rect }, { value: rect.y + rect.height, rect });
+    centreY.push({ value: rect.y + rect.height / 2, rect });
+  }
+  return {
+    rects,
+    edgeX: buildAxis(edgeX),
+    centreX: buildAxis(centreX),
+    edgeY: buildAxis(edgeY),
+    centreY: buildAxis(centreY)
+  };
+}
+function nearest(axis, v, tolerance) {
+  const { values } = axis;
+  let best = null;
+  for (let i = lowerBound(values, v - tolerance); i < values.length && values[i] <= v + tolerance; i++) {
+    const delta = values[i] - v;
+    if (best === null || Math.abs(delta) < Math.abs(best)) best = delta;
+  }
+  return best;
+}
+function matches(axis, v, eps) {
+  const { values, rects } = axis;
+  const out = [];
+  for (let i = lowerBound(values, v - eps); i < values.length && values[i] <= v + eps; i++) {
+    out.push(rects[i]);
+  }
+  return out;
+}
+function spacingCandidate(rects, moving, horizontal, tolerance) {
+  const start = (r) => horizontal ? r.x : r.y;
+  const end = (r) => horizontal ? r.x + r.width : r.y + r.height;
+  const crossStart = (r) => horizontal ? r.y : r.x;
+  const crossEnd = (r) => horizontal ? r.y + r.height : r.x + r.width;
+  const size = end(moving) - start(moving);
+  const inLane = (r, lane2) => crossStart(r) < crossEnd(lane2) && crossEnd(r) > crossStart(lane2);
+  const lane = rects.filter((r) => inLane(r, moving));
+  if (lane.length === 0) return null;
+  let before = null;
+  let after = null;
+  for (const r of lane) {
+    if (end(r) <= start(moving) + tolerance && (!before || end(r) > end(before))) before = r;
+    if (start(r) >= end(moving) - tolerance && (!after || start(r) < start(after))) after = r;
+  }
+  const neighbourOf = (r, forward) => {
+    let best2 = null;
+    for (const other of lane) {
+      if (other === r || !inLane(other, r)) continue;
+      if (forward ? start(other) >= end(r) : end(other) <= start(r)) {
+        if (!best2 || (forward ? start(other) < start(best2) : end(other) > end(best2))) best2 = other;
+      }
+    }
+    return best2;
+  };
+  const crossMid = (a, b) => (Math.max(crossStart(a), crossStart(b)) + Math.min(crossEnd(a), crossEnd(b))) / 2;
+  const segment = (from, to, cross) => horizontal ? { orientation: "horizontal", kind: "spacing", x1: from, y1: cross, x2: to, y2: cross } : { orientation: "vertical", kind: "spacing", x1: cross, y1: from, x2: cross, y2: to };
+  const candidates = [];
+  if (before && after) {
+    const b = before;
+    const a = after;
+    const pos = (end(b) + start(a) - size) / 2;
+    if (pos >= end(b)) {
+      candidates.push({
+        pos,
+        guides: (p) => [
+          segment(end(b), p, crossMid(b, moving)),
+          segment(p + size, start(a), crossMid(a, moving))
+        ]
+      });
+    }
+  }
+  if (before) {
+    const b = before;
+    const prev = neighbourOf(b, false);
+    if (prev) {
+      const gap = start(b) - end(prev);
+      candidates.push({
+        pos: end(b) + gap,
+        guides: (p) => [segment(end(prev), start(b), crossMid(prev, b)), segment(end(b), p, crossMid(b, moving))]
+      });
+    }
+  }
+  if (after) {
+    const a = after;
+    const next = neighbourOf(a, true);
+    if (next) {
+      const gap = start(next) - end(a);
+      candidates.push({
+        pos: start(a) - gap - size,
+        guides: (p) => [segment(p + size, start(a), crossMid(a, moving)), segment(end(a), start(next), crossMid(a, next))]
+      });
+    }
+  }
+  let best = null;
+  for (const c of candidates) {
+    const delta = c.pos - start(moving);
+    if (Math.abs(delta) <= tolerance && (!best || Math.abs(delta) < Math.abs(best.delta))) {
+      best = { delta, guides: c.guides(c.pos) };
+    }
+  }
+  return best;
+}
+function computeSnapGuides(moving, targets, options = {}) {
+  const index = Array.isArray(targets) ? createGuideIndex(targets) : targets;
+  const zoom = options.zoom && options.zoom > 0 ? options.zoom : 1;
+  const tolerance = (options.threshold ?? 6) / zoom;
+  const useEdges = options.edges !== false;
+  const useCentres = options.centres !== false;
+  const useSpacing = options.spacing !== false;
+  const eps = 0.5 / zoom;
+  const snapAxis = (horizontal) => {
+    const start = horizontal ? moving.x : moving.y;
+    const size = horizontal ? moving.width : moving.height;
+    const edgeAxis = horizontal ? index.edgeX : index.edgeY;
+    const centreAxis = horizontal ? index.centreX : index.centreY;
+    let delta = null;
+    const consider = (d) => {
+      if (d !== null && (delta === null || Math.abs(d) < Math.abs(delta))) delta = d;
+    };
+    if (useEdges) {
+      consider(nearest(edgeAxis, start, tolerance));
+      consider(nearest(edgeAxis, start + size, tolerance));
+    }
+    if (useCentres) consider(nearest(centreAxis, start + size / 2, tolerance));
+    const spacing = useSpacing ? spacingCandidate(index.rects, moving, horizontal, tolerance) : null;
+    if (spacing && (delta === null || Math.abs(spacing.delta) < Math.abs(delta) - eps)) {
+      return { delta: spacing.delta, spacing };
+    }
+    return { delta, spacing: null };
+  };
+  const sx = snapAxis(true);
+  const sy = snapAxis(false);
+  const dx = sx.delta ?? 0;
+  const dy = sy.delta ?? 0;
+  const snapped = { x: moving.x + dx, y: moving.y + dy, width: moving.width, height: moving.height };
+  const guides = [];
+  const alignmentGuides = (horizontal) => {
+    const start = horizontal ? snapped.x : snapped.y;
+    const size = horizontal ? snapped.width : snapped.height;
+    const lines = [];
+    if (useEdges) {
+      const axis = horizontal ? index.edgeX : index.edgeY;
+      lines.push({ value: start, kind: "edge", axis }, { value: start + size, kind: "edge", axis });
+    }
+    if (useCentres) {
+      lines.push({ value: start + size / 2, kind: "centre", axis: horizontal ? index.centreX : index.centreY });
+    }
+    for (const line of lines) {
+      const aligned = matches(line.axis, line.value, eps);
+      if (aligned.length === 0) continue;
+      const span = boundsOf([snapped, ...aligned]);
+      guides.push(
+        horizontal ? { orientation: "vertical", kind: line.kind, x1: line.value, y1: span.y, x2: line.value, y2: span.y + span.height } : { orientation: "horizontal", kind: line.kind, x1: span.x, y1: line.value, x2: span.x + span.width, y2: line.value }
+      );
+    }
+  };
+  if (sx.delta !== null) {
+    if (sx.spacing) guides.push(...shiftGuides(sx.spacing.guides, 0, dy));
+    else alignmentGuides(true);
+  }
+  if (sy.delta !== null) {
+    if (sy.spacing) guides.push(...shiftGuides(sy.spacing.guides, dx, 0));
+    else alignmentGuides(false);
+  }
+  return {
+    position: { x: snapped.x, y: snapped.y },
+    offset: { x: dx, y: dy },
+    guides,
+    snappedX: sx.delta !== null,
+    snappedY: sy.delta !== null
+  };
+}
+function shiftGuides(guides, dx, dy) {
+  return guides.map(
+    (g) => g.orientation === "horizontal" ? { ...g, y1: g.y1 + dy, y2: g.y2 + dy } : { ...g, x1: g.x1 + dx, x2: g.x2 + dx }
+  );
+}
+function collectDescendantIds(nodes, ids) {
+  const result = new Set(ids);
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const node of nodes) {
+      if (node.parentId && result.has(node.parentId) && !result.has(node.id)) {
+        result.add(node.id);
+        grew = true;
+      }
+    }
+  }
+  return result;
+}
+function createNodeGuideIndex(nodes, draggingIds, options = {}) {
+  const exclude = collectDescendantIds(nodes, draggingIds);
+  const lookup = createNodeLookup(nodes);
+  const rects = [];
+  for (const node of nodes) {
+    if (exclude.has(node.id) || node.hidden === true) continue;
+    if (options.filter && !options.filter(node)) continue;
+    rects.push(getNodeRect(node, lookup, options));
+  }
+  return createGuideIndex(rects);
+}
+function snapNodeDrag(nodes, draggingIds, options = {}) {
+  const ids = new Set(draggingIds);
+  const lookup = createNodeLookup(nodes);
+  const dragged = [...ids].map((id) => lookup.get(id)).filter((n) => !!n);
+  const empty = {
+    position: { x: 0, y: 0 },
+    offset: { x: 0, y: 0 },
+    guides: [],
+    snappedX: false,
+    snappedY: false,
+    updates: []
+  };
+  if (dragged.length === 0) return empty;
+  const bounds = boundsOf(dragged.map((n) => getNodeRect(n, lookup, options)));
+  const index = options.index ?? createNodeGuideIndex(nodes, ids, options);
+  const result = computeSnapGuides(bounds, index, options);
+  const { x: dx, y: dy } = result.offset;
+  const updates = [];
+  if (dx !== 0 || dy !== 0) {
+    for (const node of dragged) {
+      if (node.parentId && ids.has(node.parentId)) continue;
+      updates.push({ id: node.id, position: { x: node.position.x + dx, y: node.position.y + dy } });
+    }
+  }
+  return { ...result, updates };
+}
+
+// src/canvas/connectors.ts
+var CONNECTION_LINE_TYPES = [
+  "default",
+  "straight",
+  "step",
+  "smoothstep",
+  "simplebezier"
+];
+function positionToSide(position) {
+  switch (position) {
+    case "top":
+      return "above";
+    case "bottom":
+      return "below";
+    default:
+      return position;
+  }
+}
+function sideToPosition(side) {
+  switch (side) {
+    case "above":
+      return "top";
+    case "below":
+      return "bottom";
+    default:
+      return side;
+  }
+}
+function oppositePosition(position) {
+  switch (position) {
+    case "top":
+      return "bottom";
+    case "bottom":
+      return "top";
+    case "left":
+      return "right";
+    default:
+      return "left";
+  }
+}
+function handlePoint(rect, position) {
+  switch (position) {
+    case "top":
+      return { x: rect.x + rect.width / 2, y: rect.y };
+    case "bottom":
+      return { x: rect.x + rect.width / 2, y: rect.y + rect.height };
+    case "left":
+      return { x: rect.x, y: rect.y + rect.height / 2 };
+    default:
+      return { x: rect.x + rect.width, y: rect.y + rect.height / 2 };
+  }
+}
+function findConnectorSnap(pointer, targets, options = {}) {
+  const zoom = options.zoom && options.zoom > 0 ? options.zoom : 1;
+  const radius = (options.radius ?? 24) / zoom;
+  const exclude = new Set(options.excludeIds ?? []);
+  const all = ["top", "right", "bottom", "left"];
+  let best = null;
+  for (const target of targets) {
+    if (exclude.has(target.id)) continue;
+    const { rect } = target;
+    if (pointer.x < rect.x - radius || pointer.x > rect.x + rect.width + radius || pointer.y < rect.y - radius || pointer.y > rect.y + rect.height + radius) {
+      continue;
+    }
+    const inside = pointer.x >= rect.x && pointer.x <= rect.x + rect.width && pointer.y >= rect.y && pointer.y <= rect.y + rect.height;
+    for (const position of target.positions ?? all) {
+      const point = options.mode === "edge" ? closestPointOnSide(rect, position, pointer) : handlePoint(rect, position);
+      const sidePoint = closestPointOnSide(rect, position, pointer);
+      const rank = Math.hypot(pointer.x - sidePoint.x, pointer.y - sidePoint.y);
+      const distance = Math.hypot(pointer.x - point.x, pointer.y - point.y);
+      if (!inside && rank > radius) continue;
+      const better = !best || inside && !best.inside || inside === best.inside && rank < best.rank;
+      if (better) {
+        best = { nodeId: target.id, position, side: positionToSide(position), point, distance, inside, rank };
+      }
+    }
+  }
+  if (!best) return null;
+  const { inside: _inside, rank: _rank, ...snap } = best;
+  return snap;
+}
+function closestPointOnSide(rect, position, p) {
+  const clampX = Math.min(rect.x + rect.width, Math.max(rect.x, p.x));
+  const clampY = Math.min(rect.y + rect.height, Math.max(rect.y, p.y));
+  switch (position) {
+    case "top":
+      return { x: clampX, y: rect.y };
+    case "bottom":
+      return { x: clampX, y: rect.y + rect.height };
+    case "left":
+      return { x: rect.x, y: clampY };
+    default:
+      return { x: rect.x + rect.width, y: clampY };
+  }
+}
+function nearestHandlePositions(source, target) {
+  const a = centre(source);
+  const b = centre(target);
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    return dx >= 0 ? { source: "right", target: "left" } : { source: "left", target: "right" };
+  }
+  return dy >= 0 ? { source: "bottom", target: "top" } : { source: "top", target: "bottom" };
+}
+
+// src/canvas/scenes.ts
+var fallbackCounter = 0;
+function defaultId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  fallbackCounter += 1;
+  return `scene-${Date.now().toString(36)}-${fallbackCounter}`;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isValidCanvasScene(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const scene = value;
+  const vp = scene.viewport;
+  return typeof scene.id === "string" && typeof scene.name === "string" && typeof vp === "object" && vp !== null && isFiniteNumber(vp.x) && isFiniteNumber(vp.y) && isFiniteNumber(vp.zoom) && vp.zoom > 0 && (scene.nodeIds === void 0 || Array.isArray(scene.nodeIds) && scene.nodeIds.every((id) => typeof id === "string"));
+}
+function cloneScene(scene) {
+  const copy = {
+    id: scene.id,
+    name: scene.name,
+    viewport: { x: scene.viewport.x, y: scene.viewport.y, zoom: scene.viewport.zoom }
+  };
+  if (scene.nodeIds) copy.nodeIds = [...scene.nodeIds];
+  return copy;
+}
+function parseCanvasScenes(input) {
+  let value = input;
+  if (typeof input === "string") {
+    try {
+      value = JSON.parse(input);
+    } catch {
+      return [];
+    }
+  }
+  const list = Array.isArray(value) ? value : typeof value === "object" && value !== null && Array.isArray(value.scenes) ? value.scenes : [];
+  const seen = /* @__PURE__ */ new Set();
+  const scenes = [];
+  for (const entry of list) {
+    if (!isValidCanvasScene(entry) || seen.has(entry.id)) continue;
+    seen.add(entry.id);
+    scenes.push(cloneScene(entry));
+  }
+  return scenes;
+}
+var CanvasScenesStore = class {
+  scenes;
+  currentId = null;
+  cached;
+  listeners = /* @__PURE__ */ new Set();
+  createId;
+  onChange;
+  wrap;
+  constructor(options = {}) {
+    this.scenes = parseCanvasScenes(options.initialScenes ?? []);
+    this.createId = options.createId ?? defaultId;
+    this.wrap = options.wrap ?? false;
+    this.onChange = options.onChange;
+    this.cached = this.snapshot();
+  }
+  snapshot() {
+    const currentIndex = this.currentId ? this.scenes.findIndex((s) => s.id === this.currentId) : -1;
+    return {
+      scenes: this.scenes,
+      currentId: currentIndex === -1 ? null : this.currentId,
+      currentIndex
+    };
+  }
+  commit(scenes = this.scenes) {
+    this.scenes = scenes;
+    if (this.currentId && !scenes.some((s) => s.id === this.currentId)) this.currentId = null;
+    this.cached = this.snapshot();
+    this.onChange?.(this.cached);
+    for (const listener of this.listeners) listener(this.cached);
+  }
+  getState() {
+    return this.cached;
+  }
+  getScene(id) {
+    return this.scenes.find((s) => s.id === id);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** First unused "Scene N" name. */
+  nextDefaultName() {
+    const names = new Set(this.scenes.map((s) => s.name));
+    let n = this.scenes.length + 1;
+    while (names.has(`Scene ${n}`)) n += 1;
+    return `Scene ${n}`;
+  }
+  /**
+   * Adds a scene (appended, or inserted at `index`) and makes it current.
+   */
+  add(input, index) {
+    const scene = cloneScene({
+      id: input.id && !this.getScene(input.id) ? input.id : this.createId(),
+      name: input.name?.trim() || this.nextDefaultName(),
+      viewport: input.viewport,
+      nodeIds: input.nodeIds
+    });
+    if (!isValidCanvasScene(scene)) throw new Error("[CanvasScenesStore] Invalid scene viewport.");
+    const scenes = [...this.scenes];
+    const at = index === void 0 ? scenes.length : Math.max(0, Math.min(scenes.length, index));
+    scenes.splice(at, 0, scene);
+    this.currentId = scene.id;
+    this.commit(scenes);
+    return scene;
+  }
+  /** Patches a scene's name, viewport or node ids. Returns the updated scene. */
+  update(id, patch) {
+    const index = this.scenes.findIndex((s) => s.id === id);
+    if (index === -1) return void 0;
+    const current = this.scenes[index];
+    const next = cloneScene({
+      ...current,
+      ...patch,
+      name: patch.name !== void 0 ? patch.name.trim() || current.name : current.name,
+      viewport: patch.viewport ?? current.viewport,
+      id
+    });
+    if (!isValidCanvasScene(next)) throw new Error("[CanvasScenesStore] Invalid scene viewport.");
+    const scenes = [...this.scenes];
+    scenes[index] = next;
+    this.commit(scenes);
+    return next;
+  }
+  rename(id, name) {
+    return this.update(id, { name });
+  }
+  /** Moves a scene to `toIndex` (clamped). */
+  move(id, toIndex) {
+    const from = this.scenes.findIndex((s) => s.id === id);
+    if (from === -1) return;
+    const to = Math.max(0, Math.min(this.scenes.length - 1, Math.trunc(toIndex)));
+    if (from === to) return;
+    const scenes = [...this.scenes];
+    const [scene] = scenes.splice(from, 1);
+    scenes.splice(to, 0, scene);
+    this.commit(scenes);
+  }
+  /** Reorders scenes to match `ids`; unknown ids are ignored and missing scenes keep their relative order at the end. */
+  reorder(ids) {
+    const byId = new Map(this.scenes.map((s) => [s.id, s]));
+    const ordered = [];
+    for (const id of ids) {
+      const scene = byId.get(id);
+      if (scene) {
+        ordered.push(scene);
+        byId.delete(id);
+      }
+    }
+    this.commit([...ordered, ...this.scenes.filter((s) => byId.has(s.id))]);
+  }
+  remove(id) {
+    if (!this.getScene(id)) return;
+    this.commit(this.scenes.filter((s) => s.id !== id));
+  }
+  clear() {
+    this.currentId = null;
+    this.commit([]);
+  }
+  /** Marks a scene as current and returns it. */
+  goTo(id) {
+    const scene = this.getScene(id);
+    if (!scene) return void 0;
+    if (this.currentId !== id) {
+      this.currentId = id;
+      this.commit();
+    }
+    return scene;
+  }
+  step(direction) {
+    const count = this.scenes.length;
+    if (count === 0) return void 0;
+    const index = this.cached.currentIndex;
+    let next;
+    if (index === -1) next = direction === 1 ? 0 : count - 1;
+    else next = index + direction;
+    if (next < 0 || next >= count) {
+      if (!this.wrap) return void 0;
+      next = (next + count) % count;
+    }
+    return this.goTo(this.scenes[next].id);
+  }
+  /** Shows the next scene. Returns `undefined` at the end unless `wrap` is on. */
+  next() {
+    return this.step(1);
+  }
+  /** Shows the previous scene. Returns `undefined` at the start unless `wrap` is on. */
+  previous() {
+    return this.step(-1);
+  }
+  toJSON() {
+    return { version: 1, scenes: this.scenes.map(cloneScene) };
+  }
+  serialize() {
+    return JSON.stringify(this.toJSON());
+  }
+  /** Replaces all scenes from serialized data (see `parseCanvasScenes`). */
+  load(input) {
+    this.currentId = null;
+    this.commit(parseCanvasScenes(input));
+  }
+};
+function createCanvasScenesStore(options) {
+  return new CanvasScenesStore(options);
+}
+function fitViewportToRect(rect, size, options = {}) {
+  const { padding = 0.1, minZoom = 0.1, maxZoom = 2 } = options;
+  const paddedWidth = Math.max(rect.width * (1 + padding * 2), 1);
+  const paddedHeight = Math.max(rect.height * (1 + padding * 2), 1);
+  const raw = Math.min(size.width / paddedWidth, size.height / paddedHeight);
+  const zoom = Math.min(maxZoom, Math.max(minZoom, raw));
+  const cx = rect.x + rect.width / 2;
+  const cy = rect.y + rect.height / 2;
+  return { x: size.width / 2 - cx * zoom, y: size.height / 2 - cy * zoom, zoom };
+}
+function fitViewportToNodes(nodes, size, ids, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const wanted = ids ? new Set(ids) : null;
+  const rects = nodes.filter((n) => wanted ? wanted.has(n.id) : true).map((n) => getNodeRect(n, lookup, options));
+  const bounds = boundsOf(rects);
+  return bounds ? fitViewportToRect(bounds, size, options) : null;
+}
+
+// src/canvas/arrangeShortcuts.ts
+var DEFAULT_ARRANGE_SHORTCUTS = [
+  { action: "alignLeft", code: "KeyA", alt: true, label: "Alt+A" },
+  { action: "alignCenter", code: "KeyH", alt: true, label: "Alt+H" },
+  { action: "alignRight", code: "KeyD", alt: true, label: "Alt+D" },
+  { action: "alignTop", code: "KeyW", alt: true, label: "Alt+W" },
+  { action: "alignMiddle", code: "KeyV", alt: true, label: "Alt+V" },
+  { action: "alignBottom", code: "KeyS", alt: true, label: "Alt+S" },
+  { action: "distributeHorizontal", code: "KeyH", alt: true, shift: true, label: "Alt+Shift+H" },
+  { action: "distributeVertical", code: "KeyV", alt: true, shift: true, label: "Alt+Shift+V" },
+  { action: "lock", code: "KeyL", mod: true, label: "Mod+L" },
+  { action: "unlock", code: "KeyL", mod: true, alt: true, label: "Mod+Alt+L" },
+  { action: "bringForward", code: "BracketRight", mod: true, label: "Mod+]" },
+  { action: "sendBackward", code: "BracketLeft", mod: true, label: "Mod+[" },
+  { action: "bringToFront", code: "BracketRight", mod: true, alt: true, label: "Mod+Alt+]" },
+  { action: "sendToBack", code: "BracketLeft", mod: true, alt: true, label: "Mod+Alt+[" },
+  { action: "nextScene", code: "PageDown", label: "PageDown" },
+  { action: "previousScene", code: "PageUp", label: "PageUp" }
+];
+var KEY_TO_CODE = {
+  "]": "BracketRight",
+  "[": "BracketLeft",
+  PageDown: "PageDown",
+  PageUp: "PageUp"
+};
+function eventCode(event) {
+  if (event.code) return event.code;
+  if (KEY_TO_CODE[event.key]) return KEY_TO_CODE[event.key];
+  if (/^[a-z]$/i.test(event.key)) return `Key${event.key.toUpperCase()}`;
+  return event.key;
+}
+function matchArrangeShortcut(event, bindings = DEFAULT_ARRANGE_SHORTCUTS) {
+  if (isEventFromTextInput(event)) return null;
+  const code = eventCode(event);
+  const mod = event.metaKey || event.ctrlKey;
+  for (const binding of bindings) {
+    if (binding.code === code && !!binding.mod === mod && !!binding.alt === event.altKey && !!binding.shift === event.shiftKey) {
+      return binding.action;
+    }
+  }
+  return null;
+}
+
+// src/canvas/arrangeController.ts
+function createCanvasArrangeController(options) {
+  let guides = [];
+  let dragIndex = null;
+  let dragKey = "";
+  const selectedIds = (ids) => ids ? [...ids] : options.getSelectedIds?.() ?? options.getNodes().filter((n) => n.selected).map((n) => n.id);
+  const setGuides = (next) => {
+    if (next.length === 0 && guides.length === 0) return;
+    guides = next;
+    options.onGuidesChange?.(guides);
+  };
+  function apply(name, updates) {
+    if (updates.length === 0) return updates;
+    const inverse = invertNodeUpdates(options.getNodes(), updates);
+    const run = (u) => options.setNodes(applyNodeUpdates(options.getNodes(), u));
+    if (options.history) {
+      options.history.execute({ name, execute: () => run(updates), undo: () => run(inverse) });
+    } else {
+      run(updates);
+    }
+    return updates;
+  }
+  function setLocked(name, ids, locked) {
+    const nodes = options.getNodes();
+    const set = new Set(ids);
+    const changed = nodes.filter((n) => set.has(n.id) && isLocked(n) !== locked).map((n) => n.id);
+    if (changed.length === 0) return changed;
+    const lock = () => options.setNodes(lockNodes(options.getNodes(), changed));
+    const unlock = () => options.setNodes(unlockNodes(options.getNodes(), changed));
+    if (options.history) {
+      options.history.execute({ name, execute: locked ? lock : unlock, undo: locked ? unlock : lock });
+    } else if (locked) lock();
+    else unlock();
+    return changed;
+  }
+  const rect = () => options.rectOptions ?? {};
+  const controller = {
+    get guides() {
+      return guides;
+    },
+    apply,
+    align(edge, ids, alignOptions = {}) {
+      return apply(`Align ${edge}`, alignNodes(options.getNodes(), selectedIds(ids), edge, { ...rect(), ...alignOptions }));
+    },
+    distribute(axis, mode = "gaps", ids, distributeOptions = {}) {
+      return apply(
+        `Distribute ${axis}`,
+        distributeNodes(options.getNodes(), selectedIds(ids), axis, mode, { ...rect(), ...distributeOptions })
+      );
+    },
+    matchSize(dimension, ids, sizeOptions = {}) {
+      return apply(
+        "Make Same Size",
+        matchSize(options.getNodes(), selectedIds(ids), dimension, { ...rect(), ...sizeOptions })
+      );
+    },
+    reorder(operation, ids) {
+      return apply(operation, reorderNodes(options.getNodes(), selectedIds(ids), operation, rect()));
+    },
+    bringForward: (ids) => controller.reorder("bringForward", ids),
+    sendBackward: (ids) => controller.reorder("sendBackward", ids),
+    bringToFront: (ids) => controller.reorder("bringToFront", ids),
+    sendToBack: (ids) => controller.reorder("sendToBack", ids),
+    lock: (ids) => setLocked("Lock", selectedIds(ids), true),
+    unlock: (ids) => setLocked("Unlock", selectedIds(ids), false),
+    toggleLock(ids) {
+      const list = selectedIds(ids);
+      const set = new Set(list);
+      const anyUnlocked = options.getNodes().some((n) => set.has(n.id) && !isLocked(n));
+      return anyUnlocked ? controller.lock(list) : controller.unlock(list);
+    },
+    isLocked: (id) => isLocked(options.getNodes().find((n) => n.id === id)),
+    /**
+     * Runs a shortcut action. Scene actions are not handled here (see the scenes store);
+     * returns `false` for them and for unknown actions.
+     */
+    runAction(action) {
+      switch (action) {
+        case "alignLeft":
+          controller.align("left");
+          return true;
+        case "alignCenter":
+          controller.align("center");
+          return true;
+        case "alignRight":
+          controller.align("right");
+          return true;
+        case "alignTop":
+          controller.align("top");
+          return true;
+        case "alignMiddle":
+          controller.align("middle");
+          return true;
+        case "alignBottom":
+          controller.align("bottom");
+          return true;
+        case "distributeHorizontal":
+          controller.distribute("horizontal");
+          return true;
+        case "distributeVertical":
+          controller.distribute("vertical");
+          return true;
+        case "lock":
+          controller.lock();
+          return true;
+        case "unlock":
+          controller.unlock();
+          return true;
+        case "bringForward":
+          controller.bringForward();
+          return true;
+        case "sendBackward":
+          controller.sendBackward();
+          return true;
+        case "bringToFront":
+          controller.bringToFront();
+          return true;
+        case "sendToBack":
+          controller.sendToBack();
+          return true;
+        default:
+          return false;
+      }
+    },
+    /** Caches the snap targets for a drag. Optional: `drag` builds them lazily. */
+    beginDrag(ids) {
+      const list = selectedIds(ids);
+      dragKey = list.slice().sort().join("\0");
+      dragIndex = createNodeGuideIndex(options.getNodes(), list, rect());
+    },
+    /**
+     * Snaps the dragged nodes (as currently positioned in `getNodes()`) to the other
+     * nodes, writes the snapped positions back through `setNodes` (not recorded in
+     * history) and updates `guides`.
+     */
+    drag(ids) {
+      if (options.snapping === false) return null;
+      const list = selectedIds(ids);
+      const key = list.slice().sort().join("\0");
+      if (!dragIndex || key !== dragKey) controller.beginDrag(list);
+      const result = snapNodeDrag(options.getNodes(), list, {
+        ...rect(),
+        ...options.guides,
+        zoom: options.getZoom?.() ?? 1,
+        index: dragIndex
+      });
+      if (result.updates.length > 0) {
+        options.setNodes(applyNodeUpdates(options.getNodes(), result.updates));
+      }
+      setGuides(result.guides);
+      return result;
+    },
+    /**
+     * React Flow style: adjusts dragging `position` changes in an `onNodesChange` batch so
+     * the dragged nodes snap, and updates `guides`. Returns the (possibly new) changes array.
+     * A batch without a dragging position change ends the drag and clears the guides.
+     */
+    snapPositionChanges(changes) {
+      const dragging = changes.filter((c) => c.type === "position" && c.position && c.dragging);
+      if (dragging.length === 0) {
+        if (changes.some((c) => c.type === "position" && c.dragging === false)) controller.endDrag();
+        return changes;
+      }
+      if (options.snapping === false) return changes;
+      const ids = dragging.map((c) => c.id);
+      const key = ids.slice().sort().join("\0");
+      if (!dragIndex || key !== dragKey) controller.beginDrag(ids);
+      const proposed = new Map(dragging.map((c) => [c.id, c.position]));
+      const nodes = options.getNodes().map((n) => proposed.has(n.id) ? { ...n, position: proposed.get(n.id) } : n);
+      const result = snapNodeDrag(nodes, ids, {
+        ...rect(),
+        ...options.guides,
+        zoom: options.getZoom?.() ?? 1,
+        index: dragIndex
+      });
+      setGuides(result.guides);
+      const { x: dx, y: dy } = result.offset;
+      if (dx === 0 && dy === 0) return changes;
+      const parents = new Map(nodes.map((n) => [n.id, n.parentId]));
+      const shift = new Set(ids.filter((id) => !proposed.has(parents.get(id) ?? "")));
+      return changes.map(
+        (c) => c.type === "position" && c.position && c.dragging && shift.has(c.id) ? { ...c, position: { x: c.position.x + dx, y: c.position.y + dy } } : c
+      );
+    },
+    /** Clears guides and the cached snap targets. */
+    endDrag() {
+      dragIndex = null;
+      dragKey = "";
+      setGuides([]);
+    }
+  };
+  return controller;
+}
 export {
+  CONNECTION_LINE_TYPES,
+  CanvasScenesStore,
+  DEFAULT_ARRANGE_SHORTCUTS,
   DEFAULT_NODE_HEIGHT,
   DEFAULT_NODE_WIDTH,
   DEFAULT_PLACEMENT_GAP,
+  LOCKED_DATA_KEY,
+  LOCKED_PREVIOUS_FLAGS_KEY,
   ManualClock,
   StreamingLayoutManager,
+  alignNodes,
+  applyNodeUpdates,
   blendLayout,
   boundsOf,
   calculateDagreReflowDisplacement,
@@ -732,33 +1918,65 @@ export {
   canvasHeight,
   centerNodes,
   centre,
+  collectDescendantIds,
   computeNodesBoundingBox,
+  computeSnapGuides,
   connectedOnly,
   createBezierTrajectory,
+  createCanvasArrangeController,
+  createCanvasScenesStore,
   createFanOutTrajectory,
+  createGuideIndex,
+  createNodeGuideIndex,
+  createNodeLookup,
   defaultEasing,
+  distributeNodes,
   ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
+  findConnectorSnap,
+  fitViewportToNodes,
+  fitViewportToRect,
   flowSide,
+  getAbsolutePosition,
   getCenteredNodePosition,
   getLayoutedNodes,
+  getNodeRect,
+  getNodeSize,
+  handlePoint,
+  invertNodeUpdates,
   isEventFromTextInput,
+  isLocked,
   isValidCanvasEdge,
   isValidCanvasNode,
+  isValidCanvasScene,
   isValidUrl,
   layoutBounds,
   linearPositionTrajectory,
   linearTrajectory,
+  lockNodes,
+  matchArrangeShortcut,
+  matchSize,
+  nearestHandlePositions,
+  oppositePosition,
   overlaps,
   pageHidden,
   parseCanvasClipboardData,
+  parseCanvasScenes,
   placeBeside,
+  positionToSide,
+  readStyleSize,
   realClock,
   remapPastedNodes,
+  reorderNodes,
   repositionNodesTo,
   runMultiNodeTransition,
   serializeCanvasNodes,
-  withStyleOpacity
+  sideToPosition,
+  snapNodeDrag,
+  toggleLockNodes,
+  unlockNodes,
+  withStyleOpacity,
+  withStyleSize
 };
 //# sourceMappingURL=index.js.map