jbrowse-plugin-graphgenomeviewer 7.1.1 → 7.1.2

package/dist/chunks/RgfaTabixAdapter-ZTFVNM4G.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/RgfaTabixAdapter/rgfaBed.ts", "../../src/RgfaTabixAdapter/RgfaTabixAdapter.ts"],
-  "sourcesContent": ["// A segment as it appears in segs.bed.gz, and as it is repeated inside every\n// links.bed.gz row: `stableName start end segmentId rank [tags]`. The first\n// five are the SN/SO/SR tags rGFA already carries, projected to BED by\n// `gfatools gfa2bed -m`.\n//\n// `tags` is a space-separated list of GFA tags, written verbatim onto the\n// S-line formatSegment synthesizes, where the GFA parser reads them into\n// `GraphNode.tags` with no work here. It is the extension point for everything\n// the five columns cannot say: carriage on a path-derived graph (`SM:Z:`), the\n// collapse summary on a level-of-detail tier (`ct:Z:`, `cn:i:`, ...), a\n// precomputed layout position later. rGFA files have no sixth column at all,\n// so this is empty for them and nothing changes.\nexport interface RgfaSegment {\n  refName: string\n  start: number\n  end: number\n  id: string\n  rank: number\n  tags: string\n}\n\nexport interface RgfaLink {\n  source: string\n  sourceStrand: string\n  target: string\n  targetStrand: string\n  sourceSegment: RgfaSegment\n  targetSegment: RgfaSegment\n}\n\nexport function parseSegmentLine(line: string): RgfaSegment {\n  return parseSegmentRow(line).segment\n}\n\n// gfa-to-tabix's anchored layout files a segment under the reference interval\n// its bubble hangs from and states the segment's own coordinate after the rank:\n// `anchorName anchorStart anchorEnd segmentId rank stableName start end [tags]`.\n// One query over a region then returns every segment of every bubble under it,\n// and `anchored` tells a cut it has nothing left to follow.\nexport function parseSegmentRow(line: string) {\n  const cols = line.split('\\t')\n  const anchored = cols.length >= 8\n  const own = anchored ? 5 : 0\n  return {\n    anchored,\n    segment: {\n      refName: cols[own]!,\n      start: +cols[own + 1]!,\n      end: +cols[own + 2]!,\n      id: cols[3]!,\n      rank: +cols[4]!,\n      tags: cols[anchored ? 8 : 5] ?? '',\n    } satisfies RgfaSegment,\n  }\n}\n\n// Carriage as an ordinary feature attribute, for the linear track rather than\n// the graph. The tag column reaches the graph view through the synthesized\n// S-line (formatSegment below, then gfaConverter reads SM into\n// `GraphNode.samples`), and that route ends at the graph: `getFeatures` builds\n// its own features and had no way to say who carries a segment, so a lane\n// colored by carriage was not expressible.\n//\n// `SM:Z:` is its own grammar check here. build_pggb_tabix.sh wrote a bare\n// comma-separated list in this column before the tag column existed, and those\n// files are still hosted; a bare list has no prefix to match, so it is dropped\n// rather than read as one sample named `K12,Sakai,CFT073`.\n//\n// Undefined rather than [] when the tag is absent, matching gfaConverter: an\n// rGFA has no sixth column at all, so a segment that says nothing about\n// carriage stays distinguishable from one carried by nobody.\nexport function segmentSamples(segment: RgfaSegment) {\n  const tag = segment.tags.split(' ').find(t => t.startsWith('SM:Z:'))\n  if (tag === undefined) {\n    return undefined\n  }\n  const samples = tag\n    .slice('SM:Z:'.length)\n    .split(',')\n    .map(s => s.trim())\n    .filter(Boolean)\n  return samples.length > 0 ? samples : undefined\n}\n\n// `s322+` \u2014 the L-line's segment id with its orientation appended, mirroring\n// the GFA record it came from.\nfunction parseEndpoint(field: string) {\n  return { id: field.slice(0, -1), strand: field.slice(-1) }\n}\n\nexport function parseLinkLine(line: string): RgfaLink {\n  const cols = line.split('\\t')\n  const source = parseEndpoint(cols[3]!)\n  const target = parseEndpoint(cols[4]!)\n  return {\n    source: source.id,\n    sourceStrand: source.strand,\n    target: target.id,\n    targetStrand: target.strand,\n    sourceSegment: {\n      id: source.id,\n      refName: cols[5]!,\n      start: +cols[6]!,\n      end: +cols[7]!,\n      rank: +cols[8]!,\n      tags: cols[13] ?? '',\n    },\n    targetSegment: {\n      id: target.id,\n      refName: cols[9]!,\n      start: +cols[10]!,\n      end: +cols[11]!,\n      rank: +cols[12]!,\n      tags: cols[14] ?? '',\n    },\n  }\n}\n\nexport function linkKey(link: RgfaLink) {\n  return `${link.source}${link.sourceStrand}${link.target}${link.targetStrand}`\n}\n\n// The cut an anchored index gives: `under` is what the segment file returned\n// for the window, every segment of every bubble under it, and `found` is what\n// the link file returned. gfa-to-tabix files a link widely enough that `found`\n// holds every link touching a segment in `under` and every link between the\n// segments those lead to, plus links of neither kind, which are dropped here.\n// A backbone link that jumps the whole window, as a deletion or inversion\n// spanning it does, touches nothing in `under` and is kept by its own rule.\nexport function anchoredCut(\n  under: Map<string, RgfaSegment>,\n  found: RgfaLink[],\n  window: StableSpan,\n) {\n  const side = (segment: RgfaSegment) =>\n    segment.rank !== 0 || segment.refName !== window.refName\n      ? 0\n      : segment.end <= window.start\n        ? -1\n        : segment.start >= window.end\n          ? 1\n          : 0\n  const segments = new Map(under)\n  const links = new Map<string, RgfaLink>()\n  for (const link of found) {\n    if (\n      under.has(link.source) ||\n      under.has(link.target) ||\n      side(link.sourceSegment) * side(link.targetSegment) === -1\n    ) {\n      links.set(linkKey(link), link)\n      for (const segment of [link.sourceSegment, link.targetSegment]) {\n        if (!segments.has(segment.id)) {\n          segments.set(segment.id, segment)\n        }\n      }\n    }\n  }\n  for (const link of found) {\n    if (segments.has(link.source) && segments.has(link.target)) {\n      links.set(linkKey(link), link)\n    }\n  }\n  return { segments, links }\n}\n\n// Both endpoints of a link are written into every row, so the same link is\n// indexed under each endpoint's stable sequence and arrives twice for a region\n// covering both. Callers dedupe on linkKey.\n\nexport interface StableSpan {\n  refName: string\n  start: number\n  end: number\n}\n\n// Where a cut reads links once more to close itself. A hop reads the links of\n// the segments the round before it reached, so a link between two segments of\n// the last round is never read and an allele reached from both ends draws as\n// two stubs. rGFA lays an allele out as one stretch of the stable sequence that\n// introduced it, so pieces of one sequence within the window's length of each\n// other merge into a span, and reading it brings the pieces between too.\n// Backbone reached past the window is unread for the same reason; its spans\n// join only abutting pieces, since the reference past the window is not the\n// cut's to fill. A span whose segments were all read and abut is skipped.\nexport function closingSpans(\n  held: RgfaSegment[],\n  unread: Set<string>,\n  window: StableSpan,\n) {\n  const outside = (segment: RgfaSegment) =>\n    segment.refName !== window.refName ||\n    segment.end <= window.start ||\n    segment.start >= window.end\n  return [\n    ...mergedSpans(\n      held.filter(segment => segment.rank > 0),\n      unread,\n      window.end - window.start,\n    ),\n    ...mergedSpans(\n      held.filter(segment => segment.rank === 0 && outside(segment)),\n      new Set(held.map(segment => segment.id)),\n      0,\n    ),\n  ]\n}\n\nfunction mergedSpans(\n  segments: RgfaSegment[],\n  unread: Set<string>,\n  maxGap: number,\n) {\n  const sorted = [...segments].sort(\n    (a, b) => compare(a.refName, b.refName) || a.start - b.start,\n  )\n  const spans: (StableSpan & { needed: boolean })[] = []\n  for (const segment of sorted) {\n    const span = spans.at(-1)\n    if (\n      span?.refName === segment.refName &&\n      segment.start - span.end <= maxGap\n    ) {\n      span.needed ||= segment.start > span.end || unread.has(segment.id)\n      span.end = Math.max(span.end, segment.end)\n    } else {\n      spans.push({\n        refName: segment.refName,\n        start: segment.start,\n        end: segment.end,\n        needed: unread.has(segment.id),\n      })\n    }\n  }\n  return spans\n    .filter(span => span.needed)\n    .map(({ refName, start, end }): StableSpan => ({ refName, start, end }))\n}\n\n// The links a closing read keeps: each end is a segment the cut holds or one\n// lying inside a span. Following anything else is what another hop is for.\nexport function closingLinks(\n  found: RgfaLink[],\n  held: Map<string, RgfaSegment>,\n  spans: StableSpan[],\n) {\n  const inside = (segment: RgfaSegment) =>\n    held.has(segment.id) ||\n    spans.some(\n      span =>\n        span.refName === segment.refName &&\n        segment.start >= span.start &&\n        segment.end <= span.end,\n    )\n  return found.filter(\n    link => inside(link.sourceSegment) && inside(link.targetSegment),\n  )\n}\n\n// Segments carry no sequence here \u2014 the BED records only their span \u2014 so every\n// S-line is written with `*` and an LN tag, which is what the GFA spec asks for\n// and what packages/graph-core's parser reads back as the node length.\n// `NM:i:0`, `SM:Z:HG002.1,HG002.2` \u2014 the GFA tag grammar, checked rather than\n// trusted. Files built before the tag column existed put a bare comma-separated\n// sample list here, and passing that through would put a field that is not a\n// tag on an S-line, which is a malformed GFA rather than a missing annotation.\n// Dropping it degrades to the pre-tag behaviour instead.\nconst GFA_TAG = /^[A-Za-z][A-Za-z0-9]:[AifZJHB]:/\n\nfunction formatSegment(segment: RgfaSegment) {\n  const { id, refName, start, end, rank, tags } = segment\n  const valid = tags.split(' ').filter(t => GFA_TAG.test(t))\n  const extra = valid.length === 0 ? '' : `\\t${valid.join('\\t')}`\n  return `S\\t${id}\\t*\\tLN:i:${end - start}\\tSN:Z:${refName}\\tSO:i:${start}\\tSR:i:${rank}${extra}`\n}\n\nfunction formatLink(link: RgfaLink) {\n  const { source, sourceStrand, target, targetStrand } = link\n  return `L\\t${source}\\t${sourceStrand}\\t${target}\\t${targetStrand}\\t0M`\n}\n\n// Codepoint order, not localeCompare: the byte-identical-output guarantee below\n// has to hold across locales.\nfunction compare(a: string, b: string) {\n  return a < b ? -1 : a > b ? 1 : 0\n}\n\n// Deterministic ordering: the same region always produces byte-identical GFA,\n// so a layout computed from it is reproducible.\nexport function formatSubgraph(\n  segments: Map<string, RgfaSegment>,\n  links: Map<string, RgfaLink>,\n) {\n  const sortedSegments = [...segments.values()].sort(\n    (a, b) =>\n      compare(a.refName, b.refName) || a.start - b.start || compare(a.id, b.id),\n  )\n  const sortedLinks = [...links.keys()].sort((a, b) => compare(a, b))\n  return [\n    'H\\tVN:Z:1.0',\n    ...sortedSegments.map(s => formatSegment(s)),\n    ...sortedLinks.map(k => formatLink(links.get(k)!)),\n  ].join('\\n')\n}\n", "import { resolvePanSNPrefix } from '@jbrowse/bandage-core/pansn'\nimport { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter'\nimport { SimpleFeature, updateStatus } from '@jbrowse/core/util'\nimport { ObservableCreate } from '@jbrowse/core/util/rxjs'\nimport { WalkReader, referenceNodes } from '@jbrowse/graph-walks'\n\nimport { locationIsSet } from '../locationName.ts'\nimport { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'\nimport { getLines } from '../tabixRange.ts'\nimport {\n  anchoredCut,\n  closingLinks,\n  closingSpans,\n  formatSubgraph,\n  linkKey,\n  parseLinkLine,\n  parseSegmentRow,\n  segmentSamples,\n} from './rgfaBed.ts'\nimport { walkSubgraph } from './walkReader.ts'\n\nimport type { RgfaTabixAdapterConfig } from './configSchema.ts'\nimport type { SubgraphAdapterOptions, SubgraphTier } from '../GetSubgraph.ts'\nimport type { RgfaLink, RgfaSegment } from './rgfaBed.ts'\nimport type { WalkCut } from './walkRowRuns.ts'\nimport type { TabixIndexedFile } from '@gmod/tabix'\nimport type PluginManager from '@jbrowse/core/PluginManager'\nimport type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'\nimport type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'\nimport type { Feature } from '@jbrowse/core/util'\nimport type { FileLocation, Region } from '@jbrowse/core/util/types'\n\n// What a hop follows: alleles, never the backbone. A rank-0 segment reached\n// through a link is flanking backbone, usually outside the window, so querying\n// its links walks the reference away from the region, brings back more backbone,\n// and closes nothing. Every segment that closes a bubble is an allele interior,\n// and an allele interior is rank > 0 in both index formats (rGFA's SR tag, and\n// pggb's rank 0-or-1 against the anchor path). Reached backbone still becomes a\n// node and its edge still draws; it is only not walked through.\n//\n// This is gfabase's rule, arrived at from the other end. `gfabase sub` expands\n// from a seed either to the whole connected component (`--connected`, which its\n// own README calls overkill) or with `--cutpoints 1`, which takes the biconnected\n// component by *stopping at cutpoints*, the segments every end-to-end walk of\n// the chromosome must traverse. In a reference-anchored pangenome the cutpoints\n// are the backbone, and rank is what the index already states about it, so\n// `rank > 0` is that stopping rule without a connectivity index to build. The\n// third tool is the same shape again: `gfatools view -R` maps the region onto its\n// precomputed bubble decomposition and returns whole overlapping bubbles\n// (gfa_query_by_reg), which is complete for the same reason. Bandage's own\n// `--distance` is a node-step radius, but Bandage holds the entire graph in\n// memory, so its scope is a drawing filter rather than a fetch strategy.\n//\n// Measured with this rule: the E. coli paa window converges at one hop (17\n// segments at 1 and at 2), so the cut closes and stays closed. HPRC's amylase\n// window keeps growing (63 at 0, 78 at 1, 92 at 2) because its alleles have\n// alleles, and wall-clock is flat across all three, since a hop's queries go out\n// together and the remote index dominates.\n//\n// The exact version, when a graph ships a bubble index beside its segments:\n// gfatools' bubble rows carry the member segment ids of every bubble, so the\n// bubbles overlapping the region state which segments a complete cut must\n// contain. That turns the hop count into a termination condition rather than a\n// setting, and MinigraphBubbleAdapter already parses those rows.\nfunction offReference(segments: RgfaSegment[]) {\n  return segments.filter(segment => segment.rank > 0)\n}\n\ninterface GraphIndex {\n  segments: TabixIndexedFile\n  links: TabixIndexedFile\n  walks?: WalkReader\n  walkFile?: TabixIndexedFile\n  refNames: PanSNRefNames\n}\n\nexport default class RgfaTabixAdapter extends BaseFeatureDataAdapter<RgfaTabixAdapterConfig> {\n  public static capabilities = ['getFeatures', 'getRefNames']\n\n  private readonly fine\n  private coarse: GraphIndex | undefined\n\n  public constructor(\n    config: RgfaTabixAdapterConfig,\n    getSubAdapter?: getSubAdapterType,\n    pluginManager?: PluginManager,\n  ) {\n    super(config, getSubAdapter, pluginManager)\n    this.fine = this.openIndex([])\n  }\n\n  // refNames off the SEGMENT index: it is the one that names every stable\n  // sequence the graph is anchored to, where the link index only names those a\n  // link touches. A walk-indexed graph's walk file names the same sequences,\n  // and it has no segment file.\n  private openIndex(under: string[]): GraphIndex {\n    const segments = openTabixSlot(\n      this,\n      [...under, 'segmentsLocation'],\n      [...under, 'segmentsIndex'],\n    )\n    const walksLocation: FileLocation = this.getConf('walksLocation')\n    const hasWalks = under.length === 0 && locationIsSet(walksLocation)\n    const links = openTabixSlot(\n      this,\n      [...under, 'linksLocation'],\n      [...under, 'linksIndex'],\n    )\n    const walkFile = hasWalks\n      ? openTabixSlot(this, ['walksLocation'], ['walksIndex'])\n      : undefined\n    return {\n      segments,\n      links,\n      walkFile,\n      walks: walkFile ? new WalkReader(walkFile) : undefined,\n      refNames: new PanSNRefNames(walkFile ?? segments, this),\n    }\n  }\n\n  /**\n   * The haplotypes a walk-indexed graph's header names, `sample#haplotype`\n   * in byte order, or undefined when it names none\n   */\n  async getHaplotypeNames(opts: BaseOptions = {}) {\n    const header = await this.fine.walks?.header(opts)\n    return header?.haplotypes.length ? header.haplotypes : undefined\n  }\n\n  private index(tier: SubgraphTier = 'fine') {\n    if (tier === 'fine') {\n      return this.fine\n    }\n    this.coarse ??= this.openIndex(['coarse'])\n    return this.coarse\n  }\n\n  async getRefNames(opts: BaseOptions = {}) {\n    return this.fine.refNames.assemblyRefNames(opts)\n  }\n\n  public async hasDataForRefName() {\n    return true\n  }\n\n  getFeatures(query: Region, opts: BaseOptions = {}) {\n    const { signal, statusCallback } = opts\n    return ObservableCreate<Feature>(async observer => {\n      const tabixRefName = await this.fine.refNames.resolve(query, opts)\n      if (tabixRefName !== undefined) {\n        // a walk-indexed node row names only its chunk's first base, and a\n        // node crossing in from a chunk before is filed there\n        const { walks, walkFile } = this.fine\n        const start = walks\n          ? await walks.queryStart(query.start, opts)\n          : query.start\n        if (walkFile && walks) {\n          // a walk-indexed graph's reference nodes are its ref rows' steps\n          await walks.header(opts)\n          const refRows: string[][] = []\n          await updateStatus('Downloading walks', statusCallback, () =>\n            getLines(walkFile, tabixRefName, start, query.end, {\n              signal,\n              lineCallback: line => {\n                const cols = line.split('\\t')\n                if (cols[3] === 'ref') {\n                  refRows.push(cols)\n                }\n              },\n            }),\n          )\n          // every node of the chunks read that ends past the window's start\n          const seen = new Set<number>()\n          for (const node of referenceNodes(refRows)) {\n            if (\n              node.refName === tabixRefName &&\n              node.end > query.start &&\n              !seen.has(node.id)\n            ) {\n              seen.add(node.id)\n              const id = String(node.id)\n              observer.next(\n                new SimpleFeature({\n                  uniqueId: id,\n                  refName: query.refName,\n                  start: node.start,\n                  end: node.end,\n                  name: id,\n                  type: 'segment',\n                  rank: 0,\n                  stableName: node.refName,\n                }),\n              )\n            }\n          }\n          observer.complete()\n          return\n        }\n        await updateStatus('Downloading segments', statusCallback, () =>\n          getLines(this.fine.segments, tabixRefName, start, query.end, {\n            signal,\n            lineCallback: line => {\n              const { segment, anchored } = parseSegmentRow(line)\n              // An anchored index also returns the alleles under the region,\n              // which lie on other stable sequences and have no place on this\n              // one; a lookback chunk returns nodes ending before it\n              if (\n                (anchored && segment.refName !== tabixRefName) ||\n                segment.end <= query.start\n              ) {\n                return\n              }\n              // `samples` lists the haplotypes whose paths visit the segment and\n              // `sampleCount` counts them. A lane's color reads the count, and\n              // a count in jexl would otherwise rely on `.length` resolving\n              // through a member access on an array.\n              const samples = segmentSamples(segment)\n              observer.next(\n                new SimpleFeature({\n                  uniqueId: segment.id,\n                  refName: query.refName,\n                  start: segment.start,\n                  end: segment.end,\n                  name: segment.id,\n                  type: 'segment',\n                  rank: segment.rank,\n                  stableName: segment.refName,\n                  ...(samples && { samples, sampleCount: samples.length }),\n                }),\n              )\n            },\n          }),\n        )\n      }\n      observer.complete()\n    }, signal)\n  }\n\n  // Extract the graph around a region for GraphGenomeView: GFA text, or a\n  // walk-indexed graph's tables (walkSubgraph). The\n  // region's own segments come from segs.bed.gz; links.bed.gz supplies the edges\n  // incident to them *and* the coordinates of the segments on the other end,\n  // which typically sit on a different stable sequence (a rank>0 bubble) and so\n  // are not reachable by any coordinate query on this region.\n  //\n  // `hops` is extra rounds of link-following past the region's own segments\n  // and their immediate neighbours, each costing one tabix query per\n  // off-reference segment newly reached. After the last round, one more read\n  // per stretch of stable sequence the cut holds closes it (closingSpans), so\n  // an allele reached from both ends draws whole. The view asks for one hop; a\n  // hopless cut stays as cheap as it was. `signal` goes to every one of those\n  // queries, so a cut the view has replaced stops.\n  // `tier: 'coarse'` reads the `coarse` pair instead, the same way.\n  async getSubgraph(\n    region: Region,\n    opts: SubgraphAdapterOptions = {},\n  ): Promise<string | WalkCut> {\n    const { hops = 0, signal, tier } = opts\n    const index = this.index(tier)\n    const segments = new Map<string, RgfaSegment>()\n    const links = new Map<string, RgfaLink>()\n    const tabixRefName = await index.refNames.resolve(region, { signal })\n\n    const addLinksOver = async (\n      refName: string,\n      start: number,\n      end: number,\n    ) => {\n      const reached: RgfaSegment[] = []\n      await getLines(index.links, refName, start, end, {\n        signal,\n        lineCallback: line => {\n          const link = parseLinkLine(line)\n          links.set(linkKey(link), link)\n          for (const segment of [link.sourceSegment, link.targetSegment]) {\n            if (!segments.has(segment.id)) {\n              segments.set(segment.id, segment)\n              reached.push(segment)\n            }\n          }\n        },\n      })\n      return reached\n    }\n\n    if (tabixRefName === undefined) {\n      throw new Error(\n        `${region.assemblyName} ${region.refName} is not in this graph's index; a graph with PanSN names (GRCh38#0#chr1) needs ${region.assemblyName} mapped to its prefix in assemblyNameToPanSN`,\n      )\n    }\n    if (index.walks) {\n      return walkSubgraph(index.walks, tabixRefName, region, {\n        signal,\n        prefixes: opts.haplotypes?.map(lane => resolvePanSNPrefix(this, lane)),\n        walkRows: opts.walkRows,\n        stepBudget: this.getConf('walkStepBudget'),\n        byteBudget: this.getConf('walkByteBudget'),\n      })\n    }\n    const layout = { anchored: false }\n    await getLines(index.segments, tabixRefName, region.start, region.end, {\n      signal,\n      lineCallback: line => {\n        const row = parseSegmentRow(line)\n        layout.anchored ||= row.anchored\n        segments.set(row.segment.id, row.segment)\n      },\n    })\n    // An anchored index files every allele and every link under the reference\n    // interval its bubble hangs from, so one read of each file holds the whole\n    // graph under the region and there is nothing to hop to or close.\n    if (layout.anchored) {\n      const found: RgfaLink[] = []\n      await getLines(index.links, tabixRefName, region.start, region.end, {\n        signal,\n        lineCallback: line => {\n          found.push(parseLinkLine(line))\n        },\n      })\n      const cut = anchoredCut(segments, found, {\n        refName: tabixRefName,\n        start: region.start,\n        end: region.end,\n      })\n      return formatSubgraph(cut.segments, cut.links)\n    }\n    let frontier = offReference(\n      await addLinksOver(tabixRefName, region.start, region.end),\n    )\n    for (let hop = 0; hop < hops; hop++) {\n      // One hop's queries are independent of each other, so they go out\n      // together rather than one round-trip at a time. Their callbacks share\n      // the segment and link maps, which is safe because only one of them runs\n      // at a time, and the output is sorted at the end regardless of the order\n      // they arrive in.\n      const reached = await Promise.all(\n        frontier.map(segment =>\n          addLinksOver(segment.refName, segment.start, segment.end),\n        ),\n      )\n      frontier = offReference(reached.flat())\n    }\n    if (hops > 0) {\n      const spans = closingSpans(\n        [...segments.values()],\n        new Set(frontier.map(segment => segment.id)),\n        { refName: tabixRefName, start: region.start, end: region.end },\n      )\n      const found: RgfaLink[] = []\n      await Promise.all(\n        spans.map(span =>\n          getLines(index.links, span.refName, span.start, span.end, {\n            signal,\n            lineCallback: line => {\n              found.push(parseLinkLine(line))\n            },\n          }),\n        ),\n      )\n      for (const link of closingLinks(found, segments, spans)) {\n        links.set(linkKey(link), link)\n        for (const segment of [link.sourceSegment, link.targetSegment]) {\n          if (!segments.has(segment.id)) {\n            segments.set(segment.id, segment)\n          }\n        }\n      }\n    }\n\n    return formatSubgraph(segments, links)\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["parseSegmentRow", "line", "cols", "anchored", "own", "segmentSamples", "segment", "tag", "t", "samples", "parseEndpoint", "field", "parseLinkLine", "source", "target", "linkKey", "link", "anchoredCut", "under", "found", "window", "side", "segments", "links", "closingSpans", "held", "unread", "outside", "mergedSpans", "maxGap", "sorted", "a", "b", "compare", "spans", "span", "refName", "start", "end", "closingLinks", "inside", "GFA_TAG", "formatSegment", "id", "rank", "tags", "valid", "extra", "formatLink", "sourceStrand", "targetStrand", "formatSubgraph", "sortedSegments", "sortedLinks", "s", "k", "offReference", "segments", "segment", "RgfaTabixAdapter", "BaseFeatureDataAdapter", "config", "getSubAdapter", "pluginManager", "under", "openTabixSlot", "walksLocation", "hasWalks", "locationIsSet", "links", "walkFile", "WalkReader", "PanSNRefNames", "opts", "header", "tier", "query", "signal", "statusCallback", "ObservableCreate", "observer", "tabixRefName", "walks", "start", "refRows", "updateStatus", "getLines", "line", "cols", "seen", "node", "referenceNodes", "id", "SimpleFeature", "anchored", "parseSegmentRow", "samples", "segmentSamples", "region", "hops", "index", "addLinksOver", "refName", "end", "reached", "link", "parseLinkLine", "linkKey", "walkSubgraph", "lane", "resolvePanSNPrefix", "layout", "row", "found", "cut", "anchoredCut", "formatSubgraph", "frontier", "hop", "spans", "closingSpans", "span", "closingLinks"]
-}

package/dist/chunks/WalkTabixSyntenyAdapter-I6E6HAN4.js

@@ -1,2 +0,0 @@
-import{b as q,c as D,d as H,e as G}from"./chunk-2QQDYK5V.js";import{a as _}from"./chunk-LUTMKRXY.js";import{a as T,b as I,d as j,e as B}from"./chunk-WI7LRX6I.js";import{a as R}from"./chunk-KOB7YIMR.js";import{p as W,q as L}from"./chunk-T4HOC6O3.js";import"./chunk-TXI43PEN.js";import{f as $,g as v}from"./chunk-4IJKHORO.js";import"./chunk-YBLNN5FU.js";import"./chunk-MVVXRZXV.js";import{a as P,c as F,d as A,e as k,f as N,g as x}from"./chunk-IIGYYZI5.js";import"./chunk-E7J6SB5P.js";import"./chunk-7WIBGKBU.js";import"./chunk-OGQ6OQDN.js";import"./chunk-NDRLCGPC.js";import{o as C}from"./chunk-TENPGIPX.js";var Z=50;function ee(m){let e=[];for(let t=0;t<m.length;t++){let[r,s]=m[t],[n,a]=m[t+1]??[];s===a&&s<=Z&&(r==="I"&&n==="D"||r==="D"&&n==="I")?(e.push(["X",s]),t++):e.push([r,s])}return e}function te(m){return m.map(([e,t])=>`${t}${e}`).join("")}function U(m){let e=new Map,t=n=>{let a=m.get(n),i=a===void 0?0:a.end-a.start,p=e.get(i);return p===void 0&&(p="N".repeat(i),e.set(i,p)),p},r=new Map,s=n=>{let a=r.get(n);return a===void 0&&(a=Array.from(n.ids,(i,p)=>2*i+n.rev[p]),r.set(n,a)),a};return(n,a)=>L({query:s(n),target:s(a),sequenceOf:t,bases:!1})}var ae=100;function E(m,e,t){let r=m.at(-1);t>0&&(r?.[0]===e?r[1]+=t:m.push([e,t]))}function X(m){let e=s=>{let n=m.get(s>>1);return n===void 0?0:n.end-n.start},t=s=>{let n=new Float64Array(s.length+1);return s.forEach((a,i)=>{n[i+1]=n[i]+e(a)}),n},r=s=>Array.from(s.ids,(n,a)=>2*n+s.rev[a]);return(s,n)=>{let a=r(n),i=r(s),[p,y]=W(i,a,e),[h,l]=W(i.map(b=>b^1).reverse(),a,e),d=l>y,c=d?h:p,f=Math.max(y,l);if(f<ae)return[];let u=t(a),o=t(i),g=b=>d?i.length-1-c[b][0]:c[b][0],w=[];c.forEach(([,b],S)=>{if(S>0){let[K,Q]=[g(S-1),g(S)].sort((V,Y)=>V-Y);E(w,"I",o[Q]-o[K+1]),E(w,"D",u[b]-u[c[S-1][1]+1])}E(w,"=",e(a[b]))});let[z,J]=[g(0),g(c.length-1)].sort((b,S)=>b-S);return[{queryStart:o[z],queryEnd:o[J+1],targetStart:u[c[0][1]],targetEnd:u[c.at(-1)[1]+1],strand:d?"-":"+",edits:w,sharedBases:f}]}}function O({chain:m,target:e,query:t,assemblyName:r,refName:s,mateAssemblyName:n}){let a=e.hapStart+m.targetStart,i=e.hapStart+m.targetEnd,p=t.hapStart+m.queryStart,y=t.hapStart+m.queryEnd,h=ee(m.edits),l=h.reduce((f,[u,o])=>f+(u==="="?o:0),0),d=h.reduce((f,[,u])=>f+u,0),c=`${e.name}:${a}-${i}|${t.name}:${p}-${y}`;return new T({uniqueId:c,assemblyName:r,refName:s,start:a,end:i,type:"match",strand:m.strand==="-"?-1:1,CIGAR:te(h),syntenyId:c,identity:l/Math.max(d,1),numMatches:l,blockLen:d,mate:{refName:A(t.name),start:p,end:y,assemblyName:n}})}var ne=m=>F(m.name)??m.name,M=class extends I{constructor(e,t,r){super(e,t,r);let s=$(this,["walksLocation"],["walksIndex"]);this.reader=new D(s),this.refNames=new v(s,this)}get anchor(){let e=this.getConf("assemblyNames")[0];if(e===void 0)throw new Error("WalkTabixSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as");return e}async getHaplotypeNames(e={}){let{haplotypes:t}=await this.reader.header(e);return t.length>0?t:void 0}async getHeader(e={}){let{haplotypes:t,references:r}=await this.reader.header(e),{anchor:s}=this,n=N(this,s),a=x(this);return{hasCoarseTier:!1,anchorAssemblyName:s,referenceSamples:r,lanes:t.filter(i=>i!==n&&P(i)!==n).map(i=>({name:B(a,i),label:i,group:P(i)}))}}async getRefNames(e={}){let{assemblyName:t}=e;return t===void 0||t===this.anchor?this.refNames.assemblyRefNames({...e,assemblyName:this.anchor}):[]}budgets(){return{stepBudget:this.getConf("walkStepBudget"),byteBudget:this.getConf("walkByteBudget"),budgetNames:H}}async getSubgraph(e,t={}){let{signal:r,haplotypes:s,walkRows:n}=t,a=await this.refNames.resolve(e,{signal:r});if(a===void 0)throw new Error(`${e.assemblyName} ${e.refName} is not in this graph's index; the graph is cut on ${this.anchor}, mapped to its PanSN prefix in assemblyNameToPanSN`);return G(this.reader,a,e,{...this.budgets(),signal:r,prefixes:s?.map(i=>N(this,i)),walkRows:n})}async laneWalks(e,t,r,s,n){return C(n,s.statusCallback,()=>this.reader.cut(e,t,{...this.budgets(),signal:s.signal,keep:q(r,F(e)),links:!1}).catch(a=>{throw _(a)&&a instanceof Error&&(a.message=a.message.replace("to see the graph","to see lanes")),a}))}async anchorFeatures(e,t,r){let s=r.haplotypes?.length?r.haplotypes.map(o=>N(this,o)):void 0,n=N(this,r.targetAssemblyName),a=n===void 0?s:s===void 0||s.some(o=>k(n,o)||k(o,n))?[n]:[];if(a?.length===0)return[];let{start:i,end:p}=t,{graph:y,fragments:h}=await this.laneWalks(e,t,a,r,`Reading walks ${t.refName}:${i.toLocaleString()}-${p.toLocaleString()}`),l=X(y.nodes),d=x(this),c=h.filter(o=>o.name===e),f=o=>a===void 0?0:a.findIndex(g=>k(o.name,g));return h.filter(o=>o.name!==e&&f(o)>=0).sort((o,g)=>f(o)-f(g)).flatMap(o=>c.flatMap(g=>l(o,g).map(w=>O({chain:w,target:g,query:o,assemblyName:t.assemblyName,refName:t.refName,mateAssemblyName:B(d,ne(o))}))))}async pairFeatures(e,t,r,s){let[n]=r,a=r.map(l=>({pair:l,featurePrefix:N(this,l.queryAssemblyName),matePrefix:N(this,l.targetAssemblyName)})),{graph:i,fragments:p}=await this.laneWalks(e,t,a.flatMap(l=>[l.featurePrefix,l.matePrefix]),s,r.length===1&&n?`Reading ${n.queryAssemblyName} against ${n.targetAssemblyName}`:`Reading ${r.length} lane pairs`),y=U(i.nodes),h=l=>p.filter(d=>k(d.name,l));return a.flatMap(({pair:l,featurePrefix:d,matePrefix:c})=>h(d).flatMap(f=>h(c).flatMap(u=>y(u,f).map(o=>O({chain:o,target:f,query:u,assemblyName:l.queryAssemblyName,refName:A(f.name),mateAssemblyName:l.targetAssemblyName})))))}getFeatures(e,t={}){return R(async r=>{let s=e.assemblyName===this.anchor?await this.refNames.resolve(e,t):void 0;if(s!==void 0){let n=j(t),a=n.length>0?await this.pairFeatures(s,e,n,t):await this.anchorFeatures(s,e,t);for(let i of a)r.next(i)}r.complete()},t.signal)}};export{M as default};
-//# sourceMappingURL=WalkTabixSyntenyAdapter-I6E6HAN4.js.map

package/dist/chunks/WalkTabixSyntenyAdapter-I6E6HAN4.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/WalkTabixSyntenyAdapter/walkLanes.ts", "../../src/WalkTabixSyntenyAdapter/WalkTabixSyntenyAdapter.ts"],
-  "sourcesContent": ["import { weightedLcs } from '@gmod/gbz-base/lcs'\nimport { pairAlignments } from '@gmod/gbz-base/pairAlignment'\nimport { panSNContig } from '@jbrowse/bandage-core/pansn'\n\nimport SyntenyFeature from '../synteny/SyntenyFeature.ts'\n\nimport type { PairChain, PairEdit } from '@gmod/gbz-base/pairAlignment'\nimport type { WalkFragment, WalkNode } from '@jbrowse/graph-walks'\n\n// The longest bubble with equal bases on both sides that is written as\n// mismatches; a longer one stays an insertion and a deletion\nconst BALANCED_BUBBLE_MAX_BP = 50\n\n/**\n * A chain's edits with each short balanced bubble as `X`. The walks carry no\n * bases, so two walks differ wherever they leave a shared node, and a SNP is\n * one base inserted and one deleted until it is read as the mismatch it is.\n */\nexport function bubblesAsMismatches(edits: PairEdit[]) {\n  const out: PairEdit[] = []\n  for (let i = 0; i < edits.length; i++) {\n    const [op, len] = edits[i]!\n    const [nextOp, nextLen] = edits[i + 1] ?? []\n    if (\n      len === nextLen &&\n      len <= BALANCED_BUBBLE_MAX_BP &&\n      ((op === 'I' && nextOp === 'D') || (op === 'D' && nextOp === 'I'))\n    ) {\n      out.push(['X', len])\n      i++\n    } else {\n      out.push([op, len])\n    }\n  }\n  return out\n}\n\nfunction cigarOf(edits: PairEdit[]) {\n  return edits.map(([op, len]) => `${len}${op}`).join('')\n}\n\n/**\n * Aligns one walk fragment to another on the nodes both visit, from node\n * lengths alone: the fragments' steps as the handles gbz-base's chainer reads,\n * and a stand-in sequence of each node's length.\n */\nexport function walkAligner(nodes: Map<number, WalkNode>) {\n  const standIn = new Map<number, string>()\n  const sequenceOf = (id: number) => {\n    const node = nodes.get(id)\n    const length = node === undefined ? 0 : node.end - node.start\n    let sequence = standIn.get(length)\n    if (sequence === undefined) {\n      sequence = 'N'.repeat(length)\n      standIn.set(length, sequence)\n    }\n    return sequence\n  }\n  const handles = new Map<WalkFragment, number[]>()\n  const handlesOf = (fragment: WalkFragment) => {\n    let steps = handles.get(fragment)\n    if (steps === undefined) {\n      steps = Array.from(fragment.ids, (id, i) => 2 * id + fragment.rev[i]!)\n      handles.set(fragment, steps)\n    }\n    return steps\n  }\n  return (query: WalkFragment, target: WalkFragment) =>\n    pairAlignments({\n      query: handlesOf(query),\n      target: handlesOf(target),\n      sequenceOf,\n      bases: false,\n    })\n}\n\n// The fewest bases on shared nodes a record against the reference keeps,\n// gbz-base's floor for a pair record\nconst MIN_MATCH_BP = 100\n\nfunction appendEdit(edits: PairEdit[], op: PairEdit[0], len: number) {\n  const last = edits.at(-1)\n  if (len > 0) {\n    if (last?.[0] === op) {\n      last[1] += len\n    } else {\n      edits.push([op, len])\n    }\n  }\n}\n\n/**\n * Aligns a haplotype's walk fragment to the reference's as gbz-base aligns a\n * walk to its reference path: the heaviest common subsequence of their steps,\n * each node weighing its length, read in whichever direction shares more. A\n * pair chain leaves out every node either walk passes twice, which is the\n * whole of a collapsed copy-number array (amylase, KIV-2); the subsequence\n * matches one pass over it, and the other copies are insertions.\n */\nexport function referenceAligner(nodes: Map<number, WalkNode>) {\n  const lengthOf = (handle: number) => {\n    const node = nodes.get(handle >> 1)\n    return node === undefined ? 0 : node.end - node.start\n  }\n  const offsets = (handles: number[]) => {\n    const out = new Float64Array(handles.length + 1)\n    handles.forEach((handle, i) => {\n      out[i + 1] = out[i]! + lengthOf(handle)\n    })\n    return out\n  }\n  const handlesOf = (fragment: WalkFragment) =>\n    Array.from(fragment.ids, (id, i) => 2 * id + fragment.rev[i]!)\n\n  return (query: WalkFragment, target: WalkFragment): PairChain[] => {\n    const ref = handlesOf(target)\n    const hap = handlesOf(query)\n    const [same, sameWeight] = weightedLcs(hap, ref, lengthOf)\n    const [turned, turnedWeight] = weightedLcs(\n      hap.map(handle => handle ^ 1).reverse(),\n      ref,\n      lengthOf,\n    )\n    const reverse = turnedWeight > sameWeight\n    const pairs = reverse ? turned : same\n    const sharedBases = Math.max(sameWeight, turnedWeight)\n    if (sharedBases < MIN_MATCH_BP) {\n      return []\n    }\n    const refAt = offsets(ref)\n    const hapAt = offsets(hap)\n    // a pair's haplotype step, counted along the haplotype\n    const stepOf = (k: number) =>\n      reverse ? hap.length - 1 - pairs[k]![0] : pairs[k]![0]\n    const edits: PairEdit[] = []\n    pairs.forEach(([, r], k) => {\n      if (k > 0) {\n        const [lo, hi] = [stepOf(k - 1), stepOf(k)].sort((x, y) => x - y)\n        appendEdit(edits, 'I', hapAt[hi!]! - hapAt[lo! + 1]!)\n        appendEdit(edits, 'D', refAt[r]! - refAt[pairs[k - 1]![1] + 1]!)\n      }\n      appendEdit(edits, '=', lengthOf(ref[r]!))\n    })\n    const [lo, hi] = [stepOf(0), stepOf(pairs.length - 1)].sort((x, y) => x - y)\n    return [\n      {\n        queryStart: hapAt[lo!]!,\n        queryEnd: hapAt[hi! + 1]!,\n        targetStart: refAt[pairs[0]![1]]!,\n        targetEnd: refAt[pairs.at(-1)![1] + 1]!,\n        strand: reverse ? '-' : '+',\n        edits,\n        sharedBases,\n      },\n    ]\n  }\n}\n\n/**\n * One record of a walk aligned to another: on the target walk's contig, with\n * the query walk as its mate and the CIGAR read along the target, a `D` being\n * target bases the query lacks.\n */\nexport function chainFeature({\n  chain,\n  target,\n  query,\n  assemblyName,\n  refName,\n  mateAssemblyName,\n}: {\n  chain: PairChain\n  target: WalkFragment\n  query: WalkFragment\n  assemblyName: string\n  refName: string\n  mateAssemblyName: string\n}) {\n  const start = target.hapStart + chain.targetStart\n  const end = target.hapStart + chain.targetEnd\n  const mateStart = query.hapStart + chain.queryStart\n  const mateEnd = query.hapStart + chain.queryEnd\n  const edits = bubblesAsMismatches(chain.edits)\n  const matches = edits.reduce((sum, [op, n]) => sum + (op === '=' ? n : 0), 0)\n  const columns = edits.reduce((sum, [, n]) => sum + n, 0)\n  const id = `${target.name}:${start}-${end}|${query.name}:${mateStart}-${mateEnd}`\n  return new SyntenyFeature({\n    uniqueId: id,\n    assemblyName,\n    refName,\n    start,\n    end,\n    type: 'match',\n    strand: chain.strand === '-' ? -1 : 1,\n    CIGAR: cigarOf(edits),\n    syntenyId: id,\n    identity: matches / Math.max(columns, 1),\n    numMatches: matches,\n    blockLen: columns,\n    mate: {\n      refName: panSNContig(query.name),\n      start: mateStart,\n      end: mateEnd,\n      assemblyName: mateAssemblyName,\n    },\n  })\n}\n", "import {\n  assemblyByPanSNPrefix,\n  panSNContig,\n  panSNHaplotype,\n  panSNMatchesPrefix,\n  panSNSample,\n  resolvePanSNPrefix,\n} from '@jbrowse/bandage-core/pansn'\nimport { updateStatus } from '@jbrowse/core/util'\nimport { ObservableCreate } from '@jbrowse/core/util/rxjs'\nimport { WalkReader, walkNameFilter } from '@jbrowse/graph-walks'\n\nimport { chainFeature, referenceAligner, walkAligner } from './walkLanes.ts'\nimport { isNodeLimitError } from '../LinearGraphDisplay/denseWindow.ts'\nimport { BUDGET_SLOTS, walkSubgraph } from '../RgfaTabixAdapter/walkReader.ts'\nimport { PanSNRefNames, openTabixSlot } from '../panSNTabix.ts'\nimport { ComparativeAdapterBase } from '../synteny/ComparativeAdapterBase.ts'\nimport { laneAssemblyName, requestedPairs } from '../synteny/lanePairs.ts'\n\nimport type { WalkTabixSyntenyAdapterConfig } from './configSchema.ts'\nimport type { SubgraphAdapterOptions } from '../GetSubgraph.ts'\nimport type { LaneFeatureOptions, LanePair } from '../synteny/lanePairs.ts'\nimport type PluginManager from '@jbrowse/core/PluginManager'\nimport type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter'\nimport type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache'\nimport type { Feature } from '@jbrowse/core/util'\nimport type { Region } from '@jbrowse/core/util/types'\nimport type { WalkFragment } from '@jbrowse/graph-walks'\n\nconst haplotypeOf = (fragment: WalkFragment) =>\n  panSNHaplotype(fragment.name) ?? fragment.name\n\nexport default class WalkTabixSyntenyAdapter extends ComparativeAdapterBase<WalkTabixSyntenyAdapterConfig> {\n  private readonly reader\n  private readonly refNames\n\n  public constructor(\n    config: WalkTabixSyntenyAdapterConfig,\n    getSubAdapter?: getSubAdapterType,\n    pluginManager?: PluginManager,\n  ) {\n    super(config, getSubAdapter, pluginManager)\n    const walks = openTabixSlot(this, ['walksLocation'], ['walksIndex'])\n    this.reader = new WalkReader(walks)\n    this.refNames = new PanSNRefNames(walks, this)\n  }\n\n  private get anchor() {\n    const anchor = this.getConf('assemblyNames')[0]\n    if (anchor === undefined) {\n      throw new Error(\n        'WalkTabixSyntenyAdapter needs assemblyNames: its first entry is the assembly the reference sample is loaded as',\n      )\n    }\n    return anchor\n  }\n\n  /**\n   * The haplotypes the walk file's header names, `sample#haplotype` in byte\n   * order, or undefined when it names none\n   */\n  async getHaplotypeNames(opts: BaseOptions = {}) {\n    const { haplotypes } = await this.reader.header(opts)\n    return haplotypes.length > 0 ? haplotypes : undefined\n  }\n\n  /**\n   * `lanes` is every haplotype the header names but the anchor's own,\n   * declared up front so the display can offer the whole graph's haplotypes\n   * before a fetch has placed any of them\n   */\n  async getHeader(opts: BaseOptions = {}) {\n    const { haplotypes, references } = await this.reader.header(opts)\n    const { anchor } = this\n    const anchorPrefix = resolvePanSNPrefix(this, anchor)\n    const asmByPrefix = assemblyByPanSNPrefix(this)\n    return {\n      hasCoarseTier: false,\n      anchorAssemblyName: anchor,\n      referenceSamples: references,\n      lanes: haplotypes\n        .filter(\n          prefix =>\n            prefix !== anchorPrefix && panSNSample(prefix) !== anchorPrefix,\n        )\n        .map(prefix => ({\n          name: laneAssemblyName(asmByPrefix, prefix),\n          label: prefix,\n          group: panSNSample(prefix),\n        })),\n    }\n  }\n\n  // A lane's contigs are named only in its walk rows, so only the anchor's\n  // are listed\n  async getRefNames(opts: BaseOptions = {}) {\n    const { assemblyName } = opts\n    return assemblyName === undefined || assemblyName === this.anchor\n      ? this.refNames.assemblyRefNames({ ...opts, assemblyName: this.anchor })\n      : []\n  }\n\n  private budgets() {\n    return {\n      stepBudget: this.getConf('walkStepBudget'),\n      byteBudget: this.getConf('walkByteBudget'),\n      budgetNames: BUDGET_SLOTS,\n    }\n  }\n\n  /**\n   * The graph display's cut of the window, as RgfaTabixAdapter cuts a\n   * walk-indexed graph: the reference walk first, then the walks `haplotypes`\n   * asks for, and the nodes and links they visit\n   */\n  async getSubgraph(region: Region, opts: SubgraphAdapterOptions = {}) {\n    const { signal, haplotypes, walkRows } = opts\n    const refName = await this.refNames.resolve(region, { signal })\n    if (refName === undefined) {\n      throw new Error(\n        `${region.assemblyName} ${region.refName} is not in this graph's index; the graph is cut on ${this.anchor}, mapped to its PanSN prefix in assemblyNameToPanSN`,\n      )\n    }\n    return walkSubgraph(this.reader, refName, region, {\n      ...this.budgets(),\n      signal,\n      prefixes: haplotypes?.map(lane => resolvePanSNPrefix(this, lane)),\n      walkRows,\n    })\n  }\n\n  // The window's walks for the haplotypes named and the reference, with no\n  // link read; a window past a budget fails as a zoom-in notice for lanes\n  private async laneWalks(\n    refName: string,\n    region: Region,\n    prefixes: string[] | undefined,\n    opts: LaneFeatureOptions,\n    status: string,\n  ) {\n    return updateStatus(status, opts.statusCallback, () =>\n      this.reader\n        .cut(refName, region, {\n          ...this.budgets(),\n          signal: opts.signal,\n          keep: walkNameFilter(prefixes, panSNHaplotype(refName)),\n          links: false,\n        })\n        .catch((error: unknown) => {\n          if (isNodeLimitError(error) && error instanceof Error) {\n            error.message = error.message.replace(\n              'to see the graph',\n              'to see lanes',\n            )\n          }\n          throw error\n        }),\n    )\n  }\n\n  /**\n   * One record per stretch a haplotype's walk shares with the reference's,\n   * on the reference with the haplotype as its mate\n   */\n  private async anchorFeatures(\n    refName: string,\n    region: Region,\n    opts: LaneFeatureOptions,\n  ) {\n    const wanted = opts.haplotypes?.length\n      ? opts.haplotypes.map(lane => resolvePanSNPrefix(this, lane))\n      : undefined\n    const target = resolvePanSNPrefix(this, opts.targetAssemblyName)\n    const prefixes =\n      target === undefined\n        ? wanted\n        : wanted === undefined ||\n            wanted.some(\n              prefix =>\n                panSNMatchesPrefix(target, prefix) ||\n                panSNMatchesPrefix(prefix, target),\n            )\n          ? [target]\n          : []\n    if (prefixes?.length === 0) {\n      return []\n    }\n    const { start, end } = region\n    const { graph, fragments } = await this.laneWalks(\n      refName,\n      region,\n      prefixes,\n      opts,\n      `Reading walks ${region.refName}:${start.toLocaleString()}-${end.toLocaleString()}`,\n    )\n    const align = referenceAligner(graph.nodes)\n    const asmByPrefix = assemblyByPanSNPrefix(this)\n    const references = fragments.filter(f => f.name === refName)\n    // lanes come back in the order the fetch names them, which is the order\n    // the display stacks lanes of equal weight in\n    const rank = (fragment: WalkFragment) =>\n      prefixes === undefined\n        ? 0\n        : prefixes.findIndex(prefix =>\n            panSNMatchesPrefix(fragment.name, prefix),\n          )\n    const shown = fragments\n      .filter(fragment => fragment.name !== refName && rank(fragment) >= 0)\n      .sort((a, b) => rank(a) - rank(b))\n    return shown.flatMap(query =>\n      references.flatMap(reference =>\n        align(query, reference).map(chain =>\n          chainFeature({\n            chain,\n            target: reference,\n            query,\n            assemblyName: region.assemblyName,\n            refName: region.refName,\n            mateAssemblyName: laneAssemblyName(asmByPrefix, haplotypeOf(query)),\n          }),\n        ),\n      ),\n    )\n  }\n\n  /**\n   * Each pair's two lanes read out of the anchor window, all pairs in one\n   * read, and each walk of a pair's query lane aligned to each walk of its\n   * target lane. A pair's records sit on its query lane's contigs, the lane\n   * the display draws on top.\n   */\n  private async pairFeatures(\n    refName: string,\n    region: Region,\n    pairs: LanePair[],\n    opts: LaneFeatureOptions,\n  ) {\n    const [first] = pairs\n    const sides = pairs.map(pair => ({\n      pair,\n      featurePrefix: resolvePanSNPrefix(this, pair.queryAssemblyName),\n      matePrefix: resolvePanSNPrefix(this, pair.targetAssemblyName),\n    }))\n    const { graph, fragments } = await this.laneWalks(\n      refName,\n      region,\n      sides.flatMap(side => [side.featurePrefix, side.matePrefix]),\n      opts,\n      pairs.length === 1 && first\n        ? `Reading ${first.queryAssemblyName} against ${first.targetAssemblyName}`\n        : `Reading ${pairs.length} lane pairs`,\n    )\n    const align = walkAligner(graph.nodes)\n    const walksOf = (prefix: string) =>\n      fragments.filter(f => panSNMatchesPrefix(f.name, prefix))\n    return sides.flatMap(({ pair, featurePrefix, matePrefix }) =>\n      walksOf(featurePrefix).flatMap(target =>\n        walksOf(matePrefix).flatMap(query =>\n          align(query, target).map(chain =>\n            chainFeature({\n              chain,\n              target,\n              query,\n              assemblyName: pair.queryAssemblyName,\n              refName: panSNContig(target.name),\n              mateAssemblyName: pair.targetAssemblyName,\n            }),\n          ),\n        ),\n      ),\n    )\n  }\n\n  // The files are filed under the reference alone, so a window on a\n  // haplotype lane has no answer: a lane pair is read inside the anchor's\n  getFeatures(region: Region, opts: LaneFeatureOptions = {}) {\n    return ObservableCreate<Feature>(async observer => {\n      const refName =\n        region.assemblyName === this.anchor\n          ? await this.refNames.resolve(region, opts)\n          : undefined\n      if (refName !== undefined) {\n        const pairs = requestedPairs(opts)\n        const features =\n          pairs.length > 0\n            ? await this.pairFeatures(refName, region, pairs, opts)\n            : await this.anchorFeatures(refName, region, opts)\n        for (const feature of features) {\n          observer.next(feature)\n        }\n      }\n      observer.complete()\n    }, opts.signal)\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["BALANCED_BUBBLE_MAX_BP", "bubblesAsMismatches", "edits", "out", "i", "op", "len", "nextOp", "nextLen", "cigarOf", "walkAligner", "nodes", "standIn", "sequenceOf", "id", "node", "length", "sequence", "handles", "handlesOf", "fragment", "steps", "query", "target", "pairAlignments", "MIN_MATCH_BP", "appendEdit", "last", "referenceAligner", "lengthOf", "handle", "offsets", "ref", "hap", "same", "sameWeight", "weightedLcs", "turned", "turnedWeight", "reverse", "pairs", "sharedBases", "refAt", "hapAt", "stepOf", "k", "r", "lo", "hi", "x", "y", "chainFeature", "chain", "assemblyName", "refName", "mateAssemblyName", "start", "end", "mateStart", "mateEnd", "matches", "sum", "n", "columns", "SyntenyFeature", "panSNContig", "haplotypeOf", "fragment", "panSNHaplotype", "WalkTabixSyntenyAdapter", "ComparativeAdapterBase", "config", "getSubAdapter", "pluginManager", "walks", "openTabixSlot", "WalkReader", "PanSNRefNames", "anchor", "opts", "haplotypes", "references", "anchorPrefix", "resolvePanSNPrefix", "asmByPrefix", "assemblyByPanSNPrefix", "prefix", "panSNSample", "laneAssemblyName", "assemblyName", "BUDGET_SLOTS", "region", "signal", "walkRows", "refName", "walkSubgraph", "lane", "prefixes", "status", "updateStatus", "walkNameFilter", "error", "isNodeLimitError", "wanted", "target", "panSNMatchesPrefix", "start", "end", "graph", "fragments", "align", "referenceAligner", "f", "rank", "a", "b", "query", "reference", "chain", "chainFeature", "pairs", "first", "sides", "pair", "side", "walkAligner", "walksOf", "featurePrefix", "matePrefix", "panSNContig", "ObservableCreate", "observer", "requestedPairs", "features", "feature"]
-}

package/dist/chunks/chunk-2QQDYK5V.js

@@ -1,2 +0,0 @@
-import{a as ht}from"./chunk-TXI43PEN.js";import{c as ft}from"./chunk-IIGYYZI5.js";var $=r=>(r-(r&1))/2,I=r=>r&1?r-1:r+1;function U(r,t,n){if(r===".")return n;let e=0,o=!1;for(let s=0;s<=r.length;s++){let i=s<r.length?r.charCodeAt(s):44;if(i===44){let f=o?-e:e,y=f&1;t.id+=(f-y)/2,n.push(t.id*2+y),e=0,o=!1}else i===45?o=!0:e=e*10+(i-48)}return n}function D(r){return r==="."?[]:r.split(",").map(Number)}function Z(r,t){return r>I(t)?[I(t),I(r)]:[r,t]}function ut(r,t,n){let e,o;for(let s=t;s<r.length;s++){let i=r[s];if(i.startsWith("pv:")||i.startsWith("nx:")){let f=i.lastIndexOf(":"),y={refName:i[3]==="Z"?i.slice(5,f):n,start:+i.slice(f+1)};i.startsWith("pv:")?e=y:o=y}}return{prev:e,next:o}}var Y=class{constructor(){this.handles=[],this.before=[0],this.occurrences=new Map}add(t,n){for(let e=0;e<t.length;e++){let o=t[e],s=this.handles.length;this.handles.push(o),this.before.push(this.before[s]+n[e]);let i=$(o),f=this.occurrences.get(i);f?f.push(s):this.occurrences.set(i,[s])}}bp(t){return this.before[t]}first(t){var n;return(n=this.occurrences.get($(t)))===null||n===void 0?void 0:n[0]}nearest(t,n){var e;let o;for(let s of(e=this.occurrences.get($(t)))!==null&&e!==void 0?e:[])(o===void 0||Math.abs(s-n)<=Math.abs(o-n))&&(o=s);return o}reach(t,n,e){var o;let s=this.handles[t]===n,i;for(let f of(o=this.occurrences.get($(e)))!==null&&o!==void 0?o:[])s&&f>=t&&this.handles[f]===e?(i===void 0||f<i)&&(i=f):!s&&f<=t&&I(this.handles[f])===e&&(i===void 0||f>i)&&(i=f);return i}handleAt(t,n){return n?this.handles[t]:I(this.handles[t])}},L=class extends Error{},tt=(r,t)=>t?r.exit===-1?-1:I(r.exit):r.entry,pt=(r,t)=>t?r.entry===-1?-1:I(r.entry):r.exit,G=(r,t,n)=>t?I(r.interior[r.interior.length-1-n]):r.interior[n];function Nt(r){let t=[];if(r!=="."){let n=0,e=0,o=!1,s=0,i=!1;for(let f=0;f<=r.length;f++){let y=f<r.length?r.charCodeAt(f):44;if(y===44){let w=o?-e:e,S=i?s:w,v=S&1;n+=(S-v)/2,t.push(n,v,i?w:0),e=0,o=!1,i=!1}else y===58?(s=o?-e:e,e=0,o=!1,i=!0):y===45?o=!0:e=e*10+(y-48)}}return t}function gt(r,t,n,e,o,s){let i=e.indexOf(":"),f=n+ +(i<0?e:e.slice(0,i)),y=i>=0,w=y?+e.slice(i+1):0,S=a=>{let c=t[a];if(!c)throw new L(`route ${a} is not in the chunk`);return c},v=0;if(o.length>0&&tt(S(o[0]),o[1]===1)===-1){if(!s.route(o[0],o[1]===1))return;v=3}let b=n,l=r.first(b);if(l===void 0)throw new L("a walk row starts off its chunk");s.step(b);let k=(a,c)=>{let d=r.handles[l]===b,u=y?l+(d?c:-c):r.reach(l,b,a);if(u===void 0||u<0||u>=r.handles.length)throw new L("a walk row runs off its chunk");u!==l&&s.stretch(l,u,d),l=u,b=r.handleAt(u,d)};for(;v<o.length;v+=3){let a=o[v],c=o[v+1]===1,d=S(a),u=tt(d,c);if(u===-1)throw new L("an open route after the first choice");if(k(u,o[v+2]),!s.route(a,c))return;let p=pt(d,c);if(p===-1)return;if(b=p,l=r.nearest(b,l),l===void 0)throw new L("a route lands off its chunk");s.step(b)}if(k(f,w),b!==f)throw new L("a walk row misses its last handle")}function St(r,t,n,e,o){let s=new Int32Array(o),i=new Uint8Array(o),f=0,y=w=>{if(f>=o)throw new L("a walk row decodes to more steps than it states");s[f]=$(w),i[f++]=w&1};if(gt(r,t,+n[9],n[10],e,{step:y,stretch(w,S,v){if(v)for(let b=w+1;b<=S;b++)y(r.handles[b]);else for(let b=w-1;b>=S;b--)y(I(r.handles[b]))},route(w,S){let v=t[w];for(let b=0;b<v.interior.length;b++)y(G(v,S,b));return!0}}),f!==o)throw new L(`a walk row decodes to ${f} steps, not ${o}`);return{ids:s,rev:i}}function dt(r,t,n,e,o){let s=r.slice(t).find(f=>f.startsWith("SQ:Z:"));if(s===void 0)return;let i=5;for(let f=0;f<n.length;f++){let y=e[f];o.set(n[f],s.slice(i,i+y)),i+=y}}function wt(r,t,n=!1){var e,o,s;let i=new Y,f=new Map,y=[],w={sequences:new Map,rows:[],nodes:new Map,ends:[],chunk:{path:i,routes:y,walks:[],lengths:f}},S={id:0},v=r.filter(l=>l[3]==="ref").sort((l,k)=>+l[6]-+k[6]);for(let l of v){let k=l[0],a=U(l[9],{id:0},[]),c=D(l[10]),d=+l[6];i.add(a,c),n&&dt(l,11,a.map($),c,w.sequences);let u=d;for(let p=0;p<a.length;p++){let g=$(a[p]),x=c[p];f.set(g,x),w.nodes.has(g)||w.nodes.set(g,{refName:l[4],start:u,end:u+x,rank:0}),u+=x}w.ends.push({name:l[4],fragStart:+l[5],piece:+l[7],first:a[0],last:a.at(-1)}),(t===void 0||t(l[4]))&&w.rows.push({chunkStart:+l[1],name:l[4],fragStart:+l[5],hapOffset:d,piece:+l[7],n:a.length,steps:{ids:Int32Array.from(a,$),rev:Uint8Array.from(a,p=>p&1)},...ut(l,11,k)})}for(let l of r)if(l[3]==="nodes"){let k=D(l[4]),a=D(l[5]),c=0;for(let d=0;d<k.length;d++)c+=k[d],k[d]=c,f.set(c,a[d]);n&&dt(l,6,k,a,w.sequences)}else if(l[3]==="route"){let k=U(l[4],S,[]),a=U(l[5],S,[]),c=U(l[6],S,[]);y.push({entry:(e=k[0])!==null&&e!==void 0?e:-1,interior:a,exit:(o=c[0])!==null&&o!==void 0?o:-1})}let b=l=>{let k=y[l];if(!k)throw new L(`route ${l} is not in the chunk`);return k};for(let l of r){if(l[3]!=="walk")continue;let k=Nt(l[11]);w.chunk.walks.push({cols:l,choices:k});let a=l[4],c=+l[9],d=l[10],u=d.indexOf(":"),p=c,g=c+ +(u<0?d:d.slice(0,u));if(k.length>0){let x=b(k[0]),h=k[1]===1;tt(x,h)===-1&&(p=G(x,h,0));let m=k.length-3,N=b(k[m]),M=k[m+1]===1;pt(N,M)===-1&&(g=G(N,M,N.interior.length-1))}if(w.ends.push({name:a,fragStart:+l[5],piece:+l[7],first:p,last:g}),t===void 0||t(a)){let x=+l[8];for(let h=0;h<k.length;h+=3)for(let m of b(k[h]).interior){let N=$(m);if(!w.nodes.has(N)){let M=(s=f.get(N))!==null&&s!==void 0?s:0;w.nodes.set(N,{refName:a,start:0,end:M,rank:1})}}w.rows.push({chunkStart:+l[1],name:a,fragStart:+l[5],hapOffset:+l[6],piece:+l[7],n:x,steps:St(i,y,l,k,x),...ut(l,12,l[0])})}}return w}function kt(r,t,n,e){let o=new Map;for(let{path:s,routes:i,walks:f,lengths:y}of r){let w=s.handles;for(let a=1;a<w.length;a++)t.has($(w[a-1]))&&t.has($(w[a]))&&e(...Z(w[a-1],w[a]));let S=new Uint8Array(i.length);for(let a=0;a<i.length;a++){let{entry:c,interior:d,exit:u}=i[a],p=!1,g=c;for(let x of d){let h=t.has($(x));p||(p=h),h&&g!==-1&&t.has($(g))&&e(...Z(g,x)),g=x}g!==-1&&u!==-1&&t.has($(g))&&t.has($(u))&&e(...Z(g,u)),S[a]=p?1:0}let v=a=>{var c;return(c=y.get($(a)))!==null&&c!==void 0?c:0},b=new Float64Array(i.length).fill(-1),l=a=>(b[a]<0&&(b[a]=i[a].interior.reduce((c,d)=>c+v(d),0)),b[a]),k=new Uint8Array(i.length);for(let{cols:a,choices:c}of f){let d=0;for(let g=0;g<c.length;g+=3){let x=c[g];S[x]&&!k[x]&&d++}if(d===0)continue;let u=a[4],p=+a[6];gt(s,i,+a[9],a[10],c,{step(g){p+=v(g)},stretch(g,x,h){p+=h?s.bp(x+1)-s.bp(g+1):s.bp(g)-s.bp(x)},route(g,x){if(!S[g]||k[g])return p+=l(g),!0;k[g]=1;let h=i[g];for(let m=0;m<h.interior.length;m++){let N=G(h,x,m),M=$(N),A=v(N);if(t.has(M)){let E=o.get(M);(!E||u<E.refName||u===E.refName&&p<E.start)&&o.set(M,{refName:u,start:p,end:p+A,rank:1})}p+=A}return d--,d>0}})}}for(let[s,i]of o)n(s,i)}function Et(r){let t=[];for(let n of r){if(n[3]!=="ref")continue;let e=U(n[9],{id:0},[]),o=D(n[10]),s=+n[6];for(let i=0;i<e.length;i++){let f=o[i];t.push({id:$(e[i]),refName:n[4],start:s,end:s+f,rank:0}),s+=f}}return t}function mt(r){let t=new Map;for(let e of r){let o=`${e.name}	${e.fragStart}`,s=t.get(o);s||(s=new Map,t.set(o,s)),s.set(e.piece,e)}let n=[];for(let e of t.values())for(let[o,s]of e){let i=e.get(o+1);i&&n.push(Z(s.last,i.first))}return n}var q=class extends Error{constructor(t,n,e,o){super(t),this.regionTooLarge=!0,this.name="NodeLimitError",this.limit=n,this.windowBp=e,this.fitsBp=o}},Mt="#";function Q(r,t){return t!==void 0&&(r===t||r.startsWith(t+Mt))}var yt=r=>Number.parseFloat(r.toPrecision(3));function P(r){let t=yt(r/1e6);return t>=1?`${t.toLocaleString("en-US")}Mbp`:r>=1e3?`${yt(r/1e3).toLocaleString("en-US")}Kbp`:`${Math.floor(r)}bp`}function et(r,t){let n=new RegExp(`(?:^|\\t)${t}:i:(\\d+)`).exec(r);return n?+n[1]:void 0}function nt(r){var t,n,e;let o={references:[],haplotypes:[]};for(let s of r){let[i,f=""]=s.split("	");i==="#reference"?o.references.push(f):i==="#haplotype"?o.haplotypes.push(f):((t=o.format)!==null&&t!==void 0||(o.format=et(s,"format")),(n=o.chunk)!==null&&n!==void 0||(o.chunk=et(s,"chunk")),(e=o.maxNode)!==null&&e!==void 0||(o.maxNode=et(s,"maxnode")))}return o}function st(r,t){return r===void 0?1:Math.max(1,Math.ceil(r/t))}function K(r,t,n=1){return Math.max(0,(Math.floor(r/t)-n)*t)}function ot(r,t){return r===void 0||r.length===0?void 0:n=>Q(n,t)||r.some(e=>Q(n,e))}function z(r){let t=new Map;for(let e of r){let o=`${e.name}	${e.fragStart}`,s=t.get(o);s?s.push(e):t.set(o,[e])}let n=[];for(let e of t.values()){e.sort((s,i)=>s.piece-i.piece);let o=0;for(let s=1;s<=e.length;s++)(s===e.length||e[s].piece!==e[s-1].piece+1)&&(n.push(At(e.slice(o,s))),o=s)}return n}function At(r){let t=r.reduce((i,f)=>i+f.n,0),n=new Int32Array(t),e=new Uint8Array(t),o=0;for(let i of r)n.set(i.steps.ids,o),e.set(i.steps.rev,o),o+=i.n;let s=r[0];return{name:s.name,hapOffset:s.hapOffset,ids:n,rev:e,prev:s.prev,next:r.at(-1).next}}function X(r,t,n){let e=a=>{var c;return((c=t.get(a))===null||c===void 0?void 0:c.onWindow)===!0},o=a=>{let c=t.get(a);return c?.rank===0?c:void 0},s=new Map,i=a=>{a&&s.set(`${a.refName}:${a.start}`,a)},f=(a,c,d)=>{let{ids:u}=a,p=c+d;for(;p>=0&&p<u.length&&o(u[p])===void 0;)p+=d;if(p<0||p>=u.length)return i(d<0?a.prev:a.next),p-d;let g=o(u[c]),x=o(u[p]);return x.refName!==n?p-d:p===c+d&&(x.start===g.end||x.end===g.start)?c:p},y=1/0,w=-1/0,S=[];for(let a of r){let{ids:c}=a,d=-1,u=-1;for(let p=0;p<c.length;p++)e(c[p])&&(d<0&&(d=p),u=p);if(d>=0){if(a.name!==n){d=f(a,d,-1),u=f(a,u,1);for(let p of[d,u]){let g=o(c[p]);g&&(y=Math.min(y,g.start),w=Math.max(w,g.end))}}S.push({run:a,first:d,last:u})}}let v=a=>{let c=o(a);return e(a)||c?.refName===n&&c.end>y&&c.start<w},b=new Set;for(let[a,c]of t)c.onWindow&&b.add(a);for(let a of S){let{ids:c}=a.run;if(a.run.name===n){for(;a.first>0&&v(c[a.first-1]);)a.first--;for(;a.last<c.length-1&&v(c[a.last+1]);)a.last++}for(let d=a.first;d<=a.last;d++)b.add(c[d])}let l=a=>{let c=t.get(a);return c===void 0?0:c.end-c.start},k=[];for(let{run:a,first:c,last:d}of S){let{ids:u,rev:p}=a,g=c,x=d;for(;g>0&&b.has(u[g-1]);)g--;for(;x<u.length-1&&b.has(u[x+1]);)x++;let h=a.hapOffset;for(let N=0;N<g;N++)h+=l(u[N]);let m=h;for(let N=g;N<=x;N++)m+=l(u[N]);k.push({name:a.name,hapStart:h,hapEnd:m,ids:u.subarray(g,x+1),rev:p.subarray(g,x+1)})}return{kept:b,fragments:k,open:[...s.values()]}}var T=class{constructor(t){this.nodes=new Map,this.sequences=new Map,this.links=[],this.chunks=[],this.window=t}placeNode(t,n){if(this.nodes.has(t))return;let{window:e}=this;this.nodes.set(t,{...n,onWindow:n.rank===0&&n.refName===e.refName&&n.end>e.start-e.context&&n.start<e.end+e.context})}addLinkEnds(t,n){this.links.push(t,n)}addChunk(t){this.chunks.push(t)}addSequences(t){if(this.window.sequences)for(let[n,e]of t)this.sequences.set(n,e)}tables(t,n){this.chunks.length>0&&kt(this.chunks,t,(h,m)=>{let N=this.nodes.get(h);N&&this.nodes.set(h,{...N,...m})},(h,m)=>{this.links.push(h,m)});let e=[];for(let h of t){let m=this.nodes.get(h);m&&e.push({...m,id:h})}e.sort((h,m)=>h.refName<m.refName?-1:h.refName>m.refName?1:h.start-m.start||h.id-m.id);let o=new Map,s=[],i=[],f=new Map,y=new Int32Array(e.length),w=new Int32Array(e.length),S=new Float64Array(e.length),v=new Int32Array(e.length);e.forEach(({id:h,refName:m,start:N,end:M,rank:A},E)=>{o.set(h,E),s.push(String(h));let O=f.get(m);O===void 0&&(O=i.length,f.set(m,O),i.push(m)),y[E]=M-N,w[E]=O,S[E]=N,v[E]=A});let b=h=>{let m=o.get(h);return m===void 0&&(m=s.length,o.set(h,m),s.push(String(h))),m},l=new Map;for(let h=0;h<this.links.length;h+=2){let m=this.links[h],N=this.links[h+1],M=Math.floor(m/2),A=Math.floor(N/2);t.has(M)&&t.has(A)&&l.set(`${M}	${m%2?"-":"+"}	${A}	${N%2?"-":"+"}`,h)}let k=[...l.keys()].sort(),a=new Int32Array(k.length),c=new Int32Array(k.length),d=new Uint8Array(k.length);k.forEach((h,m)=>{let N=l.get(h),M=this.links[N],A=this.links[N+1];a[m]=b(Math.floor(M/2)),c[m]=b(Math.floor(A/2)),d[m]=M%2|A%2<<1});let u=this.referenceFirst(n),p=new Int32Array(u.length+1);u.forEach(({ids:h},m)=>{p[m+1]=p[m]+h.length});let g=new Int32Array(p[u.length]),x=new Uint8Array(g.length);return u.forEach(({ids:h,rev:m},N)=>{let M=p[N];for(let A=0;A<h.length;A++)g[M+A]=b(h[A]);x.set(m,M)}),{nodes:{names:s,lengths:y,refs:w,starts:S,ranks:v,refNames:i},links:{from:a,to:c,strands:d},walks:{names:u.map(h=>h.name),starts:Float64Array.from(u,h=>h.hapStart),ends:Float64Array.from(u,h=>h.hapEnd),offsets:p,steps:g,reversed:x}}}referenceFirst(t){let{refName:n}=this.window;return[...t].sort((e,o)=>+(o.name===n)-+(e.name===n)||(e.name<o.name?-1:e.name>o.name?1:e.hapStart-o.hapStart))}},rt={steps:"the step budget",bytes:"a byte budget of"};function at(r,t,n,e,o,s,i=rt){var f;let y=0,w=new Map,S=new Set;for(let c of r)y+=c.n,w.set(c.chunkStart,((f=w.get(c.chunkStart))!==null&&f!==void 0?f:0)+c.n),S.add(c.name);let v=t*n;if(y<=v)return;let b=e.end-e.start,l=0,k=0;for(let c of[...w.keys()].sort((d,u)=>d-u)){if(l+=w.get(c),l>v)break;k=Math.max(k,c+o-e.start)}let a=!s&&S.size>2&&2*y/S.size<=v;return new q(k>0?`Zoom in to about ${P(k)}${a?", or choose fewer haplotypes,":""} to see the graph`:`Too many haplotype steps here to draw ${s?"these haplotypes":"every haplotype"} (${l.toLocaleString()} steps read, over ${n} \xD7 ${i.steps} of ${t.toLocaleString()}); choose fewer haplotypes`,v,b,Math.max(k,1))}function it(r,t,n,e){let o=r.reduce((f,y)=>f+y.ids.length,0);if(o<=t)return;let s=n.end-n.start,i=Math.max(1,Math.floor(s*t/o));return new q(`Zoom in to about ${P(i)}${e?"":", or choose fewer haplotypes,"} to see the graph`,t,s,i)}async function ct(r,t,n,e,o=rt){let s=await r(n.end);if(s<=t)return;let i=0,f;for(let w=Math.floor(n.start/e)*e;w<n.end;w+=e){let S=await r(w+1);if(f??(f=S),S>t)break;i=w+e-n.start}let y=n.end-n.start;return new q(i>0?`Zoom in to about ${P(i)} to see the graph`:`Too much graph here to fetch (${bt(f??s)} against ${o.bytes} ${bt(t)})`,t,y,Math.max(i,1))}var bt=r=>`${(r/1e6).toFixed(1)} MB`;var $t=8,Ot=3,Lt=4,Bt=1e3,J=class extends Error{constructor(){super(...arguments),this.name="WalkFormatError"}};function xt(r,t,n){if(!Number.isFinite(t)||!Number.isFinite(n))throw new Error(`${r}:${t}-${n} is not a finite range to query the graph's index for`)}function Ct(r,t){return t?(t.throwIfAborted(),new Promise((n,e)=>{let o=()=>{e(t.reason instanceof Error?t.reason:new Error(String(t.reason)))};t.addEventListener("abort",o,{once:!0}),r.then(n,e).finally(()=>{t.removeEventListener("abort",o)})})):r}var lt=class{constructor(t){this.walks=t}header(t={}){if(!this.headerRead){let n=this.walks.getHeaderLines().then(e=>{var o;let s=nt(e);if(s.format!==2)throw new J("This walk file is format 1, from gfa-to-tabix 0.12 or earlier; rebuild it with gfa-to-tabix 1.0 or later");let i=(o=s.chunk)!==null&&o!==void 0?o:65536;return{...s,chunk:i,lookback:st(s.maxNode,i)}});n.catch(()=>{this.headerRead===n&&(this.headerRead=void 0)}),this.headerRead=n}return Ct(this.headerRead,t.signal)}referenceSequences(t={}){return this.walks.getReferenceSequenceNames(t)}async queryStart(t,n={}){let{chunk:e,lookback:o}=await this.header(n);return K(t,e,o)}async cut(t,n,e={}){var o;let{signal:s,keep:i,context:f=Bt,stepBudget:y=1/0,byteBudget:w=1/0,links:S=!0}=e,{chunk:v,lookback:b}=await this.header({signal:s}),l=K(n.start,v,b),k=(o=this.walks.bytesForRegions)===null||o===void 0?void 0:o.bind(this.walks),a=Number.isFinite(w)&&k!==void 0,c=async E=>a?k(E.map(O=>({refName:t,...O})),{signal:s}):0,d=a?await ct(async E=>(xt(t,l,E),c([{start:l,end:E}])),w,n,v,e.budgetNames):void 0;if(d)throw d;let u=new AbortController,p=()=>{u.abort(s?.reason)};s?.throwIfAborted(),s?.addEventListener("abort",p,{once:!0});let g=[],x,h=new T({refName:t,start:n.start,end:n.end,context:f,sequences:e.sequences}),m=new Set,N=[],M=async(E,O)=>{xt(t,E,O);let _=new Map;await this.walks.getLines(t,E,O,{signal:u.signal,lineCallback:F=>{let R=F.split("	"),B=+R[1],W=_.get(B);W?W.push(R):_.set(B,[R])}});for(let[F,R]of _){if(m.has(F))continue;m.add(F);let B=wt(R,i,e.sequences);g.push(...B.rows);for(let[W,j]of B.nodes)h.placeNode(W,j);h.addSequences(B.sequences),h.addChunk(B.chunk),N.push(...B.ends)}if(S)for(let[F,R]of mt(N))h.addLinkEnds(F,R)};try{await M(l,n.end);let E=at(g,y,$t,n,v,i!==void 0,e.budgetNames);if(E)throw E;let O=l,_=Math.floor((n.end-1)/v)*v,F=Lt*v,[R,B]=[O-F,_+F];x=X(z(g),h.nodes,t);let W=await c([{start:l,end:n.end}]);for(let j=0;j<Ot;j++){let H=x.open.filter(C=>C.refName===t&&C.start>=R&&C.start<=B).map(C=>C.start),V=[{start:Math.min(O,...H),end:O},{start:_+v,end:Math.max(_,...H)+1}].filter(C=>C.end>C.start);if(V.length===0||(W+=await c(V),W>w))break;O=Math.min(O,...H),_=Math.max(_,...H),await Promise.all(V.map(({start:C,end:vt})=>M(C,vt))),x=X(z(g),h.nodes,t)}}catch(E){throw u.abort(),E}finally{s?.removeEventListener("abort",p)}let A=it(x.fragments,y,n,i!==void 0);if(A)throw A;return{graph:h,...x}}};var _t={steps:"walkStepBudget",bytes:"walkByteBudget"};async function Jt(r,t,n,e){let{graph:o,kept:s,fragments:i}=await r.cut(t,n,{signal:e.signal,keep:ot(e.prefixes,ft(t)),stepBudget:e.walkRows?1/0:e.stepBudget,byteBudget:e.byteBudget,budgetNames:_t});return ht(o.tables(s,i),n,e.walkRows)}export{Et as a,ot as b,lt as c,_t as d,Jt as e};
-//# sourceMappingURL=chunk-2QQDYK5V.js.map

package/dist/chunks/chunk-2QQDYK5V.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../node_modules/.pnpm/@jbrowse+graph-walks@1.0.0/node_modules/@jbrowse/graph-walks/esm/walkChunk.js", "../../node_modules/.pnpm/@jbrowse+graph-walks@1.0.0/node_modules/@jbrowse/graph-walks/esm/util.js", "../../node_modules/.pnpm/@jbrowse+graph-walks@1.0.0/node_modules/@jbrowse/graph-walks/esm/walkRows.js", "../../node_modules/.pnpm/@jbrowse+graph-walks@1.0.0/node_modules/@jbrowse/graph-walks/esm/walkReader.js", "../../src/RgfaTabixAdapter/walkReader.ts"],
-  "sourcesContent": ["// A chunk of gfa-to-tabix's walk format 2, one file per reference (that\n// repo's docs/walks-format.md). A chunk lists its `ref` rows, which joined in\n// hapOffset order are the chunk's reference path R; a `nodes` row with the\n// lengths of the nodes its routes visit; `route` rows, each a way off R; and a\n// `walk` row per piece of every other path, naming the routes it takes in\n// order. A handle is 2 * id + 1 when reversed.\nconst NONE = -1;\nconst idOf = (handle) => (handle - (handle & 1)) / 2;\n// the other strand's handle; arithmetic, which holds past 2^31\nconst otherStrand = (handle) => (handle & 1 ? handle - 1 : handle + 1);\n// The handles a column of delta tokens names, each 2 * (id - previous id) +\n// reverse, from `previous.id`, which ends on the last id read\nfunction tokens(field, previous, out) {\n    if (field === '.') {\n        return out;\n    }\n    let v = 0;\n    let neg = false;\n    for (let p = 0; p <= field.length; p++) {\n        const ch = p < field.length ? field.charCodeAt(p) : 44;\n        if (ch === 44) {\n            const d = neg ? -v : v;\n            const r = d & 1;\n            previous.id += (d - r) / 2;\n            out.push(previous.id * 2 + r);\n            v = 0;\n            neg = false;\n        }\n        else if (ch === 45) {\n            neg = true;\n        }\n        else {\n            v = v * 10 + (ch - 48);\n        }\n    }\n    return out;\n}\nfunction numbers(field) {\n    return field === '.' ? [] : field.split(',').map(Number);\n}\n// A link the way round the converter writes it, so a link and its reverse\n// are one: the smaller of a and the flipped b first\nexport function canonicalLink(a, b) {\n    return a > otherStrand(b) ? [otherStrand(b), otherStrand(a)] : [a, b];\n}\nfunction tags(cols, from, anchor) {\n    let prev;\n    let next;\n    for (let k = from; k < cols.length; k++) {\n        const tag = cols[k];\n        if (tag.startsWith('pv:') || tag.startsWith('nx:')) {\n            const at = tag.lastIndexOf(':');\n            const chunk = {\n                refName: tag[3] === 'Z' ? tag.slice(5, at) : anchor,\n                start: +tag.slice(at + 1),\n            };\n            if (tag.startsWith('pv:')) {\n                prev = chunk;\n            }\n            else {\n                next = chunk;\n            }\n        }\n    }\n    return { prev, next };\n}\n// The chunk's reference path R: its handles, the bp of its steps before each\n// position, and each node's occurrences in R\nexport class RefPath {\n    constructor() {\n        this.handles = [];\n        this.before = [0];\n        this.occurrences = new Map();\n    }\n    add(handles, lengths) {\n        for (let k = 0; k < handles.length; k++) {\n            const h = handles[k];\n            const i = this.handles.length;\n            this.handles.push(h);\n            this.before.push(this.before[i] + lengths[k]);\n            const id = idOf(h);\n            const list = this.occurrences.get(id);\n            if (list) {\n                list.push(i);\n            }\n            else {\n                this.occurrences.set(id, [i]);\n            }\n        }\n    }\n    // bp of R's steps before position i\n    bp(i) {\n        return this.before[i];\n    }\n    first(handle) {\n        var _a;\n        return (_a = this.occurrences.get(idOf(handle))) === null || _a === void 0 ? void 0 : _a[0];\n    }\n    nearest(handle, i) {\n        var _a;\n        let best;\n        for (const j of (_a = this.occurrences.get(idOf(handle))) !== null && _a !== void 0 ? _a : []) {\n            if (best === undefined || Math.abs(j - i) <= Math.abs(best - i)) {\n                best = j;\n            }\n        }\n        return best;\n    }\n    // The position a stretch along R from position i, reading R the way `h`\n    // does there, first holds `target`, i itself included\n    reach(i, h, target) {\n        var _a;\n        const forward = this.handles[i] === h;\n        let found;\n        for (const j of (_a = this.occurrences.get(idOf(target))) !== null && _a !== void 0 ? _a : []) {\n            if (forward && j >= i && this.handles[j] === target) {\n                if (found === undefined || j < found) {\n                    found = j;\n                }\n            }\n            else if (!forward &&\n                j <= i &&\n                otherStrand(this.handles[j]) === target) {\n                if (found === undefined || j > found) {\n                    found = j;\n                }\n            }\n        }\n        return found;\n    }\n    handleAt(i, forward) {\n        return forward ? this.handles[i] : otherStrand(this.handles[i]);\n    }\n}\nexport class WalkRowError extends Error {\n}\nconst orientedEntry = (route, flip) => flip ? (route.exit === NONE ? NONE : otherStrand(route.exit)) : route.entry;\nconst orientedExit = (route, flip) => flip ? (route.entry === NONE ? NONE : otherStrand(route.entry)) : route.exit;\n// A route's interior handle k, taken the way round `flip` says\nconst interiorAt = (route, flip, k) => flip\n    ? otherStrand(route.interior[route.interior.length - 1 - k])\n    : route.interior[k];\n// A walk row's choices, three numbers each: route index, flip and step count,\n// from `tok` or `tok:count` tokens\nfunction parseChoices(field) {\n    const choices = [];\n    if (field !== '.') {\n        let previous = 0;\n        let v = 0;\n        let neg = false;\n        let tok = 0;\n        let colonSeen = false;\n        for (let p = 0; p <= field.length; p++) {\n            const ch = p < field.length ? field.charCodeAt(p) : 44;\n            if (ch === 44) {\n                const value = neg ? -v : v;\n                const d = colonSeen ? tok : value;\n                const r = d & 1;\n                previous += (d - r) / 2;\n                choices.push(previous, r, colonSeen ? value : 0);\n                v = 0;\n                neg = false;\n                colonSeen = false;\n            }\n            else if (ch === 58) {\n                tok = neg ? -v : v;\n                v = 0;\n                neg = false;\n                colonSeen = true;\n            }\n            else if (ch === 45) {\n                neg = true;\n            }\n            else {\n                v = v * 10 + (ch - 48);\n            }\n        }\n    }\n    return choices;\n}\n// Follows a walk row as docs/walks-format.md decodes it\nfunction traverse(path, routes, start, endField, choices, visit) {\n    const colon = endField.indexOf(':');\n    const end = start + +(colon < 0 ? endField : endField.slice(0, colon));\n    const counted = colon >= 0;\n    const tail = counted ? +endField.slice(colon + 1) : 0;\n    const routeOf = (index) => {\n        const route = routes[index];\n        if (!route) {\n            throw new WalkRowError(`route ${index} is not in the chunk`);\n        }\n        return route;\n    };\n    let k = 0;\n    if (choices.length > 0 &&\n        orientedEntry(routeOf(choices[0]), choices[1] === 1) === NONE) {\n        if (!visit.route(choices[0], choices[1] === 1)) {\n            return;\n        }\n        k = 3;\n    }\n    let h = start;\n    let i = path.first(h);\n    if (i === undefined) {\n        throw new WalkRowError('a walk row starts off its chunk');\n    }\n    visit.step(h);\n    const follow = (target, count) => {\n        const forward = path.handles[i] === h;\n        const j = counted\n            ? i + (forward ? count : -count)\n            : path.reach(i, h, target);\n        if (j === undefined || j < 0 || j >= path.handles.length) {\n            throw new WalkRowError('a walk row runs off its chunk');\n        }\n        if (j !== i) {\n            visit.stretch(i, j, forward);\n        }\n        i = j;\n        h = path.handleAt(j, forward);\n    };\n    for (; k < choices.length; k += 3) {\n        const index = choices[k];\n        const flip = choices[k + 1] === 1;\n        const route = routeOf(index);\n        const entry = orientedEntry(route, flip);\n        if (entry === NONE) {\n            throw new WalkRowError('an open route after the first choice');\n        }\n        follow(entry, choices[k + 2]);\n        if (!visit.route(index, flip)) {\n            return;\n        }\n        const exit = orientedExit(route, flip);\n        if (exit === NONE) {\n            return;\n        }\n        h = exit;\n        i = path.nearest(h, i);\n        if (i === undefined) {\n            throw new WalkRowError('a route lands off its chunk');\n        }\n        visit.step(h);\n    }\n    follow(end, tail);\n    if (h !== end) {\n        throw new WalkRowError('a walk row misses its last handle');\n    }\n}\n// A walk row's steps as node ids and reverse flags\nfunction decodeWalk(path, routes, cols, choices, n) {\n    const ids = new Int32Array(n);\n    const rev = new Uint8Array(n);\n    let at = 0;\n    const push = (h) => {\n        if (at >= n) {\n            throw new WalkRowError('a walk row decodes to more steps than it states');\n        }\n        ids[at] = idOf(h);\n        rev[at++] = h & 1;\n    };\n    traverse(path, routes, +cols[9], cols[10], choices, {\n        step: push,\n        stretch(from, to, forward) {\n            if (forward) {\n                for (let j = from + 1; j <= to; j++) {\n                    push(path.handles[j]);\n                }\n            }\n            else {\n                for (let j = from - 1; j >= to; j--) {\n                    push(otherStrand(path.handles[j]));\n                }\n            }\n        },\n        route(index, flip) {\n            const route = routes[index];\n            for (let k = 0; k < route.interior.length; k++) {\n                push(interiorAt(route, flip, k));\n            }\n            return true;\n        },\n    });\n    if (at !== n) {\n        throw new WalkRowError(`a walk row decodes to ${at} steps, not ${n}`);\n    }\n    return { ids, rev };\n}\n// The bases an SQ:Z: tag at or after column `from` joins, one node's per\n// length, as `ids` names them\nfunction sliceBases(cols, from, ids, lengths, out) {\n    const tag = cols.slice(from).find(c => c.startsWith('SQ:Z:'));\n    if (tag === undefined) {\n        return;\n    }\n    let at = 5;\n    for (let k = 0; k < ids.length; k++) {\n        const length = lengths[k];\n        out.set(ids[k], tag.slice(at, at + length));\n        at += length;\n    }\n}\n/**\n * Decodes one chunk's rows, each split on tabs. `keep` names the walk rows\n * whose steps a cut wants, undefined for every one.\n */\nexport function decodeChunk(rows, keep, withSequences = false) {\n    var _a, _b, _c;\n    const path = new RefPath();\n    const lengths = new Map();\n    const routes = [];\n    const out = {\n        sequences: new Map(),\n        rows: [],\n        nodes: new Map(),\n        ends: [],\n        chunk: { path, routes, walks: [], lengths },\n    };\n    const previous = { id: 0 };\n    const refs = rows.filter(c => c[3] === 'ref').sort((a, b) => +a[6] - +b[6]);\n    for (const cols of refs) {\n        const anchor = cols[0];\n        const handles = tokens(cols[9], { id: 0 }, []);\n        const nodeLengths = numbers(cols[10]);\n        const hapOffset = +cols[6];\n        path.add(handles, nodeLengths);\n        if (withSequences) {\n            sliceBases(cols, 11, handles.map(idOf), nodeLengths, out.sequences);\n        }\n        let start = hapOffset;\n        for (let k = 0; k < handles.length; k++) {\n            const id = idOf(handles[k]);\n            const length = nodeLengths[k];\n            lengths.set(id, length);\n            if (!out.nodes.has(id)) {\n                out.nodes.set(id, {\n                    refName: cols[4],\n                    start,\n                    end: start + length,\n                    rank: 0,\n                });\n            }\n            start += length;\n        }\n        out.ends.push({\n            name: cols[4],\n            fragStart: +cols[5],\n            piece: +cols[7],\n            first: handles[0],\n            last: handles.at(-1),\n        });\n        if (keep === undefined || keep(cols[4])) {\n            out.rows.push({\n                chunkStart: +cols[1],\n                name: cols[4],\n                fragStart: +cols[5],\n                hapOffset,\n                piece: +cols[7],\n                n: handles.length,\n                steps: {\n                    ids: Int32Array.from(handles, idOf),\n                    rev: Uint8Array.from(handles, h => h & 1),\n                },\n                ...tags(cols, 11, anchor),\n            });\n        }\n    }\n    for (const cols of rows) {\n        if (cols[3] === 'nodes') {\n            const ids = numbers(cols[4]);\n            const nodeLengths = numbers(cols[5]);\n            let id = 0;\n            for (let k = 0; k < ids.length; k++) {\n                id += ids[k];\n                ids[k] = id;\n                lengths.set(id, nodeLengths[k]);\n            }\n            if (withSequences) {\n                sliceBases(cols, 6, ids, nodeLengths, out.sequences);\n            }\n        }\n        else if (cols[3] === 'route') {\n            const entry = tokens(cols[4], previous, []);\n            const interior = tokens(cols[5], previous, []);\n            const exit = tokens(cols[6], previous, []);\n            routes.push({ entry: (_a = entry[0]) !== null && _a !== void 0 ? _a : NONE, interior, exit: (_b = exit[0]) !== null && _b !== void 0 ? _b : NONE });\n        }\n    }\n    const routeOf = (index) => {\n        const route = routes[index];\n        if (!route) {\n            throw new WalkRowError(`route ${index} is not in the chunk`);\n        }\n        return route;\n    };\n    for (const cols of rows) {\n        if (cols[3] !== 'walk') {\n            continue;\n        }\n        const choices = parseChoices(cols[11]);\n        out.chunk.walks.push({ cols, choices });\n        const name = cols[4];\n        const start = +cols[9];\n        const endField = cols[10];\n        const colon = endField.indexOf(':');\n        let first = start;\n        let last = start + +(colon < 0 ? endField : endField.slice(0, colon));\n        if (choices.length > 0) {\n            const lead = routeOf(choices[0]);\n            const leadFlip = choices[1] === 1;\n            if (orientedEntry(lead, leadFlip) === NONE) {\n                first = interiorAt(lead, leadFlip, 0);\n            }\n            const at = choices.length - 3;\n            const tail = routeOf(choices[at]);\n            const tailFlip = choices[at + 1] === 1;\n            if (orientedExit(tail, tailFlip) === NONE) {\n                last = interiorAt(tail, tailFlip, tail.interior.length - 1);\n            }\n        }\n        out.ends.push({\n            name,\n            fragStart: +cols[5],\n            piece: +cols[7],\n            first,\n            last,\n        });\n        if (keep === undefined || keep(name)) {\n            const n = +cols[8];\n            // the walk's nodes off R, by length; placeAndLink gives their position\n            for (let k = 0; k < choices.length; k += 3) {\n                for (const h of routeOf(choices[k]).interior) {\n                    const id = idOf(h);\n                    if (!out.nodes.has(id)) {\n                        const length = (_c = lengths.get(id)) !== null && _c !== void 0 ? _c : 0;\n                        out.nodes.set(id, { refName: name, start: 0, end: length, rank: 1 });\n                    }\n                }\n            }\n            out.rows.push({\n                chunkStart: +cols[1],\n                name,\n                fragStart: +cols[5],\n                hapOffset: +cols[6],\n                piece: +cols[7],\n                n,\n                steps: decodeWalk(path, routes, cols, choices, n),\n                ...tags(cols, 12, cols[0]),\n            });\n        }\n    }\n    return out;\n}\n/**\n * The positions of the cut's nodes off R, and the links among the cut's\n * nodes, from the chunks a cut read: `kept` holds the node ids the cut draws.\n * A node off R takes its position from the path whose name sorts first among\n * those visiting it in the chunks read, at its earliest offset, as format 1's\n * node rows had it. Links are R's and the routes', both ends in the cut.\n */\nexport function placeAndLink(chunks, kept, place, link) {\n    const best = new Map();\n    for (const { path, routes, walks, lengths } of chunks) {\n        const handles = path.handles;\n        for (let k = 1; k < handles.length; k++) {\n            if (kept.has(idOf(handles[k - 1])) && kept.has(idOf(handles[k]))) {\n                link(...canonicalLink(handles[k - 1], handles[k]));\n            }\n        }\n        // routes holding a node of the cut off R\n        const wanted = new Uint8Array(routes.length);\n        for (let index = 0; index < routes.length; index++) {\n            const { entry, interior, exit } = routes[index];\n            let any = false;\n            let from = entry;\n            for (const h of interior) {\n                const inCut = kept.has(idOf(h));\n                any || (any = inCut);\n                if (inCut && from !== NONE && kept.has(idOf(from))) {\n                    link(...canonicalLink(from, h));\n                }\n                from = h;\n            }\n            if (from !== NONE &&\n                exit !== NONE &&\n                kept.has(idOf(from)) &&\n                kept.has(idOf(exit))) {\n                link(...canonicalLink(from, exit));\n            }\n            wanted[index] = any ? 1 : 0;\n        }\n        const lengthOf = (h) => { var _a; return (_a = lengths.get(idOf(h))) !== null && _a !== void 0 ? _a : 0; };\n        const bp = new Float64Array(routes.length).fill(-1);\n        const routeBp = (index) => {\n            if (bp[index] < 0) {\n                bp[index] = routes[index].interior.reduce((s, h) => s + lengthOf(h), 0);\n            }\n            return bp[index];\n        };\n        // Walk rows run in path-name order, so a route's first taker is the\n        // first-named path to reach its nodes here; each row is followed only as\n        // far as the last route it is first to take\n        const taken = new Uint8Array(routes.length);\n        for (const { cols, choices } of walks) {\n            let remaining = 0;\n            for (let k = 0; k < choices.length; k += 3) {\n                const index = choices[k];\n                if (wanted[index] && !taken[index]) {\n                    remaining++;\n                }\n            }\n            if (remaining === 0) {\n                continue;\n            }\n            const name = cols[4];\n            let offset = +cols[6];\n            traverse(path, routes, +cols[9], cols[10], choices, {\n                step(h) {\n                    offset += lengthOf(h);\n                },\n                stretch(from, to, forward) {\n                    offset += forward\n                        ? path.bp(to + 1) - path.bp(from + 1)\n                        : path.bp(from) - path.bp(to);\n                },\n                route(index, flip) {\n                    if (!wanted[index] || taken[index]) {\n                        offset += routeBp(index);\n                        return true;\n                    }\n                    taken[index] = 1;\n                    const route = routes[index];\n                    for (let k = 0; k < route.interior.length; k++) {\n                        const h = interiorAt(route, flip, k);\n                        const id = idOf(h);\n                        const length = lengthOf(h);\n                        if (kept.has(id)) {\n                            const held = best.get(id);\n                            if (!held ||\n                                name < held.refName ||\n                                (name === held.refName && offset < held.start)) {\n                                best.set(id, {\n                                    refName: name,\n                                    start: offset,\n                                    end: offset + length,\n                                    rank: 1,\n                                });\n                            }\n                        }\n                        offset += length;\n                    }\n                    remaining--;\n                    return remaining > 0;\n                },\n            });\n        }\n    }\n    for (const [id, node] of best) {\n        place(id, node);\n    }\n}\n// The reference's nodes in a chunk's ref rows, with their positions\nexport function referenceNodes(rows) {\n    const nodes = [];\n    for (const cols of rows) {\n        if (cols[3] !== 'ref') {\n            continue;\n        }\n        const handles = tokens(cols[9], { id: 0 }, []);\n        const nodeLengths = numbers(cols[10]);\n        let start = +cols[6];\n        for (let k = 0; k < handles.length; k++) {\n            const length = nodeLengths[k];\n            nodes.push({\n                id: idOf(handles[k]),\n                refName: cols[4],\n                start,\n                end: start + length,\n                rank: 0,\n            });\n            start += length;\n        }\n    }\n    return nodes;\n}\n// Links between consecutive pieces of a path, each piece's last step to the\n// next one's first, among the pieces read\nexport function pieceLinks(ends) {\n    const byPath = new Map();\n    for (const e of ends) {\n        const key = `${e.name}\\t${e.fragStart}`;\n        let pieces = byPath.get(key);\n        if (!pieces) {\n            pieces = new Map();\n            byPath.set(key, pieces);\n        }\n        pieces.set(e.piece, e);\n    }\n    const links = [];\n    for (const pieces of byPath.values()) {\n        for (const [piece, e] of pieces) {\n            const next = pieces.get(piece + 1);\n            if (next) {\n                links.push(canonicalLink(e.last, next.first));\n            }\n        }\n    }\n    return links;\n}\n", "/**\n * A window too large to cut. `regionTooLarge` and the name are what JBrowse\n * and @jbrowse/bandage-core read a zoom-in notice by; `fitsBp` is about how\n * wide a window would fit.\n */\nexport class RegionTooLargeError extends Error {\n    constructor(message, limit, windowBp, fitsBp) {\n        super(message);\n        this.regionTooLarge = true;\n        this.name = 'NodeLimitError';\n        this.limit = limit;\n        this.windowBp = windowBp;\n        this.fitsBp = fitsBp;\n    }\n}\nconst SEP = '#';\nexport function panSNHaplotype(refName) {\n    const parts = refName.split(SEP);\n    return parts.length >= 3 ? `${parts[0]}${SEP}${parts[1]}` : undefined;\n}\nexport function panSNMatchesPrefix(refName, prefix) {\n    return (prefix !== undefined &&\n        (refName === prefix || refName.startsWith(prefix + SEP)));\n}\nconst precise = (n) => Number.parseFloat(n.toPrecision(3));\n// `1.5Kbp`, `12Mbp`, `850bp`, as JBrowse writes a span\nexport function bpString(bp) {\n    const mb = precise(bp / 1000000);\n    return mb >= 1\n        ? `${mb.toLocaleString('en-US')}Mbp`\n        : bp >= 1000\n            ? `${precise(bp / 1000).toLocaleString('en-US')}Kbp`\n            : `${Math.floor(bp)}bp`;\n}\n", "import { RegionTooLargeError, bpString, panSNMatchesPrefix } from \"./util.js\";\nimport { placeAndLink } from \"./walkChunk.js\";\nfunction integerTag(line, tag) {\n    const match = new RegExp(`(?:^|\\\\t)${tag}:i:(\\\\d+)`).exec(line);\n    return match ? +match[1] : undefined;\n}\n/**\n * What a walk file's header states: a `#walks` line with the format, the\n * chunk size and the longest node in bp, `format:i:2\\tchunk:i:65536\\tmaxnode:i:1024`,\n * a `#reference\\tGRCh38` line naming the reference sample and a\n * `#haplotype\\tHG002#1` line per other haplotype with rows\n */\nexport function walkHeader(lines) {\n    var _a, _b, _c;\n    const header = { references: [], haplotypes: [] };\n    for (const line of lines) {\n        const [key, value = ''] = line.split('\\t');\n        if (key === '#reference') {\n            header.references.push(value);\n        }\n        else if (key === '#haplotype') {\n            header.haplotypes.push(value);\n        }\n        else {\n            (_a = header.format) !== null && _a !== void 0 ? _a : (header.format = integerTag(line, 'format'));\n            (_b = header.chunk) !== null && _b !== void 0 ? _b : (header.chunk = integerTag(line, 'chunk'));\n            (_c = header.maxNode) !== null && _c !== void 0 ? _c : (header.maxNode = integerTag(line, 'maxnode'));\n        }\n    }\n    return header;\n}\n/**\n * How many chunks before the window's own a cut reads. A node is filed under\n * the chunk holding its start, so a node `maxNode` bp long reaching into the\n * window starts at most ceil(maxNode / chunk) chunks back. At least one, since\n * the chunk before carries the detour a haplotype takes into the window's\n * first reference node; one when the header gives no `maxnode:i:`, which holds\n * for vg's graphs, chopped to nodes of at most 1,024 bp.\n */\nexport function lookbackChunks(maxNode, chunk) {\n    return maxNode === undefined ? 1 : Math.max(1, Math.ceil(maxNode / chunk));\n}\n// The first base a cut queries: the start of the chunk `lookback` chunks\n// before the one holding the window's start\nexport function chunkQueryStart(start, chunk, lookback = 1) {\n    return Math.max(0, (Math.floor(start / chunk) - lookback) * chunk);\n}\n// Which walks a cut decodes: the reference's, and those `wanted` names by\n// PanSN prefix at sample or haplotype depth; undefined decodes every one\nexport function walkNameFilter(wanted, referenceHaplotype) {\n    return wanted === undefined || wanted.length === 0\n        ? undefined\n        : (name) => panSNMatchesPrefix(name, referenceHaplotype) ||\n            wanted.some(prefix => panSNMatchesPrefix(name, prefix));\n}\nexport function joinPieces(rows) {\n    const byPath = new Map();\n    for (const row of rows) {\n        const key = `${row.name}\\t${row.fragStart}`;\n        const list = byPath.get(key);\n        if (list) {\n            list.push(row);\n        }\n        else {\n            byPath.set(key, [row]);\n        }\n    }\n    const runs = [];\n    for (const pieces of byPath.values()) {\n        pieces.sort((a, b) => a.piece - b.piece);\n        let from = 0;\n        for (let i = 1; i <= pieces.length; i++) {\n            if (i === pieces.length ||\n                pieces[i].piece !== pieces[i - 1].piece + 1) {\n                runs.push(decodeRun(pieces.slice(from, i)));\n                from = i;\n            }\n        }\n    }\n    return runs;\n}\nfunction decodeRun(pieces) {\n    const n = pieces.reduce((sum, p) => sum + p.n, 0);\n    const ids = new Int32Array(n);\n    const rev = new Uint8Array(n);\n    let at = 0;\n    for (const p of pieces) {\n        ids.set(p.steps.ids, at);\n        rev.set(p.steps.rev, at);\n        at += p.n;\n    }\n    const first = pieces[0];\n    return {\n        name: first.name,\n        hapOffset: first.hapOffset,\n        ids,\n        rev,\n        prev: first.prev,\n        next: pieces.at(-1).next,\n    };\n}\n/**\n * The cut a window draws from its walks: the reference inside the window plus\n * its context, and each run from its first to its last step on that stretch.\n * A run that leaves the reference there, through steps off it or across a\n * deletion, is followed to the reference step where it rejoins, when the read\n * holds it, and otherwise through the steps off the reference it holds: at\n * the ABCA7 VNTR four haplotypes leave inside the repeat and rejoin 1.8 kb\n * past the window, and cut at the context they measured as partial walks. The reference is cut out as far as those rejoins reach, and\n * a run then runs on outward while the next step's node is already in the\n * cut. Without the run-on a haplotype whose alternate allele straddles the\n * edge stopped short of a node other walks had brought into the cut, and that\n * node drew without it. The run-on adds no node, so one pass is enough, but\n * it reaches through nodes other walks brought in, so with a window edge inside\n * a collapsed array a row's length depends on which haplotypes are cut.\n */\nexport function walkCut(runs, nodes, refName) {\n    const onWindow = (id) => { var _a; return ((_a = nodes.get(id)) === null || _a === void 0 ? void 0 : _a.onWindow) === true; };\n    const reference = (id) => {\n        const node = nodes.get(id);\n        return (node === null || node === void 0 ? void 0 : node.rank) === 0 ? node : undefined;\n    };\n    // the chunks walks cut off at the end of a run go on in\n    const open = new Map();\n    const goesOn = (chunk) => {\n        if (chunk) {\n            open.set(`${chunk.refName}:${chunk.start}`, chunk);\n        }\n    };\n    // Where a walk stops being followed from step `at`, going by `dir`: the\n    // reference step it rejoins at past any steps off the reference, or across\n    // a deletion; else its last step off the reference before the run ends,\n    // noting the chunk the path goes on in, or reaches another reference\n    // sequence\n    const rejoin = (run, at, dir) => {\n        const { ids } = run;\n        let i = at + dir;\n        while (i >= 0 && i < ids.length && reference(ids[i]) === undefined) {\n            i += dir;\n        }\n        if (i < 0 || i >= ids.length) {\n            goesOn(dir < 0 ? run.prev : run.next);\n            return i - dir;\n        }\n        const from = reference(ids[at]);\n        const to = reference(ids[i]);\n        if (to.refName !== refName) {\n            return i - dir;\n        }\n        const adjacent = i === at + dir && (to.start === from.end || to.end === from.start);\n        return adjacent ? at : i;\n    };\n    let reachStart = Infinity;\n    let reachEnd = -Infinity;\n    const spans = [];\n    for (const run of runs) {\n        const { ids } = run;\n        let first = -1;\n        let last = -1;\n        for (let i = 0; i < ids.length; i++) {\n            if (onWindow(ids[i])) {\n                if (first < 0) {\n                    first = i;\n                }\n                last = i;\n            }\n        }\n        if (first >= 0) {\n            if (run.name !== refName) {\n                first = rejoin(run, first, -1);\n                last = rejoin(run, last, 1);\n                for (const i of [first, last]) {\n                    const node = reference(ids[i]);\n                    if (node) {\n                        reachStart = Math.min(reachStart, node.start);\n                        reachEnd = Math.max(reachEnd, node.end);\n                    }\n                }\n            }\n            spans.push({ run, first, last });\n        }\n    }\n    const inReach = (id) => {\n        const node = reference(id);\n        return (onWindow(id) ||\n            ((node === null || node === void 0 ? void 0 : node.refName) === refName &&\n                node.end > reachStart &&\n                node.start < reachEnd));\n    };\n    const kept = new Set();\n    for (const [id, node] of nodes) {\n        if (node.onWindow) {\n            kept.add(id);\n        }\n    }\n    for (const span of spans) {\n        const { ids } = span.run;\n        if (span.run.name === refName) {\n            while (span.first > 0 && inReach(ids[span.first - 1])) {\n                span.first--;\n            }\n            while (span.last < ids.length - 1 && inReach(ids[span.last + 1])) {\n                span.last++;\n            }\n        }\n        for (let i = span.first; i <= span.last; i++) {\n            kept.add(ids[i]);\n        }\n    }\n    const length = (id) => {\n        const node = nodes.get(id);\n        return node === undefined ? 0 : node.end - node.start;\n    };\n    const fragments = [];\n    for (const { run, first: f, last: l } of spans) {\n        const { ids, rev } = run;\n        let first = f;\n        let last = l;\n        while (first > 0 && kept.has(ids[first - 1])) {\n            first--;\n        }\n        while (last < ids.length - 1 && kept.has(ids[last + 1])) {\n            last++;\n        }\n        let hapStart = run.hapOffset;\n        for (let i = 0; i < first; i++) {\n            hapStart += length(ids[i]);\n        }\n        let hapEnd = hapStart;\n        for (let i = first; i <= last; i++) {\n            hapEnd += length(ids[i]);\n        }\n        fragments.push({\n            name: run.name,\n            hapStart,\n            hapEnd,\n            ids: ids.subarray(first, last + 1),\n            rev: rev.subarray(first, last + 1),\n        });\n    }\n    return { kept, fragments, open: [...open.values()] };\n}\n/**\n * The nodes and links of the chunks a cut reads, and the tables of the cut\n * they make with its walks. A node in two chunks is placed once.\n */\nexport class WalkGraph {\n    constructor(window) {\n        this.nodes = new Map();\n        this.sequences = new Map();\n        this.links = [];\n        // the chunks read, whose nodes off R and links tables() fills in\n        this.chunks = [];\n        this.window = window;\n    }\n    // A node with its position, unless the cut already holds it\n    placeNode(id, node) {\n        if (this.nodes.has(id)) {\n            return;\n        }\n        const { window } = this;\n        this.nodes.set(id, {\n            ...node,\n            onWindow: node.rank === 0 &&\n                node.refName === window.refName &&\n                node.end > window.start - window.context &&\n                node.start < window.end + window.context,\n        });\n    }\n    // A link between two endpoints, each id * 2 + 1 when reversed\n    addLinkEnds(source, target) {\n        this.links.push(source, target);\n    }\n    addChunk(chunk) {\n        this.chunks.push(chunk);\n    }\n    // Bases of nodes a chunk's rows give, for a window that asks for them\n    addSequences(sequences) {\n        if (this.window.sequences) {\n            for (const [id, bases] of sequences) {\n                this.sequences.set(id, bases);\n            }\n        }\n    }\n    /**\n     * The cut as typed arrays, which the worker transfers rather than copies:\n     * nodes by reference position, each link once in the order its L line\n     * sorts, then a walk per fragment, the reference's first and the rest by\n     * name. graphTablesGFA writes them as the GFA they stand for, the same bytes\n     * for the same rows.\n     */\n    tables(kept, fragments) {\n        if (this.chunks.length > 0) {\n            placeAndLink(this.chunks, kept, (id, node) => {\n                const held = this.nodes.get(id);\n                if (held) {\n                    this.nodes.set(id, { ...held, ...node });\n                }\n            }, (a, b) => {\n                this.links.push(a, b);\n            });\n        }\n        const held = [];\n        for (const id of kept) {\n            const node = this.nodes.get(id);\n            if (node) {\n                held.push({ ...node, id });\n            }\n        }\n        held.sort((x, y) => x.refName < y.refName\n            ? -1\n            : x.refName > y.refName\n                ? 1\n                : x.start - y.start || x.id - y.id);\n        const index = new Map();\n        const names = [];\n        const refNames = [];\n        const refIndex = new Map();\n        const lengths = new Int32Array(held.length);\n        const refs = new Int32Array(held.length);\n        const starts = new Float64Array(held.length);\n        const ranks = new Int32Array(held.length);\n        held.forEach(({ id, refName, start, end, rank }, i) => {\n            index.set(id, i);\n            names.push(String(id));\n            let ref = refIndex.get(refName);\n            if (ref === undefined) {\n                ref = refNames.length;\n                refIndex.set(refName, ref);\n                refNames.push(refName);\n            }\n            lengths[i] = end - start;\n            refs[i] = ref;\n            starts[i] = start;\n            ranks[i] = rank;\n        });\n        // a kept node with no row of its own is named, and not drawn\n        const nodeIndex = (id) => {\n            let i = index.get(id);\n            if (i === undefined) {\n                i = names.length;\n                index.set(id, i);\n                names.push(String(id));\n            }\n            return i;\n        };\n        const byLine = new Map();\n        for (let i = 0; i < this.links.length; i += 2) {\n            const a = this.links[i];\n            const b = this.links[i + 1];\n            const source = Math.floor(a / 2);\n            const target = Math.floor(b / 2);\n            if (kept.has(source) && kept.has(target)) {\n                byLine.set(`${source}\\t${a % 2 ? '-' : '+'}\\t${target}\\t${b % 2 ? '-' : '+'}`, i);\n            }\n        }\n        const lines = [...byLine.keys()].sort();\n        const from = new Int32Array(lines.length);\n        const to = new Int32Array(lines.length);\n        const strands = new Uint8Array(lines.length);\n        lines.forEach((line, k) => {\n            const i = byLine.get(line);\n            const a = this.links[i];\n            const b = this.links[i + 1];\n            from[k] = nodeIndex(Math.floor(a / 2));\n            to[k] = nodeIndex(Math.floor(b / 2));\n            strands[k] = (a % 2) | ((b % 2) << 1);\n        });\n        const walks = this.referenceFirst(fragments);\n        const offsets = new Int32Array(walks.length + 1);\n        walks.forEach(({ ids }, p) => {\n            offsets[p + 1] = offsets[p] + ids.length;\n        });\n        const steps = new Int32Array(offsets[walks.length]);\n        const reversed = new Uint8Array(steps.length);\n        walks.forEach(({ ids, rev }, p) => {\n            const at = offsets[p];\n            for (let j = 0; j < ids.length; j++) {\n                steps[at + j] = nodeIndex(ids[j]);\n            }\n            reversed.set(rev, at);\n        });\n        return {\n            nodes: { names, lengths, refs, starts, ranks, refNames },\n            links: { from, to, strands },\n            walks: {\n                names: walks.map(f => f.name),\n                starts: Float64Array.from(walks, f => f.hapStart),\n                ends: Float64Array.from(walks, f => f.hapEnd),\n                offsets,\n                steps,\n                reversed,\n            },\n        };\n    }\n    // The view anchors on the first walk when no walk names the assembly, as\n    // gbz-base's cut has it; in file order that was whichever haplotype the\n    // chunk listed first, CHM13 on a GRCh38 window\n    referenceFirst(fragments) {\n        const { refName } = this.window;\n        return [...fragments].sort((a, b) => Number(b.name === refName) - Number(a.name === refName) ||\n            (a.name < b.name ? -1 : a.name > b.name ? 1 : a.hapStart - b.hapStart));\n    }\n}\nexport const BUDGET_NAMES = {\n    steps: 'the step budget',\n    bytes: 'a byte budget of',\n};\nexport function stepBudgetError(rows, stepBudget, readPerKept, window, chunk, filtered, names = BUDGET_NAMES) {\n    var _a;\n    let total = 0;\n    const perChunk = new Map();\n    const walks = new Set();\n    for (const row of rows) {\n        total += row.n;\n        perChunk.set(row.chunkStart, ((_a = perChunk.get(row.chunkStart)) !== null && _a !== void 0 ? _a : 0) + row.n);\n        walks.add(row.name);\n    }\n    const budget = stepBudget * readPerKept;\n    if (total <= budget) {\n        return undefined;\n    }\n    const windowBp = window.end - window.start;\n    let read = 0;\n    let fitsBp = 0;\n    for (const cs of [...perChunk.keys()].sort((a, b) => a - b)) {\n        read += perChunk.get(cs);\n        if (read > budget) {\n            break;\n        }\n        fitsBp = Math.max(fitsBp, cs + chunk - window.start);\n    }\n    const fewerFit = !filtered && walks.size > 2 && (2 * total) / walks.size <= budget;\n    return new RegionTooLargeError(fitsBp > 0\n        ? `Zoom in to about ${bpString(fitsBp)}${fewerFit ? ', or choose fewer haplotypes,' : ''} to see the graph`\n        : `Too many haplotype steps here to draw ${filtered ? 'these haplotypes' : 'every haplotype'} (${read.toLocaleString()} steps read, over ${readPerKept} \u00D7 ${names.steps} of ${stepBudget.toLocaleString()}); choose fewer haplotypes`, budget, windowBp, Math.max(fitsBp, 1));\n}\n/**\n * The zoom-in notice for a cut that keeps more steps than `budget`, or\n * undefined when it fits. The span that fits is the window scaled by how far\n * over the cut is.\n */\nexport function keptStepsError(fragments, budget, window, filtered) {\n    const total = fragments.reduce((sum, f) => sum + f.ids.length, 0);\n    if (total <= budget) {\n        return undefined;\n    }\n    const windowBp = window.end - window.start;\n    const fitsBp = Math.max(1, Math.floor((windowBp * budget) / total));\n    return new RegionTooLargeError(`Zoom in to about ${bpString(fitsBp)}${filtered ? '' : ', or choose fewer haplotypes,'} to see the graph`, budget, windowBp, fitsBp);\n}\n/**\n * The zoom-in notice for a cut whose three files would fetch more than\n * `budget` compressed bytes, or undefined when they fit. `bytesTo(end)` is the\n * indexes' estimate for a read from the window's first query base to `end`;\n * the span that fits grows a chunk at a time from the chunk holding the\n * window's start, and when that chunk and those before it are over on their\n * own, no zoom fits.\n */\nexport async function byteBudgetError(bytesTo, budget, window, chunk, names = BUDGET_NAMES) {\n    const bytes = await bytesTo(window.end);\n    if (bytes <= budget) {\n        return undefined;\n    }\n    let fitsBp = 0;\n    let least;\n    for (let cs = Math.floor(window.start / chunk) * chunk; cs < window.end; cs += chunk) {\n        const read = await bytesTo(cs + 1);\n        least !== null && least !== void 0 ? least : (least = read);\n        if (read > budget) {\n            break;\n        }\n        fitsBp = cs + chunk - window.start;\n    }\n    const windowBp = window.end - window.start;\n    return new RegionTooLargeError(fitsBp > 0\n        ? `Zoom in to about ${bpString(fitsBp)} to see the graph`\n        : `Too much graph here to fetch (${megabytes(least !== null && least !== void 0 ? least : bytes)} against ${names.bytes} ${megabytes(budget)})`, budget, windowBp, Math.max(fitsBp, 1));\n}\nconst megabytes = (bytes) => `${(bytes / 1e6).toFixed(1)} MB`;\n", "import { decodeChunk, pieceLinks } from \"./walkChunk.js\";\nimport { WalkGraph, byteBudgetError, chunkQueryStart, joinPieces, keptStepsError, lookbackChunks, stepBudgetError, walkCut, walkHeader, } from \"./walkRows.js\";\n// A window reads whole chunks and keeps the steps on it, so a narrow window\n// reads several times what it keeps: 464 haplotypes across the 1.5 kb ABCA7\n// repeat read 5.0 M steps and keep 1.16 M, and the cut takes 0.4 s from warm\n// files. The step budget bounds what the cut keeps, and rows are read to this\n// multiple of it.\nconst READ_STEPS_PER_KEPT = 8;\n// A walk the read cuts off goes on in the chunk its row names, out to which a\n// cut reads on, in at most this many rounds and this many chunks from the read\nconst FOLLOW_ROUNDS = 3;\nconst FOLLOW_CHUNKS = 4;\n// bp of reference a cut keeps past each end of the window\nconst WALK_CONTEXT = 1000;\n// A walk file gfa-to-tabix 0.12 or earlier wrote, which the reader refuses\nexport class WalkFormatError extends Error {\n    constructor() {\n        super(...arguments);\n        this.name = 'WalkFormatError';\n    }\n}\n// @gmod/tabix loops forever on a NaN end and reads nothing for a NaN start\n// (GMOD/tabix-js#157), so every query refuses a range that is not finite first\nfunction checkRange(refName, start, end) {\n    if (!Number.isFinite(start) || !Number.isFinite(end)) {\n        throw new Error(`${refName}:${start}-${end} is not a finite range to query the graph's index for`);\n    }\n}\n// Settles like `promise` unless `signal` aborts first\nfunction raceAbort(promise, signal) {\n    if (!signal) {\n        return promise;\n    }\n    signal.throwIfAborted();\n    return new Promise((resolve, reject) => {\n        const onAbort = () => {\n            reject(signal.reason instanceof Error\n                ? signal.reason\n                : new Error(String(signal.reason)));\n        };\n        signal.addEventListener('abort', onAbort, { once: true });\n        promise.then(resolve, reject).finally(() => {\n            signal.removeEventListener('abort', onAbort);\n        });\n    });\n}\n/**\n * A `gfa-to-tabix --walks` file, `<prefix>.<sample>.walks.bed.gz`, read a\n * window at a time: one read over whole chunks, from the lookback chunks\n * before the window to its end, each chunk decoded once. The index first\n * estimates the bytes the read fetches, and a window past the byte budget\n * reads no row. Only the walks `keep` accepts are decoded. The step budget\n * bounds the steps the cut keeps, and rows holding READ_STEPS_PER_KEPT times\n * as many stop the read.\n */\nexport class WalkReader {\n    constructor(walks) {\n        this.walks = walks;\n    }\n    // The header, read once for every caller: one caller giving up stops only\n    // its own wait, and a read that fails is tried again by the next caller\n    header(opts = {}) {\n        if (!this.headerRead) {\n            const read = this.walks.getHeaderLines().then(lines => {\n                var _a;\n                const header = walkHeader(lines);\n                if (header.format !== 2) {\n                    throw new WalkFormatError('This walk file is format 1, from gfa-to-tabix 0.12 or earlier; rebuild it with gfa-to-tabix 1.0 or later');\n                }\n                const chunk = (_a = header.chunk) !== null && _a !== void 0 ? _a : 65536;\n                return {\n                    ...header,\n                    chunk,\n                    lookback: lookbackChunks(header.maxNode, chunk),\n                };\n            });\n            read.catch(() => {\n                if (this.headerRead === read) {\n                    this.headerRead = undefined;\n                }\n            });\n            this.headerRead = read;\n        }\n        return raceAbort(this.headerRead, opts.signal);\n    }\n    // The reference sequences the walk file holds windows on\n    referenceSequences(opts = {}) {\n        return this.walks.getReferenceSequenceNames(opts);\n    }\n    async queryStart(start, opts = {}) {\n        const { chunk, lookback } = await this.header(opts);\n        return chunkQueryStart(start, chunk, lookback);\n    }\n    async cut(refName, region, opts = {}) {\n        var _a;\n        const { signal, keep, context = WALK_CONTEXT, stepBudget = Infinity, byteBudget = Infinity, links = true, } = opts;\n        const { chunk, lookback } = await this.header({ signal });\n        const from = chunkQueryStart(region.start, chunk, lookback);\n        const bytesForRegions = (_a = this.walks.bytesForRegions) === null || _a === void 0 ? void 0 : _a.bind(this.walks);\n        const budgeted = Number.isFinite(byteBudget) && bytesForRegions !== undefined;\n        const bytesFor = async (spans) => budgeted\n            ? bytesForRegions(spans.map(span => ({ refName, ...span })), { signal })\n            : 0;\n        const tooLarge = budgeted\n            ? await byteBudgetError(async (end) => {\n                checkRange(refName, from, end);\n                return bytesFor([{ start: from, end }]);\n            }, byteBudget, region, chunk, opts.budgetNames)\n            : undefined;\n        if (tooLarge) {\n            throw tooLarge;\n        }\n        const reads = new AbortController();\n        const stop = () => {\n            reads.abort(signal === null || signal === void 0 ? void 0 : signal.reason);\n        };\n        signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();\n        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', stop, { once: true });\n        const rows = [];\n        let cut;\n        const graph = new WalkGraph({\n            refName,\n            start: region.start,\n            end: region.end,\n            context,\n            sequences: opts.sequences,\n        });\n        const decoded = new Set();\n        const ends = [];\n        // each chunk read is decoded once, into its rows, nodes and the links\n        // between pieces\n        const readChunks = async (start, end) => {\n            checkRange(refName, start, end);\n            const byChunk = new Map();\n            await this.walks.getLines(refName, start, end, {\n                signal: reads.signal,\n                lineCallback: line => {\n                    const cols = line.split('\\t');\n                    const cs = +cols[1];\n                    const held = byChunk.get(cs);\n                    if (held) {\n                        held.push(cols);\n                    }\n                    else {\n                        byChunk.set(cs, [cols]);\n                    }\n                },\n            });\n            for (const [cs, chunkRows] of byChunk) {\n                if (decoded.has(cs)) {\n                    continue;\n                }\n                decoded.add(cs);\n                const chunkCut = decodeChunk(chunkRows, keep, opts.sequences);\n                rows.push(...chunkCut.rows);\n                for (const [id, node] of chunkCut.nodes) {\n                    graph.placeNode(id, node);\n                }\n                graph.addSequences(chunkCut.sequences);\n                graph.addChunk(chunkCut.chunk);\n                ends.push(...chunkCut.ends);\n            }\n            if (links) {\n                for (const [a, b] of pieceLinks(ends)) {\n                    graph.addLinkEnds(a, b);\n                }\n            }\n        };\n        try {\n            await readChunks(from, region.end);\n            const tooManyRead = stepBudgetError(rows, stepBudget, READ_STEPS_PER_KEPT, region, chunk, keep !== undefined, opts.budgetNames);\n            if (tooManyRead) {\n                throw tooManyRead;\n            }\n            // the chunks read, first to last, which a follow widens to the\n            // farthest chunk a cut-off walk goes on in, so the reference between\n            // is read too\n            let first = from;\n            let last = Math.floor((region.end - 1) / chunk) * chunk;\n            const reach = FOLLOW_CHUNKS * chunk;\n            const [lo, hi] = [first - reach, last + reach];\n            cut = walkCut(joinPieces(rows), graph.nodes, refName);\n            let spent = await bytesFor([{ start: from, end: region.end }]);\n            for (let round = 0; round < FOLLOW_ROUNDS; round++) {\n                const starts = cut.open\n                    .filter(c => c.refName === refName && c.start >= lo && c.start <= hi)\n                    .map(c => c.start);\n                const spans = [\n                    { start: Math.min(first, ...starts), end: first },\n                    { start: last + chunk, end: Math.max(last, ...starts) + 1 },\n                ].filter(span => span.end > span.start);\n                if (spans.length === 0) {\n                    break;\n                }\n                spent += await bytesFor(spans);\n                if (spent > byteBudget) {\n                    break;\n                }\n                first = Math.min(first, ...starts);\n                last = Math.max(last, ...starts);\n                await Promise.all(spans.map(({ start, end }) => readChunks(start, end)));\n                cut = walkCut(joinPieces(rows), graph.nodes, refName);\n            }\n        }\n        catch (error) {\n            reads.abort();\n            throw error;\n        }\n        finally {\n            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', stop);\n        }\n        const tooMany = keptStepsError(cut.fragments, stepBudget, region, keep !== undefined);\n        if (tooMany) {\n            throw tooMany;\n        }\n        return { graph, ...cut };\n    }\n}\n", "import { panSNHaplotype } from '@jbrowse/bandage-core/pansn'\nimport { walkNameFilter } from '@jbrowse/graph-walks'\n\nimport { walkCutFor } from './walkRowRuns.ts'\n\nimport type { WalkReader } from '@jbrowse/graph-walks'\n\n// The zoom-in notices name the config slots that set the budgets\nexport const BUDGET_SLOTS = {\n  steps: 'walkStepBudget',\n  bytes: 'walkByteBudget',\n}\n\n/**\n * The graph display's cut of a walk-indexed window: the reference walk, the\n * walks of `prefixes` (every walk when undefined), and the nodes and links\n * they visit. Walk rows draw runs, so the step budget spares them.\n * @jbrowse/graph-walks reads and cuts the window.\n */\nexport async function walkSubgraph(\n  reader: WalkReader,\n  refName: string,\n  region: { start: number; end: number },\n  opts: {\n    signal?: AbortSignal\n    prefixes?: string[]\n    walkRows?: boolean\n    stepBudget: number\n    byteBudget: number\n  },\n) {\n  const { graph, kept, fragments } = await reader.cut(refName, region, {\n    signal: opts.signal,\n    keep: walkNameFilter(opts.prefixes, panSNHaplotype(refName)),\n    stepBudget: opts.walkRows ? Infinity : opts.stepBudget,\n    byteBudget: opts.byteBudget,\n    budgetNames: BUDGET_SLOTS,\n  })\n  return walkCutFor(graph.tables(kept, fragments), region, opts.walkRows)\n}\n"],
-  "mappings": "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",
-  "names": ["idOf", "handle", "otherStrand", "tokens", "field", "previous", "out", "v", "neg", "p", "ch", "d", "r", "numbers", "canonicalLink", "a", "b", "tags", "cols", "from", "anchor", "prev", "next", "k", "tag", "at", "chunk", "RefPath", "handles", "lengths", "h", "i", "id", "list", "_a", "best", "j", "target", "forward", "found", "WalkRowError", "orientedEntry", "route", "flip", "orientedExit", "interiorAt", "parseChoices", "choices", "tok", "colonSeen", "value", "traverse", "path", "routes", "start", "endField", "visit", "colon", "end", "counted", "tail", "routeOf", "index", "follow", "count", "entry", "exit", "decodeWalk", "n", "ids", "rev", "push", "to", "sliceBases", "c", "length", "decodeChunk", "rows", "keep", "withSequences", "_b", "_c", "refs", "nodeLengths", "hapOffset", "interior", "name", "first", "last", "lead", "leadFlip", "tailFlip", "placeAndLink", "chunks", "kept", "place", "link", "walks", "wanted", "any", "inCut", "lengthOf", "bp", "routeBp", "s", "taken", "remaining", "offset", "held", "node", "referenceNodes", "nodes", "pieceLinks", "ends", "byPath", "key", "pieces", "links", "piece", "e", "RegionTooLargeError", "message", "limit", "windowBp", "fitsBp", "SEP", "panSNMatchesPrefix", "refName", "prefix", "SEP", "precise", "n", "bpString", "bp", "mb", "integerTag", "line", "tag", "match", "walkHeader", "lines", "_a", "_b", "_c", "header", "key", "value", "lookbackChunks", "maxNode", "chunk", "chunkQueryStart", "start", "lookback", "walkNameFilter", "wanted", "referenceHaplotype", "name", "panSNMatchesPrefix", "prefix", "joinPieces", "rows", "byPath", "row", "list", "runs", "pieces", "a", "b", "from", "i", "decodeRun", "n", "sum", "p", "ids", "rev", "at", "first", "walkCut", "nodes", "refName", "onWindow", "id", "reference", "node", "open", "goesOn", "rejoin", "run", "dir", "to", "reachStart", "reachEnd", "spans", "last", "inReach", "kept", "span", "length", "fragments", "f", "l", "hapStart", "hapEnd", "WalkGraph", "window", "source", "target", "sequences", "bases", "placeAndLink", "held", "x", "y", "index", "names", "refNames", "refIndex", "lengths", "refs", "starts", "ranks", "end", "rank", "ref", "nodeIndex", "byLine", "strands", "k", "walks", "offsets", "steps", "reversed", "j", "BUDGET_NAMES", "stepBudgetError", "stepBudget", "readPerKept", "filtered", "total", "perChunk", "budget", "windowBp", "read", "fitsBp", "cs", "fewerFit", "RegionTooLargeError", "bpString", "keptStepsError", "byteBudgetError", "bytesTo", "bytes", "least", "megabytes", "READ_STEPS_PER_KEPT", "FOLLOW_ROUNDS", "FOLLOW_CHUNKS", "WALK_CONTEXT", "WalkFormatError", "checkRange", "refName", "start", "end", "raceAbort", "promise", "signal", "resolve", "reject", "onAbort", "WalkReader", "walks", "opts", "read", "lines", "_a", "header", "walkHeader", "chunk", "lookbackChunks", "lookback", "chunkQueryStart", "region", "keep", "context", "stepBudget", "byteBudget", "links", "from", "bytesForRegions", "budgeted", "bytesFor", "spans", "span", "tooLarge", "byteBudgetError", "reads", "stop", "rows", "cut", "graph", "WalkGraph", "decoded", "ends", "readChunks", "byChunk", "line", "cols", "cs", "held", "chunkRows", "chunkCut", "decodeChunk", "id", "node", "a", "b", "pieceLinks", "tooManyRead", "stepBudgetError", "first", "last", "reach", "lo", "hi", "walkCut", "joinPieces", "spent", "round", "starts", "c", "error", "tooMany", "keptStepsError", "BUDGET_SLOTS", "walkSubgraph", "reader", "refName", "region", "opts", "graph", "kept", "fragments", "walkNameFilter", "panSNHaplotype", "walkCutFor"]
-}