@pixerate/editor 0.140.4 → 0.142.1

package/dist/chunk-UBRYHNRU.cjs

@@ -0,0 +1,591 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/canvas/layout.ts
+var _dagre = require('@dagrejs/dagre'); var _dagre2 = _interopRequireDefault(_dagre);
+var DEFAULT_NODE_WIDTH = 200;
+var DEFAULT_NODE_HEIGHT = 60;
+var DEFAULT_PLACEMENT_GAP = 48;
+function getCenteredNodePosition(width = 0, height = 0, screenToFlowPosition, screenDimensions) {
+  const rect = _nullishCoalesce(screenDimensions, () => ( (typeof document !== "undefined" ? { width: document.documentElement.clientWidth, height: document.documentElement.clientHeight } : { width: 1920, height: 1080 })));
+  const flowPos = screenToFlowPosition({ x: rect.width / 2, y: rect.height / 2 });
+  return {
+    x: flowPos.x - width / 2,
+    y: flowPos.y - height / 2
+  };
+}
+function centerNodes(nodes, screenToFlowPosition, getNodesBounds, screenDimensions) {
+  if (nodes.length === 0) {
+    return [];
+  }
+  const bounds = getNodesBounds(nodes);
+  const boundingBoxOrigin = { x: bounds.x, y: bounds.y };
+  const centeredPosition = getCenteredNodePosition(
+    bounds.width,
+    bounds.height,
+    screenToFlowPosition,
+    screenDimensions
+  );
+  const deltaX = centeredPosition.x - boundingBoxOrigin.x;
+  const deltaY = centeredPosition.y - boundingBoxOrigin.y;
+  return nodes.map((node) => ({
+    ...node,
+    position: {
+      x: node.position.x + deltaX,
+      y: node.position.y + deltaY
+    }
+  }));
+}
+function getLayoutedNodes(nodes, edges, getNodesBounds, options = {}) {
+  if (nodes.length === 0) return [];
+  const {
+    direction = "LR",
+    ranksep = 100,
+    nodesep = 25,
+    defaultNodeWidth = DEFAULT_NODE_WIDTH,
+    defaultNodeHeight = DEFAULT_NODE_HEIGHT
+  } = options;
+  const dagreGraph = new _dagre2.default.graphlib.Graph();
+  dagreGraph.setDefaultEdgeLabel(() => ({}));
+  dagreGraph.setGraph({ rankdir: direction, ranksep, nodesep });
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  nodes.forEach((node) => {
+    const nodeWidth = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _2 => _2.measured, 'optionalAccess', _3 => _3.width]), () => ( node.width)), () => ( defaultNodeWidth));
+    const nodeHeight = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _4 => _4.measured, 'optionalAccess', _5 => _5.height]), () => ( node.height)), () => ( defaultNodeHeight));
+    dagreGraph.setNode(node.id, { width: nodeWidth, height: nodeHeight });
+  });
+  edges.forEach((edge) => {
+    if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+      dagreGraph.setEdge(edge.source, edge.target);
+    }
+  });
+  _dagre2.default.layout(dagreGraph);
+  return nodes.map((node) => {
+    const nodeWithPosition = dagreGraph.node(node.id);
+    const nodeWidth = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _6 => _6.measured, 'optionalAccess', _7 => _7.width]), () => ( node.width)), () => ( defaultNodeWidth));
+    const nodeHeight = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _8 => _8.measured, 'optionalAccess', _9 => _9.height]), () => ( node.height)), () => ( defaultNodeHeight));
+    return {
+      ...node,
+      position: {
+        x: nodeWithPosition.x - nodeWidth / 2,
+        y: nodeWithPosition.y - nodeHeight / 2
+      }
+    };
+  });
+}
+function estimateNodeSize(node, defaultWidth = DEFAULT_NODE_WIDTH, defaultHeight = DEFAULT_NODE_HEIGHT) {
+  const label = String(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _10 => _10.data, 'optionalAccess', _11 => _11.label]), () => ( _optionalChain([node, 'access', _12 => _12.data, 'optionalAccess', _13 => _13.title]))), () => ( node.id)), () => ( "")));
+  const lines = label.split(/\n|<br\s*\/?>/);
+  const longest = Math.max(...lines.map((l) => l.replace(/<[^>]+>/g, "").length), 1);
+  const width = Math.min(480, Math.max(defaultWidth, longest * 8 + 48));
+  const height = Math.max(defaultHeight, lines.length * 20 + 24);
+  return { width, height };
+}
+function boundsOf(rects) {
+  if (!rects.length) return null;
+  const minX = Math.min(...rects.map((r) => r.x));
+  const minY = Math.min(...rects.map((r) => r.y));
+  const maxX = Math.max(...rects.map((r) => r.x + r.width));
+  const maxY = Math.max(...rects.map((r) => r.y + r.height));
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function centre(r) {
+  return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+}
+function overlaps(a, b, pad = 16) {
+  return a.x < b.x + b.width + pad && a.x + a.width + pad > b.x && a.y < b.y + b.height + pad && a.y + a.height + pad > b.y;
+}
+function flowSide(direction = "LR") {
+  switch (direction) {
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+    case "BT":
+      return "above";
+    case "TB":
+    default:
+      return "below";
+  }
+}
+function ensureLayout(nodes, edges, options = {}) {
+  if (nodes.length === 0) return [];
+  const stored = _nullishCoalesce(options.storedPositions, () => ( {}));
+  const missing = nodes.filter((n) => !stored[n.id]);
+  if (missing.length === 0) {
+    return nodes.map((n) => ({
+      ...n,
+      position: { ...stored[n.id] }
+    }));
+  }
+  const autoLayouted = getLayoutedNodes(nodes, edges, void 0, options);
+  const autoMap = new Map(
+    autoLayouted.map((n) => [n.id, n.position])
+  );
+  const both = nodes.filter((n) => stored[n.id] && autoMap.has(n.id));
+  if (both.length === 0) {
+    return autoLayouted;
+  }
+  let dx = 0;
+  let dy = 0;
+  for (const n of both) {
+    const s = stored[n.id];
+    const a = autoMap.get(n.id);
+    dx += s.x - a.x;
+    dy += s.y - a.y;
+  }
+  dx /= both.length;
+  dy /= both.length;
+  return nodes.map((node) => {
+    if (stored[node.id]) {
+      return {
+        ...node,
+        position: { ...stored[node.id] }
+      };
+    }
+    const autoPos = _nullishCoalesce(autoMap.get(node.id), () => ( { x: 0, y: 0 }));
+    return {
+      ...node,
+      position: {
+        x: Math.round(autoPos.x + dx),
+        y: Math.round(autoPos.y + dy)
+      }
+    };
+  });
+}
+function placeBeside(rects, size, side, nearNodeId, options = {}) {
+  const {
+    gap = DEFAULT_PLACEMENT_GAP,
+    ignore = [],
+    maxAttempts = 32
+  } = options;
+  const skip = new Set([nearNodeId, ...ignore].filter(Boolean));
+  const obstacles = Object.entries(rects).filter(([id]) => !skip.has(id)).map(([, r]) => r);
+  const anchor = nearNodeId && rects[nearNodeId] || boundsOf(Object.values(rects)) || { x: 0, y: 0, width: 0, height: 0 };
+  const anchorCenter = centre(anchor);
+  let baseX;
+  let baseY;
+  switch (side) {
+    case "right":
+      baseX = anchor.x + anchor.width + gap;
+      baseY = anchorCenter.y - size.height / 2;
+      break;
+    case "left":
+      baseX = anchor.x - gap - size.width;
+      baseY = anchorCenter.y - size.height / 2;
+      break;
+    case "above":
+      baseX = anchorCenter.x - size.width / 2;
+      baseY = anchor.y - gap - size.height;
+      break;
+    case "below":
+    default:
+      baseX = anchorCenter.x - size.width / 2;
+      baseY = anchor.y + anchor.height + gap;
+      break;
+  }
+  const isHorizontal = side === "right" || side === "left";
+  const step = (isHorizontal ? size.height : size.width) + 20;
+  for (let i = 0; i < maxAttempts; i++) {
+    const offset = i === 0 ? 0 : Math.ceil(i / 2) * step * (i % 2 === 1 ? 1 : -1);
+    const candidateBox = {
+      x: isHorizontal ? baseX : baseX + offset,
+      y: isHorizontal ? baseY + offset : baseY,
+      width: size.width,
+      height: size.height
+    };
+    if (!obstacles.some((obstacle) => overlaps(candidateBox, obstacle, 8))) {
+      return {
+        x: Math.round(candidateBox.x),
+        y: Math.round(candidateBox.y)
+      };
+    }
+  }
+  return {
+    x: Math.round(baseX),
+    y: Math.round(baseY)
+  };
+}
+
+// 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 _nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _14 => _14.measured, 'optionalAccess', _15 => _15.width]), () => ( node.width)), () => ( styleSize.width));
+  let height = _nullishCoalesce(_nullishCoalesce(_optionalChain([node, 'access', _16 => _16.measured, 'optionalAccess', _17 => _17.height]), () => ( node.height)), () => ( styleSize.height));
+  if (width === void 0 || height === void 0) {
+    const fallback = options.estimate === false ? { width: _nullishCoalesce(options.defaultWidth, () => ( 200)), height: _nullishCoalesce(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 _optionalChain([node, 'optionalAccess', _18 => _18.data, 'optionalAccess', _19 => _19[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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 - ((_nullishCoalesce(update.width, () => ( rect.width))) - rect.width) / 2,
+        y: node.position.y - ((_nullishCoalesce(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 = _nullishCoalesce(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;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_NODE_WIDTH = DEFAULT_NODE_WIDTH; exports.DEFAULT_NODE_HEIGHT = DEFAULT_NODE_HEIGHT; exports.DEFAULT_PLACEMENT_GAP = DEFAULT_PLACEMENT_GAP; exports.getCenteredNodePosition = getCenteredNodePosition; exports.centerNodes = centerNodes; exports.getLayoutedNodes = getLayoutedNodes; exports.estimateNodeSize = estimateNodeSize; exports.boundsOf = boundsOf; exports.centre = centre; exports.overlaps = overlaps; exports.flowSide = flowSide; exports.ensureLayout = ensureLayout; exports.placeBeside = placeBeside; exports.LOCKED_DATA_KEY = LOCKED_DATA_KEY; exports.LOCKED_PREVIOUS_FLAGS_KEY = LOCKED_PREVIOUS_FLAGS_KEY; exports.readStyleSize = readStyleSize; exports.withStyleSize = withStyleSize; exports.getNodeSize = getNodeSize; exports.getAbsolutePosition = getAbsolutePosition; exports.createNodeLookup = createNodeLookup; exports.getNodeRect = getNodeRect; exports.isLocked = isLocked; exports.lockNodes = lockNodes; exports.unlockNodes = unlockNodes; exports.toggleLockNodes = toggleLockNodes; exports.alignNodes = alignNodes; exports.distributeNodes = distributeNodes; exports.matchSize = matchSize; exports.reorderNodes = reorderNodes; exports.applyNodeUpdates = applyNodeUpdates; exports.invertNodeUpdates = invertNodeUpdates;

package/dist/{chunk-GEY73RUW.cjs → chunk-UJGAA6AK.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/animation/presence.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/tools/presence.ts
 var PRESENCE_COLORS = ["#7c3aed", "#db2777", "#0891b2", "#ea580c", "#16a34a"];
 var PresenceStore = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this); }
   __init() {this.state = { actors: [] }}

package/dist/{chunk-LMSFXRAJ.js → chunk-VGJTUCWM.js}

@@ -20,7 +20,7 @@ import {
   rangesIntersect,
   searchFormulaFunctions,
   tokenizeFormula
-} from "./chunk-E747F3D5.js";
+} from "./chunk-CC6WKVIH.js";
 import {
   NumberFormat,
   colNameToIndex,