@jbrowse/bandage-core 9.10.0 → 10.0.0

package/dist/chunks/{chunk-LTUWJKHD.js → chunk-Q7LYHGGQ.js}

@@ -4,12 +4,16 @@ import {
 import {
   wellKnownSample
 } from "./chunk-RAKOB6IV.js";
+import {
+  gfaTables
+} from "./chunk-G45YY72K.js";
 import {
   panSNMatchesPrefix,
   panSNSample
 } from "./chunk-BPLIXMH7.js";
 
 // src/gbzWindow.ts
+import { isReverse, nodeId } from "@gmod/gbz-base";
 var NoReferenceSampleError = class extends Error {
   constructor(anchor, referenceSamples) {
     super(
@@ -82,13 +86,12 @@ var GBZ_CUT_DEFAULTS = {
   snarls: "contained",
   limit: 1e5
 };
-async function cutWindowGFA(db, query, start, end, opts) {
-  if (!query) {
-    return "";
-  }
-  const subgraphs = await db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
+async function windowCuts(db, query, start, end, opts) {
+  return db.getSubgraphs({ ...opts, path: query, start, end, haplotypes: "all" }).catch((error) => {
     throw nodeLimitError(error, opts.limit, end - start) ?? error;
   });
+}
+async function joinedGFA(db, subgraphs) {
   const paths = await db.paths();
   return joinCuts(
     await Promise.all(subgraphs.map((subgraph) => subgraph.toGFA())),
@@ -97,6 +100,109 @@ async function cutWindowGFA(db, query, start, end, opts) {
     )
   );
 }
+async function cutWindowGFA(db, query, start, end, opts) {
+  return query ? joinedGFA(db, await windowCuts(db, query, start, end, opts)) : "";
+}
+async function cutWindowTables(db, query, start, end, opts) {
+  if (!query) {
+    return "";
+  }
+  const subgraphs = await windowCuts(db, query, start, end, opts);
+  if (subgraphs.length === 1) {
+    return compactTables(subgraphs[0].toCompactSubgraph());
+  }
+  const text = await joinedGFA(db, subgraphs);
+  return text && gfaTables(text) || text;
+}
+function segmentIndex(ids, names) {
+  let low = Infinity;
+  let high = -Infinity;
+  for (const id of ids) {
+    low = Math.min(low, id);
+    high = Math.max(high, id);
+  }
+  const span = high - low + 1;
+  const table = ids.length > 0 && span <= 16 * ids.length ? new Int32Array(span).fill(-1) : void 0;
+  const extra = /* @__PURE__ */ new Map();
+  ids.forEach((id, i) => {
+    if (table) {
+      table[id - low] = i;
+    } else {
+      extra.set(id, i);
+    }
+  });
+  return (handle) => {
+    const id = nodeId(handle);
+    const tabled = table !== void 0 && id >= low && id <= high;
+    const i = tabled ? table[id - low] : extra.get(id) ?? -1;
+    if (i >= 0) {
+      return i;
+    }
+    if (tabled) {
+      table[id - low] = names.length;
+    } else {
+      extra.set(id, names.length);
+    }
+    names.push(String(id));
+    return names.length - 1;
+  };
+}
+var WALK_NAME = /^(.*)\[(\d+)-(\d+)\]$/;
+function compactTables(cut) {
+  const names = Array.from(cut.nodeIds, String);
+  const indexOf = segmentIndex(cut.nodeIds, names);
+  const declared = cut.nodeIds.length;
+  const linkCount = cut.edges.length / 2;
+  const from = new Int32Array(linkCount);
+  const to = new Int32Array(linkCount);
+  const strands = new Uint8Array(linkCount);
+  for (let k = 0; k < linkCount; k++) {
+    const a = cut.edges[2 * k];
+    const b = cut.edges[2 * k + 1];
+    from[k] = indexOf(a);
+    to[k] = indexOf(b);
+    strands[k] = (isReverse(a) ? 1 : 0) | (isReverse(b) ? 2 : 0);
+  }
+  const walks = cut.paths.filter((path) => path.steps.length > 0);
+  const offsets = new Int32Array(walks.length + 1);
+  walks.forEach((walk, p) => {
+    offsets[p + 1] = offsets[p] + walk.steps.length;
+  });
+  const steps = new Int32Array(offsets[walks.length]);
+  const reversed = new Uint8Array(steps.length);
+  const starts = new Float64Array(walks.length);
+  const ends = new Float64Array(walks.length);
+  const walkNames = walks.map((walk, p) => {
+    const named = WALK_NAME.exec(walk.name);
+    starts[p] = named ? +named[2] : 0;
+    ends[p] = named ? +named[3] : -1;
+    let at = offsets[p];
+    for (const handle of walk.steps) {
+      steps[at] = indexOf(handle);
+      reversed[at++] = isReverse(handle) ? 1 : 0;
+    }
+    return named ? named[1] : walk.name;
+  });
+  return {
+    nodes: {
+      names,
+      lengths: Int32Array.from(cut.nodeSequences, (s) => s.length),
+      refs: new Int32Array(declared).fill(-1),
+      starts: new Float64Array(declared),
+      ranks: new Int32Array(declared),
+      refNames: []
+    },
+    links: { from, to, strands },
+    walks: {
+      names: walkNames,
+      starts,
+      ends,
+      offsets,
+      steps,
+      reversed
+    }
+  };
+}
 
 export {
   NoReferenceSampleError,
@@ -108,5 +214,7 @@ export {
   referencePathQuery,
   nodeLimitError,
   GBZ_CUT_DEFAULTS,
-  cutWindowGFA
+  cutWindowGFA,
+  cutWindowTables,
+  compactTables
 };

package/dist/chunks/{chunk-MVMP6AGI.js → chunk-QIVPRZ4H.js}

@@ -1,10 +1,10 @@
 import {
   encodedColor,
   resolveEncoding
-} from "./chunk-KYY5363X.js";
+} from "./chunk-VOWI544A.js";
 import {
   pathOrigin
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 import {
   panSNContig
 } from "./chunk-BPLIXMH7.js";
@@ -90,14 +90,19 @@ function reversedNodes(graph, walk) {
   if (!referencePath || walk.reference) {
     return { reversed, bp };
   }
-  const walkPath = pathOrigin(walk.name).name;
+  const visits = graph.pathVisits;
+  if (!visits) {
+    return { reversed, bp };
+  }
+  const own = visits.pathIndex(pathOrigin(walk.name).name);
+  const theirs = visits.pathIndex(referencePath);
   const byId = new Map(graph.nodes.map((n) => [n.id, n]));
   for (const id of walk.progress.keys()) {
     const node = byId.get(id);
-    const visits = node ? graph.pathVisits?.get(node.name) : void 0;
-    const own = visits?.find((v) => v.path === walkPath)?.strand;
-    const theirs = visits?.find((v) => v.path === referencePath)?.strand;
-    if (own && theirs && own !== theirs) {
+    const slot = node ? visits.slot(node.name) : -1;
+    const a = slot < 0 ? -1 : visits.firstBy(slot, own);
+    const b = slot < 0 ? -1 : visits.firstBy(slot, theirs);
+    if (a >= 0 && b >= 0 && visits.reversed[a] !== visits.reversed[b]) {
       reversed.add(id);
       bp += node.length;
     }

package/dist/chunks/{chunk-J7YKQ5YW.js → chunk-QXAB2FLJ.js}

@@ -4,7 +4,7 @@ import {
 import {
   pathOrigin,
   surveyPaths
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 
 // src/gfa/gfaConverter.ts
 function surveySegments(gfaGraph) {

package/dist/chunks/chunk-RAEABQNW.js

@@ -0,0 +1,227 @@
+// src/pathVisits.ts
+var PathVisits = class {
+  constructor(columns) {
+    this.segments = columns.segments;
+    this.offsets = columns.offsets;
+    this.path = columns.path;
+    this.start = columns.start;
+    this.reversed = columns.reversed;
+    this.paths = columns.paths;
+    this.samples = columns.samples;
+    this.slots = new Map(this.segments.map((s, i) => [s, i]));
+  }
+  static from(entries) {
+    const builder = new PathVisitsBuilder();
+    for (const [segment, visits] of entries) {
+      builder.declare(segment);
+      for (const v of visits) {
+        builder.add(segment, v.path, v.sample, v.start, v.strand === "-");
+      }
+    }
+    return builder.build();
+  }
+  get size() {
+    return this.segments.length;
+  }
+  // the segment's index into `segments` and `offsets`, -1 when unvisited
+  slot(segment) {
+    return this.slots.get(segment) ?? -1;
+  }
+  pathIndex(path) {
+    return this.paths.indexOf(path);
+  }
+  // the first of `slot`'s visits by path `p`, -1 for none
+  firstBy(slot, p) {
+    for (let i = this.offsets[slot]; i < this.offsets[slot + 1]; i++) {
+      if (this.path[i] === p) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  // Paths' steps replayed in walk order against their visits: the k-th call
+  // for one path and segment answers that path's k-th visit there, -1 past
+  // its last. A walk in pieces lists its pieces in path order, so replaying
+  // the pieces in order reads each step's own visit.
+  replay() {
+    const cursor = /* @__PURE__ */ new Map();
+    return (slot, p) => {
+      if (slot < 0 || p < 0) {
+        return -1;
+      }
+      const key = slot * this.paths.length + p;
+      const end = this.offsets[slot + 1];
+      let at = cursor.get(key) ?? this.offsets[slot];
+      while (at < end && this.path[at] !== p) {
+        at++;
+      }
+      cursor.set(key, at + 1);
+      return at < end ? at : -1;
+    };
+  }
+  // the visits of paths `keepPath` accepts, at segments `keepSegment` does
+  filter(keepPath, keepSegment = () => true) {
+    const kept = this.paths.map(keepPath);
+    const builder = new PathVisitsBuilder();
+    this.segments.forEach((segment, s) => {
+      if (!keepSegment(segment)) {
+        return;
+      }
+      const slot = builder.declare(segment);
+      for (let i = this.offsets[s]; i < this.offsets[s + 1]; i++) {
+        const p = this.path[i];
+        if (kept[p]) {
+          builder.addAt(
+            slot,
+            builder.pathOf(this.paths[p], this.samples[p]),
+            this.start[i],
+            this.reversed[i] === 1
+          );
+        }
+      }
+    });
+    return builder.build();
+  }
+  strand(i) {
+    return this.reversed[i] ? "-" : "+";
+  }
+  visit(i) {
+    const p = this.path[i];
+    return {
+      path: this.paths[p],
+      sample: this.samples[p],
+      start: this.start[i],
+      strand: this.strand(i)
+    };
+  }
+  visitsAt(slot) {
+    const out = [];
+    for (let i = this.offsets[slot]; i < this.offsets[slot + 1]; i++) {
+      out.push(this.visit(i));
+    }
+    return out;
+  }
+  get(segment) {
+    const slot = this.slot(segment);
+    return slot < 0 ? void 0 : this.visitsAt(slot);
+  }
+  has(segment) {
+    return this.slots.has(segment);
+  }
+  keys() {
+    return this.segments[Symbol.iterator]();
+  }
+  *values() {
+    for (let s = 0; s < this.segments.length; s++) {
+      yield this.visitsAt(s);
+    }
+  }
+  *entries() {
+    for (let s = 0; s < this.segments.length; s++) {
+      yield [this.segments[s], this.visitsAt(s)];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var Column = class {
+  constructor(data) {
+    this.data = data;
+    this.length = 0;
+  }
+  push(value) {
+    if (this.length === this.data.length) {
+      const grown = new this.data.constructor(
+        this.data.length * 2
+      );
+      grown.set(this.data);
+      this.data = grown;
+    }
+    this.data[this.length++] = value;
+  }
+};
+var PathVisitsBuilder = class {
+  constructor() {
+    this.segments = [];
+    this.slots = /* @__PURE__ */ new Map();
+    this.paths = [];
+    this.samples = [];
+    this.pathIndex = /* @__PURE__ */ new Map();
+    this.slot = new Column(new Int32Array(1024));
+    this.path = new Column(new Int32Array(1024));
+    this.start = new Column(new Float64Array(1024));
+    this.reversed = new Column(new Uint8Array(1024));
+  }
+  // a segment's place in iteration order, though it has no visits yet
+  declare(segment) {
+    let s = this.slots.get(segment);
+    if (s === void 0) {
+      s = this.segments.length;
+      this.slots.set(segment, s);
+      this.segments.push(segment);
+    }
+    return s;
+  }
+  // a path's index, so a caller adding many of its visits names it once
+  pathOf(path, sample) {
+    let p = this.pathIndex.get(path);
+    if (p === void 0) {
+      p = this.paths.length;
+      this.pathIndex.set(path, p);
+      this.paths.push(path);
+      this.samples.push(sample);
+    }
+    return p;
+  }
+  add(segment, path, sample, start, reversed) {
+    this.addAt(
+      this.declare(segment),
+      this.pathOf(path, sample),
+      start,
+      reversed
+    );
+  }
+  addAt(slot, path, start, reversed) {
+    this.slot.push(slot);
+    this.path.push(path);
+    this.start.push(start);
+    this.reversed.push(reversed ? 1 : 0);
+  }
+  build() {
+    const n = this.slot.length;
+    const segments = this.segments.length;
+    const offsets = new Int32Array(segments + 1);
+    const slot = this.slot.data;
+    for (let i = 0; i < n; i++) {
+      offsets[slot[i] + 1]++;
+    }
+    for (let s = 0; s < segments; s++) {
+      offsets[s + 1] += offsets[s];
+    }
+    const fill = offsets.slice(0, segments);
+    const path = new Int32Array(n);
+    const start = new Float64Array(n);
+    const reversed = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+      const at = fill[slot[i]]++;
+      path[at] = this.path.data[i];
+      start[at] = this.start.data[i];
+      reversed[at] = this.reversed.data[i];
+    }
+    return new PathVisits({
+      segments: this.segments,
+      offsets,
+      path,
+      start,
+      reversed,
+      paths: this.paths,
+      samples: this.samples
+    });
+  }
+};
+
+export {
+  PathVisits,
+  PathVisitsBuilder
+};

package/dist/chunks/{chunk-XZ2BLAA6.js → chunk-REE4GUDM.js}

@@ -1,6 +1,6 @@
 import {
   pathOrigin
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 import {
   isGenericSample
 } from "./chunk-BPLIXMH7.js";

package/dist/chunks/{chunk-2FLBFVMO.js → chunk-RJXPPYA7.js}

@@ -5,23 +5,23 @@ import {
   stripGeneGaps,
   walkStripFrame,
   walkStripLabelsTree
-} from "./chunk-DMH4NL2M.js";
+} from "./chunk-WI7ZHJ27.js";
 import {
   walkRowsKey,
   walkRowsKeyTree,
   walkRowsTree
-} from "./chunk-FJZ2TB46.js";
+} from "./chunk-VZNKA3K2.js";
 import {
   Canvas2DRenderer
 } from "./chunk-WBCOREDZ.js";
-import {
-  genePins
-} from "./chunk-BUBZ32IC.js";
 import {
   EXON_COLOR,
   exonOutlineTree,
   exonStretches
 } from "./chunk-3S3YVOJ7.js";
+import {
+  genePins
+} from "./chunk-BUBZ32IC.js";
 import {
   geneLabelCandidates
 } from "./chunk-DRG4236Y.js";
@@ -36,17 +36,17 @@ import {
 } from "./chunk-LOCJN3BZ.js";
 import {
   version
-} from "./chunk-2VTM3DHG.js";
+} from "./chunk-CDPYXHVR.js";
 import {
   axisScaleOf
-} from "./chunk-PT37VS5B.js";
+} from "./chunk-OOLNLCIO.js";
 import {
   facetLifts,
   walkLift
-} from "./chunk-MVMP6AGI.js";
+} from "./chunk-QIVPRZ4H.js";
 import {
   encodingStops
-} from "./chunk-KYY5363X.js";
+} from "./chunk-VOWI544A.js";
 import {
   rangeText,
   walkKey
@@ -54,15 +54,15 @@ import {
 import {
   buildGeometry,
   computeReferenceRamp
-} from "./chunk-4IYP43W6.js";
+} from "./chunk-NP356MC2.js";
 import {
   walkRowLabels,
   walkRowsExtent
-} from "./chunk-TOVOJNT7.js";
+} from "./chunk-3APK25GI.js";
 import {
   pathLegend,
   walkLabelsOf
-} from "./chunk-XZ2BLAA6.js";
+} from "./chunk-REE4GUDM.js";
 import {
   nodeInk
 } from "./chunk-PBENCR5L.js";
@@ -70,7 +70,7 @@ import {
   FIT_PADDING,
   drawingBounds,
   fitTransform
-} from "./chunk-HRAU4VTB.js";
+} from "./chunk-W4GZCVUK.js";
 import {
   referenceLabel
 } from "./chunk-RAKOB6IV.js";

package/dist/chunks/{chunk-KYY5363X.js → chunk-VOWI544A.js}

@@ -2,7 +2,7 @@ import {
   REFERENCE_RAMP_ALT_COLOR,
   REFERENCE_RAMP_MAX_HUE,
   hslToRgb
-} from "./chunk-4IYP43W6.js";
+} from "./chunk-NP356MC2.js";
 import {
   packAbgr
 } from "./chunk-G2FD7S3C.js";

package/dist/chunks/{chunk-FJZ2TB46.js → chunk-VZNKA3K2.js}

@@ -3,13 +3,13 @@ import {
   RAMP_GRADIENT_STOPS,
   rampHueCss,
   rampStops
-} from "./chunk-K5NYTPLC.js";
+} from "./chunk-DCJC32QW.js";
 import {
   el
 } from "./chunk-NNODIW4U.js";
 import {
   REFERENCE_RAMP_ALT_CSS
-} from "./chunk-4IYP43W6.js";
+} from "./chunk-NP356MC2.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/chunks/{chunk-HRAU4VTB.js → chunk-W4GZCVUK.js}

@@ -9,13 +9,10 @@ import {
 } from "./chunk-PUG7LXDF.js";
 import {
   convertGFAToGraph
-} from "./chunk-J7YKQ5YW.js";
-import {
-  gfaTables
-} from "./chunk-G45YY72K.js";
+} from "./chunk-QXAB2FLJ.js";
 import {
   graphFromTables
-} from "./chunk-OA7RIMZ2.js";
+} from "./chunk-PSMKPSO4.js";
 import {
   parseGFA
 } from "./chunk-CDLPYR5O.js";
@@ -26,7 +23,10 @@ import {
 } from "./chunk-JVLURPFW.js";
 import {
   anchorGraph
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
+import {
+  gfaTables
+} from "./chunk-G45YY72K.js";
 import {
   mergeRuns,
   splitRuns

package/dist/chunks/{chunk-DMH4NL2M.js → chunk-WI7ZHJ27.js}

@@ -2,13 +2,13 @@ import {
   alongRow,
   boxesGenes,
   rowPitch
-} from "./chunk-FJZ2TB46.js";
+} from "./chunk-VZNKA3K2.js";
 import {
   el
 } from "./chunk-NNODIW4U.js";
 import {
   pathOrigin
-} from "./chunk-IGJCTPFB.js";
+} from "./chunk-EMUUNWRU.js";
 import {
   LABEL_CHAR_PX
 } from "./chunk-AB35TJST.js";

package/dist/cli/figure.js

@@ -6,18 +6,18 @@ import {
 } from "../chunks/chunk-BXEPA4KS.js";
 import {
   figureSvg
-} from "../chunks/chunk-2FLBFVMO.js";
+} from "../chunks/chunk-RJXPPYA7.js";
 import "../chunks/chunk-47DYCZOK.js";
-import "../chunks/chunk-DMH4NL2M.js";
+import "../chunks/chunk-WI7ZHJ27.js";
 import {
   genesOnRow,
   placeRowGenes
-} from "../chunks/chunk-FJZ2TB46.js";
+} from "../chunks/chunk-VZNKA3K2.js";
 import "../chunks/chunk-WBCOREDZ.js";
 import "../chunks/chunk-4BYTEJGW.js";
-import "../chunks/chunk-BUBZ32IC.js";
 import "../chunks/chunk-3S3YVOJ7.js";
-import "../chunks/chunk-K5NYTPLC.js";
+import "../chunks/chunk-BUBZ32IC.js";
+import "../chunks/chunk-DCJC32QW.js";
 import "../chunks/chunk-DRG4236Y.js";
 import "../chunks/chunk-FP4H7SFT.js";
 import "../chunks/chunk-MLSWIMZO.js";
@@ -32,10 +32,10 @@ import "../chunks/chunk-LYJ4US66.js";
 import {
   LAYOUT_MODES,
   layoutModeByValue
-} from "../chunks/chunk-FUUJ76KD.js";
-import "../chunks/chunk-LOEA5IHZ.js";
-import "../chunks/chunk-CXKZYLYS.js";
+} from "../chunks/chunk-ICXMWYOA.js";
+import "../chunks/chunk-IM4SJUPO.js";
 import "../chunks/chunk-CWFNEKST.js";
+import "../chunks/chunk-LOEA5IHZ.js";
 import "../chunks/chunk-L3O7AWLI.js";
 import "../chunks/chunk-TZFWUT2C.js";
 import "../chunks/chunk-HNQPEMYE.js";
@@ -48,46 +48,47 @@ import {
   haplotypeIndexBeside,
   openGbz,
   parseRegion
-} from "../chunks/chunk-73RSLGZT.js";
-import "../chunks/chunk-LTUWJKHD.js";
+} from "../chunks/chunk-FLFBYSJO.js";
+import "../chunks/chunk-Q7LYHGGQ.js";
 import "../chunks/chunk-WSIFAZU7.js";
 import "../chunks/chunk-LOCJN3BZ.js";
-import "../chunks/chunk-2VTM3DHG.js";
-import "../chunks/chunk-PT37VS5B.js";
-import "../chunks/chunk-MVMP6AGI.js";
-import "../chunks/chunk-KYY5363X.js";
+import "../chunks/chunk-CDPYXHVR.js";
+import "../chunks/chunk-OOLNLCIO.js";
+import "../chunks/chunk-QIVPRZ4H.js";
+import "../chunks/chunk-VOWI544A.js";
 import "../chunks/chunk-2LQ5BWT7.js";
-import "../chunks/chunk-4IYP43W6.js";
+import "../chunks/chunk-NP356MC2.js";
 import "../chunks/chunk-G2FD7S3C.js";
 import "../chunks/chunk-WFB5TXRA.js";
-import "../chunks/chunk-TOVOJNT7.js";
+import "../chunks/chunk-3APK25GI.js";
 import {
   filterSamples,
   walkRows
-} from "../chunks/chunk-6PYZYBBF.js";
-import "../chunks/chunk-XZ2BLAA6.js";
+} from "../chunks/chunk-KAN2WTG5.js";
+import "../chunks/chunk-REE4GUDM.js";
 import "../chunks/chunk-PBENCR5L.js";
 import {
   engineSettingsOf,
   forceLayout,
   loadGraph
-} from "../chunks/chunk-HRAU4VTB.js";
+} from "../chunks/chunk-W4GZCVUK.js";
 import "../chunks/chunk-IGVV37VI.js";
 import "../chunks/chunk-OPPVSPEF.js";
 import "../chunks/chunk-PUG7LXDF.js";
-import "../chunks/chunk-J7YKQ5YW.js";
-import "../chunks/chunk-G45YY72K.js";
-import "../chunks/chunk-OA7RIMZ2.js";
+import "../chunks/chunk-QXAB2FLJ.js";
 import "../chunks/chunk-QYBZZI5H.js";
+import "../chunks/chunk-PSMKPSO4.js";
 import "../chunks/chunk-CDLPYR5O.js";
 import "../chunks/chunk-JVLURPFW.js";
-import "../chunks/chunk-IGJCTPFB.js";
+import "../chunks/chunk-EMUUNWRU.js";
+import "../chunks/chunk-RAEABQNW.js";
 import "../chunks/chunk-ES2N6V56.js";
 import {
   featuresOnBackbone,
   graphBackbone,
   refNameBinding
 } from "../chunks/chunk-RAKOB6IV.js";
+import "../chunks/chunk-G45YY72K.js";
 import "../chunks/chunk-BPLIXMH7.js";
 import "../chunks/chunk-3ZZSX5HN.js";
 import "../chunks/chunk-AB35TJST.js";