@jbrowse/bandage-core 7.1.0 → 7.2.0

package/dist/chunks/{chunk-2WA4EY25.js → chunk-QMJ4J5PT.js}

@@ -1,3 +1,6 @@
+import {
+  Canvas2DRenderer
+} from "./chunk-CH3DLBUT.js";
 import {
   svgCanvas
 } from "./chunk-47DYCZOK.js";
@@ -11,9 +14,6 @@ import {
   walkRowsKeyTree,
   walkRowsTree
 } from "./chunk-UGD6ZMOF.js";
-import {
-  Canvas2DRenderer
-} from "./chunk-CH3DLBUT.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
@@ -24,10 +24,10 @@ import {
 } from "./chunk-BUBZ32IC.js";
 import {
   version
-} from "./chunk-MAPRJ2H2.js";
+} from "./chunk-S73EYTZA.js";
 import {
   axisScaleOf
-} from "./chunk-AWCMVPVP.js";
+} from "./chunk-Y7UR3MDE.js";
 import {
   facetLifts,
   walkLift
@@ -43,7 +43,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-6UFS3EWI.js";
+} from "./chunk-EPWYRSHH.js";
 import {
   buildGeometry,
   computeReferenceRamp

package/dist/chunks/{chunk-MAPRJ2H2.js → chunk-S73EYTZA.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var version = "7.1.0";
+var version = "7.2.0";
 
 export {
   version

package/dist/chunks/{chunk-O4TGF4WS.js → chunk-UNOE2NDN.js}

@@ -1,21 +1,11 @@
+import {
+  stressPlacement
+} from "./chunk-LYJ4US66.js";
 import {
   isBackbone
 } from "./chunk-FYQWPEEY.js";
 
 // src/layout/stressEngine.ts
-var LAYOUT_ENGINES = [
-  {
-    value: "fmmm",
-    label: "Bandage (FMMM)",
-    description: "Bandage's force-directed layout: OGDF's fast multipole multilevel method, compiled to wasm."
-  },
-  {
-    value: "stress",
-    label: "Stress (experimental)",
-    description: "Stress layout by stochastic gradient descent in plain JS: distances along the graph become distances on the page, so the reference reads straight and a repeat loop reads as a ring."
-  }
-];
-var LAYOUT_ENGINE_VALUES = LAYOUT_ENGINES.map((e) => e.value);
 var QUALITY = [
   { walks: 2, iterations: 15 },
   { walks: 4, iterations: 30 },
@@ -24,11 +14,12 @@ var QUALITY = [
   { walks: 16, iterations: 120 }
 ];
 var UNTANGLE_PASSES = 20;
-var UNTANGLE_RADIUS = 15;
+var UNTANGLE_LINKS = 3;
 var UNTANGLE_PUSH = 0.3;
 var SMOOTH_PASSES = 2;
 var MAX_HOPS = 200;
 var EPS = 0.1;
+var WARM = 0.5;
 function flipped(strand, name) {
   const own = name.at(-1);
   return (strand === "+" || strand === "-") && (own === "+" || own === "-") && strand !== own;
@@ -137,12 +128,36 @@ function chains(request) {
     off,
     nb,
     wt,
-    n
+    n,
+    link
   };
 }
+function components(c) {
+  const { n, off, nb } = c;
+  const comp = new Int32Array(n).fill(-1);
+  const members = [];
+  for (let s = 0; s < n; s++) {
+    if (comp[s] >= 0) {
+      continue;
+    }
+    const queue = [s];
+    comp[s] = members.length;
+    for (const u of queue) {
+      for (let e = off[u]; e < off[u + 1]; e++) {
+        const v = nb[e];
+        if (comp[v] < 0) {
+          comp[v] = members.length;
+          queue.push(v);
+        }
+      }
+    }
+    members.push(queue);
+  }
+  return { comp, members };
+}
 function stressLayout(request, opts = {}) {
   const c = chains(request);
-  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per } = c;
+  const { n, off, nb, wt, seedX, seedY, backbone, first, count, per, link } = c;
   const o = request.options;
   const quality = QUALITY[Math.max(0, Math.min(4, num(opts.quality ?? o.quality, 2)))];
   const gap = num(opts.componentSeparation ?? o.componentSeparation, 15);
@@ -153,6 +168,7 @@ function stressLayout(request, opts = {}) {
   if (n === 0) {
     return { nodePositions };
   }
+  const { comp, members } = components(c);
   let dmin = Infinity;
   let total = 0;
   for (let e = 0; e < nb.length; e++) {
@@ -167,9 +183,13 @@ function stressLayout(request, opts = {}) {
       break;
     }
   }
+  const placed = anySeed ? stressPlacement(c) : void 0;
   const side = Math.sqrt(n) * 20;
   for (let i = 0; i < n; i++) {
-    if (anySeed && !Number.isNaN(seedX[i])) {
+    if (placed && !Number.isNaN(placed.X[i])) {
+      X[i] = placed.X[i];
+      Y[i] = placed.Y[i];
+    } else if (anySeed && !Number.isNaN(seedX[i])) {
       X[i] = seedX[i] + rand() - 0.5;
       Y[i] = seedY[i] + rand() - 0.5;
     } else {
@@ -177,15 +197,18 @@ function stressLayout(request, opts = {}) {
       Y[i] = rand() * side;
     }
   }
-  const refIdx = [];
-  for (let i = 0; i < n; i++) {
-    if (backbone[i] && !Number.isNaN(seedX[i])) {
-      refIdx.push(i);
+  const refIdx = members.map(
+    (points) => Int32Array.from(
+      points.filter((i) => backbone[i] && !Number.isNaN(seedX[i])).sort((a, b) => seedX[a] - seedX[b])
+    )
+  );
+  const refX = refIdx.map((idx) => Float64Array.from(idx, (i) => seedX[i]));
+  let span = 0;
+  for (const xs of refX) {
+    if (xs.length) {
+      span = Math.max(span, xs[xs.length - 1] - xs[0]);
     }
   }
-  refIdx.sort((a, b) => seedX[a] - seedX[b]);
-  const refX = Float64Array.from(refIdx, (i) => seedX[i]);
-  const span = refIdx.length ? refX[refX.length - 1] - refX[0] : 0;
   const dmax = Math.max(span, total / 4, dmin * 10);
   const etaMax = dmax * dmax;
   const etaMin = EPS * dmin * dmin;
@@ -209,6 +232,7 @@ function stressLayout(request, opts = {}) {
     X[j] = X[j] + rx;
     Y[j] = Y[j] + ry;
   };
+  let walked = 0;
   const walk = (i, length) => {
     let chain = c.chainOf[i];
     let idx = c.indexOf[i];
@@ -219,48 +243,57 @@ function stressLayout(request, opts = {}) {
       const step = per[chain];
       const toEnd = (dir > 0 ? points - 1 - idx : idx) * step;
       if (remaining <= toEnd) {
-        return first[chain] + idx + dir * Math.round(remaining / step);
+        const steps = Math.round(remaining / step);
+        walked = length - remaining + steps * step;
+        return first[chain] + idx + dir * steps;
       }
       remaining -= toEnd;
       const out = c.links[chain][dir > 0 ? 1 : 0];
       if (out.length === 0) {
+        walked = length - remaining;
         return first[chain] + (dir > 0 ? points - 1 : 0);
       }
       const [next, enterSide] = out[Math.floor(rand() * out.length)];
-      remaining -= num(o.edgeLength, 1);
+      remaining -= link;
       chain = next;
       dir = enterSide === 0 ? 1 : -1;
       idx = enterSide === 0 ? 0 : count[next] - 1;
       if (remaining <= 0) {
+        walked = length - remaining;
         return first[chain] + idx;
       }
     }
     return -1;
   };
-  const refPartner = (i) => {
-    const length = Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
-    const target = seedX[i] + length;
+  const referenceTerm = (i, eta) => {
+    const idx = refIdx[comp[i]];
+    if (!backbone[i] || idx.length < 2 || Number.isNaN(seedX[i])) {
+      return;
+    }
+    const xs = refX[comp[i]];
+    const target = seedX[i] + Math.exp(logMin + rand() * (logMax - logMin)) * (rand() < 0.5 ? -1 : 1);
     let lo = 0;
-    let hi = refX.length;
+    let hi = xs.length;
     while (lo < hi) {
       const mid = lo + hi >> 1;
-      if (refX[mid] < target) {
+      if (xs[mid] < target) {
         lo = mid + 1;
       } else {
         hi = mid;
       }
     }
-    return refIdx[Math.min(lo, refIdx.length - 1)];
-  };
-  const referenceTerm = (i, eta) => {
-    if (!backbone[i] || refIdx.length < 2 || Number.isNaN(seedX[i])) {
+    const j = idx[Math.min(lo, idx.length - 1)];
+    const d = seedX[j] - seedX[i];
+    if (j === i || d === 0) {
       return;
     }
-    const j = refPartner(i);
-    const d = Math.abs(seedX[i] - seedX[j]);
-    if (j !== i && d > 0) {
-      move(i, j, d, eta);
+    let mu = eta / (d * d);
+    if (mu > 1) {
+      mu = 1;
     }
+    const r = mu * (X[j] - X[i] - d) / 2;
+    X[i] = X[i] + r;
+    X[j] = X[j] - r;
   };
   const adjacentTerms = (i, eta) => {
     for (let e = off[i]; e < off[i + 1]; e++) {
@@ -274,7 +307,8 @@ function stressLayout(request, opts = {}) {
   for (let i = 0; i < n; i++) {
     order[i] = i;
   }
-  for (let t = 0; t < iterations; t++) {
+  const warm = anySeed ? Math.floor(WARM * iterations) : 0;
+  for (let t = warm; t < iterations; t++) {
     const eta = etaMax * Math.exp(-lambda * t);
     for (let k = n - 1; k > 0; k--) {
       const r = Math.floor(rand() * (k + 1));
@@ -288,15 +322,15 @@ function stressLayout(request, opts = {}) {
       for (let w = 0; w < walks; w++) {
         const length = Math.exp(logMin + rand() * (logMax - logMin));
         const j = walk(i, length);
-        if (j >= 0 && j !== i) {
-          move(i, j, length, eta);
+        if (j >= 0 && j !== i && walked > 0) {
+          move(i, j, walked, eta);
         }
       }
       referenceTerm(i, eta);
     }
   }
-  const cell = UNTANGLE_RADIUS;
-  const key = (x, y) => Math.floor(x / cell) * 73856093 ^ Math.floor(y / cell) * 19349663;
+  const radius = UNTANGLE_LINKS * link;
+  const key = (x, y) => Math.floor(x / radius) * 73856093 ^ Math.floor(y / radius) * 19349663;
   for (let u = 0; u < UNTANGLE_PASSES; u++) {
     const grid = /* @__PURE__ */ new Map();
     for (let i = 0; i < n; i++) {
@@ -309,8 +343,8 @@ function stressLayout(request, opts = {}) {
       }
     }
     for (let i = 0; i < n; i++) {
-      const cx = Math.floor(X[i] / cell);
-      const cy = Math.floor(Y[i] / cell);
+      const cx = Math.floor(X[i] / radius);
+      const cy = Math.floor(Y[i] / radius);
       for (let gx = cx - 1; gx <= cx + 1; gx++) {
         for (let gy = cy - 1; gy <= cy + 1; gy++) {
           const list = grid.get(gx * 73856093 ^ gy * 19349663);
@@ -334,18 +368,18 @@ function stressLayout(request, opts = {}) {
             const dx = X[i] - X[j];
             const dy = Y[i] - Y[j];
             const mag = Math.sqrt(dx * dx + dy * dy);
-            if (mag >= UNTANGLE_RADIUS) {
+            if (mag >= radius) {
               continue;
             }
             let rx;
             let ry;
             if (mag > 1e-6) {
-              const r = UNTANGLE_PUSH * (UNTANGLE_RADIUS - mag) / (2 * mag);
+              const r = UNTANGLE_PUSH * (radius - mag) / (2 * mag);
               rx = r * dx;
               ry = r * dy;
             } else {
-              rx = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
-              ry = UNTANGLE_PUSH * UNTANGLE_RADIUS * (rand() - 0.5);
+              rx = UNTANGLE_PUSH * radius * (rand() - 0.5);
+              ry = UNTANGLE_PUSH * radius * (rand() - 0.5);
             }
             X[i] = X[i] + rx;
             Y[i] = Y[i] + ry;
@@ -374,28 +408,9 @@ function stressLayout(request, opts = {}) {
         Y[a + i] = 0.5 * ys[i] + 0.25 * (ys[i - 1] + ys[i + 1]);
       }
     }
-    let length = 0;
-    let cx = 0;
-    let cy = 0;
-    for (let i = 0; i < m; i++) {
-      cx += X[a + i];
-      cy += Y[a + i];
-      if (i > 0) {
-        length += Math.hypot(
-          X[a + i] - X[a + i - 1],
-          Y[a + i] - Y[a + i - 1]
-        );
-      }
-    }
-    cx /= m;
-    cy /= m;
-    const scale = length > 0 ? per[k] * (m - 1) / length : 1;
-    for (let i = 0; i < m; i++) {
-      X[a + i] = cx + (X[a + i] - cx) * scale;
-      Y[a + i] = cy + (Y[a + i] - cy) * scale;
-    }
+    respace(X, Y, a, m, per[k]);
   }
-  packComponents(c, X, Y, anySeed, gap);
+  packComponents(comp, members, X, Y, anySeed, gap);
   for (let k = 0; k < c.ids.length; k++) {
     const points = [];
     for (let i = 0; i < count[k]; i++) {
@@ -405,99 +420,110 @@ function stressLayout(request, opts = {}) {
   }
   return { nodePositions };
 }
-function packComponents(c, X, Y, anySeed, gap) {
-  const { n, off, nb } = c;
-  const comp = new Int32Array(n).fill(-1);
-  let components = 0;
-  for (let s = 0; s < n; s++) {
-    if (comp[s] >= 0) {
-      continue;
+function respace(X, Y, a, m, per) {
+  const arc = new Float64Array(m);
+  for (let i = 1; i < m; i++) {
+    arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
+  }
+  if (!arc[m - 1]) {
+    return;
+  }
+  const loss = per * (m - 1) - arc[m - 1];
+  if (loss > 0) {
+    extend(X, Y, a, a + 1, loss / 2);
+    extend(X, Y, a + m - 1, a + m - 2, loss / 2);
+    for (let i = 1; i < m; i++) {
+      arc[i] = arc[i - 1] + Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);
     }
-    const queue = [s];
-    comp[s] = components;
-    for (const u of queue) {
-      for (let e = off[u]; e < off[u + 1]; e++) {
-        const v = nb[e];
-        if (comp[v] < 0) {
-          comp[v] = components;
-          queue.push(v);
-        }
-      }
+  }
+  const total = arc[m - 1];
+  const xs = X.slice(a, a + m);
+  const ys = Y.slice(a, a + m);
+  let seg = 1;
+  for (let i = 1; i + 1 < m; i++) {
+    const s = total * i / (m - 1);
+    while (seg < m - 1 && arc[seg] < s) {
+      seg++;
     }
-    components++;
+    const span = arc[seg] - arc[seg - 1];
+    const t = span > 0 ? (s - arc[seg - 1]) / span : 0;
+    X[a + i] = xs[seg - 1] + (xs[seg] - xs[seg - 1]) * t;
+    Y[a + i] = ys[seg - 1] + (ys[seg] - ys[seg - 1]) * t;
   }
+}
+function extend(X, Y, end, next, by) {
+  const dx = X[end] - X[next];
+  const dy = Y[end] - Y[next];
+  const mag = Math.hypot(dx, dy);
+  if (mag > 0) {
+    X[end] = X[end] + dx / mag * by;
+    Y[end] = Y[end] + dy / mag * by;
+  }
+}
+function packComponents(comp, members, X, Y, anySeed, gap) {
   if (!anySeed) {
-    for (let k = 0; k < components; k++) {
-      rotateToPrincipalAxis(X, Y, comp, k);
+    for (const points of members) {
+      rotateToPrincipalAxis(X, Y, points);
     }
   }
-  if (components < 2) {
+  if (members.length < 2) {
     return;
   }
-  const minX = new Float64Array(components).fill(Infinity);
-  const minY = new Float64Array(components).fill(Infinity);
-  const maxY = new Float64Array(components).fill(-Infinity);
-  for (let i = 0; i < n; i++) {
+  const minX = new Float64Array(members.length).fill(Infinity);
+  const minY = new Float64Array(members.length).fill(Infinity);
+  const maxY = new Float64Array(members.length).fill(-Infinity);
+  for (let i = 0; i < X.length; i++) {
     const k = comp[i];
     minX[k] = Math.min(minX[k], X[i]);
     minY[k] = Math.min(minY[k], Y[i]);
     maxY[k] = Math.max(maxY[k], Y[i]);
   }
-  const shift = new Float64Array(components);
+  const shift = new Float64Array(members.length);
   let y = 0;
-  for (let k = 0; k < components; k++) {
+  for (let k = 0; k < members.length; k++) {
     shift[k] = y - minY[k];
     y += maxY[k] - minY[k] + gap;
   }
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < X.length; i++) {
     const k = comp[i];
     X[i] = X[i] - minX[k];
     Y[i] = Y[i] + shift[k];
   }
 }
-function rotateToPrincipalAxis(X, Y, comp, k) {
-  let m = 0;
+function rotateToPrincipalAxis(X, Y, points) {
+  if (points.length < 3) {
+    return;
+  }
   let cx = 0;
   let cy = 0;
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      cx += X[i];
-      cy += Y[i];
-      m++;
-    }
-  }
-  if (m < 3) {
-    return;
+  for (const i of points) {
+    cx += X[i];
+    cy += Y[i];
   }
-  cx /= m;
-  cy /= m;
+  cx /= points.length;
+  cy /= points.length;
   let sxx = 0;
   let syy = 0;
   let sxy = 0;
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      const dx = X[i] - cx;
-      const dy = Y[i] - cy;
-      sxx += dx * dx;
-      syy += dy * dy;
-      sxy += dx * dy;
-    }
+  for (const i of points) {
+    const dx = X[i] - cx;
+    const dy = Y[i] - cy;
+    sxx += dx * dx;
+    syy += dy * dy;
+    sxy += dx * dy;
   }
   const angle = -0.5 * Math.atan2(2 * sxy, sxx - syy);
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
-  for (let i = 0; i < X.length; i++) {
-    if (comp[i] === k) {
-      const dx = X[i] - cx;
-      const dy = Y[i] - cy;
-      X[i] = cx + cos * dx - sin * dy;
-      Y[i] = cy + sin * dx + cos * dy;
-    }
+  for (const i of points) {
+    const dx = X[i] - cx;
+    const dy = Y[i] - cy;
+    X[i] = cx + cos * dx - sin * dy;
+    Y[i] = cy + sin * dx + cos * dy;
   }
 }
 
 export {
-  LAYOUT_ENGINES,
-  LAYOUT_ENGINE_VALUES,
+  chains,
   stressLayout
 };

package/dist/chunks/{chunk-AWCMVPVP.js → chunk-Y7UR3MDE.js}

@@ -1,6 +1,6 @@
 import {
   clampZoom
-} from "./chunk-6UFS3EWI.js";
+} from "./chunk-EPWYRSHH.js";
 
 // src/viewport.ts
 function axisScaleOf(scale, pixelRows) {

package/dist/cli/figure.js

@@ -5,9 +5,12 @@ import {
   genesFromText
 } from "../chunks/chunk-BXEPA4KS.js";
 import {
+  LAYOUT_ENGINE_VALUES,
+  isLayoutEngineKind,
   layoutEngine
-} from "../chunks/chunk-L53SXJZI.js";
-import "../chunks/chunk-O4TGF4WS.js";
+} from "../chunks/chunk-6EJIU6IA.js";
+import "../chunks/chunk-UNOE2NDN.js";
+import "../chunks/chunk-LYJ4US66.js";
 import {
   LAYOUT_MODES,
   layoutModeByValue
@@ -23,32 +26,31 @@ import "../chunks/chunk-C44YRP5F.js";
 import "../chunks/chunk-7XHHVYG7.js";
 import {
   figureSvg
-} from "../chunks/chunk-2WA4EY25.js";
+} from "../chunks/chunk-QMJ4J5PT.js";
+import "../chunks/chunk-CH3DLBUT.js";
+import "../chunks/chunk-4BYTEJGW.js";
 import "../chunks/chunk-47DYCZOK.js";
 import "../chunks/chunk-KREASK3Z.js";
 import {
   genesOnRow,
   placeRowGenes
 } from "../chunks/chunk-UGD6ZMOF.js";
-import "../chunks/chunk-CH3DLBUT.js";
-import "../chunks/chunk-4BYTEJGW.js";
 import "../chunks/chunk-3S3YVOJ7.js";
 import "../chunks/chunk-BUBZ32IC.js";
-import "../chunks/chunk-MAPRJ2H2.js";
-import "../chunks/chunk-AWCMVPVP.js";
+import "../chunks/chunk-S73EYTZA.js";
+import "../chunks/chunk-Y7UR3MDE.js";
 import "../chunks/chunk-MH5IA57M.js";
 import "../chunks/chunk-TQ7VCGJR.js";
 import "../chunks/chunk-2LQ5BWT7.js";
 import {
   forceLayout,
   loadGraph
-} from "../chunks/chunk-6UFS3EWI.js";
+} from "../chunks/chunk-EPWYRSHH.js";
 import "../chunks/chunk-PUG7LXDF.js";
 import "../chunks/chunk-IGVV37VI.js";
 import "../chunks/chunk-72N5DJHZ.js";
 import "../chunks/chunk-QYBZZI5H.js";
 import "../chunks/chunk-CDLPYR5O.js";
-import "../chunks/chunk-YZ5CCEDH.js";
 import "../chunks/chunk-VECR253P.js";
 import "../chunks/chunk-VST5SR4C.js";
 import "../chunks/chunk-UMNCCYBN.js";
@@ -57,6 +59,7 @@ import "../chunks/chunk-GJMC3PGM.js";
 import "../chunks/chunk-FP4H7SFT.js";
 import "../chunks/chunk-MLSWIMZO.js";
 import "../chunks/chunk-WFB5TXRA.js";
+import "../chunks/chunk-JVLURPFW.js";
 import "../chunks/chunk-3JANT2SW.js";
 import {
   filterSamples,
@@ -202,8 +205,16 @@ function checkLayout(layout) {
     );
   }
 }
+function checkEngine(engine) {
+  if (engine !== void 0 && !isLayoutEngineKind(engine)) {
+    throw new Error(
+      `no "${engine}" layout engine: one of ${LAYOUT_ENGINE_VALUES.join(", ")}`
+    );
+  }
+}
 async function renderSpec(spec, base) {
   checkLayout(spec.layout);
+  checkEngine(spec.engine);
   const resolve = (location) => isUrl(location) ? location : path.resolve(base, location);
   let source;
   if (spec.gbz) {

package/dist/figure.js

@@ -1,25 +1,24 @@
 import {
   figureSvg
-} from "./chunks/chunk-2WA4EY25.js";
+} from "./chunks/chunk-QMJ4J5PT.js";
+import "./chunks/chunk-CH3DLBUT.js";
+import "./chunks/chunk-4BYTEJGW.js";
 import "./chunks/chunk-47DYCZOK.js";
 import "./chunks/chunk-KREASK3Z.js";
 import "./chunks/chunk-UGD6ZMOF.js";
-import "./chunks/chunk-CH3DLBUT.js";
-import "./chunks/chunk-4BYTEJGW.js";
 import "./chunks/chunk-3S3YVOJ7.js";
 import "./chunks/chunk-BUBZ32IC.js";
-import "./chunks/chunk-MAPRJ2H2.js";
-import "./chunks/chunk-AWCMVPVP.js";
+import "./chunks/chunk-S73EYTZA.js";
+import "./chunks/chunk-Y7UR3MDE.js";
 import "./chunks/chunk-MH5IA57M.js";
 import "./chunks/chunk-TQ7VCGJR.js";
 import "./chunks/chunk-2LQ5BWT7.js";
-import "./chunks/chunk-6UFS3EWI.js";
+import "./chunks/chunk-EPWYRSHH.js";
 import "./chunks/chunk-PUG7LXDF.js";
 import "./chunks/chunk-IGVV37VI.js";
 import "./chunks/chunk-72N5DJHZ.js";
 import "./chunks/chunk-QYBZZI5H.js";
 import "./chunks/chunk-CDLPYR5O.js";
-import "./chunks/chunk-YZ5CCEDH.js";
 import "./chunks/chunk-VECR253P.js";
 import "./chunks/chunk-VST5SR4C.js";
 import "./chunks/chunk-UMNCCYBN.js";
@@ -28,6 +27,7 @@ import "./chunks/chunk-GJMC3PGM.js";
 import "./chunks/chunk-FP4H7SFT.js";
 import "./chunks/chunk-MLSWIMZO.js";
 import "./chunks/chunk-WFB5TXRA.js";
+import "./chunks/chunk-JVLURPFW.js";
 import "./chunks/chunk-3JANT2SW.js";
 import "./chunks/chunk-SZNZ2T6D.js";
 import "./chunks/chunk-E7FWQQHP.js";