@visualli/core 0.1.1

package/dist/index.js

@@ -0,0 +1,2119 @@
+// src/layout/circularLayout.ts
+function applyCircularLayout(nodes, options = {}) {
+  const {
+    radiusPercentage = 0.135,
+    containerWidth = 2e3,
+    containerHeight = 2e3,
+    centerX = 0,
+    centerY = 0
+  } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const radius = Math.min(containerWidth, containerHeight) * radiusPercentage;
+  const startAngle = nodes.length === 2 ? 0 : -Math.PI / 2;
+  const angleStep = 2 * Math.PI / nodes.length;
+  for (let i = 0; i < nodes.length; i++) {
+    const angle = startAngle + i * angleStep;
+    nodes[i].x = centerX + radius * Math.cos(angle);
+    nodes[i].y = centerY + radius * Math.sin(angle);
+  }
+  return nodes;
+}
+function calculateMinimumRadius(nodeCount, nodeWidth = 200, nodePadding = 150) {
+  if (nodeCount <= 1) return 0;
+  const angleStep = 2 * Math.PI / nodeCount;
+  const minChordLength = nodeWidth + nodePadding;
+  return minChordLength / (2 * Math.sin(angleStep / 2));
+}
+function calculateOptimalRadiusPercentage(nodeCount, containerWidth = 2e3, containerHeight = 2e3, nodeWidth = 200, nodePadding = 120) {
+  const minRadius = calculateMinimumRadius(nodeCount, nodeWidth, nodePadding);
+  const minDimension = Math.min(containerWidth, containerHeight);
+  return Math.min(0.45, Math.max(0.135, minRadius / minDimension));
+}
+
+// src/layout/linearLayout.ts
+function applyLinearHorizontalLayout(nodes, options = {}) {
+  const { nodeWidth = 200, hGap = 180, centerX = 0, centerY = 0 } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const spacing = nodeWidth + hGap;
+  const totalWidth = (nodes.length - 1) * spacing;
+  const startX = centerX - totalWidth / 2;
+  for (let i = 0; i < nodes.length; i++) {
+    nodes[i].x = startX + i * spacing;
+    nodes[i].y = centerY;
+  }
+  return nodes;
+}
+function applyLinearVerticalLayout(nodes, options = {}) {
+  const { nodeHeight = 80, vGap = 220, centerX = 0, centerY = 0 } = options;
+  if (nodes.length === 0) return nodes;
+  if (nodes.length === 1) {
+    nodes[0].x = centerX;
+    nodes[0].y = centerY;
+    return nodes;
+  }
+  const spacing = nodeHeight + vGap;
+  const totalHeight = (nodes.length - 1) * spacing;
+  const startY = centerY - totalHeight / 2;
+  for (let i = 0; i < nodes.length; i++) {
+    nodes[i].x = centerX;
+    nodes[i].y = startY + i * spacing;
+  }
+  return nodes;
+}
+
+// src/layout/layoutUtils.ts
+function getNodeBounds(node) {
+  const baseWidth = Math.max(120, node.title.length * 8 + 40);
+  const baseHeight = Math.max(40, 32 + 16);
+  const padding = 20;
+  return {
+    x: node.x - baseWidth / 2 - padding,
+    y: node.y - baseHeight / 2 - padding,
+    width: baseWidth + padding * 2,
+    height: baseHeight + padding * 2
+  };
+}
+function checkCollision(box1, box2) {
+  return !(box1.x + box1.width < box2.x || box2.x + box2.width < box1.x || box1.y + box1.height < box2.y || box2.y + box2.height < box1.y);
+}
+function resolveCollisions(nodes, maxIterations = 10) {
+  const result = [...nodes];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let hasCollisions = false;
+    const byLevel = result.reduce((acc, n) => {
+      var _a;
+      (acc[_a = n.level] ?? (acc[_a] = [])).push(n);
+      return acc;
+    }, {});
+    for (const levelNodes of Object.values(byLevel)) {
+      for (let i = 0; i < levelNodes.length; i++) {
+        for (let j = i + 1; j < levelNodes.length; j++) {
+          const n1 = levelNodes[i];
+          const n2 = levelNodes[j];
+          if (!checkCollision(getNodeBounds(n1), getNodeBounds(n2))) continue;
+          hasCollisions = true;
+          const dx = n2.x - n1.x;
+          const dy = n2.y - n1.y;
+          const dist = Math.sqrt(dx * dx + dy * dy);
+          if (dist < 1) {
+            n2.x += 100;
+          } else {
+            const b1 = getNodeBounds(n1);
+            const b2 = getNodeBounds(n2);
+            const minSep = (b1.width + b2.width) / 2;
+            const overlap = minSep - dist + 20;
+            if (overlap > 0) {
+              const move = overlap / 2;
+              n1.x -= dx / dist * move;
+              n1.y -= dy / dist * move;
+              n2.x += dx / dist * move;
+              n2.y += dy / dist * move;
+            }
+          }
+        }
+      }
+    }
+    if (!hasCollisions) break;
+  }
+  return result;
+}
+function optimizeLayout(nodes) {
+  const result = [...nodes];
+  const iterations = 5;
+  const repulsion = 1e3;
+  const damp = 0.8;
+  for (let iter = 0; iter < iterations; iter++) {
+    const forces = /* @__PURE__ */ new Map();
+    result.forEach((n) => forces.set(n.id, { x: 0, y: 0 }));
+    for (let i = 0; i < result.length; i++) {
+      for (let j = i + 1; j < result.length; j++) {
+        const n1 = result[i];
+        const n2 = result[j];
+        if (n1.level !== n2.level) continue;
+        const dx = n2.x - n1.x;
+        const dy = n2.y - n1.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist <= 0 || dist >= 300) continue;
+        const force = repulsion / (dist * dist);
+        const f1 = forces.get(n1.id);
+        const f2 = forces.get(n2.id);
+        f1.x -= dx / dist * force;
+        f1.y -= dy / dist * force;
+        f2.x += dx / dist * force;
+        f2.y += dy / dist * force;
+      }
+    }
+    result.forEach((n) => {
+      const f = forces.get(n.id);
+      n.x += f.x * damp;
+      n.y += f.y * damp;
+    });
+  }
+  return resolveCollisions(result);
+}
+
+// src/parser/visualliParser.ts
+function toVisualliLayer(schemaLayer) {
+  return {
+    type: "layer",
+    id: schemaLayer.id,
+    level: schemaLayer.level,
+    parentLayerId: schemaLayer.parentLayerId,
+    parentNodeId: schemaLayer.parentNodeId,
+    layout: schemaLayer.layout,
+    nodes: schemaLayer.nodes ?? [],
+    connections: schemaLayer.connections ?? [],
+    containers: schemaLayer.containers ?? []
+  };
+}
+var VisualliParseError = class extends Error {
+  constructor(message, lineNumber) {
+    super(message);
+    this.lineNumber = lineNumber;
+    this.name = "VisualliParseError";
+  }
+};
+function parseVisualliFile(content) {
+  const lines = content.trim().split("\n");
+  const doc = {
+    meta: null,
+    layers: /* @__PURE__ */ new Map(),
+    layersByLevel: /* @__PURE__ */ new Map(),
+    rootLayer: null
+  };
+  let lineNumber = 0;
+  for (const line of lines) {
+    lineNumber++;
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (err) {
+      throw new VisualliParseError(
+        `Failed to parse JSON at line ${lineNumber}: ${err}`,
+        lineNumber
+      );
+    }
+    if (!obj["type"]) {
+      throw new VisualliParseError(
+        `Missing 'type' field at line ${lineNumber}`,
+        lineNumber
+      );
+    }
+    switch (obj["type"]) {
+      case "meta":
+        doc.meta = obj;
+        break;
+      case "layer": {
+        const schemaLayer = obj;
+        const layer = toVisualliLayer(schemaLayer);
+        doc.layers.set(layer.id, layer);
+        if (!doc.layersByLevel.has(layer.level)) {
+          doc.layersByLevel.set(layer.level, []);
+        }
+        doc.layersByLevel.get(layer.level).push(layer);
+        if (layer.level === 0) {
+          doc.rootLayer = layer;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!doc.meta) throw new VisualliParseError("Missing required meta section");
+  if (!doc.rootLayer) throw new VisualliParseError("Missing root layer (level 0)");
+  return doc;
+}
+async function loadVisualliFile(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return parseVisualliFile(await response.text());
+}
+function parseVisualliFromMongoDB(visualliJsonl) {
+  if (!visualliJsonl || typeof visualliJsonl !== "string") {
+    throw new VisualliParseError("Invalid visualli data: expected a JSONL string");
+  }
+  const trimmed = visualliJsonl.trim();
+  if (!trimmed) throw new VisualliParseError("Empty visualli data from MongoDB");
+  return parseVisualliFile(trimmed);
+}
+function loadVisualliFileFromFile(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        resolve(parseVisualliFile(e.target?.result));
+      } catch (err) {
+        reject(err);
+      }
+    };
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsText(file);
+  });
+}
+function getChildLayers(doc, nodeId) {
+  const result = [];
+  for (const layer of doc.layers.values()) {
+    if (layer.parentNodeId === nodeId) result.push(layer);
+  }
+  return result;
+}
+function countLayersBeneath(doc, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) return 0;
+  visited.add(nodeId);
+  const children = getChildLayers(doc, nodeId);
+  if (children.length === 0) return 0;
+  let maxDepth = 0;
+  for (const layer of children) {
+    let depth = 1;
+    for (const node of layer.nodes) {
+      depth = Math.max(depth, 1 + countLayersBeneath(doc, node.id, visited));
+    }
+    maxDepth = Math.max(maxDepth, depth);
+  }
+  return maxDepth;
+}
+
+// src/parser/visualliConverter.ts
+function doNodesOverlap(n1, n2, padding = 20) {
+  return !(n1.x + n1.width / 2 + padding < n2.x - n2.width / 2 - padding || n1.x - n1.width / 2 - padding > n2.x + n2.width / 2 + padding || n1.y + n1.height / 2 + padding < n2.y - n2.height / 2 - padding || n1.y - n1.height / 2 - padding > n2.y + n2.height / 2 + padding);
+}
+function resolveNodeOverlaps(nodes, maxIterations = 10) {
+  const padding = 150;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    let any = false;
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const n1 = nodes[i];
+        const n2 = nodes[j];
+        if (!doNodesOverlap(n1, n2, padding)) continue;
+        any = true;
+        const dx = n2.x - n1.x;
+        const dy = n2.y - n1.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < 1) {
+          n2.x += n2.width / 2 + padding;
+          continue;
+        }
+        const minDist = (n1.width + n2.width) / 2 + padding;
+        if (dist < minDist) {
+          const push = (minDist - dist) / 2;
+          n1.x -= dx / dist * push;
+          n1.y -= dy / dist * push;
+          n2.x += dx / dist * push;
+          n2.y += dy / dist * push;
+        }
+      }
+    }
+    if (!any) break;
+  }
+}
+var COLOR_PALETTE = [
+  "#12C7D3",
+  "#325E8C",
+  "#8A70A6",
+  "#F54A57",
+  "#FF6C4D",
+  "#F28C16",
+  "#FFD347",
+  "#12C7D3",
+  "#7F7F7F",
+  "#8D8D8D",
+  "#12C7D3"
+];
+function getRandomColorForNode(nodeId) {
+  let hash = 0;
+  for (let i = 0; i < nodeId.length; i++) {
+    hash = nodeId.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const index = Math.abs(hash) % COLOR_PALETTE.length;
+  return COLOR_PALETTE[index];
+}
+function applyFormation(nodes, formation) {
+  if (nodes.length === 0) return;
+  if (nodes.length === 1) {
+    nodes[0].x = 0;
+    nodes[0].y = 0;
+    return;
+  }
+  if (formation === "linear-horizontal" || formation === "linear") {
+    applyLinearHorizontalLayout(nodes, { centerX: 0, centerY: 0 });
+  } else if (formation === "linear-vertical") {
+    applyLinearVerticalLayout(nodes, { centerX: 0, centerY: 0 });
+  } else {
+    const r = Math.max(250, nodes.length * 70);
+    const step = 2 * Math.PI / nodes.length;
+    for (let i = 0; i < nodes.length; i++) {
+      nodes[i].x = r * Math.cos(i * step);
+      nodes[i].y = r * Math.sin(i * step);
+    }
+  }
+}
+function containerBBox(nodes, padding) {
+  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    minX = Math.min(minX, n.x - n.width / 2);
+    maxX = Math.max(maxX, n.x + n.width / 2);
+    minY = Math.min(minY, n.y - n.height / 2);
+    maxY = Math.max(maxY, n.y + n.height / 2);
+  }
+  return { width: maxX - minX + padding * 2, height: maxY - minY + padding * 2 };
+}
+function proxyLinearH(proxies, gap = 180) {
+  const total = proxies.reduce((s, p) => s + p.width, 0) + gap * (proxies.length - 1);
+  let x = -total / 2;
+  for (const p of proxies) {
+    p.x = x + p.width / 2;
+    p.y = 0;
+    x += p.width + gap;
+  }
+}
+function proxyLinearV(proxies, gap = 180) {
+  const total = proxies.reduce((s, p) => s + p.height, 0) + gap * (proxies.length - 1);
+  let y = -total / 2;
+  for (const p of proxies) {
+    p.x = 0;
+    p.y = y + p.height / 2;
+    y += p.height + gap;
+  }
+}
+function proxyRadial(proxies, radius = 500) {
+  if (proxies.length === 1) {
+    proxies[0].x = 0;
+    proxies[0].y = 0;
+    return;
+  }
+  const startAngle = proxies.length === 2 ? 0 : -Math.PI / 2;
+  const step = 2 * Math.PI / proxies.length;
+  for (let i = 0; i < proxies.length; i++) {
+    const angle = startAngle + i * step;
+    proxies[i].x = radius * Math.cos(angle);
+    proxies[i].y = radius * Math.sin(angle);
+  }
+}
+function calculateNodeWidth(title) {
+  return Math.max(200, title.length * 8 + 40);
+}
+function makeFlatNode(nodeId, label, summary, layer, color, branchCount, x = 0, y = 0) {
+  return {
+    id: nodeId,
+    parentId: layer.parentNodeId ?? null,
+    x,
+    y,
+    level: layer.level,
+    title: label,
+    description: summary,
+    color,
+    width: calculateNodeWidth(label),
+    height: 80,
+    isExpanded: branchCount > 0,
+    branchCount,
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+}
+function convertLayerWithContainers(layer, doc) {
+  const PADDING = 80;
+  const flatNodes = [];
+  for (const node of layer.nodes) {
+    const label = Array.isArray(node.data.label) ? node.data.label.join(" ") : node.data.label || "Untitled";
+    const branchCount = countLayersBeneath(doc, node.id);
+    flatNodes.push(
+      makeFlatNode(
+        node.id,
+        label,
+        node.data.summary || "",
+        layer,
+        node.data.color || getRandomColorForNode(node.id),
+        branchCount
+      )
+    );
+  }
+  const byId = new Map(flatNodes.map((n) => [n.id, n]));
+  const containerNodeIds = /* @__PURE__ */ new Set();
+  const containerGroups = /* @__PURE__ */ new Map();
+  for (const container of layer.containers) {
+    const group = container.nodes.map((id) => byId.get(id)).filter((n) => !!n);
+    if (!group.length) continue;
+    container.nodes.forEach((id) => containerNodeIds.add(id));
+    const formation = container.data?.["formation"] ?? "radial";
+    applyFormation(group, formation);
+    containerGroups.set(container.id, group);
+  }
+  const proxies = [];
+  for (const node of layer.nodes) {
+    if (!containerNodeIds.has(node.id)) {
+      const nodeWidth = calculateNodeWidth(node.data.label);
+      proxies.push({ id: node.id, x: 0, y: 0, width: nodeWidth, height: 80 });
+    }
+  }
+  for (const container of layer.containers) {
+    const group = containerGroups.get(container.id);
+    if (!group?.length) continue;
+    const bbox = containerBBox(group, PADDING);
+    proxies.push({ id: `__c__${container.id}`, x: 0, y: 0, width: bbox.width, height: bbox.height });
+  }
+  const layout = layer.layout || "radial";
+  if (layout === "linear-horizontal") proxyLinearH(proxies, 180);
+  else if (layout === "linear-vertical") proxyLinearV(proxies, 180);
+  else proxyRadial(proxies, 500);
+  for (const proxy of proxies) {
+    if (proxy.id.startsWith("__c__")) {
+      const group = containerGroups.get(proxy.id.slice(5));
+      group?.forEach((n) => {
+        n.x += proxy.x;
+        n.y += proxy.y;
+      });
+    } else {
+      const fn = byId.get(proxy.id);
+      if (fn) {
+        fn.x = proxy.x;
+        fn.y = proxy.y;
+      }
+    }
+  }
+  resolveNodeOverlaps(flatNodes);
+  return flatNodes;
+}
+function convertLayerToFlatNodes(layer, doc) {
+  if ((layer.containers ?? []).length > 0) {
+    return convertLayerWithContainers(layer, doc);
+  }
+  const flatNodes = [];
+  for (const node of layer.nodes) {
+    const label = Array.isArray(node.data.label) ? node.data.label.join(" ") : node.data.label || "Untitled";
+    const branchCount = countLayersBeneath(doc, node.id);
+    flatNodes.push(
+      makeFlatNode(
+        node.id,
+        label,
+        node.data.summary || "",
+        layer,
+        node.data.color || getRandomColorForNode(node.id),
+        branchCount,
+        0,
+        0
+      )
+    );
+  }
+  if (flatNodes.length > 0) {
+    const layout = layer.layout || "radial";
+    if (layout === "linear-horizontal") {
+      applyLinearHorizontalLayout(flatNodes, { centerX: 0, centerY: 0 });
+    } else if (layout === "linear-vertical") {
+      applyLinearVerticalLayout(flatNodes, { centerX: 0, centerY: 0 });
+    } else {
+      const pct = calculateOptimalRadiusPercentage(flatNodes.length, 2e3, 2e3, 200, 30);
+      applyCircularLayout(flatNodes, {
+        radiusPercentage: pct,
+        containerWidth: 2e3,
+        containerHeight: 2e3,
+        centerX: 0,
+        centerY: 0
+      });
+    }
+  }
+  resolveNodeOverlaps(flatNodes);
+  return flatNodes;
+}
+function convertVisualliToFlatNodes(doc) {
+  const map = /* @__PURE__ */ new Map();
+  for (const layer of doc.layers.values()) {
+    for (const node of convertLayerToFlatNodes(layer, doc)) {
+      map.set(node.id, node);
+    }
+  }
+  for (const node of map.values()) {
+    node.childrenIds = [];
+    for (const candidate of map.values()) {
+      if (candidate.parentId === node.id) node.childrenIds.push(candidate.id);
+    }
+  }
+  return map;
+}
+function getNodesForLayer(doc, layerId) {
+  const layer = doc.layers.get(layerId);
+  return layer ? convertLayerToFlatNodes(layer, doc) : [];
+}
+
+// src/parser/mindmapUtils.ts
+function flattenNodes(nodes) {
+  const result = [];
+  const traverse = (list) => {
+    for (const n of list) {
+      result.push(n);
+      if (n.children) traverse(n.children);
+    }
+  };
+  traverse(nodes);
+  return result;
+}
+function getVisibleNodes(nodes, zoom, focusedNode) {
+  const flat = flattenNodes(nodes);
+  if (focusedNode) {
+    const focused = flat.find((n) => n.id === focusedNode);
+    if (focused) {
+      return focused.children ? [focused, ...focused.children] : [focused];
+    }
+  }
+  if (zoom <= 0.7) return flat.filter((n) => n.level === 0);
+  const maxLevel = Math.floor((zoom - 0.7) / 0.05);
+  return flat.filter((n) => n.level <= maxLevel);
+}
+function getNodeConnections(nodes) {
+  const flat = flattenNodes(nodes);
+  const result = [];
+  for (const n of flat) {
+    if (!n.parent) continue;
+    const parent = flat.find((p) => p.id === n.parent);
+    if (parent) result.push({ from: parent, to: n, label: n.relationshipLabel });
+  }
+  return result;
+}
+function getTopLevelConnections(nodes, topLevelConnections) {
+  const flat = flattenNodes(nodes);
+  const result = [];
+  for (const conn of topLevelConnections) {
+    const from = flat.find((n) => n.id === conn.from);
+    const to = flat.find((n) => n.id === conn.to);
+    if (from && to) result.push({ from, to, label: conn.label ?? "" });
+  }
+  return result;
+}
+function calculateDistance(x1, y1, x2, y2) {
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+}
+
+// src/constants/design.ts
+var DS_COLORS = {
+  light: {
+    bgApp: "#F0EDE6",
+    bgSurface: "#FAF8F4",
+    bgInput: "#FFFFFF",
+    border: "#DDD9D0",
+    borderDivider: "#E8E4DC",
+    primary: "#1B2D4F",
+    primaryHover: "#243B68",
+    textPrimary: "#1A1A18",
+    textSecondary: "#6B6860",
+    textMuted: "#747270",
+    textOnPrimary: "#FAF8F4",
+    hoverItem: "rgba(27,45,79,0.07)",
+    focusRing: "rgba(27,45,79,0.40)",
+    btnMuted: "#8E8C88"
+  },
+  dark: {
+    bgApp: "#141412",
+    bgSurface: "#1C1C1A",
+    bgInput: "#262622",
+    border: "#333330",
+    borderDivider: "#2A2A28",
+    primary: "#BB532D",
+    primaryHover: "#CC6440",
+    textPrimary: "#F0EDE6",
+    textSecondary: "#B0ABA3",
+    textMuted: "#8E8C88",
+    textOnPrimary: "#FAF8F4",
+    hoverItem: "rgba(198,94,56,0.12)",
+    focusRing: "rgba(198,94,56,0.50)",
+    btnMuted: "#4A4845"
+  }
+};
+var DS_TYPOGRAPHY = {
+  fontDisplay: "'Nunito', sans-serif",
+  fontBody: "'Nunito Sans', sans-serif",
+  logo: { size: "20px", weight: 800, letterSpacing: "0.04em" },
+  heading: { size: "16px", weight: 700, letterSpacing: "-0.2px" },
+  cta: { size: "11px", weight: 800, letterSpacing: "0.12em", transform: "uppercase" },
+  body: { size: "13px", weight: 400 },
+  input: { size: "13px", weight: 300, style: "italic" },
+  search: { size: "12px", weight: 400 },
+  username: { size: "13px", weight: 600 },
+  avatar: { size: "11px", weight: 700 },
+  footer: { size: "12px", weight: 400 },
+  empty: { size: "11px", weight: 300, style: "italic" }
+};
+var DS_RADII = {
+  sidebar: 16,
+  input: 8,
+  cta: 7,
+  item: 6,
+  swatch: 10
+};
+var BRAND_COLORS = {
+  primary: {
+    50: "#EFF6FF",
+    100: "#DBEAFE",
+    200: "#BFDBFE",
+    300: "#93C5FD",
+    400: "#60A5FA",
+    500: "#3B82F6",
+    600: "#2563EB",
+    700: "#1D4ED8",
+    800: "#1E40AF",
+    900: "#1E3A8A"
+  },
+  secondary: {
+    50: "#F0FDF4",
+    100: "#DCFCE7",
+    200: "#BBF7D0",
+    300: "#86EFAC",
+    400: "#4ADE80",
+    500: "#10B981",
+    600: "#059669",
+    700: "#047857",
+    800: "#065F46",
+    900: "#064E3B"
+  },
+  accent: {
+    purple: "#8B5CF6",
+    cyan: "#06B6D4",
+    sky: "#0EA5E9",
+    lime: "#84CC16",
+    amber: "#F59E0B",
+    red: "#EF4444"
+  }
+};
+var LEVEL_COLORS = {
+  level0: BRAND_COLORS.primary[500],
+  level1: BRAND_COLORS.primary[400],
+  level2: BRAND_COLORS.primary[300],
+  level3: BRAND_COLORS.primary[200],
+  level4: BRAND_COLORS.primary[300],
+  level5: BRAND_COLORS.primary[400],
+  level6: BRAND_COLORS.primary[500],
+  level7: BRAND_COLORS.primary[600],
+  level8: BRAND_COLORS.primary[700]
+};
+var LEVEL_COLOR_ARRAY = [
+  LEVEL_COLORS.level0,
+  LEVEL_COLORS.level1,
+  LEVEL_COLORS.level2,
+  LEVEL_COLORS.level3,
+  LEVEL_COLORS.level4,
+  LEVEL_COLORS.level5,
+  LEVEL_COLORS.level6,
+  LEVEL_COLORS.level7,
+  LEVEL_COLORS.level8
+];
+var PARENT_FALLBACK_COLORS = [
+  "#12C7D3",
+  "#325E8C",
+  "#8A70A6",
+  "#F54A57",
+  "#FF6C4D",
+  "#F28C16",
+  "#FFD347",
+  "#7F7F7F",
+  "#8D8D8D"
+];
+var SEMANTIC_COLORS = {
+  success: BRAND_COLORS.secondary[500],
+  error: BRAND_COLORS.accent.red,
+  warning: BRAND_COLORS.accent.amber,
+  info: BRAND_COLORS.primary[500]
+};
+var THEME_COLORS = {
+  light: {
+    background: { primary: "#FAF8F4", secondary: "#F0EDE6", tertiary: "#FFFFFF" },
+    text: { primary: "#1A1A18", secondary: "#6B6860", tertiary: "#747270" },
+    border: { primary: "#DDD9D0", secondary: "#E8E4DC" }
+  },
+  dark: {
+    background: { primary: "#1C1C1A", secondary: "#141412", tertiary: "#262622" },
+    text: { primary: "#F0EDE6", secondary: "#B0ABA3", tertiary: "#8E8C88" },
+    border: { primary: "#333330", secondary: "#2A2A28" }
+  }
+};
+var CANVAS_COLORS = {
+  node: {
+    border: "#FFFFFF",
+    titleColor: "#1e1b4b",
+    badgeBackground: "#FFC107",
+    badgeStroke: "#fcd34d"
+  }
+};
+var SPACING = {
+  xs: 4,
+  sm: 8,
+  md: 16,
+  lg: 24,
+  xl: 32,
+  "2xl": 48,
+  "3xl": 64,
+  "4xl": 96
+};
+var LAYOUT_SPACING = {
+  nodeSpacing: 200,
+  levelSpacing: 150,
+  containerPadding: 20,
+  gridSize: 50
+};
+var FONTS = {
+  primary: "'Inter', sans-serif",
+  secondary: "'Poppins', sans-serif",
+  mono: "'Roboto Mono', monospace"
+};
+var FONT_SIZES = {
+  xs: "0.75rem",
+  sm: "0.875rem",
+  base: "1rem",
+  lg: "1.125rem",
+  xl: "1.25rem",
+  "2xl": "1.5rem",
+  "3xl": "1.875rem",
+  "4xl": "2.25rem"
+};
+function getColorForLevel(level) {
+  return LEVEL_COLOR_ARRAY[level % LEVEL_COLOR_ARRAY.length];
+}
+function darkenHexColor(hex, amount = 0.22) {
+  if (!hex || !hex.startsWith("#")) return hex;
+  let r, g, b;
+  if (hex.length === 4) {
+    r = parseInt(hex[1] + hex[1], 16);
+    g = parseInt(hex[2] + hex[2], 16);
+    b = parseInt(hex[3] + hex[3], 16);
+  } else if (hex.length === 7) {
+    r = parseInt(hex.slice(1, 3), 16);
+    g = parseInt(hex.slice(3, 5), 16);
+    b = parseInt(hex.slice(5, 7), 16);
+  } else {
+    return hex;
+  }
+  if (isNaN(r) || isNaN(g) || isNaN(b)) return hex;
+  const rn = r / 255, gn = g / 255, bn = b / 255;
+  const cmax = Math.max(rn, gn, bn), cmin = Math.min(rn, gn, bn);
+  const d = cmax - cmin;
+  const l = (cmax + cmin) / 2;
+  const s = d === 0 ? 0 : d / (1 - Math.abs(2 * l - 1));
+  let h = 0;
+  if (d !== 0) {
+    const seg = cmax === rn ? (gn - bn) / d : cmax === gn ? (bn - rn) / d + 2 : (rn - gn) / d + 4;
+    h = (seg * 60 + 360) % 360;
+  }
+  const newL = Math.max(0, l - amount);
+  const c2 = (1 - Math.abs(2 * newL - 1)) * s;
+  const x2 = c2 * (1 - Math.abs(h / 60 % 2 - 1));
+  const m2 = newL - c2 / 2;
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (h < 60) {
+    r1 = c2;
+    g1 = x2;
+    b1 = 0;
+  } else if (h < 120) {
+    r1 = x2;
+    g1 = c2;
+    b1 = 0;
+  } else if (h < 180) {
+    r1 = 0;
+    g1 = c2;
+    b1 = x2;
+  } else if (h < 240) {
+    r1 = 0;
+    g1 = x2;
+    b1 = c2;
+  } else if (h < 300) {
+    r1 = x2;
+    g1 = 0;
+    b1 = c2;
+  } else {
+    r1 = c2;
+    g1 = 0;
+    b1 = x2;
+  }
+  const toHex = (v) => Math.round((v + m2) * 255).toString(16).padStart(2, "0");
+  return `#${toHex(r1)}${toHex(g1)}${toHex(b1)}`;
+}
+function getThemeBackground(isDark, variant = "primary") {
+  return isDark ? THEME_COLORS.dark.background[variant] : THEME_COLORS.light.background[variant];
+}
+function getThemeText(isDark, variant = "primary") {
+  return isDark ? THEME_COLORS.dark.text[variant] : THEME_COLORS.light.text[variant];
+}
+function getThemeBorder(isDark, variant = "primary") {
+  return isDark ? THEME_COLORS.dark.border[variant] : THEME_COLORS.light.border[variant];
+}
+
+// src/parser/configUtils.ts
+function createMindMapConfig(nodes, topLevelConnections, title = "Untitled Mindmap") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      title,
+      description: `Interactive mindmap with ${nodes.length} nodes`,
+      version: "1.0.0",
+      created: now,
+      lastModified: now
+    },
+    nodes,
+    topLevelConnections,
+    settings: {
+      defaultColors: {
+        level0: LEVEL_COLORS.level0,
+        level1: LEVEL_COLORS.level1,
+        level2: LEVEL_COLORS.level2,
+        level3: LEVEL_COLORS.level3
+      },
+      layout: {
+        nodeSpacing: LAYOUT_SPACING.nodeSpacing,
+        levelSpacing: LAYOUT_SPACING.levelSpacing
+      }
+    }
+  };
+}
+function generateId(prefix, level, index) {
+  return `${prefix}-l${level}-${index}`;
+}
+function generateLevelNodes(parentId, level, maxLevels, xOffset = 0, yOffset = 0) {
+  if (level >= maxLevels) return [];
+  const count = 5;
+  const levelSpacing = 200;
+  const nodeSpacing = 300;
+  const nodes = [];
+  for (let i = 0; i < count; i++) {
+    const nodeId = parentId ? generateId(`${parentId}-${i}`, level, i) : generateId("root", level, i);
+    const x = xOffset + (i - (count - 1) / 2) * nodeSpacing;
+    const y = yOffset + level * levelSpacing;
+    const node = {
+      id: nodeId,
+      title: `Level ${level} Node ${i + 1}`,
+      level,
+      x,
+      y,
+      color: getColorForLevel(level),
+      relationshipLabel: level > 0 ? "child" : void 0,
+      parent: parentId ?? void 0
+    };
+    const children = generateLevelNodes(nodeId, level + 1, maxLevels, x, y + levelSpacing);
+    if (children.length > 0) node.children = children;
+    nodes.push(node);
+  }
+  return nodes;
+}
+function generateSampleConfig(maxLevels = 9) {
+  const nodes = generateLevelNodes(null, 0, maxLevels, 0, 0);
+  const topLevelConnections = nodes.slice(0, -1).map((n, i) => ({
+    from: n.id,
+    to: nodes[i + 1].id,
+    label: "related to"
+  }));
+  return {
+    metadata: {
+      id: `mindmap-${Date.now()}`,
+      title: "Sample Mind Map",
+      description: "A sample mind map",
+      version: "1.0.0",
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      lastModified: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    nodes,
+    topLevelConnections,
+    settings: {
+      defaultColors: {
+        level0: LEVEL_COLORS.level0,
+        level1: LEVEL_COLORS.level1,
+        level2: LEVEL_COLORS.level2,
+        level3: LEVEL_COLORS.level3,
+        level4: LEVEL_COLORS.level4,
+        level5: LEVEL_COLORS.level5,
+        level6: LEVEL_COLORS.level6,
+        level7: LEVEL_COLORS.level7,
+        level8: LEVEL_COLORS.level8
+      },
+      layout: {
+        nodeSpacing: LAYOUT_SPACING.nodeSpacing,
+        levelSpacing: LAYOUT_SPACING.levelSpacing
+      }
+    }
+  };
+}
+
+// src/constants/performanceConstants.ts
+var FPS_TARGET = 60;
+var FPS_WARNING_THRESHOLD = 45;
+var FPS_CRITICAL_THRESHOLD = 30;
+var TARGET_FRAME_TIME = 1e3 / FPS_TARGET;
+var MAX_FRAME_TIME = 18;
+var FPS_TARGETS = {
+  PAN_MIN: 30,
+  ZOOM_TARGET: 60,
+  WARNING_THRESHOLD: 20
+};
+var TIMING_THRESHOLDS = {
+  VIEWPORT_QUERY_MAX: 5,
+  SPATIAL_UPDATE_MAX: 10,
+  DRAG_RESPONSE_MAX: 16,
+  LOAD_5K_TARGET: 2e3,
+  LOAD_10K_TARGET: 3e3,
+  VIEWPORT_DEBOUNCE: 100,
+  SPATIAL_INDEX_BUILD: 50
+};
+var MEMORY_TARGET_MB = 500;
+var MEMORY_WARNING_MB = 600;
+var MEMORY_CRITICAL_MB = 800;
+var MEMORY_LIMITS = {
+  MAX_10K_NODES: 500,
+  MAX_GROWTH_PERCENT: 20,
+  WARNING_THRESHOLD: 400
+};
+var VIEWPORT_MARGIN = 0.1;
+var MAX_VISIBLE_NODES = 800;
+var CULLING_QUERY_TIME_BUDGET = 5;
+var RBUSH_MAX_ENTRIES = 16;
+var SPATIAL_INDEX_BUILD_BUDGET = 50;
+var NODE_MIN_WIDTH = 200;
+var NODE_HEIGHT = 80;
+var NODE_PADDING = 40;
+var CHAR_WIDTH = 8;
+var TITLE_MAX_LENGTH = 150;
+var CORNER_RADIUS = 8;
+var BORDER_WIDTH_NORMAL = 2;
+var BORDER_WIDTH_SELECTED = 3;
+var COLOR_SELECTED = "#1B2D4F";
+var COLOR_BORDER_LIGHT = "#4A3728";
+var COLOR_BORDER_DARK = "#FAF6F1";
+var COLOR_DEFAULT_NODE = "#FAF6F1";
+var ZOOM_MIN = 0.05;
+var ZOOM_MAX = 5;
+var ZOOM_DEFAULT = 1;
+var ZOOM_STEP = 0.1;
+var ZOOM_WHEEL_SENSITIVITY = 1e-3;
+var ZOOM_NAV_IN_THRESHOLD = 2.7;
+var ZOOM_NAV_OUT_THRESHOLD = 0.4;
+var TEXT_LABEL_HIDE_BELOW_ZOOM = 0.3;
+var QUALITY_HIGH = {
+  shadows: true,
+  bezierCurves: true,
+  animations: true,
+  textQuality: "high",
+  antialiasing: true
+};
+var QUALITY_MEDIUM = {
+  shadows: false,
+  bezierCurves: true,
+  animations: true,
+  textQuality: "medium",
+  antialiasing: true
+};
+var QUALITY_LOW = {
+  shadows: false,
+  bezierCurves: false,
+  animations: false,
+  textQuality: "low",
+  antialiasing: false
+};
+var FPS_SAMPLE_WINDOW = 60;
+var FPS_UPDATE_INTERVAL = 1e3;
+var MEMORY_CHECK_INTERVAL = 5e3;
+var PERFORMANCE_TOAST_COOLDOWN = 1e4;
+var FPS_DOWNGRADE_THRESHOLD = 45;
+var FPS_UPGRADE_THRESHOLD = 58;
+var FPS_STABILIZATION_FRAMES = 180;
+var DEFAULT_CANVAS_WIDTH = 1920;
+var DEFAULT_CANVAS_HEIGHT = 1080;
+var CLICK_THRESHOLD = 5;
+var DOUBLE_CLICK_DELAY = 300;
+var DRAG_START_DISTANCE = 10;
+var MAX_NODES = 2e4;
+var CIRCULAR_REFERENCE_MAX_DEPTH = 1e3;
+var RESIZE_DEBOUNCE = 300;
+var SCROLL_THROTTLE = 16;
+var SEARCH_DEBOUNCE = 500;
+var NODE_COUNT_THRESHOLDS = {
+  SPATIAL_INDEX_MIN: 100,
+  VIEWPORT_CULLING_MIN: 500,
+  CANVAS_RENDERING_MIN: 2e3,
+  DOM_RENDERING_MAX: 5e3
+};
+var VIEWPORT_CONFIG = {
+  BUFFER_PERCENT: 0.2,
+  MIN_VISIBLE_NODES: 10
+};
+
+// src/constants/renderConfig.ts
+var DEFAULT_RENDER_CONFIG = {
+  renderMode: "canvas",
+  qualityLevel: "high",
+  cullingEnabled: false,
+  fpsTarget: FPS_TARGET,
+  memoryLimit: MEMORY_TARGET_MB
+};
+var SIMPLIFIED_RENDER_CONFIG = {
+  renderMode: "simplified",
+  qualityLevel: "low",
+  cullingEnabled: true,
+  fpsTarget: 30,
+  memoryLimit: 400
+};
+var QUALITY_SETTINGS = {
+  high: QUALITY_HIGH,
+  medium: QUALITY_MEDIUM,
+  low: QUALITY_LOW
+};
+var FEATURE_FLAGS = {
+  viewportCulling: true,
+  spatialIndexing: true,
+  shadows: true,
+  bezierCurves: true,
+  animations: true,
+  branchBadges: true,
+  autoQualityAdjustment: true,
+  performanceMonitoring: true,
+  performanceToasts: true,
+  debugOverlay: false,
+  showFPS: false,
+  showMemory: false,
+  showVisibleCount: false
+};
+var RENDER_MODES = {
+  canvas: {
+    name: "Canvas",
+    description: "Full Konva canvas rendering with all features",
+    features: { culling: true, shadows: true, bezierCurves: true, animations: true }
+  },
+  simplified: {
+    name: "Simplified",
+    description: "Reduced feature set for low-end devices",
+    features: { culling: true, shadows: false, bezierCurves: false, animations: false }
+  }
+};
+var QUALITY_LEVELS = {
+  high: { name: "High", description: "All visual features enabled", targetFPS: 60, features: QUALITY_HIGH },
+  medium: { name: "Medium", description: "Shadows disabled, other features enabled", targetFPS: 60, features: QUALITY_MEDIUM },
+  low: { name: "Low", description: "Minimal visual features, max performance", targetFPS: 30, features: QUALITY_LOW }
+};
+function getOptimalQualityLevel(currentFPS, currentQuality) {
+  if (currentFPS < 45 && currentQuality === "high") return "medium";
+  if (currentFPS < 30 && currentQuality === "medium") return "low";
+  if (currentFPS > 58 && currentQuality === "low") return "medium";
+  if (currentFPS > 58 && currentQuality === "medium") return "high";
+  return currentQuality;
+}
+function getRenderConfigForQuality(quality) {
+  return { qualityLevel: quality, fpsTarget: QUALITY_LEVELS[quality].targetFPS };
+}
+function isFeatureEnabled(featureName, config) {
+  if (!FEATURE_FLAGS[featureName]) return false;
+  const qs = QUALITY_SETTINGS[config.qualityLevel];
+  switch (featureName) {
+    case "shadows":
+      return qs.shadows;
+    case "bezierCurves":
+      return qs.bezierCurves;
+    case "animations":
+      return qs.animations;
+    default:
+      return FEATURE_FLAGS[featureName];
+  }
+}
+function getRecommendedRenderConfig() {
+  if (typeof performance === "undefined" || !performance["memory"]) {
+    return SIMPLIFIED_RENDER_CONFIG;
+  }
+  const memory = performance["memory"];
+  if (memory?.["jsHeapSizeLimit"] && memory["jsHeapSizeLimit"] < 512 * 1024 * 1024) {
+    return SIMPLIFIED_RENDER_CONFIG;
+  }
+  return DEFAULT_RENDER_CONFIG;
+}
+
+// src/viewport/viewportUtils.ts
+function calculateViewportBounds(viewport, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  const worldW = canvasWidth / viewport.zoomLevel;
+  const worldH = canvasHeight / viewport.zoomLevel;
+  const mx = worldW * VIEWPORT_MARGIN;
+  const my = worldH * VIEWPORT_MARGIN;
+  return {
+    minX: viewport.centerX - worldW / 2 - mx,
+    minY: viewport.centerY - worldH / 2 - my,
+    maxX: viewport.centerX + worldW / 2 + mx,
+    maxY: viewport.centerY + worldH / 2 + my
+  };
+}
+function recalculateViewportBounds(viewport, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  return {
+    ...viewport,
+    visibleBounds: calculateViewportBounds(viewport, canvasWidth, canvasHeight)
+  };
+}
+function worldToScreen(worldX, worldY, viewport, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  return {
+    x: (worldX - viewport.centerX) * viewport.zoomLevel + canvasWidth / 2,
+    y: (worldY - viewport.centerY) * viewport.zoomLevel + canvasHeight / 2
+  };
+}
+function screenToWorld(screenX, screenY, viewport, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  return {
+    x: (screenX - canvasWidth / 2) / viewport.zoomLevel + viewport.centerX,
+    y: (screenY - canvasHeight / 2) / viewport.zoomLevel + viewport.centerY
+  };
+}
+function clampZoom(zoom) {
+  return Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, zoom));
+}
+function panViewport(deltaX, deltaY, viewport) {
+  return {
+    ...viewport,
+    centerX: viewport.centerX - deltaX / viewport.zoomLevel,
+    centerY: viewport.centerY - deltaY / viewport.zoomLevel
+  };
+}
+function setViewportCenter(x, y, viewport) {
+  return { ...viewport, centerX: x, centerY: y };
+}
+function zoomViewport(delta, viewport, pivotX, pivotY, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  const newZoom = clampZoom(viewport.zoomLevel * (1 + delta));
+  let cx = viewport.centerX;
+  let cy = viewport.centerY;
+  if (pivotX !== void 0 && pivotY !== void 0) {
+    const worldPivot = screenToWorld(pivotX, pivotY, viewport, canvasWidth, canvasHeight);
+    cx = worldPivot.x - (pivotX - canvasWidth / 2) / newZoom;
+    cy = worldPivot.y - (pivotY - canvasHeight / 2) / newZoom;
+  }
+  return { ...viewport, centerX: cx, centerY: cy, zoomLevel: newZoom };
+}
+function focusOnNode(nodeX, nodeY, zoom) {
+  const clamped = clampZoom(zoom);
+  return {
+    centerX: nodeX,
+    centerY: nodeY,
+    zoomLevel: clamped,
+    rotation: 0,
+    visibleBounds: calculateViewportBounds(
+      { centerX: nodeX, centerY: nodeY, zoomLevel: clamped, rotation: 0, visibleBounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 } }
+    )
+  };
+}
+function isNodeInViewport(nodeX, nodeY, nodeWidth, nodeHeight, viewport, canvasWidth = DEFAULT_CANVAS_WIDTH, canvasHeight = DEFAULT_CANVAS_HEIGHT) {
+  const bounds = calculateViewportBounds(viewport, canvasWidth, canvasHeight);
+  const hw = nodeWidth / 2;
+  const hh = nodeHeight / 2;
+  return !(nodeX + hw < bounds.minX || nodeX - hw > bounds.maxX || nodeY + hh < bounds.minY || nodeY - hh > bounds.maxY);
+}
+
+// src/performance/performanceMonitor.ts
+var FPSMonitor = class {
+  constructor() {
+    this.frameTimes = [];
+    this.lastTime = 0;
+    this.currentFPS = FPS_TARGET;
+    this.rafId = null;
+  }
+  start() {
+    if (this.rafId !== null) return;
+    const measure = (ts) => {
+      if (this.lastTime > 0) {
+        this.frameTimes.push(ts - this.lastTime);
+        if (this.frameTimes.length > FPS_SAMPLE_WINDOW) this.frameTimes.shift();
+        this.currentFPS = this.calc();
+      }
+      this.lastTime = ts;
+      this.rafId = requestAnimationFrame(measure);
+    };
+    this.rafId = requestAnimationFrame(measure);
+  }
+  stop() {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+  }
+  calc() {
+    if (this.frameTimes.length === 0) return FPS_TARGET;
+    const avg = this.frameTimes.reduce((a, b) => a + b, 0) / this.frameTimes.length;
+    return Math.round(1e3 / avg);
+  }
+  getFPS() {
+    return this.currentFPS;
+  }
+  getAverageFPS() {
+    return this.currentFPS;
+  }
+  getP95FrameTime() {
+    if (this.frameTimes.length === 0) return 0;
+    const sorted = [...this.frameTimes].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length * 0.95)];
+  }
+  reset() {
+    this.frameTimes = [];
+    this.currentFPS = FPS_TARGET;
+  }
+};
+var MemoryMonitor = class {
+  constructor() {
+    this.timer = null;
+    this.current = 0;
+  }
+  start(onUpdate) {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => {
+      this.current = this.measure();
+      onUpdate?.(this.current);
+    }, MEMORY_CHECK_INTERVAL);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  measure() {
+    const mem = performance["memory"];
+    return mem ? mem["usedJSHeapSize"] / (1024 * 1024) : 0;
+  }
+  getMemoryMB() {
+    return this.current;
+  }
+  getStats() {
+    const mem = performance["memory"];
+    if (!mem) return null;
+    return {
+      usedJSHeapSize: mem["usedJSHeapSize"],
+      totalJSHeapSize: mem["totalJSHeapSize"],
+      jsHeapSizeLimit: mem["jsHeapSizeLimit"],
+      heapUsagePercent: mem["usedJSHeapSize"] / mem["jsHeapSizeLimit"] * 100
+    };
+  }
+  static isSupported() {
+    return !!performance["memory"];
+  }
+};
+var PerformanceProfiler = class {
+  constructor() {
+    this.marks = /* @__PURE__ */ new Map();
+    this.measures = /* @__PURE__ */ new Map();
+  }
+  mark(label) {
+    this.marks.set(label, performance.now());
+  }
+  measure(label) {
+    const start = this.marks.get(label);
+    if (start === void 0) return 0;
+    const duration = performance.now() - start;
+    const list = this.measures.get(label) ?? [];
+    list.push(duration);
+    this.measures.set(label, list);
+    this.marks.delete(label);
+    return duration;
+  }
+  getAverage(label) {
+    const list = this.measures.get(label);
+    if (!list?.length) return 0;
+    return list.reduce((a, b) => a + b, 0) / list.length;
+  }
+  getP95(label) {
+    const list = this.measures.get(label);
+    if (!list?.length) return 0;
+    const sorted = [...list].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length * 0.95)];
+  }
+  clear(label) {
+    if (label) {
+      this.marks.delete(label);
+      this.measures.delete(label);
+    } else {
+      this.marks.clear();
+      this.measures.clear();
+    }
+  }
+};
+
+// src/animations/easing.ts
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+var easeInOutQuart = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeInCubic = (t) => t * t * t;
+var easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+var easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+function createCubicBezier(x1, y1, x2, y2) {
+  const N = 256;
+  const lut = new Float64Array(N + 1);
+  for (let i = 0; i <= N; i++) {
+    const target = i / N;
+    let lo = 0, hi = 1;
+    for (let j = 0; j < 20; j++) {
+      const mid = (lo + hi) / 2;
+      const om = 1 - mid;
+      const x = 3 * om * om * mid * x1 + 3 * om * mid * mid * x2 + mid * mid * mid;
+      if (x < target) lo = mid;
+      else hi = mid;
+    }
+    const u = (lo + hi) / 2;
+    const ou = 1 - u;
+    lut[i] = 3 * ou * ou * u * y1 + 3 * ou * u * u * y2 + u * u * u;
+  }
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    const s = t * N;
+    const i = s | 0;
+    return lut[i] + (lut[i + 1] - lut[i]) * (s - i);
+  };
+}
+var easeZoomTransition = createCubicBezier(0.2, 0.8, 0.2, 1);
+
+// src/animations/constants.ts
+var ANIMATION_DURATION = {
+  ZOOM_IN_LAYER: 500,
+  ZOOM_OUT_LAYER: 500,
+  ZOOM_GESTURE: 500,
+  FADE_OUT: 200,
+  FADE_IN: 250,
+  COLOR_TRANSITION: 500,
+  CURSOR_CHANGE: 150,
+  LOADING_FADE: 200
+};
+var ANIMATION_PHASES = {
+  ZOOM_IN: {
+    ZOOM_TO_TARGET: 500,
+    FADE_OUT_START: 120,
+    FADE_OUT: 280,
+    CONTENT_SWAP: 310,
+    FADE_IN: 200,
+    TOTAL: 510
+  },
+  ZOOM_OUT: {
+    FADE_OUT: 200,
+    ZOOM_BACK: 50,
+    FADE_IN: 250,
+    TOTAL: 500
+  }
+};
+var ZOOM_THRESHOLDS = {
+  ENTER_LAYER: 5,
+  EXIT_LAYER: 0.5,
+  GESTURE_TRIGGER: 0.8
+};
+var COOLDOWN = {
+  NAVIGATION: 1e3,
+  ZOOM_GESTURE: 800,
+  DOUBLE_CLICK: 200
+};
+var OPACITY = {
+  VISIBLE: 1,
+  HIDDEN: 0,
+  TRANSITIONING: 0.3
+};
+var TARGET_ZOOM = {
+  NORMAL: 1,
+  FOCUSED: 0.8,
+  FILL_NODE: 3,
+  DETAIL: 2
+};
+var VIEWPORT_FRAMING = {
+  NODE_FILL_RATIO: 0.7,
+  EXIT_NODE_SIZE: 0.4,
+  PADDING_RATIO: 0.1
+};
+
+// src/spatial/spatialIndex.ts
+import RBush from "rbush";
+var RBushSpatialIndex = class {
+  constructor() {
+    this.tree = new RBush();
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  insert(nodeId, bounds) {
+    this.tree.insert({ ...bounds, nodeId });
+    this.cache.set(nodeId, bounds);
+  }
+  remove(nodeId, bounds) {
+    this.tree.remove({ ...bounds, nodeId }, (a, b) => a.nodeId === b.nodeId);
+    this.cache.delete(nodeId);
+  }
+  update(nodeId, oldBounds, newBounds) {
+    this.remove(nodeId, oldBounds);
+    this.insert(nodeId, newBounds);
+  }
+  query(bounds) {
+    return this.tree.search(bounds).map((item) => item.nodeId);
+  }
+  clear() {
+    this.tree.clear();
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  bulkLoad(items) {
+    const rbushItems = items.map(({ nodeId, bounds }) => ({ ...bounds, nodeId }));
+    this.tree.load(rbushItems);
+    for (const { nodeId, bounds } of items) this.cache.set(nodeId, bounds);
+  }
+  /** Return the cached bounding box for a node (undefined if not indexed). */
+  getBounds(nodeId) {
+    return this.cache.get(nodeId);
+  }
+};
+
+// ../../node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => {
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+      console.warn(
+        "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+      );
+    }
+    listeners.clear();
+  };
+  const api = { setState, getState, getInitialState, subscribe, destroy };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+// src/stores/index.ts
+var selectionStore = createStore((set, get) => ({
+  selectedId: null,
+  select: (nodeId) => set({ selectedId: nodeId }),
+  clear: () => set({ selectedId: null }),
+  toggle: (nodeId) => set((s) => ({ selectedId: s.selectedId === nodeId ? null : nodeId })),
+  isSelected: (nodeId) => get().selectedId === nodeId
+}));
+var renderConfigStore = createStore((set, get) => ({
+  ...DEFAULT_RENDER_CONFIG,
+  setQualityLevel: (level) => set(getRenderConfigForQuality(level)),
+  setRenderMode: (mode) => set({ renderMode: mode }),
+  setCullingEnabled: (enabled) => set({ cullingEnabled: enabled }),
+  autoAdjustQuality: (fps) => set((s) => {
+    const q = getOptimalQualityLevel(fps, s.qualityLevel);
+    return q !== s.qualityLevel ? getRenderConfigForQuality(q) : s;
+  }),
+  autoAdjustQualityByMemory: (mb) => set((s) => {
+    const q = mb > 500 ? "low" : mb > 400 && s.qualityLevel === "high" ? "medium" : s.qualityLevel;
+    return q !== s.qualityLevel ? getRenderConfigForQuality(q) : s;
+  }),
+  resetToDefaults: () => set({ ...DEFAULT_RENDER_CONFIG }),
+  isFeatureEnabled: (feature) => isFeatureEnabled(feature, get())
+}));
+
+// src/utils/navigation.ts
+function getConnectionsForLayer(doc, layerId) {
+  const layer = doc.layers.get(layerId);
+  if (!layer) return [];
+  return layer.connections.map((c) => ({
+    from: c.from,
+    to: c.to,
+    level: layer.level,
+    label: c.data?.label
+  }));
+}
+function getChildLayerForNode(doc, nodeId, currentLayerId) {
+  for (const [, layer] of doc.layers) {
+    if (layer.parentLayerId === currentLayerId && layer.parentNodeId === nodeId) {
+      return layer;
+    }
+  }
+  return null;
+}
+function getLayerForNavigation(doc, nodeId, currentLayerId) {
+  return getChildLayerForNode(doc, nodeId, currentLayerId);
+}
+function calculateFitZoom(nodes, canvasWidth, canvasHeight, padding = 0.15) {
+  if (nodes.length === 0) return 1;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    minX = Math.min(minX, n.x - n.width / 2);
+    minY = Math.min(minY, n.y - n.height / 2);
+    maxX = Math.max(maxX, n.x + n.width / 2);
+    maxY = Math.max(maxY, n.y + n.height / 2);
+  }
+  const rawW = maxX - minX;
+  const rawH = maxY - minY;
+  const spreadW = nodes.length === 1 ? Math.max(rawW, 600) : rawW;
+  const spreadH = nodes.length === 1 ? Math.max(rawH, 400) : rawH;
+  const zoomX = canvasWidth * (1 - padding) / spreadW;
+  const zoomY = canvasHeight * (1 - padding) / spreadH;
+  const z = Math.min(zoomX, zoomY);
+  return Math.max(z * 0.8, ZOOM_NAV_OUT_THRESHOLD);
+}
+function calculateFitCenter(nodes) {
+  if (nodes.length === 0) return { x: 0, y: 0 };
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const n of nodes) {
+    minX = Math.min(minX, n.x - n.width / 2);
+    minY = Math.min(minY, n.y - n.height / 2);
+    maxX = Math.max(maxX, n.x + n.width / 2);
+    maxY = Math.max(maxY, n.y + n.height / 2);
+  }
+  return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+}
+function getContainersForLayer(doc, layerId) {
+  const layer = doc.layers.get(layerId);
+  if (!layer) return [];
+  return layer.containers.map((c) => {
+    const label = c.data?.label ?? c.id;
+    return { id: c.id, label, nodeIds: c.nodes, level: layer.level };
+  });
+}
+function calculateFitView(nodes, canvasWidth, canvasHeight) {
+  const center = calculateFitCenter(nodes);
+  const zoom = calculateFitZoom(nodes, canvasWidth, canvasHeight);
+  return { centerX: center.x, centerY: center.y, zoomLevel: zoom };
+}
+
+// src/rendering/culling.ts
+var DEFAULT_SPATIAL_INDEX_THRESHOLD = 200;
+function getViewportVisibleNodes(options) {
+  const {
+    nodes,
+    viewport,
+    canvasWidth,
+    canvasHeight,
+    levelFilter,
+    skipCulling = false,
+    isDragging = false,
+    spatialIndex,
+    spatialIndexThreshold = DEFAULT_SPATIAL_INDEX_THRESHOLD
+  } = options;
+  const filtered = levelFilter !== void 0 ? nodes.filter((n) => n.level === levelFilter) : nodes;
+  if (filtered.length === 0) return [];
+  if (skipCulling || isDragging) return filtered;
+  const bounds = calculateViewportBounds(viewport, canvasWidth, canvasHeight);
+  if (filtered.length < spatialIndexThreshold) {
+    return filtered.filter(
+      (n) => n.x + n.width >= bounds.minX && n.x <= bounds.maxX && n.y + n.height >= bounds.minY && n.y <= bounds.maxY
+    );
+  }
+  if (spatialIndex) {
+    const nodeIds = spatialIndex.query({
+      minX: bounds.minX,
+      minY: bounds.minY,
+      maxX: bounds.maxX,
+      maxY: bounds.maxY
+    });
+    const idSet = new Set(nodeIds);
+    return filtered.filter((n) => idSet.has(n.id));
+  }
+  return filtered.filter(
+    (n) => n.x + n.width >= bounds.minX && n.x <= bounds.maxX && n.y + n.height >= bounds.minY && n.y <= bounds.maxY
+  );
+}
+
+// src/config/textScaling.ts
+var NODE_TEXT_BASE_FONT_PX = 28;
+var DESCRIPTION_TEXT_BASE_FONT_PX = 12;
+var CONTAINER_LABEL_BASE_FONT_PX = 24;
+var EDGE_LABEL_BASE_FONT_PX = 18;
+var OVERLAY_FONT_UPPER_BOOST_PX = 8;
+var NODE_TEXT_SAFE_BLOB_FILL_RATIO = 0.88;
+function computeNodeTextWorldScale(nodeWidth, zoomLevel) {
+  const safeZoom = Math.max(zoomLevel, 1e-4);
+  const baseRadiusX = nodeWidth / 2;
+  const baseRadiusY = Math.max(NODE_HEIGHT * 1.6 / 2, baseRadiusX * 0.74);
+  const textNaturalWidth = nodeWidth - 40;
+  const textNaturalHeight = NODE_HEIGHT - 20;
+  const maxScaleX = baseRadiusX * 2 * NODE_TEXT_SAFE_BLOB_FILL_RATIO / Math.max(textNaturalWidth, 1);
+  const maxScaleY = baseRadiusY * 2 * NODE_TEXT_SAFE_BLOB_FILL_RATIO / Math.max(textNaturalHeight, 1);
+  const fitScale = Math.max(0.01, Math.min(maxScaleX, maxScaleY));
+  return Math.min(1 / safeZoom, fitScale);
+}
+function computeNodeTextScreenScale(nodeWidth, zoomLevel) {
+  return computeNodeTextWorldScale(nodeWidth, zoomLevel) * zoomLevel;
+}
+function computeOverlayScale(zoomLevel) {
+  const safeZoom = Math.max(zoomLevel, 1e-4);
+  const inverseScale = 1 / safeZoom;
+  const maxScale = (NODE_TEXT_BASE_FONT_PX + OVERLAY_FONT_UPPER_BOOST_PX) / NODE_TEXT_BASE_FONT_PX;
+  return Math.min(Math.max(inverseScale, 1), maxScale);
+}
+function computeEdgeLabelScale(zoomLevel) {
+  const safeZoom = Math.max(zoomLevel, 1e-4);
+  return Math.min(Math.max(EDGE_LABEL_BASE_FONT_PX / safeZoom, 10), 32);
+}
+
+// src/config/blobShapes.ts
+var BLOB_LAYER_CONFIG = [
+  { opacity: 0.3, rotation: -15, scaleUp: 1.3, strokeWidth: 3, dash: [6, 4] },
+  // Layer #3 (outermost)
+  { opacity: 0.4, rotation: -10, scaleUp: 1.2, strokeWidth: 1, dash: void 0 },
+  // Layer #2
+  { opacity: 0.5, rotation: -5, scaleUp: 1.1, strokeWidth: 2, dash: void 0 }
+  // Layer #1
+];
+var NODE_LAYER_CONFIG = { opacity: 1, rotation: 0, strokeWidth: 3 };
+var ALL_BLOB_SHAPES = [
+  // Shape 0 · Blob 1
+  [
+    { x: 1.12, y: 0 },
+    { x: 0.86, y: 0.56 },
+    { x: 0.46, y: 0.94 },
+    { x: -0.08, y: 1.06 },
+    { x: -0.68, y: 0.82 },
+    { x: -0.96, y: 0.08 },
+    { x: -0.55, y: -0.82 },
+    { x: 0.04, y: -1.02 },
+    { x: 0.72, y: -0.8 },
+    { x: 1.08, y: -0.38 }
+  ],
+  // Shape 1 · Blob 2
+  [
+    { x: -0.489, y: -0.625 },
+    { x: -0.384, y: -0.716 },
+    { x: -0.285, y: -0.792 },
+    { x: -0.189, y: -0.855 },
+    { x: -0.09, y: -0.903 },
+    { x: 0.014, y: -0.932 },
+    { x: 0.129, y: -0.94 },
+    { x: 0.255, y: -0.924 },
+    { x: 0.412, y: -0.876 },
+    { x: 0.516, y: -0.832 },
+    { x: 0.612, y: -0.78 },
+    { x: 0.695, y: -0.725 },
+    { x: 0.767, y: -0.666 },
+    { x: 0.83, y: -0.606 },
+    { x: 0.885, y: -0.546 },
+    { x: 0.933, y: -0.486 },
+    { x: 0.979, y: -0.425 },
+    { x: 1.006, y: -0.385 },
+    { x: 1.034, y: -0.334 },
+    { x: 1.058, y: -0.276 },
+    { x: 1.078, y: -0.209 },
+    { x: 1.092, y: -0.133 },
+    { x: 1.101, y: -0.046 },
+    { x: 1.102, y: 0.052 },
+    { x: 1.094, y: 0.173 },
+    { x: 1.083, y: 0.244 },
+    { x: 1.063, y: 0.324 },
+    { x: 1.034, y: 0.401 },
+    { x: 0.996, y: 0.477 },
+    { x: 0.948, y: 0.549 },
+    { x: 0.889, y: 0.617 },
+    { x: 0.82, y: 0.681 },
+    { x: 0.735, y: 0.741 },
+    { x: 0.658, y: 0.783 },
+    { x: 0.569, y: 0.822 },
+    { x: 0.474, y: 0.855 },
+    { x: 0.372, y: 0.882 },
+    { x: 0.265, y: 0.904 },
+    { x: 0.156, y: 0.92 },
+    { x: 0.046, y: 0.931 },
+    { x: -0.069, y: 0.938 },
+    { x: -0.155, y: 0.935 },
+    { x: -0.25, y: 0.919 },
+    { x: -0.346, y: 0.89 },
+    { x: -0.443, y: 0.851 },
+    { x: -0.539, y: 0.8 },
+    { x: -0.633, y: 0.738 },
+    { x: -0.723, y: 0.667 },
+    { x: -0.808, y: 0.585 },
+    { x: -0.882, y: 0.501 },
+    { x: -0.944, y: 0.421 },
+    { x: -0.994, y: 0.343 },
+    { x: -1.034, y: 0.267 },
+    { x: -1.064, y: 0.192 },
+    { x: -1.085, y: 0.12 },
+    { x: -1.097, y: 0.042 },
+    { x: -1.102, y: 1e-3 },
+    { x: -1.09, y: -0.243 },
+    { x: -1.05, y: -0.365 },
+    { x: -0.99, y: -0.441 },
+    { x: -0.911, y: -0.479 },
+    { x: -0.819, y: -0.499 },
+    { x: -0.715, y: -0.517 },
+    { x: -0.605, y: -0.551 }
+  ],
+  // Shape 2 · Blob 3
+  [
+    { x: 3e-3, y: -0.97 },
+    { x: 0.163, y: -0.984 },
+    { x: 0.286, y: -1.028 },
+    { x: 0.389, y: -1.096 },
+    { x: 0.488, y: -1.174 },
+    { x: 0.597, y: -1.21 },
+    { x: 0.728, y: -1.165 },
+    { x: 0.867, y: -1.036 },
+    { x: 0.996, y: -0.839 },
+    { x: 1.098, y: -0.59 },
+    { x: 1.158, y: -0.304 },
+    { x: 1.153, y: 0.012 },
+    { x: 1.08, y: 0.336 },
+    { x: 0.944, y: 0.639 },
+    { x: 0.756, y: 0.889 },
+    { x: 0.484, y: 1.072 },
+    { x: 0.339, y: 1.079 },
+    { x: 0.219, y: 1.051 },
+    { x: 0.131, y: 0.994 },
+    { x: 0.059, y: 0.939 },
+    { x: 8e-3, y: 0.915 },
+    { x: -0.105, y: 0.931 },
+    { x: -0.176, y: 0.965 },
+    { x: -0.249, y: 1.005 },
+    { x: -0.345, y: 1.039 },
+    { x: -0.497, y: 1.055 },
+    { x: -0.672, y: 1.032 },
+    { x: -0.817, y: 0.952 },
+    { x: -0.945, y: 0.81 },
+    { x: -1.054, y: 0.6 },
+    { x: -1.16, y: 0.302 },
+    { x: -1.187, y: -0.011 },
+    { x: -1.165, y: -0.326 },
+    { x: -1.097, y: -0.599 },
+    { x: -0.991, y: -0.838 },
+    { x: -0.852, y: -0.912 },
+    { x: -0.695, y: -0.958 },
+    { x: -0.53, y: -0.988 },
+    { x: -0.357, y: -0.992 },
+    { x: -0.18, y: -0.983 }
+  ],
+  // Shape 3 · Blob 4
+  [
+    { x: -0.734, y: -1.127 },
+    { x: -0.656, y: -1.146 },
+    { x: -0.567, y: -1.142 },
+    { x: -0.468, y: -1.115 },
+    { x: -0.358, y: -1.079 },
+    { x: -0.238, y: -1.034 },
+    { x: -0.107, y: -0.989 },
+    { x: 0.035, y: -0.953 },
+    { x: 0.188, y: -0.929 },
+    { x: 0.325, y: -0.916 },
+    { x: 0.484, y: -0.896 },
+    { x: 0.65, y: -0.854 },
+    { x: 0.811, y: -0.77 },
+    { x: 0.955, y: -0.631 },
+    { x: 1.068, y: -0.422 },
+    { x: 1.138, y: -0.126 },
+    { x: 1.152, y: 0.272 },
+    { x: 1.121, y: 0.451 },
+    { x: 1.046, y: 0.602 },
+    { x: 0.928, y: 0.727 },
+    { x: 0.767, y: 0.833 },
+    { x: 0.565, y: 0.925 },
+    { x: 0.323, y: 1.001 },
+    { x: 0.042, y: 1.075 },
+    { x: -0.277, y: 1.142 },
+    { x: -0.368, y: 1.147 },
+    { x: -0.475, y: 1.136 },
+    { x: -0.589, y: 1.104 },
+    { x: -0.704, y: 1.05 },
+    { x: -0.815, y: 0.973 },
+    { x: -0.913, y: 0.871 },
+    { x: -0.993, y: 0.746 },
+    { x: -1.048, y: 0.593 },
+    { x: -1.109, y: 0.298 },
+    { x: -1.145, y: 0.018 },
+    { x: -1.154, y: -0.243 },
+    { x: -1.135, y: -0.482 },
+    { x: -1.085, y: -0.695 },
+    { x: -1.003, y: -0.874 },
+    { x: -0.886, y: -1.02 }
+  ],
+  // Shape 4 · Blob 5
+  [
+    { x: -0.734, y: 1.127 },
+    { x: -0.656, y: 1.146 },
+    { x: -0.567, y: 1.142 },
+    { x: -0.468, y: 1.115 },
+    { x: -0.358, y: 1.079 },
+    { x: -0.238, y: 1.034 },
+    { x: -0.107, y: 0.989 },
+    { x: 0.035, y: 0.953 },
+    { x: 0.188, y: 0.929 },
+    { x: 0.325, y: 0.916 },
+    { x: 0.484, y: 0.896 },
+    { x: 0.65, y: 0.854 },
+    { x: 0.811, y: 0.77 },
+    { x: 0.955, y: 0.631 },
+    { x: 1.068, y: 0.422 },
+    { x: 1.138, y: 0.126 },
+    { x: 1.152, y: -0.272 },
+    { x: 1.121, y: -0.451 },
+    { x: 1.046, y: -0.602 },
+    { x: 0.928, y: -0.727 },
+    { x: 0.767, y: -0.833 },
+    { x: 0.565, y: -0.925 },
+    { x: 0.323, y: -1.001 },
+    { x: 0.042, y: -1.075 },
+    { x: -0.277, y: -1.142 },
+    { x: -0.368, y: -1.147 },
+    { x: -0.475, y: -1.136 },
+    { x: -0.589, y: -1.104 },
+    { x: -0.704, y: -1.05 },
+    { x: -0.815, y: -0.973 },
+    { x: -0.913, y: -0.871 },
+    { x: -0.993, y: -0.746 },
+    { x: -1.048, y: -0.593 },
+    { x: -1.109, y: -0.298 },
+    { x: -1.145, y: -0.018 },
+    { x: -1.154, y: 0.243 },
+    { x: -1.135, y: 0.482 },
+    { x: -1.085, y: 0.695 },
+    { x: -1.003, y: 0.874 },
+    { x: -0.886, y: 1.02 }
+  ],
+  // Shape 5 · Blob 6
+  [
+    { x: 1e-3, y: -1.006 },
+    { x: 0.134, y: -1.001 },
+    { x: 0.262, y: -1.024 },
+    { x: 0.382, y: -1.073 },
+    { x: 0.498, y: -1.107 },
+    { x: 0.614, y: -1.105 },
+    { x: 0.733, y: -1.049 },
+    { x: 0.85, y: -0.932 },
+    { x: 0.953, y: -0.755 },
+    { x: 1.03, y: -0.529 },
+    { x: 1.067, y: -0.265 },
+    { x: 1.054, y: 0.018 },
+    { x: 0.986, y: 0.3 },
+    { x: 0.868, y: 0.557 },
+    { x: 0.715, y: 0.766 },
+    { x: 0.55, y: 0.909 },
+    { x: 0.396, y: 0.984 },
+    { x: 0.262, y: 1.005 },
+    { x: 0.148, y: 1.003 },
+    { x: 0.037, y: 1.008 },
+    { x: -0.083, y: 1.04 },
+    { x: -0.22, y: 1.118 },
+    { x: -0.36, y: 1.192 },
+    { x: -0.5, y: 1.234 },
+    { x: -0.65, y: 1.175 },
+    { x: -0.81, y: 1.045 },
+    { x: -0.99, y: 0.855 },
+    { x: -1.14, y: 0.61 },
+    { x: -1.24, y: 0.33 },
+    { x: -1.27, y: 0.04 },
+    { x: -1.275, y: -0.25 },
+    { x: -1.225, y: -0.5 },
+    { x: -1.08, y: -0.72 },
+    { x: -0.89, y: -0.92 },
+    { x: -0.734, y: -1.053 },
+    { x: -0.614, y: -1.112 },
+    { x: -0.498, y: -1.127 },
+    { x: -0.381, y: -1.11 },
+    { x: -0.261, y: -1.095 },
+    { x: -0.133, y: -1.058 },
+    { x: 1e-3, y: -1.01 },
+    { x: 0.134, y: -1.001 }
+  ]
+];
+var ACTIVE_BLOB_TYPES = [0, 1, 2, 3, 4, 5];
+var BLOB_TEXT_OFFSETS = [0, 0, 0, 0, 0, -0.1];
+function getBlobTypeForLayer(level) {
+  const numTypes = ACTIVE_BLOB_TYPES.length;
+  if (numTypes <= 1) return ACTIVE_BLOB_TYPES[0] ?? 0;
+  let currentType = 0;
+  for (let i = 1; i <= level; i++) {
+    const pseudoRandom = Math.floor(Math.abs(Math.sin((i + 1) * 12.9898) * 43758.5453));
+    const stepOffset = pseudoRandom % (numTypes - 1) + 1;
+    currentType = (currentType + stepOffset) % numTypes;
+  }
+  return ACTIVE_BLOB_TYPES[currentType];
+}
+function drawBlobPath(ctx, radiusX, radiusY, blobType) {
+  const srcPts = ALL_BLOB_SHAPES[blobType] ?? ALL_BLOB_SHAPES[0];
+  const pts = srcPts.map((p) => ({ x: p.x * radiusX, y: p.y * radiusY }));
+  ctx.beginPath();
+  const last = pts[pts.length - 1];
+  const first = pts[0];
+  ctx.moveTo((last.x + first.x) / 2, (last.y + first.y) / 2);
+  for (let i = 0; i < pts.length; i++) {
+    const curr = pts[i];
+    const next = pts[(i + 1) % pts.length];
+    ctx.quadraticCurveTo(curr.x, curr.y, (curr.x + next.x) / 2, (curr.y + next.y) / 2);
+  }
+  ctx.closePath();
+}
+export {
+  ACTIVE_BLOB_TYPES,
+  ALL_BLOB_SHAPES,
+  ANIMATION_DURATION,
+  ANIMATION_PHASES,
+  BLOB_LAYER_CONFIG,
+  BLOB_TEXT_OFFSETS,
+  BORDER_WIDTH_NORMAL,
+  BORDER_WIDTH_SELECTED,
+  BRAND_COLORS,
+  CANVAS_COLORS,
+  CHAR_WIDTH,
+  CIRCULAR_REFERENCE_MAX_DEPTH,
+  CLICK_THRESHOLD,
+  COLOR_BORDER_DARK,
+  COLOR_BORDER_LIGHT,
+  COLOR_DEFAULT_NODE,
+  COLOR_SELECTED,
+  CONTAINER_LABEL_BASE_FONT_PX,
+  COOLDOWN,
+  CORNER_RADIUS,
+  CULLING_QUERY_TIME_BUDGET,
+  DEFAULT_CANVAS_HEIGHT,
+  DEFAULT_CANVAS_WIDTH,
+  DEFAULT_RENDER_CONFIG,
+  DESCRIPTION_TEXT_BASE_FONT_PX,
+  DOUBLE_CLICK_DELAY,
+  DRAG_START_DISTANCE,
+  DS_COLORS,
+  DS_RADII,
+  DS_TYPOGRAPHY,
+  EDGE_LABEL_BASE_FONT_PX,
+  FEATURE_FLAGS,
+  FONTS,
+  FONT_SIZES,
+  FPSMonitor,
+  FPS_CRITICAL_THRESHOLD,
+  FPS_DOWNGRADE_THRESHOLD,
+  FPS_SAMPLE_WINDOW,
+  FPS_STABILIZATION_FRAMES,
+  FPS_TARGET,
+  FPS_TARGETS,
+  FPS_UPDATE_INTERVAL,
+  FPS_UPGRADE_THRESHOLD,
+  FPS_WARNING_THRESHOLD,
+  LAYOUT_SPACING,
+  LEVEL_COLORS,
+  LEVEL_COLOR_ARRAY,
+  MAX_FRAME_TIME,
+  MAX_NODES,
+  MAX_VISIBLE_NODES,
+  MEMORY_CHECK_INTERVAL,
+  MEMORY_CRITICAL_MB,
+  MEMORY_LIMITS,
+  MEMORY_TARGET_MB,
+  MEMORY_WARNING_MB,
+  MemoryMonitor,
+  NODE_COUNT_THRESHOLDS,
+  NODE_HEIGHT,
+  NODE_LAYER_CONFIG,
+  NODE_MIN_WIDTH,
+  NODE_PADDING,
+  NODE_TEXT_BASE_FONT_PX,
+  OPACITY,
+  OVERLAY_FONT_UPPER_BOOST_PX,
+  PARENT_FALLBACK_COLORS,
+  PERFORMANCE_TOAST_COOLDOWN,
+  PerformanceProfiler,
+  QUALITY_HIGH,
+  QUALITY_LEVELS,
+  QUALITY_LOW,
+  QUALITY_MEDIUM,
+  QUALITY_SETTINGS,
+  RBUSH_MAX_ENTRIES,
+  RBushSpatialIndex,
+  RENDER_MODES,
+  RESIZE_DEBOUNCE,
+  SCROLL_THROTTLE,
+  SEARCH_DEBOUNCE,
+  SEMANTIC_COLORS,
+  SIMPLIFIED_RENDER_CONFIG,
+  SPACING,
+  SPATIAL_INDEX_BUILD_BUDGET,
+  TARGET_FRAME_TIME,
+  TARGET_ZOOM,
+  TEXT_LABEL_HIDE_BELOW_ZOOM,
+  THEME_COLORS,
+  TIMING_THRESHOLDS,
+  TITLE_MAX_LENGTH,
+  VIEWPORT_CONFIG,
+  VIEWPORT_FRAMING,
+  VIEWPORT_MARGIN,
+  VisualliParseError,
+  ZOOM_DEFAULT,
+  ZOOM_MAX,
+  ZOOM_MIN,
+  ZOOM_NAV_IN_THRESHOLD,
+  ZOOM_NAV_OUT_THRESHOLD,
+  ZOOM_STEP,
+  ZOOM_THRESHOLDS,
+  ZOOM_WHEEL_SENSITIVITY,
+  applyCircularLayout,
+  applyLinearHorizontalLayout,
+  applyLinearVerticalLayout,
+  calculateDistance,
+  calculateFitCenter,
+  calculateFitView,
+  calculateFitZoom,
+  calculateMinimumRadius,
+  calculateOptimalRadiusPercentage,
+  calculateViewportBounds,
+  checkCollision,
+  clampZoom,
+  computeEdgeLabelScale,
+  computeNodeTextScreenScale,
+  computeNodeTextWorldScale,
+  computeOverlayScale,
+  convertLayerToFlatNodes,
+  convertVisualliToFlatNodes,
+  countLayersBeneath,
+  createCubicBezier,
+  createMindMapConfig,
+  darkenHexColor,
+  drawBlobPath,
+  easeInCubic,
+  easeInOutCubic,
+  easeInOutQuart,
+  easeInOutSine,
+  easeOutCubic,
+  easeOutQuad,
+  easeZoomTransition,
+  flattenNodes,
+  focusOnNode,
+  generateSampleConfig,
+  getBlobTypeForLayer,
+  getChildLayerForNode,
+  getChildLayers,
+  getColorForLevel,
+  getConnectionsForLayer,
+  getContainersForLayer,
+  getLayerForNavigation,
+  getNodeBounds,
+  getNodeConnections,
+  getNodesForLayer,
+  getOptimalQualityLevel,
+  getRecommendedRenderConfig,
+  getRenderConfigForQuality,
+  getThemeBackground,
+  getThemeBorder,
+  getThemeText,
+  getTopLevelConnections,
+  getViewportVisibleNodes,
+  getVisibleNodes,
+  isFeatureEnabled,
+  isNodeInViewport,
+  loadVisualliFile,
+  loadVisualliFileFromFile,
+  optimizeLayout,
+  panViewport,
+  parseVisualliFile,
+  parseVisualliFromMongoDB,
+  recalculateViewportBounds,
+  renderConfigStore,
+  resolveCollisions,
+  resolveNodeOverlaps,
+  screenToWorld,
+  selectionStore,
+  setViewportCenter,
+  worldToScreen,
+  zoomViewport
+};
+//# sourceMappingURL=index.js.map